Glib

object Glib

Skipped during bindings generation

  • function aligned_alloc: Return type gpointer is unsupported

  • function aligned_alloc0: Return type gpointer is unsupported

  • parameter mem: gpointer

  • parameter mem: gpointer

  • function ascii_digit_value: C function g_ascii_digit_value is ignored

  • function ascii_dtostr: C function g_ascii_dtostr is ignored

  • function ascii_formatd: C function g_ascii_formatd is ignored

  • function ascii_strcasecmp: C function g_ascii_strcasecmp is ignored

  • function ascii_strdown: C function g_ascii_strdown is ignored

  • function ascii_string_to_signed: C function g_ascii_string_to_signed is ignored

  • function ascii_string_to_unsigned: C function g_ascii_string_to_unsigned is ignored

  • function ascii_strncasecmp: C function g_ascii_strncasecmp is ignored

  • function ascii_strtod: C function g_ascii_strtod is ignored

  • function ascii_strtoll: C function g_ascii_strtoll is ignored

  • function ascii_strtoull: C function g_ascii_strtoull is ignored

  • function ascii_strup: C function g_ascii_strup is ignored

  • function ascii_tolower: C function g_ascii_tolower is ignored

  • function ascii_toupper: C function g_ascii_toupper is ignored

  • function ascii_xdigit_value: C function g_ascii_xdigit_value is ignored

  • parameter arg1: Unsupported string with cType const char* const*

  • function async_queue_new: Return type AsyncQueue is unsupported

  • parameter item_free_func: DestroyNotify

  • parameter func: VoidFunc

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: Unsupported pointer to primitive type

  • parameter atomic: gpointer

  • parameter atomic: gpointer

  • parameter atomic: gpointer

  • parameter atomic: gpointer

  • parameter atomic: gpointer

  • parameter atomic: gpointer

  • parameter atomic: gpointer

  • parameter atomic: gpointer

  • parameter atomic: gpointer

  • parameter mem_block: gpointer

  • function atomic_rc_box_alloc: Return type gpointer is unsupported

  • function atomic_rc_box_alloc0: Return type gpointer is unsupported

  • parameter mem_block: gpointer

  • parameter mem_block: gpointer

  • parameter mem_block: gpointer

  • parameter mem_block: gpointer

  • parameter arc: Unsupported pointer to primitive type

  • parameter arc: Unsupported pointer to primitive type

  • parameter arc: Unsupported pointer to primitive type

  • parameter arc: Unsupported pointer to primitive type

  • parameter out_len: out_len: Out parameter is not supported

  • function base64_decode_inplace: In/Out parameter is not supported

  • parameter data: Array parameter of type guint8 is not supported

  • function base64_encode_close: In/Out parameter is not supported

  • function base64_encode_step: In/Out parameter is not supported

  • parameter address: Unsupported pointer to primitive type

  • parameter address: Unsupported pointer to primitive type

  • parameter address: Unsupported pointer to primitive type

  • parameter array: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • function byte_array_new: Array parameter of type guint8 is not supported

  • parameter data: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • function byte_array_sized_new: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • parameter array: Array parameter of type guint8 is not supported

  • parameter pid: Pid

  • parameter pid: Pid

  • function chmod: C function g_chmod is ignored

  • parameter data: Array parameter of type guint8 is not supported

  • parameter key: Array parameter of type guint8 is not supported

  • parameter key: Array parameter of type guint8 is not supported

  • parameter str: Array parameter of type guint8 is not supported

  • parameter str: Array parameter of type guint8 is not supported

  • function creat: C function g_creat is ignored

  • parameter datalist: Data

  • parameter datalist: Data

  • parameter datalist: Data

  • parameter datalist: Data

  • parameter datalist: Data

  • parameter datalist: Data

  • parameter datalist: Data

  • parameter dataset_location: gpointer

  • parameter dataset_location: gpointer

  • parameter dataset_location: gpointer

  • parameter year: DateYear

  • parameter year: DateYear

  • parameter year: DateYear

  • parameter year: DateYear

  • function date_strftime: C function g_date_strftime is ignored

  • parameter day: DateDay

  • parameter day: DateDay

  • parameter year: DateYear

  • parameter v1: gpointer

  • parameter v: gpointer

  • parameter v1: gpointer

  • parameter v: gpointer

  • parameter error_type_init: ErrorInitFunc

  • parameter error_type_init: ErrorInitFunc

  • parameter contents: contents: Out parameter is not supported

  • parameter name_used: name_used: Out parameter is not supported

  • parameter contents: Array parameter of type guint8 is not supported

  • parameter contents: Array parameter of type guint8 is not supported

  • parameter hostname: hostname: Out parameter is not supported

  • parameter bytes_read: bytes_read: Out parameter is not supported

  • parameter bytes_read: bytes_read: Out parameter is not supported

  • function fopen: Return type gpointer is unsupported

  • parameter mem: gpointer

  • parameter mem: gpointer

  • parameter stream: gpointer

  • function fsync: C function g_fsync is ignored

  • parameter charset: charset: Out parameter is not supported

  • parameter charset: charset: Out parameter is not supported

  • parameter filename_charsets: filename_charsets: Out parameter is not supported

  • parameter key: gpointer

  • parameter key: gpointer

  • function hash_table_find: Return type gpointer is unsupported

  • parameter key: gpointer

  • parameter key: gpointer

  • parameter lookup_key: gpointer

  • parameter key: gpointer

  • parameter key: gpointer

  • parameter key: gpointer

  • parameter lookup_key: gpointer

  • parameter func: HookCompareFunc

  • parameter data: gpointer

  • parameter v1: gpointer

  • parameter v: gpointer

  • parameter v1: gpointer

  • parameter v: gpointer

  • parameter condition: C Type GIOCondition is ignored

  • parameter condition: C Type GIOCondition is ignored

  • parameter allocator: Allocator

  • parameter bytes_read: bytes_read: Out parameter is not supported

  • parameter opsysstring: Array parameter of type guint8 is not supported

  • parameter unused_data: gpointer

  • parameter fields: LogField

  • parameter fields: LogField

  • parameter domains: Unsupported string with cType const gchar* const*

  • parameter fields: LogField

  • parameter fields: LogField

  • parameter fields: LogField

  • parameter fields: LogField

  • parameter buf: StatBuf

  • function malloc: Return type gpointer is unsupported

  • function malloc0: Return type gpointer is unsupported

  • function malloc0_n: Return type gpointer is unsupported

  • function malloc_n: Return type gpointer is unsupported

  • parameter mem: gpointer

  • parameter mem: gpointer

  • function mkdir: C function g_mkdir is ignored

  • parameter allocator: Allocator

  • parameter nullify_location: gpointer

  • function once_init_enter: In/Out parameter is not supported

  • parameter location: Unsupported pointer to primitive type

  • parameter location: gpointer

  • function once_init_leave: In/Out parameter is not supported

  • parameter location: gpointer

  • function open: C function g_open is ignored

  • parameter keys: DebugKey

  • parameter v1: gpointer

  • parameter address: gpointer

  • parameter address: gpointer

  • parameter ptr: gpointer

  • parameter address: gpointer

  • parameter address: gpointer

  • parameter address: gpointer

  • function prefix_error_literal: C function g_prefix_error_literal is ignored

  • parameter dest: dest: Out parameter is not supported

  • parameter pbase: gpointer

  • function quark_to_string: C function g_quark_to_string is ignored

  • parameter mem_block: gpointer

  • function rc_box_alloc: Return type gpointer is unsupported

  • function rc_box_alloc0: Return type gpointer is unsupported

  • parameter mem_block: gpointer

  • parameter mem_block: gpointer

  • parameter mem_block: gpointer

  • parameter mem_block: gpointer

  • parameter mem: gpointer

  • parameter mem: gpointer

  • parameter rc: Unsupported pointer to primitive type

  • parameter rc: Unsupported pointer to primitive type

  • parameter rc: Unsupported pointer to primitive type

  • parameter rc: Unsupported pointer to primitive type

  • parameter str: Unsupported string type with cType: char*

  • parameter str: Unsupported string type with cType: char*

  • parameter str: Unsupported string type with cType: char*

  • parameter has_references: has_references: Out parameter is not supported

  • function remove: C function g_remove is ignored

  • function rename: C function g_rename is ignored

  • parameter begin: SequenceIter

  • parameter iter: SequenceIter

  • parameter iter: SequenceIter

  • parameter src: SequenceIter

  • parameter dest: SequenceIter

  • parameter begin: SequenceIter

  • parameter iter: SequenceIter

  • parameter begin: SequenceIter

  • parameter iter: SequenceIter

  • parameter iter: SequenceIter

  • parameter iter: SequenceIter

  • parameter a: SequenceIter

  • parameter err: err: Out parameter is not supported

  • function set_prgname_once: C function g_set_prgname_once is ignored

  • parameter argcp: argcp: Out parameter is not supported

  • function slice_alloc: Return type gpointer is unsupported

  • function slice_alloc0: Return type gpointer is unsupported

  • parameter mem_block: gpointer

  • parameter mem_block: gpointer

  • parameter mem_chain: gpointer

  • parameter n_values: Unsupported pointer to primitive type

  • parameter allocator: Allocator

  • parameter user_data: gpointer

  • parameter user_data: gpointer

  • parameter child_pid: child_pid: Out parameter is not supported

  • parameter child_pid: child_pid: Out parameter is not supported

  • parameter child_pid: child_pid: Out parameter is not supported

  • parameter source_fds: Array parameter of type gint is not supported

  • parameter pid: Pid

  • parameter standard_output: standard_output: Out parameter is not supported

  • parameter standard_output: standard_output: Out parameter is not supported

  • parameter buf: StatBuf

  • function stpcpy: C function g_stpcpy is ignored

  • function str_equal: C function g_str_equal is ignored

  • function str_has_prefix: C function g_str_has_prefix is ignored

  • function str_has_suffix: C function g_str_has_suffix is ignored

  • function str_hash: C function g_str_hash is ignored

  • function str_is_ascii: C function g_str_is_ascii is ignored

  • function str_match_string: C function g_str_match_string is ignored

  • function str_to_ascii: C function g_str_to_ascii is ignored

  • function str_tokenize_and_fold: C function g_str_tokenize_and_fold is ignored

  • function strcanon: C function g_strcanon is ignored

  • function strcasecmp: C function g_strcasecmp is ignored

  • function strchomp: C function g_strchomp is ignored

  • function strchug: C function g_strchug is ignored

  • function strcmp0: C function g_strcmp0 is ignored

  • function strcompress: C function g_strcompress is ignored

  • function strdelimit: C function g_strdelimit is ignored

  • function strdown: C function g_strdown is ignored

  • function strdup: C function g_strdup is ignored

  • function strdupv: C function g_strdupv is ignored

  • function strerror: C function g_strerror is ignored

  • function strescape: C function g_strescape is ignored

  • function strfreev: C function g_strfreev is ignored

  • function strip_context: C function g_strip_context is ignored

  • function strjoinv: C function g_strjoinv is ignored

  • function strlcat: C function g_strlcat is ignored

  • function strlcpy: C function g_strlcpy is ignored

  • function strncasecmp: C function g_strncasecmp is ignored

  • function strndup: C function g_strndup is ignored

  • function strnfill: C function g_strnfill is ignored

  • function strreverse: C function g_strreverse is ignored

  • function strrstr: C function g_strrstr is ignored

  • function strrstr_len: C function g_strrstr_len is ignored

  • function strsignal: C function g_strsignal is ignored

  • function strsplit: C function g_strsplit is ignored

  • function strsplit_set: C function g_strsplit_set is ignored

  • function strstr_len: C function g_strstr_len is ignored

  • function strtod: C function g_strtod is ignored

  • function strup: C function g_strup is ignored

  • function strv_contains: C function g_strv_contains is ignored

  • function strv_equal: C function g_strv_equal is ignored

  • function strv_get_type: C function g_strv_get_type is ignored

  • function strv_length: C function g_strv_length is ignored

  • parameter test_data: gpointer

  • parameter test_data: gpointer

  • parameter test_func: TestFunc

  • parameter destroy_func: DestroyNotify

  • parameter gfree_pointer: gpointer

  • parameter suite: TestSuite

  • parameter retval: gpointer

  • function trash_stack_height: C function g_trash_stack_height is ignored

  • function trash_stack_peek: Return type gpointer is unsupported

  • function trash_stack_pop: Return type gpointer is unsupported

  • parameter data_p: gpointer

  • function try_malloc: Return type gpointer is unsupported

  • function try_malloc0: Return type gpointer is unsupported

  • function try_malloc0_n: Return type gpointer is unsupported

  • function try_malloc_n: Return type gpointer is unsupported

  • parameter mem: gpointer

  • parameter mem: gpointer

  • parameter str: Array parameter of type gunichar is not supported

  • parameter str: Array parameter of type gunichar is not supported

  • parameter ch: ch: Out parameter is not supported

  • parameter a: a: Out parameter is not supported

  • parameter result: result: Out parameter is not supported

  • parameter mirrored_ch: mirrored_ch: Out parameter is not supported

  • parameter outbuf: outbuf: Out parameter is not supported

  • parameter result_len: Unsupported pointer to primitive type

  • parameter string: Array parameter of type gunichar is not supported

  • parameter condition: C Type GIOCondition is ignored

  • parameter condition: C Type GIOCondition is ignored

  • function unix_get_passwd_entry: Return type gpointer is unsupported

  • parameter fds: Array parameter of type gint is not supported

  • parameter unescaped: Array parameter of type guint8 is not supported

  • parameter scheme: scheme: Out parameter is not supported

  • parameter scheme: scheme: Out parameter is not supported

  • parameter scheme: scheme: Out parameter is not supported

  • parameter str: Array parameter of type guint16 is not supported

  • parameter str: Array parameter of type guint16 is not supported

  • function utf8_casefold: C function g_utf8_casefold is ignored

  • function utf8_collate: C function g_utf8_collate is ignored

  • function utf8_collate_key: C function g_utf8_collate_key is ignored

  • function utf8_collate_key_for_filename: C function g_utf8_collate_key_for_filename is ignored

  • function utf8_find_next_char: C function g_utf8_find_next_char is ignored

  • function utf8_find_prev_char: C function g_utf8_find_prev_char is ignored

  • function utf8_get_char: C function g_utf8_get_char is ignored

  • function utf8_get_char_validated: C function g_utf8_get_char_validated is ignored

  • function utf8_make_valid: C function g_utf8_make_valid is ignored

  • function utf8_normalize: C function g_utf8_normalize is ignored

  • function utf8_offset_to_pointer: C function g_utf8_offset_to_pointer is ignored

  • function utf8_pointer_to_offset: C function g_utf8_pointer_to_offset is ignored

  • function utf8_prev_char: C function g_utf8_prev_char is ignored

  • function utf8_strchr: C function g_utf8_strchr is ignored

  • function utf8_strdown: C function g_utf8_strdown is ignored

  • function utf8_strlen: C function g_utf8_strlen is ignored

  • function utf8_strncpy: C function g_utf8_strncpy is ignored

  • function utf8_strrchr: C function g_utf8_strrchr is ignored

  • function utf8_strreverse: C function g_utf8_strreverse is ignored

  • function utf8_strup: C function g_utf8_strup is ignored

  • function utf8_substring: C function g_utf8_substring is ignored

  • function utf8_to_ucs4: C function g_utf8_to_ucs4 is ignored

  • function utf8_to_ucs4_fast: C function g_utf8_to_ucs4_fast is ignored

  • function utf8_to_utf16: C function g_utf8_to_utf16 is ignored

  • function utf8_truncate_middle: C function g_utf8_truncate_middle is ignored

  • function utf8_validate: C function g_utf8_validate is ignored

  • function utf8_validate_len: C function g_utf8_validate_len is ignored

  • parameter utb: gpointer

  • function variant_get_gtype: C function g_variant_get_gtype is ignored

  • parameter endptr: Unsupported string with cType const gchar**

  • parameter endptr: endptr: Out parameter is not supported

  • callback CacheDupFunc: Return type gpointer is unsupported

  • callback CacheNewFunc: Return type gpointer is unsupported

  • callback CompletionFunc: Callback with String return value is not supported

  • callback CopyFunc: Return type gpointer is unsupported

  • callback DuplicateFunc: Return type gpointer is unsupported

  • callback OptionArgFunc: Callbacks that throw are not supported

  • callback OptionErrorFunc: Callbacks that throw are not supported

  • callback OptionParseFunc: Callbacks that throw are not supported

  • callback ThreadFunc: Return type gpointer is unsupported

  • callback TranslateFunc: Callback with String return value is not supported

  • bitfield IOCondition: C Type GIOCondition is ignored

  • record Allocator: Disguised records are ignored

  • record AsyncQueue: Disguised records are ignored

  • record Cache: Disguised records are ignored

  • record Data: Disguised records are ignored

  • record MemChunk: Disguised records are ignored

  • record OptionContext: Disguised records are ignored

  • record Relation: Disguised records are ignored

  • record Sequence: Disguised records are ignored

  • record SequenceIter: Disguised records are ignored

  • record SourcePrivate: Disguised records are ignored

  • record StatBuf: Disguised records are ignored

  • record StringChunk: Disguised records are ignored

  • record TestCase: Disguised records are ignored

  • record TestSuite: Disguised records are ignored

  • record Timer: Disguised records are ignored

  • record TreeNode: Disguised records are ignored

Properties

Link copied to clipboard
const val ALLOC_AND_FREE: Int = 2
Link copied to clipboard
const val ALLOC_ONLY: Int = 1
Link copied to clipboard
const val ALLOCATOR_LIST: Int = 1
Link copied to clipboard
const val ALLOCATOR_NODE: Int = 3
Link copied to clipboard
const val ALLOCATOR_SLIST: Int = 2
Link copied to clipboard
const val ANALYZER_ANALYZING: Int = 1
Link copied to clipboard
const val ASCII_DTOSTR_BUF_SIZE: Int = 39

A good size for a buffer to be passed into func@GLib.ascii_dtostr. It is guaranteed to be enough for all output of that function on systems with 64bit IEEE-compatible doubles.

Link copied to clipboard
const val ATOMIC_REF_COUNT_INIT: Int = 1

Evaluates to the initial reference count for gatomicrefcount.

Link copied to clipboard
const val BIG_ENDIAN: Int = 4321

Specifies one of the possible types of byte order. See %G_BYTE_ORDER.

Link copied to clipboard
const val C_STD_VERSION: Int = 199000

The C standard version the code is compiling against, it's normally defined with the same value of __STDC_VERSION__ for C standard compatible compilers, while it uses the lowest standard version in pure MSVC, given that in such compiler the definition depends on a compilation flag.

Link copied to clipboard
const val CSET_A_2_Z: String

The set of uppercase ASCII alphabet characters. Used for specifying valid identifier characters in #GScannerConfig.

Link copied to clipboard
const val CSET_a_2_z: String

The set of lowercase ASCII alphabet characters. Used for specifying valid identifier characters in #GScannerConfig.

Link copied to clipboard
const val CSET_DIGITS: String

The set of ASCII digits. Used for specifying valid identifier characters in #GScannerConfig.

Link copied to clipboard
const val DATALIST_FLAGS_MASK: Int = 3

A bitmask that restricts the possible flags passed to g_datalist_set_flags(). Passing a flags value where flags & ~G_DATALIST_FLAGS_MASK != 0 is an error.

Link copied to clipboard
const val DATE_BAD_DAY: Int = 0

Represents an invalid #GDateDay.

Link copied to clipboard
const val DATE_BAD_JULIAN: Int = 0

Represents an invalid Julian day number.

Link copied to clipboard
const val DATE_BAD_YEAR: Int = 0

Represents an invalid year.

Link copied to clipboard
const val DIR_SEPARATOR: Int = 47

The directory separator character. This is '/' on UNIX machines and '\' under Windows.

Link copied to clipboard

The directory separator as a string. This is "/" on UNIX machines and "\" under Windows.

Link copied to clipboard
const val E: Double = 2.718282

The base of natural logarithms.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard

Expands to "" on all modern compilers, and to FUNCTION on gcc version 2.x. Don't use it.

Link copied to clipboard

Expands to "" on all modern compilers, and to PRETTY_FUNCTION on gcc version 2.x. Don't use it.

Link copied to clipboard
const val GSIZE_FORMAT: String
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
const val HAVE_GINT64: Int = 1
Link copied to clipboard
const val HAVE_GNUC_VARARGS: Int = 1
Link copied to clipboard
const val HAVE_GNUC_VISIBILITY: Int = 1

Defined to 1 if gcc-style visibility handling is supported.

Link copied to clipboard
const val HAVE_GROWING_STACK: Int = 0
Link copied to clipboard
const val HAVE_ISO_VARARGS: Int = 1
Link copied to clipboard
const val HOOK_FLAG_USER_SHIFT: Int = 4

The position of the first bit which is not reserved for internal use be the #GHook implementation, i.e. 1 << G_HOOK_FLAG_USER_SHIFT is the first bit which can be used for application-defined flags.

Link copied to clipboard
const val IEEE754_DOUBLE_BIAS: Int = 1023

The bias by which exponents in double-precision floats are offset.

Link copied to clipboard

The bias by which exponents in single-precision floats are offset.

Link copied to clipboard

The name of the main group of a desktop entry file, as defined in the Desktop Entry Specification. Consult the specification for more details about the meanings of the keys below.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string list giving the available application actions.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings giving the categories in which the desktop entry should be shown in a menu.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the tooltip for the desktop entry.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean set to true if the application is D-Bus activatable.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the command line to execute. It is only valid for desktop entries with the Application type.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the generic name of the desktop entry.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the desktop entry has been deleted by the user.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the name of the icon to be displayed for the desktop entry.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings giving the MIME types supported by this desktop entry.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the specific name of the desktop entry.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the desktop entry should be shown in menus.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings identifying the environments that should not display the desktop entry.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings identifying the environments that should display the desktop entry.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string containing the working directory to run the program in. It is only valid for desktop entries with the Application type.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the application supports the Startup Notification Protocol Specification.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is string identifying the WM class or name hint of a window that the application will create, which can be used to emulate Startup Notification with older applications.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the program should be run in a terminal window.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the file name of a binary on disk used to determine if the program is actually installed. It is only valid for desktop entries with the Application type.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the type of the desktop entry.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the URL to access. It is only valid for desktop entries with the Link type.

Link copied to clipboard

A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the version of the Desktop Entry Specification used for the desktop entry file.

Link copied to clipboard

The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing applications.

Link copied to clipboard

The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing directories.

Link copied to clipboard

The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing links to documents.

Link copied to clipboard
const val LITTLE_ENDIAN: Int = 1234

Specifies one of the possible types of byte order. See %G_BYTE_ORDER.

Link copied to clipboard
const val LN10: Double = 2.302585

The natural logarithm of 10.

Link copied to clipboard
const val LN2: Double = 0.693147

The natural logarithm of 2.

Link copied to clipboard
const val LOG_2_BASE_10: Double = 0.30103

Multiplying the base 2 exponent by this number yields the base 10 exponent.

Link copied to clipboard
const val LOG_DOMAIN: Char = '0'

Defines the log domain. See #log-domains.

Link copied to clipboard
const val LOG_FATAL_MASK: Int = 5

GLib log levels that are considered fatal by default.

Link copied to clipboard
const val LOG_LEVEL_USER_SHIFT: Int = 8

Log levels below 1<<G_LOG_LEVEL_USER_SHIFT are used by GLib. Higher bits can be used for user-defined log levels.

Link copied to clipboard
const val MAJOR_VERSION: Int = 2

The major version number of the GLib library.

Link copied to clipboard
const val MAXINT16: Short = 32767
Link copied to clipboard
const val MAXINT32: Int
Link copied to clipboard
const val MAXINT64: Long
Link copied to clipboard
const val MAXINT8: Byte
Link copied to clipboard
const val MAXUINT16: <Error class: unknown class>
Link copied to clipboard
const val MAXUINT32: <Error class: unknown class>
Link copied to clipboard
const val MAXUINT64: <Error class: unknown class>
Link copied to clipboard
const val MAXUINT8: <Error class: unknown class>
Link copied to clipboard
const val MICRO_VERSION: Int = 2

The micro version number of the GLib library.

Link copied to clipboard
const val MININT16: Short

The minimum value which can be held in a #gint16.

Link copied to clipboard
const val MININT32: Int

The minimum value which can be held in a #gint32.

Link copied to clipboard
const val MININT64: Long

The minimum value which can be held in a #gint64.

Link copied to clipboard
const val MININT8: Byte

The minimum value which can be held in a #gint8.

Link copied to clipboard
const val MINOR_VERSION: Int = 82

The minor version number of the GLib library.

Link copied to clipboard
Link copied to clipboard

If a long option in the main group has this name, it is not treated as a regular option. Instead it collects all non-option arguments which would otherwise be left in argv. The option must be of type %G_OPTION_ARG_CALLBACK, %G_OPTION_ARG_STRING_ARRAY or %G_OPTION_ARG_FILENAME_ARRAY.

Link copied to clipboard
const val PDP_ENDIAN: Int = 3412

Specifies one of the possible types of byte order (currently unused). See %G_BYTE_ORDER.

Link copied to clipboard
const val PI: Double = 3.141593

The value of pi (ratio of circle's circumference to its diameter).

Link copied to clipboard
const val PI_2: Double = 1.570796

Pi divided by 2.

Link copied to clipboard
const val PI_4: Double = 0.785398

Pi divided by 4.

Link copied to clipboard
const val PID_FORMAT: String

A format specifier that can be used in printf()-style format strings when printing a #GPid.

Link copied to clipboard

A format specifier that can be used in printf()-style format strings when printing the @fd member of a #GPollFD.

Link copied to clipboard
const val PRIORITY_DEFAULT: Int = 0

Use this for default priority event sources.

Link copied to clipboard
const val PRIORITY_DEFAULT_IDLE: Int = 200

Use this for default priority idle functions.

Link copied to clipboard
const val PRIORITY_HIGH: Int

Use this for high priority event sources.

Link copied to clipboard
const val PRIORITY_HIGH_IDLE: Int = 100

Use this for high priority idle functions.

Link copied to clipboard
const val PRIORITY_LOW: Int = 300

Use this for very low priority background tasks.

Link copied to clipboard
const val REF_COUNT_INIT: Int

Evaluates to the initial reference count for grefcount.

Link copied to clipboard
const val SEARCHPATH_SEPARATOR: Int = 58

The search path separator character. This is ':' on UNIX machines and ';' under Windows.

Link copied to clipboard

The search path separator as a string. This is ":" on UNIX machines and ";" under Windows.

Link copied to clipboard
const val SIZEOF_LONG: Int = 8
Link copied to clipboard
const val SIZEOF_SIZE_T: Int = 8
Link copied to clipboard
const val SIZEOF_SSIZE_T: Int = 8
Link copied to clipboard
const val SIZEOF_VOID_P: Int = 8
Link copied to clipboard
const val SOURCE_CONTINUE: Boolean = true

Use this macro as the return value of a callback@GLib.SourceFunc to leave the struct@GLib.Source in the main loop.

Link copied to clipboard
const val SOURCE_REMOVE: Boolean = false

Use this macro as the return value of a callback@GLib.SourceFunc to remove the struct@GLib.Source from the main loop.

Link copied to clipboard
const val SQRT2: Double = 1.414214

The square root of two.

Link copied to clipboard

The standard delimiters, used in func@GLib.strdelimit.

Link copied to clipboard
const val SYSDEF_AF_INET: Int = 2
Link copied to clipboard
const val SYSDEF_AF_INET6: Int = 10
Link copied to clipboard
const val SYSDEF_AF_UNIX: Int = 1
Link copied to clipboard
const val SYSDEF_MSG_DONTROUTE: Int = 4
Link copied to clipboard
const val SYSDEF_MSG_OOB: Int = 1
Link copied to clipboard
const val SYSDEF_MSG_PEEK: Int = 2
Link copied to clipboard

Creates a unique temporary directory for each unit test and uses g_set_user_dirs() to set XDG directories to point into subdirectories of it for the duration of the unit test. The directory tree is cleaned up after the test finishes successfully. Note that this doesn’t take effect until g_test_run() is called, so calls to (for example) g_get_user_home_dir() will return the system-wide value when made in a test program’s main() function.

Link copied to clipboard
const val TIME_SPAN_DAY: Long = 86400000000

Evaluates to a time span of one day.

Link copied to clipboard
const val TIME_SPAN_HOUR: Long = 3600000000

Evaluates to a time span of one hour.

Link copied to clipboard
const val TIME_SPAN_MILLISECOND: Long = 1000

Evaluates to a time span of one millisecond.

Link copied to clipboard
const val TIME_SPAN_MINUTE: Long = 60000000

Evaluates to a time span of one minute.

Link copied to clipboard
const val TIME_SPAN_SECOND: Long = 1000000

Evaluates to a time span of one second.

Link copied to clipboard

The maximum length (in codepoints) of a compatibility or canonical decomposition of a single Unicode character.

Link copied to clipboard

Generic delimiters characters as defined in RFC 3986. Includes :/?#[]@.

Subcomponent delimiter characters as defined in RFC 3986. Includes !$&'()*+,;=.

Link copied to clipboard
const val USEC_PER_SEC: Int = 1000000

Number of microseconds in one second (1 million). This macro is provided for code readability.

Link copied to clipboard
const val VA_COPY_AS_ARRAY: Int = 1
Link copied to clipboard
const val VERSION_MIN_REQUIRED: Int = 2

A macro that should be defined by the user prior to including the glib.h header. The definition should be one of the predefined GLib version macros: %GLIB_VERSION_2_26, %GLIB_VERSION_2_28,...

Link copied to clipboard
const val WIN32_MSG_HANDLE: Int = 19981206

Functions

Link copied to clipboard
fun access(filename: String, mode: Int): Int

A wrapper for the POSIX access() function. This function is used to test a pathname for one or several of read, write or execute permissions, or just existence.

Link copied to clipboard
fun assertionMessage(domain: String, file: String, line: Int, func: String, message: String)
Link copied to clipboard
fun assertionMessageCmpint(domain: String, file: String, line: Int, func: String, expr: String, arg1: <Error class: unknown class>, cmp: String, arg2: <Error class: unknown class>, numtype: Char)
Link copied to clipboard
fun assertionMessageCmpstr(domain: String, file: String, line: Int, func: String, expr: String, arg1: String, cmp: String, arg2: String)
Link copied to clipboard
fun assertionMessageError(domain: String, file: String, line: Int, func: String, expr: String, error: Error, errorDomain: <Error class: unknown class>, errorCode: Int)
Link copied to clipboard
fun assertWarning(logDomain: String, file: String, line: Int, prettyFunction: String, expression: String)
Link copied to clipboard
fun basename(fileName: String): String

Gets the name of the file without any leading directory components. It returns a pointer into the given file name string.

Link copied to clipboard
fun bitNthLsf(mask: <Error class: unknown class>, nthBit: Int): Int

Find the position of the first bit set in @mask, searching from (but not including) @nth_bit upwards. Bits are numbered from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63, usually). To start searching from the 0th bit, set @nth_bit to -1.

Link copied to clipboard
fun bitNthMsf(mask: <Error class: unknown class>, nthBit: Int): Int

Find the position of the first bit set in @mask, searching from (but not including) @nth_bit downwards. Bits are numbered from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63, usually). To start searching from the last bit, set @nth_bit to -1 or GLIB_SIZEOF_LONG * 8.

Link copied to clipboard
fun bitStorage(number: <Error class: unknown class>): <Error class: unknown class>

Gets the number of bits used to hold @number, e.g. if @number is 4, 3 bits are needed.

Link copied to clipboard
Link copied to clipboard
fun bookmarkFileErrorQuark(): <Error class: unknown class>
Link copied to clipboard

Creates a filename from a vector of elements using the correct separator for the current platform.

Link copied to clipboard
fun buildPathv(separator: String, args: List<String>): String

Behaves exactly like g_build_path(), but takes the path elements as a string array, instead of variadic arguments.

Link copied to clipboard
fun canonicalizeFilename(filename: String, relativeTo: String? = null): String

Gets the canonical file name from @filename. All triple slashes are turned into single slashes, and all .. and .s resolved against @relative_to.

Link copied to clipboard
fun chdir(path: String): Int

A wrapper for the POSIX chdir() function. The function changes the current directory of the process to @path.

Link copied to clipboard

Gets the length in bytes of digests of type @checksum_type

Link copied to clipboard
fun checkVersion(requiredMajor: <Error class: unknown class>, requiredMinor: <Error class: unknown class>, requiredMicro: <Error class: unknown class>): String?

Checks that the GLib library in use is compatible with the given version.

Link copied to clipboard
fun clearError(): <Error class: unknown class><Unit>

If @err or *@err is null, does nothing. Otherwise, calls g_error_free() on *@err and sets *@err to null.

Link copied to clipboard
fun close(fd: Int): <Error class: unknown class><Boolean>

This wraps the close() call. In case of error, %errno will be preserved, but the error will also be stored as a #GError in @error. In case of success, %errno is undefined.

Link copied to clipboard
fun closefrom(lowfd: Int): Int

Close every file descriptor equal to or greater than @lowfd.

Link copied to clipboard

Computes the checksum for a binary @data. This is a convenience wrapper for g_checksum_new(), g_checksum_get_string() and g_checksum_free().

Link copied to clipboard
fun computeChecksumForString(checksumType: ChecksumType, str: String, length: Long): String

Computes the checksum of a string.

Link copied to clipboard
fun computeHmacForBytes(digestType: ChecksumType, key: Bytes, data: Bytes): String

Computes the HMAC for a binary @data. This is a convenience wrapper for g_hmac_new(), g_hmac_get_string() and g_hmac_unref().

Link copied to clipboard
fun convertErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun dateValidJulian(julianDate: <Error class: unknown class>): Boolean

Returns true if the Julian day is valid. Anything greater than zero is basically a valid Julian, though there is a 32-bit limit.

Link copied to clipboard

Returns true if the month value is valid. The 12 #GDateMonth enumeration values are the only valid months.

Link copied to clipboard

Returns true if the weekday is valid. The seven #GDateWeekday enumeration values are the only valid weekdays.

Link copied to clipboard
fun dcgettext(domain: String? = null, msgid: String, category: Int): String

This is a variant of g_dgettext() that allows specifying a locale category instead of always using LC_MESSAGES. See g_dgettext() for more information about how this functions differs from calling dcgettext() directly.

Link copied to clipboard
fun dgettext(domain: String? = null, msgid: String): String

This function is a wrapper of dgettext() which does not translate the message if the default domain as set with textdomain() has no translations for the current locale.

Link copied to clipboard
fun dirMakeTmp(tmpl: String? = null): <Error class: unknown class><String>

Creates a subdirectory in the preferred directory for temporary files (as returned by g_get_tmp_dir()).

Link copied to clipboard
fun dngettext(domain: String? = null, msgid: String, msgidPlural: String, n: <Error class: unknown class>): String

This function is a wrapper of dngettext() which does not translate the message if the default domain as set with textdomain() has no translations for the current locale.

Link copied to clipboard
fun dpgettext(domain: String? = null, msgctxtid: String, msgidoffset: <Error class: unknown class>): String

This function is a variant of g_dgettext() which supports a disambiguating message context. GNU gettext uses the '\004' character to separate the message context and message id in @msgctxtid. If 0 is passed as @msgidoffset, this function will fall back to trying to use the deprecated convention of using "|" as a separation character.

Link copied to clipboard
fun dpgettext2(domain: String? = null, context: String, msgid: String): String

This function is a variant of g_dgettext() which supports a disambiguating message context. GNU gettext uses the '\004' character to separate the message context and message id in @msgctxtid.

Link copied to clipboard
fun environGetenv(envp: List<String>? = null, variable: String): String?

Returns the value of the environment variable @variable in the provided list @envp.

Link copied to clipboard
fun environSetenv(envp: List<String>? = null, variable: String, value: String, overwrite: Boolean): List<String>

Sets the environment variable @variable in the provided list

Link copied to clipboard
fun environUnsetenv(envp: List<String>? = null, variable: String): List<String>

Removes the environment variable @variable from the provided environment @envp.

Link copied to clipboard
fun fdwalkSetCloexec(lowfd: Int): Int

Mark every file descriptor equal to or greater than @lowfd to be closed at the next execve() or similar, as if via the FD_CLOEXEC flag.

Link copied to clipboard

Gets a #GFileError constant based on the passed-in @err_no.

Link copied to clipboard
fun fileErrorQuark(): <Error class: unknown class>
Link copied to clipboard

Returns the display basename for the particular filename, guaranteed to be valid UTF-8. The display name might not be identical to the filename, for instance there might be problems converting it to UTF-8, and some files can be translated in the display.

Link copied to clipboard

Converts a filename into a valid UTF-8 string. The conversion is not necessarily reversible, so you should keep the original around and use the return value of this function only for display purposes. Unlike g_filename_to_utf8(), the result is guaranteed to be non-null even if the filename actually isn't in the GLib file name encoding.

Link copied to clipboard
fun filenameToUri(filename: String, hostname: String? = null): <Error class: unknown class><String>

Converts an absolute filename to an escaped ASCII-encoded URI, with the path component following Section 3.3. of RFC 2396.

Link copied to clipboard
fun fileReadLink(filename: String): <Error class: unknown class><String>

Reads the contents of the symbolic link @filename like the POSIX readlink() function.

Link copied to clipboard
fun fileTest(filename: String, test: FileTest): Boolean

Returns true if any of the tests in the bitfield @test are true. For example, (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR) will return true if the file exists; the check whether it's a directory doesn't matter since the existence test is true. With the current set of available tests, there's no point passing in more than one test at a time.

Link copied to clipboard

Locates the first executable named @program in the user's path, in the same way that execvp() would locate it. Returns an allocated string with the absolute path name, or null if the program is not found in the path. If @program is already an absolute path, returns a copy of

Link copied to clipboard
fun formatSize(size: <Error class: unknown class>): String

Formats a size (for example the size of a file) into a human readable string. Sizes are rounded to the nearest size prefix (kB, MB, GB) and are displayed rounded to the nearest tenth. E.g. the file size 3292528 bytes will be converted into the string "3.2 MB". The returned string is UTF-8, and may use a non-breaking space to separate the number and units, to ensure they aren’t separated when line wrapped.

Link copied to clipboard

Formats a size (for example the size of a file) into a human readable string. Sizes are rounded to the nearest size prefix (KB, MB, GB) and are displayed rounded to the nearest tenth. E.g. the file size 3292528 bytes will be converted into the string "3.1 MB".

Link copied to clipboard
fun formatSizeFull(size: <Error class: unknown class>, flags: FormatSizeFlags): String

Formats a size.

Link copied to clipboard

Gets a human-readable name for the application, as set by g_set_application_name(). This name should be localized if possible, and is intended for display to the user. Contrast with g_get_prgname(), which gets a non-localized name. If g_set_application_name() has not been called, returns the result of g_get_prgname() (which may be null if g_set_prgname() has also not been called).

Link copied to clipboard

Gets the character set for the current locale.

Link copied to clipboard

Gets the current directory.

Link copied to clipboard
fun getCurrentTime(result: TimeVal)

Equivalent to the UNIX gettimeofday() function, but portable.

Link copied to clipboard
fun getenv(variable: String): String?

Returns the value of an environment variable.

Link copied to clipboard

Gets the list of environment variables for the current process.

Link copied to clipboard

Gets the current user's home directory.

Link copied to clipboard

Return a name for the machine.

Link copied to clipboard

Computes a list of applicable locale names, which can be used to e.g. construct locale-dependent filenames or search paths. The returned list is sorted from most desirable to least desirable and always contains the default locale "C".

Link copied to clipboard

Computes a list of applicable locale names with a locale category name, which can be used to construct the fallback locale-dependent filenames or search paths. The returned list is sorted from most desirable to least desirable and always contains the default locale "C".

Link copied to clipboard

Returns a list of derived variants of @locale, which can be used to e.g. construct locale-dependent filenames or search paths. The returned list is sorted from most desirable to least desirable. This function handles territory, charset and extra locale modifiers. See man:setlocale for information about locales and their format.

Link copied to clipboard

Queries the system monotonic time.

Link copied to clipboard
fun getNumProcessors(): <Error class: unknown class>

Determine the approximate number of threads that the system will schedule simultaneously for this process. This is intended to be used as a parameter to g_thread_pool_new() for CPU bound tasks and similar cases.

Link copied to clipboard
fun getOsInfo(keyName: String): String

Get information about the operating system.

Link copied to clipboard

Gets the name of the program. This name should not be localized, in contrast to g_get_application_name().

Link copied to clipboard

Gets the real name of the user. This usually comes from the user's entry in the passwd file. The encoding of the returned string is system-defined. (On Windows, it is, however, always UTF-8.) If the real user name cannot be determined, the string "Unknown" is returned.

Link copied to clipboard

Queries the system wall-clock time.

Link copied to clipboard

Returns an ordered list of base directories in which to access system-wide configuration information.

Link copied to clipboard

Returns an ordered list of base directories in which to access system-wide application data.

Link copied to clipboard

Gets the directory to use for temporary files.

Link copied to clipboard

Returns a base directory in which to store non-essential, cached data specific to particular user.

Link copied to clipboard

Returns a base directory in which to store user-specific application configuration information such as user preferences and settings.

Link copied to clipboard

Returns a base directory in which to access application data such as icons that is customized for a particular user.

Link copied to clipboard

Gets the user name of the current user. The encoding of the returned string is system-defined. On UNIX, it might be the preferred file name encoding, or something else, and there is no guarantee that it is even consistent on a machine. On Windows, it is always UTF-8.

Link copied to clipboard

Returns a directory that is unique to the current user on the local system.

Link copied to clipboard

Returns the full path of a special directory using its logical id.

Link copied to clipboard

Returns a base directory in which to store state files specific to particular user.

Link copied to clipboard
fun hashTableDestroy(hashTable: HashTable)

Destroys all keys and values in the #GHashTable and decrements its reference count by 1. If keys and/or values are dynamically allocated, you should either free them first or create the #GHashTable with destroy notifiers using g_hash_table_new_full(). In the latter case the destroy functions you supplied will be called on all keys and values during the destruction phase.

Link copied to clipboard
fun hashTableForeach(hashTable: HashTable, func: HFunc)

Calls the given function for each of the key/value pairs in the #GHashTable. The function is passed the key and value of each pair, and the given @user_data parameter. The hash table may not be modified while iterating over it (you can't add/remove items). To remove all items matching a predicate, use g_hash_table_foreach_remove().

Link copied to clipboard
fun hashTableForeachRemove(hashTable: HashTable, func: HRFunc): <Error class: unknown class>

Calls the given function for each key/value pair in the #GHashTable. If the function returns true, then the key/value pair is removed from the #GHashTable. If you supplied key or value destroy functions when creating the #GHashTable, they are used to free the memory allocated for the removed keys and values.

Link copied to clipboard
fun hashTableForeachSteal(hashTable: HashTable, func: HRFunc): <Error class: unknown class>

Calls the given function for each key/value pair in the #GHashTable. If the function returns true, then the key/value pair is removed from the #GHashTable, but no key or value destroy functions are called.

Link copied to clipboard

Creates a new #GHashTable like g_hash_table_new_full() with a reference count of 1.

Link copied to clipboard

Atomically increments the reference count of @hash_table by one. This function is MT-safe and may be called from any thread.

Link copied to clipboard

Removes all keys and their associated values from a #GHashTable.

Link copied to clipboard
fun hashTableSize(hashTable: HashTable): <Error class: unknown class>

Returns the number of elements contained in the #GHashTable.

Link copied to clipboard

Removes all keys and their associated values from a #GHashTable without calling the key and value destroy functions.

Link copied to clipboard
fun hashTableUnref(hashTable: HashTable)

Atomically decrements the reference count of @hash_table by one. If the reference count drops to 0, all keys and values will be destroyed, and all memory allocated by the hash table is released. This function is MT-safe and may be called from any thread.

Link copied to clipboard
fun hookDestroy(hookList: HookList, hookId: <Error class: unknown class>): Boolean

Destroys a #GHook, given its ID.

Link copied to clipboard
fun hookDestroyLink(hookList: HookList, hook: Hook)

Removes one #GHook from a #GHookList, marking it inactive and calling g_hook_unref() on it.

Link copied to clipboard
fun hookFree(hookList: HookList, hook: Hook)

Calls the #GHookList @finalize_hook function if it exists, and frees the memory allocated for the #GHook.

Link copied to clipboard
fun hookInsertBefore(hookList: HookList, sibling: Hook? = null, hook: Hook)

Inserts a #GHook into a #GHookList, before a given #GHook.

Link copied to clipboard
fun hookPrepend(hookList: HookList, hook: Hook)

Prepends a #GHook on the start of a #GHookList.

Link copied to clipboard
fun hookUnref(hookList: HookList, hook: Hook)

Decrements the reference count of a #GHook. If the reference count falls to 0, the #GHook is removed from the #GHookList and g_hook_free() is called to free it.

Link copied to clipboard

Tests if @hostname contains segments with an ASCII-compatible encoding of an Internationalized Domain Name. If this returns true, you should decode the hostname with g_hostname_to_unicode() before displaying it to the user.

Link copied to clipboard

Tests if @hostname is the string form of an IPv4 or IPv6 address. (Eg, "192.168.0.1".)

Link copied to clipboard

Tests if @hostname contains Unicode characters. If this returns true, you need to encode the hostname with g_hostname_to_ascii() before using it in non-IDN-aware contexts.

Link copied to clipboard
fun hostnameToAscii(hostname: String): String

Converts @hostname to its canonical ASCII form; an ASCII-only string containing no uppercase letters and not ending with a trailing dot.

Link copied to clipboard

Converts @hostname to its canonical presentation form; a UTF-8 string in Unicode normalization form C, containing no uppercase letters, no forbidden characters, and no ASCII-encoded segments, and not ending with a trailing dot.

Link copied to clipboard
fun idleAdd(priority: Int, function: SourceFunc): <Error class: unknown class>

Adds a function to be called whenever there are no higher priority events pending.

Link copied to clipboard

Creates a new idle source.

Link copied to clipboard
fun internStaticString(string: String? = null): String

Returns a canonical representation for @string. Interned strings can be compared for equality by comparing the pointers, instead of using strcmp(). g_intern_static_string() does not copy the string, therefore @string must not be freed or modified.

Link copied to clipboard
fun internString(string: String? = null): String

Returns a canonical representation for @string. Interned strings can be compared for equality by comparing the pointers, instead of using strcmp().

Link copied to clipboard

Converts an errno error number to a #GIOChannelError.

Link copied to clipboard
fun ioChannelErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun keyFileErrorQuark(): <Error class: unknown class>
Link copied to clipboard

Gets the names of all variables set in the environment.

Link copied to clipboard
Link copied to clipboard

Return whether debug output from the GLib logging system is enabled.

Link copied to clipboard
fun logRemoveHandler(logDomain: String, handlerId: <Error class: unknown class>)

Removes the log handler.

Link copied to clipboard

Sets the message levels which are always fatal, in any log domain.

Link copied to clipboard

Enable or disable debug output from the GLib logging system for all domains.

Link copied to clipboard
fun logSetFatalMask(logDomain: String, fatalMask: LogLevelFlags): LogLevelFlags

Sets the log levels which are fatal in the given domain.

Link copied to clipboard
fun logSetHandler(logDomain: String? = null, logLevels: LogLevelFlags, logFunc: LogFunc): <Error class: unknown class>

Like func@GLib.log_set_handler, but takes a destroy notify for the @user_data.

Link copied to clipboard

Set a writer function which will be called to format and write out each log message.

Link copied to clipboard
fun logVariant(logDomain: String? = null, logLevel: LogLevelFlags, fields: Variant)

Log a message with structured data, accepting the data within a type@GLib.Variant.

Link copied to clipboard

Configure whether the built-in log functions will output all log messages to stderr.

Link copied to clipboard
fun logWriterDefaultWouldDrop(logLevel: LogLevelFlags, logDomain: String? = null): Boolean

Check whether func@GLib.log_writer_default and func@GLib.log_default_handler would ignore a message with the given domain and level.

Link copied to clipboard

Check whether the given @output_fd file descriptor is a connection to the systemd journal, or something else (like a log file or stdout or stderr).

Link copied to clipboard

Check whether the given @output_fd file descriptor supports ANSI color escape sequences.

Link copied to clipboard

Returns the global-default main context. This is the main context used for main loop functions when a main loop is not explicitly specified, and corresponds to the "main" main loop. See also func@GLib.MainContext.get_thread_default.

Link copied to clipboard

Gets the thread-default #GMainContext for this thread. Asynchronous operations that want to be able to be run in contexts other than the default one should call this method or func@GLib.MainContext.ref_thread_default to get a struct@GLib.MainContext to add their struct@GLib.Sources to. (Note that even in single-threaded programs applications may sometimes want to temporarily push a non-default context, so it is not safe to assume that this will always return null if you are running in the default thread.)

Link copied to clipboard

Gets the thread-default struct@GLib.MainContext for this thread, as with func@GLib.MainContext.get_thread_default, but also adds a reference to it with method@GLib.MainContext.ref. In addition, unlike func@GLib.MainContext.get_thread_default, if the thread-default context is the global-default context, this will return that struct@GLib.MainContext (with a ref added to it) rather than returning null.

Link copied to clipboard

Returns the currently firing source for this thread.

Link copied to clipboard
fun mainDepth(): Int

Returns the depth of the stack of calls to method@GLib.MainContext.dispatch on any #GMainContext in the current thread. That is, when called from the toplevel, it gives 0. When called from within a callback from method@GLib.MainContext.iteration (or method@GLib.MainLoop.run, etc.) it returns 1. When called from within a callback to a recursive call to method@GLib.MainContext.iteration, it returns 2. And so forth.

Link copied to clipboard
fun markupErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun markupEscapeText(text: String, length: Long): String

Escapes text so that the markup parser will parse it verbatim. Less than, greater than, ampersand, etc. are replaced with the corresponding entities. This function would typically be used when writing out a file to be parsed with the markup parser.

Link copied to clipboard
Link copied to clipboard

Checks whether the allocator used by g_malloc() is the system's malloc implementation. If it returns true memory allocated with malloc() can be used interchangeably with memory allocated using g_malloc(). This function is useful for avoiding an extra copy of allocated memory returned by a non-GLib-based API.

Link copied to clipboard

GLib used to support some tools for memory profiling, but this no longer works. There are many other useful tools for memory profiling these days which can be used instead.

Link copied to clipboard
fun memSetVtable(vtable: MemVTable)

This function used to let you override the memory allocation function. However, its use was incompatible with the use of global constructors in GLib and GIO, because those use the GLib allocators before main is reached. Therefore this function is now deprecated and is just a stub.

Link copied to clipboard
fun mkdirWithParents(pathname: String, mode: Int): Int

Create a directory if it doesn't already exist. Create intermediate parent directories as needed, too.

Link copied to clipboard
Link copied to clipboard
fun numberParserErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun onErrorQuery(prgName: String)

Prompts the user with [E]xit, [H]alt, show [S]tack trace or [P]roceed. This function is intended to be used for debugging use only. The following example shows how it can be used together with the g_log() functions.

Link copied to clipboard

Invokes gdb, which attaches to the current process and shows a stack trace. Called by g_on_error_query() when the "Stack trace" option is selected. You can get the current process's program name with g_get_prgname(), assuming that you have called gtk_init() or gdk_init().

Link copied to clipboard
fun optionErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun pathGetBasename(fileName: String): String

Gets the last component of the filename.

Link copied to clipboard
fun pathGetDirname(fileName: String): String

Gets the directory components of a file name. For example, the directory component of /usr/bin/test is /usr/bin. The directory component of / is /.

Link copied to clipboard
fun pathIsAbsolute(fileName: String): Boolean

Returns true if the given @file_name is an absolute file name. Note that this is a somewhat vague concept on Windows.

Link copied to clipboard
fun pathSkipRoot(fileName: String): String?

Returns a pointer into @file_name after the root component, i.e. after the "/" in UNIX or "C:\" under Windows. If @file_name is not an absolute path it returns null.

Link copied to clipboard
fun patternMatchSimple(pattern: String, string: String): Boolean

Matches a string against a pattern given as a string.

Link copied to clipboard
fun poll(fds: PollFD, nfds: <Error class: unknown class>, timeout: Int): Int

Polls @fds, as with the poll() system call, but portably. (On systems that don't have poll(), it is emulated using select().) This is used internally by #GMainContext, but it can be called directly if you need to block until a file descriptor is ready, but don't want to run the full main loop.

Link copied to clipboard
fun quarkFromStaticString(string: String? = null): <Error class: unknown class>

Gets the #GQuark identifying the given (static) string. If the string does not currently have an associated #GQuark, a new #GQuark is created, linked to the given string.

Link copied to clipboard
fun quarkFromString(string: String? = null): <Error class: unknown class>

Gets the #GQuark identifying the given string. If the string does not currently have an associated #GQuark, a new #GQuark is created, using a copy of the string.

Link copied to clipboard
fun quarkTryString(string: String? = null): <Error class: unknown class>

Gets the #GQuark associated with the given string, or 0 if string is null or it has no associated #GQuark.

Link copied to clipboard

Returns a random #gdouble equally distributed over the range [0..1).

Link copied to clipboard

Returns a random #gdouble equally distributed over the range [@begin..@end).

Link copied to clipboard
fun randomInt(): <Error class: unknown class>

Return a random #guint32 equally distributed over the range 0..2^32-1.

Link copied to clipboard
fun randomIntRange(begin: Int, end: Int): Int

Returns a random #gint32 equally distributed over the range @begin..@end-1.

Link copied to clipboard
fun randomSetSeed(seed: <Error class: unknown class>)

Sets the seed for the global random number generator, which is used by the g_random_* functions, to @seed.

Link copied to clipboard

Creates a new reference counted string and copies the contents of @str into it.

Link copied to clipboard

Creates a new reference counted string and copies the content of @str into it.

Link copied to clipboard

Creates a new reference counted string and copies the contents of @str into it, up to @len bytes.

Link copied to clipboard
fun regexErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun regexEscapeNul(string: String, length: Int): String

Escapes the nul characters in @string to "\x00". It can be used to compile a regex with embedded nul characters.

Link copied to clipboard
fun regexEscapeString(string: String, length: Int): String

Escapes the special characters used for regular expressions in @string, for instance "a.b*c" becomes "a\.b\*c". This function is useful to dynamically generate regular expressions.

Link copied to clipboard
fun regexMatchSimple(pattern: String, string: String, compileOptions: RegexCompileFlags, matchOptions: RegexMatchFlags): Boolean

Scans for a match in @string for @pattern.

Link copied to clipboard
fun regexSplitSimple(pattern: String, string: String, compileOptions: RegexCompileFlags, matchOptions: RegexMatchFlags): List<String>

Breaks the string on the pattern, and returns an array of the tokens. If the pattern contains capturing parentheses, then the text for each of the substrings will also be returned. If the pattern does not match anywhere in the string, then the whole string is returned as the first token.

Link copied to clipboard

Resets the cache used for g_get_user_special_dir(), so that the latest on-disk version is used. Call this only if you just changed the data on disk yourself.

Link copied to clipboard
Link copied to clipboard
fun rmdir(filename: String): Int

A wrapper for the POSIX rmdir() function. The rmdir() function deletes a directory from the filesystem.

Link copied to clipboard
fun setApplicationName(applicationName: String)

Sets a human-readable name for the application. This name should be localized if possible, and is intended for display to the user. Contrast with g_set_prgname(), which sets a non-localized name. g_set_prgname() will be called automatically by gtk_init(), but g_set_application_name() will not.

Link copied to clipboard
fun setenv(variable: String, value: String, overwrite: Boolean): Boolean

Sets an environment variable. On UNIX, both the variable's name and value can be arbitrary byte strings, except that the variable's name cannot contain '='. On Windows, they should be in UTF-8.

Link copied to clipboard
fun setPrgname(prgname: String)

Sets the name of the program. This name should not be localized, in contrast to g_set_application_name().

Link copied to clipboard
fun shellErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun shellQuote(unquotedString: String): String

Quotes a string so that the shell (/bin/sh) will interpret the quoted string to mean @unquoted_string.

Link copied to clipboard
fun shellUnquote(quotedString: String): <Error class: unknown class><String>

Unquotes a string as the shell (/bin/sh) would.

Link copied to clipboard
Link copied to clipboard
fun sliceSetConfig(ckey: SliceConfig, value: Long)
Link copied to clipboard
Link copied to clipboard
fun sourceRemove(tag: <Error class: unknown class>): Boolean

Removes the source with the given ID from the default main context. You must use method@GLib.Source.destroy for sources added to a non-default main context.

Link copied to clipboard
fun sourceSetNameById(tag: <Error class: unknown class>, name: String)

Sets the name of a source using its ID.

Link copied to clipboard
fun spacedPrimesClosest(num: <Error class: unknown class>): <Error class: unknown class>

Gets the smallest prime number from a built-in array of primes which is larger than @num. This is used within GLib to calculate the optimum size of a #GHashTable.

Link copied to clipboard
fun spawnCheckExitStatus(waitStatus: Int): <Error class: unknown class><Boolean>

An old name for g_spawn_check_wait_status(), deprecated because its name is misleading.

Link copied to clipboard
fun spawnCheckWaitStatus(waitStatus: Int): <Error class: unknown class><Boolean>

Set @error if @wait_status indicates the child exited abnormally (e.g. with a nonzero exit code, or via a fatal signal).

Link copied to clipboard
fun spawnCommandLineAsync(commandLine: String): <Error class: unknown class><Boolean>

A simple version of g_spawn_async() that parses a command line with g_shell_parse_argv() and passes it to g_spawn_async().

Link copied to clipboard
fun spawnErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun spawnExitErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun testAssertExpectedMessagesInternal(domain: String, file: String, line: Int, func: String)
Link copied to clipboard
fun testBug(bugUriSnippet: String)

This function adds a message to test reports that associates a bug URI with a test case.

Link copied to clipboard
fun testBugBase(uriPattern: String)

Specify the base URI for bug reports.

Link copied to clipboard

Attempt to disable system crash reporting infrastructure.

Link copied to clipboard
fun testExpectMessage(logDomain: String? = null, logLevel: LogLevelFlags, pattern: String)

Indicates that a message with the given @log_domain and @log_level, with text matching @pattern, is expected to be logged.

Link copied to clipboard
fun testFail()

Indicates that a test failed. This function can be called multiple times from the same test. You can use this function if your test failed in a recoverable way.

Link copied to clipboard

Returns whether a test has already failed. This will be the case when g_test_fail(), g_test_incomplete() or g_test_skip() have been called, but also if an assertion has failed.

Link copied to clipboard

Gets the pathname of the directory containing test files of the type specified by @file_type.

Link copied to clipboard

Gets the test path for the test currently being run.

Link copied to clipboard
fun testIncomplete(msg: String? = null)

Indicates that a test failed because of some incomplete functionality. This function can be called multiple times from the same test.

Link copied to clipboard
Link copied to clipboard

Get a reproducible random floating point number, see g_test_rand_int() for details on test case random numbers.

Link copied to clipboard
fun testRandDoubleRange(rangeStart: Double, rangeEnd: Double): Double

Get a reproducible random floating pointer number out of a specified range, see g_test_rand_int() for details on test case random numbers.

Link copied to clipboard

Get a reproducible random integer number.

Link copied to clipboard
fun testRandIntRange(begin: Int, end: Int): Int

Get a reproducible random integer number out of a specified range, see g_test_rand_int() for details on test case random numbers.

Link copied to clipboard
fun testRun(): Int

Runs all tests under the toplevel suite which can be retrieved with g_test_get_root(). Similar to g_test_run_suite(), the test cases to be run are filtered according to test path arguments (-p testpath and -s testpath) as parsed by g_test_init(). g_test_run_suite() or g_test_run() may only be called once in a program.

Link copied to clipboard

Changes the behaviour of the various g_assert_*() macros, g_test_assert_expected_messages() and the various g_test_trap_assert_*() macros to not abort to program, but instead call g_test_fail() and continue. (This also changes the behavior of g_test_fail() so that it will not cause the test program to abort after completing the failed test.)

Link copied to clipboard
fun testSkip(msg: String? = null)

Indicates that a test was skipped.

Link copied to clipboard

Returns true (after g_test_init() has been called) if the test program is running under g_test_trap_subprocess().

Link copied to clipboard
fun testSummary(summary: String)

Set the summary for a test, which describes what the test checks, and how it goes about checking it. This may be included in test report output, and is useful documentation for anyone reading the source code or modifying a test in future. It must be a single line.

Link copied to clipboard

Get the number of seconds since the last start of the timer with g_test_timer_start().

Link copied to clipboard

Report the last result of g_test_timer_elapsed().

Link copied to clipboard

Start a timing test. Call g_test_timer_elapsed() when the task is supposed to be done. Call this function again to restart the timer.

Link copied to clipboard
fun testTrapAssertions(domain: String, file: String, line: Int, func: String, assertionFlags: <Error class: unknown class>, pattern: String)
Link copied to clipboard
fun testTrapFork(usecTimeout: <Error class: unknown class>, testTrapFlags: TestTrapFlags): Boolean

Fork the current test program to execute a test case that might not return or that might abort.

Link copied to clipboard

Check the result of the last g_test_trap_subprocess() call.

Link copied to clipboard

Check the result of the last g_test_trap_subprocess() call.

Link copied to clipboard
fun testTrapSubprocess(testPath: String? = null, usecTimeout: <Error class: unknown class>, testFlags: TestSubprocessFlags)

Respawns the test program to run only @test_path in a subprocess.

Link copied to clipboard
fun testTrapSubprocessWithEnvp(testPath: String? = null, envp: List<String>? = null, usecTimeout: <Error class: unknown class>, testFlags: TestSubprocessFlags)

Respawns the test program to run only @test_path in a subprocess with the given @envp environment.

Link copied to clipboard
fun threadErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun threadPoolGetMaxIdleTime(): <Error class: unknown class>

This function will return the maximum @interval that a thread will wait in the thread pool for new tasks before being stopped.

Link copied to clipboard

Returns the maximal allowed number of unused threads.

Link copied to clipboard
fun threadPoolGetNumUnusedThreads(): <Error class: unknown class>

Returns the number of currently unused threads.

Link copied to clipboard
fun threadPoolSetMaxIdleTime(interval: <Error class: unknown class>)

This function will set the maximum @interval that a thread waiting in the pool for new tasks can be idle for before being stopped. This function is similar to calling g_thread_pool_stop_unused_threads() on a regular timeout, except this is done on a per thread basis.

Link copied to clipboard

Sets the maximal number of unused threads to @max_threads. If @max_threads is -1, no limit is imposed on the number of unused threads.

Link copied to clipboard

Stops all currently unused threads. This does not change the maximal number of unused threads. This function can be used to regularly stop all unused threads e.g. from g_timeout_add().

Link copied to clipboard

This function returns the #GThread corresponding to the current thread. Note that this function does not increase the reference count of the returned struct.

Link copied to clipboard

Causes the calling thread to voluntarily relinquish the CPU, so that other threads can run.

Link copied to clipboard
fun timeoutAdd(priority: Int, interval: <Error class: unknown class>, function: SourceFunc): <Error class: unknown class>

Sets a function to be called at regular intervals, with the given priority. The function is called repeatedly until it returns false, at which point the timeout is automatically destroyed and the function will not be called again. The @notify function is called when the timeout is destroyed. The first call to the function will be at the end of the first @interval.

Link copied to clipboard
fun timeoutAddSeconds(priority: Int, interval: <Error class: unknown class>, function: SourceFunc): <Error class: unknown class>

Sets a function to be called at regular intervals, with @priority.

Link copied to clipboard
fun timeoutSourceNew(interval: <Error class: unknown class>): Source

Creates a new timeout source.

Link copied to clipboard
fun timeoutSourceNewSeconds(interval: <Error class: unknown class>): Source

Creates a new timeout source.

Link copied to clipboard

Converts a string containing an ISO 8601 encoded date and time to a #GTimeVal and puts it into @time_.

Link copied to clipboard
fun unicharBreakType(c: <Error class: unknown class>): UnicodeBreakType

Determines the break type of @c. @c should be a Unicode character (to derive a character from UTF-8 encoded text, use g_utf8_get_char()). The break type is used to find word and line breaks ("text boundaries"), Pango implements the Unicode boundary resolution algorithms and normally you would use a function such as pango_break() instead of caring about break types yourself.

Link copied to clipboard
fun unicharCombiningClass(uc: <Error class: unknown class>): Int

Determines the canonical combining class of a Unicode character.

Link copied to clipboard
fun unicharDigitValue(c: <Error class: unknown class>): Int

Determines the numeric value of a character as a decimal digit.

Link copied to clipboard
fun unicharGetScript(ch: <Error class: unknown class>): UnicodeScript

Looks up the #GUnicodeScript for a particular character (as defined by Unicode Standard Annex \#24). No check is made for @ch being a valid Unicode character; if you pass in invalid character, the result is undefined.

Link copied to clipboard
fun unicharIsalnum(c: <Error class: unknown class>): Boolean

Determines whether a character is alphanumeric. Given some UTF-8 text, obtain a character value with g_utf8_get_char().

Link copied to clipboard
fun unicharIsalpha(c: <Error class: unknown class>): Boolean

Determines whether a character is alphabetic (i.e. a letter). Given some UTF-8 text, obtain a character value with g_utf8_get_char().

Link copied to clipboard
fun unicharIscntrl(c: <Error class: unknown class>): Boolean

Determines whether a character is a control character. Given some UTF-8 text, obtain a character value with g_utf8_get_char().

Link copied to clipboard
fun unicharIsdefined(c: <Error class: unknown class>): Boolean

Determines if a given character is assigned in the Unicode standard.

Link copied to clipboard
fun unicharIsdigit(c: <Error class: unknown class>): Boolean

Determines whether a character is numeric (i.e. a digit). This covers ASCII 0-9 and also digits in other languages/scripts. Given some UTF-8 text, obtain a character value with g_utf8_get_char().

Link copied to clipboard
fun unicharIsgraph(c: <Error class: unknown class>): Boolean

Determines whether a character is printable and not a space (returns false for control characters, format characters, and spaces). g_unichar_isprint() is similar, but returns true for spaces. Given some UTF-8 text, obtain a character value with g_utf8_get_char().

Link copied to clipboard
fun unicharIslower(c: <Error class: unknown class>): Boolean

Determines whether a character is a lowercase letter. Given some UTF-8 text, obtain a character value with g_utf8_get_char().

Link copied to clipboard
fun unicharIsmark(c: <Error class: unknown class>): Boolean

Determines whether a character is a mark (non-spacing mark, combining mark, or enclosing mark in Unicode speak). Given some UTF-8 text, obtain a character value with g_utf8_get_char().

Link copied to clipboard
fun unicharIsprint(c: <Error class: unknown class>): Boolean

Determines whether a character is printable. Unlike g_unichar_isgraph(), returns true for spaces. Given some UTF-8 text, obtain a character value with g_utf8_get_char().

Link copied to clipboard
fun unicharIspunct(c: <Error class: unknown class>): Boolean

Determines whether a character is punctuation or a symbol. Given some UTF-8 text, obtain a character value with g_utf8_get_char().

Link copied to clipboard
fun unicharIsspace(c: <Error class: unknown class>): Boolean

Determines whether a character is a space, tab, or line separator (newline, carriage return, etc.). Given some UTF-8 text, obtain a character value with g_utf8_get_char().

Link copied to clipboard
fun unicharIstitle(c: <Error class: unknown class>): Boolean

Determines if a character is titlecase. Some characters in Unicode which are composites, such as the DZ digraph have three case variants instead of just two. The titlecase form is used at the beginning of a word where only the first letter is capitalized. The titlecase form of the DZ digraph is U+01F2 LATIN CAPITAL LETTTER D WITH SMALL LETTER Z.

Link copied to clipboard
fun unicharIsupper(c: <Error class: unknown class>): Boolean

Determines if a character is uppercase.

Link copied to clipboard
fun unicharIswide(c: <Error class: unknown class>): Boolean

Determines if a character is typically rendered in a double-width cell.

Link copied to clipboard
fun unicharIswideCjk(c: <Error class: unknown class>): Boolean

Determines if a character is typically rendered in a double-width cell under legacy East Asian locales. If a character is wide according to g_unichar_iswide(), then it is also reported wide with this function, but the converse is not necessarily true. See the Unicode Standard Annex #11 for details.

Link copied to clipboard
fun unicharIsxdigit(c: <Error class: unknown class>): Boolean

Determines if a character is a hexadecimal digit.

Link copied to clipboard
fun unicharIszerowidth(c: <Error class: unknown class>): Boolean

Determines if a given character typically takes zero width when rendered. The return value is true for all non-spacing and enclosing marks (e.g., combining accents), format characters, zero-width space, but not U+00AD SOFT HYPHEN.

Link copied to clipboard
fun unicharTolower(c: <Error class: unknown class>): <Error class: unknown class>

Converts a character to lower case.

Link copied to clipboard
fun unicharTotitle(c: <Error class: unknown class>): <Error class: unknown class>

Converts a character to the titlecase.

Link copied to clipboard
fun unicharToupper(c: <Error class: unknown class>): <Error class: unknown class>

Converts a character to uppercase.

Link copied to clipboard
fun unicharType(c: <Error class: unknown class>): UnicodeType

Classifies a Unicode character by type.

Link copied to clipboard
fun unicharValidate(ch: <Error class: unknown class>): Boolean

Checks whether @ch is a valid Unicode character. Some possible integer values of @ch will not be valid. 0 is considered a valid character, though it's normally a string terminator.

Link copied to clipboard
fun unicharXdigitValue(c: <Error class: unknown class>): Int

Determines the numeric value of a character as a hexadecimal digit.

Link copied to clipboard
fun unicodeScriptFromIso15924(iso15924: <Error class: unknown class>): UnicodeScript

Looks up the Unicode script for @iso15924. ISO 15924 assigns four-letter codes to scripts. For example, the code for Arabic is 'Arab'. This function accepts four letter codes encoded as a @guint32 in a big-endian fashion. That is, the code expected for Arabic is 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).

Link copied to clipboard
fun unicodeScriptToIso15924(script: UnicodeScript): <Error class: unknown class>

Looks up the ISO 15924 code for @script. ISO 15924 assigns four-letter codes to scripts. For example, the code for Arabic is 'Arab'. The four letter codes are encoded as a @guint32 by this function in a big-endian fashion. That is, the code returned for Arabic is 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).

Link copied to clipboard
fun unixErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun unixSetFdNonblocking(fd: Int, nonblock: Boolean): <Error class: unknown class><Boolean>

Control the non-blocking state of the given file descriptor, according to @nonblock. On most systems this uses %O_NONBLOCK, but on some older ones may use %O_NDELAY.

Link copied to clipboard
fun unixSignalAdd(priority: Int, signum: Int, handler: SourceFunc): <Error class: unknown class>

A convenience function for g_unix_signal_source_new(), which attaches to the default #GMainContext. You can remove the watch using g_source_remove().

Link copied to clipboard

Create a #GSource that will be dispatched upon delivery of the UNIX signal @signum. In GLib versions before 2.36, only SIGHUP, SIGINT, SIGTERM can be monitored. In GLib 2.36, SIGUSR1 and SIGUSR2 were added. In GLib 2.54, SIGWINCH was added.

Link copied to clipboard
fun unlink(filename: String): Int

A wrapper for the POSIX unlink() function. The unlink() function deletes a name from the filesystem. If this was the last link to the file and no processes have it opened, the diskspace occupied by the file is freed.

Link copied to clipboard
fun unsetenv(variable: String)

Removes an environment variable from the environment.

Link copied to clipboard
fun uriBuild(flags: UriFlags, scheme: String, userinfo: String? = null, host: String? = null, port: Int, path: String, query: String? = null, fragment: String? = null): Uri

Creates a new #GUri from the given components according to @flags.

Link copied to clipboard
fun uriBuildWithUser(flags: UriFlags, scheme: String, user: String? = null, password: String? = null, authParams: String? = null, host: String? = null, port: Int, path: String, query: String? = null, fragment: String? = null): Uri

Creates a new #GUri from the given components according to @flags (%G_URI_FLAGS_HAS_PASSWORD is added unconditionally). The @flags must be coherent with the passed values, in particular use %-encoded values with %G_URI_FLAGS_ENCODED.

Link copied to clipboard
fun uriErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun uriEscapeString(unescaped: String, reservedCharsAllowed: String? = null, allowUtf8: Boolean): String

Escapes a string for use in a URI.

Link copied to clipboard
fun uriIsValid(uriString: String, flags: UriFlags): <Error class: unknown class><Boolean>

Parses @uri_string according to @flags, to determine whether it is a valid #relative-and-absolute-uris, i.e. it does not need to be resolved relative to another URI using g_uri_parse_relative().

Link copied to clipboard
fun uriJoin(flags: UriFlags, scheme: String? = null, userinfo: String? = null, host: String? = null, port: Int, path: String, query: String? = null, fragment: String? = null): String

Joins the given components together according to @flags to create an absolute URI string. @path may not be null (though it may be the empty string).

Link copied to clipboard
fun uriJoinWithUser(flags: UriFlags, scheme: String? = null, user: String? = null, password: String? = null, authParams: String? = null, host: String? = null, port: Int, path: String, query: String? = null, fragment: String? = null): String

Joins the given components together according to @flags to create an absolute URI string. @path may not be null (though it may be the empty string).

Link copied to clipboard

Splits an URI list conforming to the text/uri-list mime type defined in RFC 2483 into individual URIs, discarding any comments. The URIs are not validated.

Link copied to clipboard
fun uriParse(uriString: String, flags: UriFlags): <Error class: unknown class><Uri>

Parses @uri_string according to @flags. If the result is not a valid #relative-and-absolute-uris, it will be discarded, and an error returned.

Link copied to clipboard
fun uriParseParams(params: String, length: Long, separators: String, flags: UriParamsFlags): <Error class: unknown class><HashTable>

Many URI schemes include one or more attribute/value pairs as part of the URI value. This method can be used to parse them into a hash table. When an attribute has multiple occurrences, the last value is the final returned value. If you need to handle repeated attributes differently, use #GUriParamsIter.

Link copied to clipboard

Gets the scheme portion of a URI string. RFC 3986 decodes the scheme as: |[ URI = scheme ":" hier-part "#" fragment ]| Common schemes include file, https, svn+ssh, etc.

Link copied to clipboard

Gets the scheme portion of a URI string. RFC 3986 decodes the scheme as: |[ URI = scheme ":" hier-part "#" fragment ]| Common schemes include file, https, svn+ssh, etc.

Link copied to clipboard
fun uriResolveRelative(baseUriString: String? = null, uriRef: String, flags: UriFlags): <Error class: unknown class><String>

Parses @uri_ref according to @flags and, if it is a #relative-and-absolute-uris, resolves it relative to

Link copied to clipboard
fun uriUnescapeBytes(escapedString: String, length: Long, illegalCharacters: String? = null): <Error class: unknown class><Bytes>

Unescapes a segment of an escaped string as binary data.

Link copied to clipboard
fun uriUnescapeSegment(escapedString: String? = null, escapedStringEnd: String? = null, illegalCharacters: String? = null): String?

Unescapes a segment of an escaped string.

Link copied to clipboard
fun uriUnescapeString(escapedString: String, illegalCharacters: String? = null): String?

Unescapes a whole escaped string.

Link copied to clipboard
fun usleep(microseconds: <Error class: unknown class>)

Pauses the current thread for the given number of microseconds.

Link copied to clipboard

Parses the string @str and verify if it is a UUID.

Link copied to clipboard

Generates a random UUID (RFC 4122 version 4) as a string. It has the same randomness guarantees as #GRand, so must not be used for cryptographic purposes such as key generation, nonces, salts or one-time pads.

Link copied to clipboard

Determines if a given string is a valid D-Bus object path. You should ensure that a string is a valid D-Bus object path before passing it to g_variant_new_object_path().

Link copied to clipboard

Determines if a given string is a valid D-Bus type signature. You should ensure that a string is a valid D-Bus type signature before passing it to g_variant_new_signature().

Link copied to clipboard

Pretty-prints a message showing the context of a #GVariant parse error within the string for which parsing was attempted.

Link copied to clipboard
fun variantParseErrorQuark(): <Error class: unknown class>
Link copied to clipboard
fun variantParserGetErrorQuark(): <Error class: unknown class>

Same as g_variant_error_quark().

Link copied to clipboard
Link copied to clipboard
fun variantTypeStringGetDepth(typeString: String): <Error class: unknown class>
Link copied to clipboard

Checks if @type_string is a valid GVariant type string. This call is equivalent to calling g_variant_type_string_scan() and confirming that the following character is a nul terminator.