Glib
Skipped during bindings generation
function
aligned_alloc
: Return type gpointer is unsupportedfunction
aligned_alloc0
: Return type gpointer is unsupportedparameter
mem
: gpointerparameter
mem
: gpointerfunction
ascii_digit_value
: C function g_ascii_digit_value is ignoredfunction
ascii_dtostr
: C function g_ascii_dtostr is ignoredfunction
ascii_formatd
: C function g_ascii_formatd is ignoredfunction
ascii_strcasecmp
: C function g_ascii_strcasecmp is ignoredfunction
ascii_strdown
: C function g_ascii_strdown is ignoredfunction
ascii_string_to_signed
: C function g_ascii_string_to_signed is ignoredfunction
ascii_string_to_unsigned
: C function g_ascii_string_to_unsigned is ignoredfunction
ascii_strncasecmp
: C function g_ascii_strncasecmp is ignoredfunction
ascii_strtod
: C function g_ascii_strtod is ignoredfunction
ascii_strtoll
: C function g_ascii_strtoll is ignoredfunction
ascii_strtoull
: C function g_ascii_strtoull is ignoredfunction
ascii_strup
: C function g_ascii_strup is ignoredfunction
ascii_tolower
: C function g_ascii_tolower is ignoredfunction
ascii_toupper
: C function g_ascii_toupper is ignoredfunction
ascii_xdigit_value
: C function g_ascii_xdigit_value is ignoredparameter
arg1
: Unsupported string with cType const char* const*function
async_queue_new
: Return type AsyncQueue is unsupportedparameter
item_free_func
: DestroyNotifyparameter
func
: VoidFuncparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: Unsupported pointer to primitive typeparameter
atomic
: gpointerparameter
atomic
: gpointerparameter
atomic
: gpointerparameter
atomic
: gpointerparameter
atomic
: gpointerparameter
atomic
: gpointerparameter
atomic
: gpointerparameter
atomic
: gpointerparameter
atomic
: gpointerparameter
mem_block
: gpointerfunction
atomic_rc_box_alloc
: Return type gpointer is unsupportedfunction
atomic_rc_box_alloc0
: Return type gpointer is unsupportedparameter
mem_block
: gpointerparameter
mem_block
: gpointerparameter
mem_block
: gpointerparameter
mem_block
: gpointerparameter
arc
: Unsupported pointer to primitive typeparameter
arc
: Unsupported pointer to primitive typeparameter
arc
: Unsupported pointer to primitive typeparameter
arc
: Unsupported pointer to primitive typeparameter
out_len
: out_len: Out parameter is not supportedfunction
base64_decode_inplace
: In/Out parameter is not supportedparameter
data
: Array parameter of type guint8 is not supportedfunction
base64_encode_close
: In/Out parameter is not supportedfunction
base64_encode_step
: In/Out parameter is not supportedparameter
address
: Unsupported pointer to primitive typeparameter
address
: Unsupported pointer to primitive typeparameter
address
: Unsupported pointer to primitive typeparameter
array
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedfunction
byte_array_new
: Array parameter of type guint8 is not supportedparameter
data
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedfunction
byte_array_sized_new
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedparameter
array
: Array parameter of type guint8 is not supportedparameter
pid
: Pidparameter
pid
: Pidfunction
chmod
: C function g_chmod is ignoredparameter
data
: Array parameter of type guint8 is not supportedparameter
key
: Array parameter of type guint8 is not supportedparameter
key
: Array parameter of type guint8 is not supportedparameter
str
: Array parameter of type guint8 is not supportedparameter
str
: Array parameter of type guint8 is not supportedfunction
creat
: C function g_creat is ignoredparameter
datalist
: Dataparameter
datalist
: Dataparameter
datalist
: Dataparameter
datalist
: Dataparameter
datalist
: Dataparameter
datalist
: Dataparameter
datalist
: Dataparameter
dataset_location
: gpointerparameter
dataset_location
: gpointerparameter
dataset_location
: gpointerparameter
year
: DateYearparameter
year
: DateYearparameter
year
: DateYearparameter
year
: DateYearfunction
date_strftime
: C function g_date_strftime is ignoredparameter
day
: DateDayparameter
day
: DateDayparameter
year
: DateYearparameter
v1
: gpointerparameter
v
: gpointerparameter
v1
: gpointerparameter
v
: gpointerparameter
error_type_init
: ErrorInitFuncparameter
error_type_init
: ErrorInitFuncparameter
contents
: contents: Out parameter is not supportedparameter
name_used
: name_used: Out parameter is not supportedparameter
contents
: Array parameter of type guint8 is not supportedparameter
contents
: Array parameter of type guint8 is not supportedparameter
hostname
: hostname: Out parameter is not supportedparameter
bytes_read
: bytes_read: Out parameter is not supportedparameter
bytes_read
: bytes_read: Out parameter is not supportedfunction
fopen
: Return type gpointer is unsupportedparameter
mem
: gpointerparameter
mem
: gpointerparameter
stream
: gpointerfunction
fsync
: C function g_fsync is ignoredparameter
charset
: charset: Out parameter is not supportedparameter
charset
: charset: Out parameter is not supportedparameter
filename_charsets
: filename_charsets: Out parameter is not supportedparameter
key
: gpointerparameter
key
: gpointerfunction
hash_table_find
: Return type gpointer is unsupportedparameter
key
: gpointerparameter
key
: gpointerparameter
lookup_key
: gpointerparameter
key
: gpointerparameter
key
: gpointerparameter
key
: gpointerparameter
lookup_key
: gpointerparameter
func
: HookCompareFuncparameter
data
: gpointerparameter
v1
: gpointerparameter
v
: gpointerparameter
v1
: gpointerparameter
v
: gpointerparameter
condition
: C Type GIOCondition is ignoredparameter
condition
: C Type GIOCondition is ignoredparameter
allocator
: Allocatorparameter
bytes_read
: bytes_read: Out parameter is not supportedparameter
opsysstring
: Array parameter of type guint8 is not supportedparameter
unused_data
: gpointerparameter
fields
: LogFieldparameter
fields
: LogFieldparameter
domains
: Unsupported string with cType const gchar* const*parameter
fields
: LogFieldparameter
fields
: LogFieldparameter
fields
: LogFieldparameter
fields
: LogFieldparameter
buf
: StatBuffunction
malloc
: Return type gpointer is unsupportedfunction
malloc0
: Return type gpointer is unsupportedfunction
malloc0_n
: Return type gpointer is unsupportedfunction
malloc_n
: Return type gpointer is unsupportedparameter
mem
: gpointerparameter
mem
: gpointerfunction
mkdir
: C function g_mkdir is ignoredparameter
allocator
: Allocatorparameter
nullify_location
: gpointerfunction
once_init_enter
: In/Out parameter is not supportedparameter
location
: Unsupported pointer to primitive typeparameter
location
: gpointerfunction
once_init_leave
: In/Out parameter is not supportedparameter
location
: gpointerfunction
open
: C function g_open is ignoredparameter
keys
: DebugKeyparameter
v1
: gpointerparameter
address
: gpointerparameter
address
: gpointerparameter
ptr
: gpointerparameter
address
: gpointerparameter
address
: gpointerparameter
address
: gpointerfunction
prefix_error_literal
: C function g_prefix_error_literal is ignoredparameter
dest
: dest: Out parameter is not supportedparameter
pbase
: gpointerfunction
quark_to_string
: C function g_quark_to_string is ignoredparameter
mem_block
: gpointerfunction
rc_box_alloc
: Return type gpointer is unsupportedfunction
rc_box_alloc0
: Return type gpointer is unsupportedparameter
mem_block
: gpointerparameter
mem_block
: gpointerparameter
mem_block
: gpointerparameter
mem_block
: gpointerparameter
mem
: gpointerparameter
mem
: gpointerparameter
rc
: Unsupported pointer to primitive typeparameter
rc
: Unsupported pointer to primitive typeparameter
rc
: Unsupported pointer to primitive typeparameter
rc
: Unsupported pointer to primitive typeparameter
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 supportedfunction
remove
: C function g_remove is ignoredfunction
rename
: C function g_rename is ignoredparameter
begin
: SequenceIterparameter
iter
: SequenceIterparameter
iter
: SequenceIterparameter
src
: SequenceIterparameter
dest
: SequenceIterparameter
begin
: SequenceIterparameter
iter
: SequenceIterparameter
begin
: SequenceIterparameter
iter
: SequenceIterparameter
iter
: SequenceIterparameter
iter
: SequenceIterparameter
a
: SequenceIterparameter
err
: err: Out parameter is not supportedfunction
set_prgname_once
: C function g_set_prgname_once is ignoredparameter
argcp
: argcp: Out parameter is not supportedfunction
slice_alloc
: Return type gpointer is unsupportedfunction
slice_alloc0
: Return type gpointer is unsupportedparameter
mem_block
: gpointerparameter
mem_block
: gpointerparameter
mem_chain
: gpointerparameter
n_values
: Unsupported pointer to primitive typeparameter
allocator
: Allocatorparameter
user_data
: gpointerparameter
user_data
: gpointerparameter
child_pid
: child_pid: Out parameter is not supportedparameter
child_pid
: child_pid: Out parameter is not supportedparameter
child_pid
: child_pid: Out parameter is not supportedparameter
source_fds
: Array parameter of type gint is not supportedparameter
pid
: Pidparameter
standard_output
: standard_output: Out parameter is not supportedparameter
standard_output
: standard_output: Out parameter is not supportedparameter
buf
: StatBuffunction
stpcpy
: C function g_stpcpy is ignoredfunction
str_equal
: C function g_str_equal is ignoredfunction
str_has_prefix
: C function g_str_has_prefix is ignoredfunction
str_has_suffix
: C function g_str_has_suffix is ignoredfunction
str_hash
: C function g_str_hash is ignoredfunction
str_is_ascii
: C function g_str_is_ascii is ignoredfunction
str_match_string
: C function g_str_match_string is ignoredfunction
str_to_ascii
: C function g_str_to_ascii is ignoredfunction
str_tokenize_and_fold
: C function g_str_tokenize_and_fold is ignoredfunction
strcanon
: C function g_strcanon is ignoredfunction
strcasecmp
: C function g_strcasecmp is ignoredfunction
strchomp
: C function g_strchomp is ignoredfunction
strchug
: C function g_strchug is ignoredfunction
strcmp0
: C function g_strcmp0 is ignoredfunction
strcompress
: C function g_strcompress is ignoredfunction
strdelimit
: C function g_strdelimit is ignoredfunction
strdown
: C function g_strdown is ignoredfunction
strdup
: C function g_strdup is ignoredfunction
strdupv
: C function g_strdupv is ignoredfunction
strerror
: C function g_strerror is ignoredfunction
strescape
: C function g_strescape is ignoredfunction
strfreev
: C function g_strfreev is ignoredfunction
strip_context
: C function g_strip_context is ignoredfunction
strjoinv
: C function g_strjoinv is ignoredfunction
strlcat
: C function g_strlcat is ignoredfunction
strlcpy
: C function g_strlcpy is ignoredfunction
strncasecmp
: C function g_strncasecmp is ignoredfunction
strndup
: C function g_strndup is ignoredfunction
strnfill
: C function g_strnfill is ignoredfunction
strreverse
: C function g_strreverse is ignoredfunction
strrstr
: C function g_strrstr is ignoredfunction
strrstr_len
: C function g_strrstr_len is ignoredfunction
strsignal
: C function g_strsignal is ignoredfunction
strsplit
: C function g_strsplit is ignoredfunction
strsplit_set
: C function g_strsplit_set is ignoredfunction
strstr_len
: C function g_strstr_len is ignoredfunction
strtod
: C function g_strtod is ignoredfunction
strup
: C function g_strup is ignoredfunction
strv_contains
: C function g_strv_contains is ignoredfunction
strv_equal
: C function g_strv_equal is ignoredfunction
strv_get_type
: C function g_strv_get_type is ignoredfunction
strv_length
: C function g_strv_length is ignoredparameter
test_data
: gpointerparameter
test_data
: gpointerparameter
test_func
: TestFuncparameter
destroy_func
: DestroyNotifyparameter
gfree_pointer
: gpointerparameter
suite
: TestSuiteparameter
retval
: gpointerfunction
trash_stack_height
: C function g_trash_stack_height is ignoredfunction
trash_stack_peek
: Return type gpointer is unsupportedfunction
trash_stack_pop
: Return type gpointer is unsupportedparameter
data_p
: gpointerfunction
try_malloc
: Return type gpointer is unsupportedfunction
try_malloc0
: Return type gpointer is unsupportedfunction
try_malloc0_n
: Return type gpointer is unsupportedfunction
try_malloc_n
: Return type gpointer is unsupportedparameter
mem
: gpointerparameter
mem
: gpointerparameter
str
: Array parameter of type gunichar is not supportedparameter
str
: Array parameter of type gunichar is not supportedparameter
ch
: ch: Out parameter is not supportedparameter
a
: a: Out parameter is not supportedparameter
result
: result: Out parameter is not supportedparameter
mirrored_ch
: mirrored_ch: Out parameter is not supportedparameter
outbuf
: outbuf: Out parameter is not supportedparameter
result_len
: Unsupported pointer to primitive typeparameter
string
: Array parameter of type gunichar is not supportedparameter
condition
: C Type GIOCondition is ignoredparameter
condition
: C Type GIOCondition is ignoredfunction
unix_get_passwd_entry
: Return type gpointer is unsupportedparameter
fds
: Array parameter of type gint is not supportedparameter
unescaped
: Array parameter of type guint8 is not supportedparameter
scheme
: scheme: Out parameter is not supportedparameter
scheme
: scheme: Out parameter is not supportedparameter
scheme
: scheme: Out parameter is not supportedparameter
str
: Array parameter of type guint16 is not supportedparameter
str
: Array parameter of type guint16 is not supportedfunction
utf8_casefold
: C function g_utf8_casefold is ignoredfunction
utf8_collate
: C function g_utf8_collate is ignoredfunction
utf8_collate_key
: C function g_utf8_collate_key is ignoredfunction
utf8_collate_key_for_filename
: C function g_utf8_collate_key_for_filename is ignoredfunction
utf8_find_next_char
: C function g_utf8_find_next_char is ignoredfunction
utf8_find_prev_char
: C function g_utf8_find_prev_char is ignoredfunction
utf8_get_char
: C function g_utf8_get_char is ignoredfunction
utf8_get_char_validated
: C function g_utf8_get_char_validated is ignoredfunction
utf8_make_valid
: C function g_utf8_make_valid is ignoredfunction
utf8_normalize
: C function g_utf8_normalize is ignoredfunction
utf8_offset_to_pointer
: C function g_utf8_offset_to_pointer is ignoredfunction
utf8_pointer_to_offset
: C function g_utf8_pointer_to_offset is ignoredfunction
utf8_prev_char
: C function g_utf8_prev_char is ignoredfunction
utf8_strchr
: C function g_utf8_strchr is ignoredfunction
utf8_strdown
: C function g_utf8_strdown is ignoredfunction
utf8_strlen
: C function g_utf8_strlen is ignoredfunction
utf8_strncpy
: C function g_utf8_strncpy is ignoredfunction
utf8_strrchr
: C function g_utf8_strrchr is ignoredfunction
utf8_strreverse
: C function g_utf8_strreverse is ignoredfunction
utf8_strup
: C function g_utf8_strup is ignoredfunction
utf8_substring
: C function g_utf8_substring is ignoredfunction
utf8_to_ucs4
: C function g_utf8_to_ucs4 is ignoredfunction
utf8_to_ucs4_fast
: C function g_utf8_to_ucs4_fast is ignoredfunction
utf8_to_utf16
: C function g_utf8_to_utf16 is ignoredfunction
utf8_truncate_middle
: C function g_utf8_truncate_middle is ignoredfunction
utf8_validate
: C function g_utf8_validate is ignoredfunction
utf8_validate_len
: C function g_utf8_validate_len is ignoredparameter
utb
: gpointerfunction
variant_get_gtype
: C function g_variant_get_gtype is ignoredparameter
endptr
: Unsupported string with cType const gchar**parameter
endptr
: endptr: Out parameter is not supportedcallback
CacheDupFunc
: Return type gpointer is unsupportedcallback
CacheNewFunc
: Return type gpointer is unsupportedcallback
CompletionFunc
: Callback with String return value is not supportedcallback
CopyFunc
: Return type gpointer is unsupportedcallback
DuplicateFunc
: Return type gpointer is unsupportedcallback
OptionArgFunc
: Callbacks that throw are not supportedcallback
OptionErrorFunc
: Callbacks that throw are not supportedcallback
OptionParseFunc
: Callbacks that throw are not supportedcallback
ThreadFunc
: Return type gpointer is unsupportedcallback
TranslateFunc
: Callback with String return value is not supportedbitfield
IOCondition
: C Type GIOCondition is ignoredrecord
Allocator
: Disguised records are ignoredrecord
AsyncQueue
: Disguised records are ignoredrecord
Cache
: Disguised records are ignoredrecord
Data
: Disguised records are ignoredrecord
MemChunk
: Disguised records are ignoredrecord
OptionContext
: Disguised records are ignoredrecord
Relation
: Disguised records are ignoredrecord
Sequence
: Disguised records are ignoredrecord
SequenceIter
: Disguised records are ignoredrecord
SourcePrivate
: Disguised records are ignoredrecord
StatBuf
: Disguised records are ignoredrecord
StringChunk
: Disguised records are ignoredrecord
TestCase
: Disguised records are ignoredrecord
TestSuite
: Disguised records are ignoredrecord
Timer
: Disguised records are ignoredrecord
TreeNode
: Disguised records are ignored
Properties
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.
Evaluates to the initial reference count for gatomicrefcount
.
Specifies one of the possible types of byte order. See %G_BYTE_ORDER.
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.
The set of uppercase ASCII alphabet characters. Used for specifying valid identifier characters in #GScannerConfig.
The set of lowercase ASCII alphabet characters. Used for specifying valid identifier characters in #GScannerConfig.
The set of ASCII digits. Used for specifying valid identifier characters in #GScannerConfig.
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.
Represents an invalid #GDateDay.
Represents an invalid Julian day number.
Represents an invalid year.
The directory separator character. This is '/' on UNIX machines and '\' under Windows.
The directory separator as a string. This is "/" on UNIX machines and "\" under Windows.
Expands to "" on all modern compilers, and to FUNCTION on gcc version 2.x. Don't use it.
Expands to "" on all modern compilers, and to PRETTY_FUNCTION on gcc version 2.x. Don't use it.
Defined to 1 if gcc-style visibility handling is supported.
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.
The bias by which exponents in double-precision floats are offset.
The bias by which exponents in single-precision floats are offset.
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.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string list giving the available application actions.
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.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the tooltip for the desktop entry.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean set to true if the application is D-Bus activatable.
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.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the generic name of the desktop entry.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the desktop entry has been deleted by the user.
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.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings giving the MIME types supported by this desktop entry.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized string giving the specific name of the desktop entry.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the desktop entry should be shown in menus.
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.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of strings identifying the environments that should display the desktop entry.
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.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the application supports the Startup Notification Protocol Specification.
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.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean stating whether the program should be run in a terminal window.
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.
A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string giving the type of the desktop entry.
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.
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.
The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing applications.
The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing directories.
The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop entries representing links to documents.
Specifies one of the possible types of byte order. See %G_BYTE_ORDER.
Multiplying the base 2 exponent by this number yields the base 10 exponent.
Defines the log domain. See #log-domains.
GLib log levels that are considered fatal by default.
Log levels below 1<<G_LOG_LEVEL_USER_SHIFT
are used by GLib. Higher bits can be used for user-defined log levels.
The major version number of the GLib library.
The micro version number of the GLib library.
The minor version number of the GLib library.
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.
Specifies one of the possible types of byte order (currently unused). See %G_BYTE_ORDER.
A format specifier that can be used in printf()-style format strings when printing a #GPid.
A format specifier that can be used in printf()-style format strings when printing the @fd member of a #GPollFD.
Use this for default priority event sources.
Use this for default priority idle functions.
Use this for high priority event sources.
Use this for high priority idle functions.
Use this for very low priority background tasks.
Evaluates to the initial reference count for grefcount
.
The search path separator character. This is ':' on UNIX machines and ';' under Windows.
The search path separator as a string. This is ":" on UNIX machines and ";" under Windows.
Use this macro as the return value of a callback@GLib.SourceFunc to leave the struct@GLib.Source in the main loop.
Use this macro as the return value of a callback@GLib.SourceFunc to remove the struct@GLib.Source from the main loop.
The standard delimiters, used in func@GLib.strdelimit.
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.
Evaluates to a time span of one day.
Evaluates to a time span of one hour.
Evaluates to a time span of one millisecond.
Evaluates to a time span of one minute.
Evaluates to a time span of one second.
The maximum length (in codepoints) of a compatibility or canonical decomposition of a single Unicode character.
Generic delimiters characters as defined in RFC 3986. Includes :/?#[]@
.
Subcomponent delimiter characters as defined in RFC 3986. Includes !$&'()*+,;=
.
Number of microseconds in one second (1 million). This macro is provided for code readability.
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,...
Functions
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.
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.
Gets the number of bits used to hold @number, e.g. if @number is 4, 3 bits are needed.
Creates a filename from a vector of elements using the correct separator for the current platform.
Behaves exactly like g_build_path(), but takes the path elements as a string array, instead of variadic arguments.
Gets the canonical file name from @filename. All triple slashes are turned into single slashes, and all ..
and .
s resolved against @relative_to.
Gets the length in bytes of digests of type @checksum_type
Checks that the GLib library in use is compatible with the given version.
If @err or *@err is null, does nothing. Otherwise, calls g_error_free() on *@err and sets *@err to null.
Computes the checksum for a binary @data. This is a convenience wrapper for g_checksum_new(), g_checksum_get_string() and g_checksum_free().
Computes the checksum of a 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().
Returns true if the Julian day is valid. Anything greater than zero is basically a valid Julian, though there is a 32-bit limit.
Returns true if the month value is valid. The 12 #GDateMonth enumeration values are the only valid months.
Returns true if the weekday is valid. The seven #GDateWeekday enumeration values are the only valid weekdays.
Creates a subdirectory in the preferred directory for temporary files (as returned by g_get_tmp_dir()).
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.
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.
Returns the value of the environment variable @variable in the provided list @envp.
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.
Gets a #GFileError constant based on the passed-in @err_no.
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.
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.
Converts an absolute filename to an escaped ASCII-encoded URI, with the path component following Section 3.3. of RFC 2396.
Reads the contents of the symbolic link @filename like the POSIX readlink()
function.
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.
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
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.
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".
Formats a size.
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).
Gets the character set for the current locale.
Gets the current directory.
Equivalent to the UNIX gettimeofday() function, but portable.
Gets the list of environment variables for the current process.
Gets the current user's home directory.
Return a name for the machine.
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".
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".
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.
Queries the system monotonic time.
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.
Gets the name of the program. This name should not be localized, in contrast to g_get_application_name().
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.
Queries the system wall-clock time.
Returns an ordered list of base directories in which to access system-wide configuration information.
Returns an ordered list of base directories in which to access system-wide application data.
Returns a base directory in which to store non-essential, cached data specific to particular user.
Returns a base directory in which to store user-specific application configuration information such as user preferences and settings.
Returns a base directory in which to access application data such as icons that is customized for a particular user.
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.
Returns a directory that is unique to the current user on the local system.
Returns the full path of a special directory using its logical id.
Returns a base directory in which to store state files specific to particular user.
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.
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().
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.
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.
Creates a new #GHashTable like g_hash_table_new_full() with a reference count of 1.
Atomically increments the reference count of @hash_table by one. This function is MT-safe and may be called from any thread.
Removes all keys and their associated values from a #GHashTable.
Returns the number of elements contained in the #GHashTable.
Removes all keys and their associated values from a #GHashTable without calling the key and value destroy functions.
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.
Destroys a #GHook, given its ID.
Removes one #GHook from a #GHookList, marking it inactive and calling g_hook_unref() on it.
Inserts a #GHook into a #GHookList, before a given #GHook.
Prepends a #GHook on the start of a #GHookList.
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.
Tests if @hostname is the string form of an IPv4 or IPv6 address. (Eg, "192.168.0.1".)
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.
Converts @hostname to its canonical ASCII form; an ASCII-only string containing no uppercase letters and not ending with a trailing dot.
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.
Adds a function to be called whenever there are no higher priority events pending.
Creates a new idle source.
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.
Returns a canonical representation for @string. Interned strings can be compared for equality by comparing the pointers, instead of using strcmp().
Converts an errno
error number to a #GIOChannelError.
Return whether debug output from the GLib logging system is enabled.
Removes the log handler.
Sets the message levels which are always fatal, in any log domain.
Enable or disable debug output from the GLib logging system for all domains.
Sets the log levels which are fatal in the given domain.
Like func@GLib.log_set_handler, but takes a destroy notify for the @user_data.
Set a writer function which will be called to format and write out each log message.
Log a message with structured data, accepting the data within a type@GLib.Variant.
Configure whether the built-in log functions will output all log messages to stderr
.
Check whether func@GLib.log_writer_default and func@GLib.log_default_handler would ignore a message with the given domain and level.
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
).
Check whether the given @output_fd file descriptor supports ANSI color escape sequences.
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.
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.)
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.
Returns the currently firing source for this thread.
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.
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.
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.
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.
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.
Create a directory if it doesn't already exist. Create intermediate parent directories as needed, too.
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.
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().
Gets the last component of the filename.
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 /
.
Returns true if the given @file_name is an absolute file name. Note that this is a somewhat vague concept on Windows.
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.
Matches a string against a pattern given as a string.
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.
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.
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.
Gets the #GQuark associated with the given string, or 0 if string is null or it has no associated #GQuark.
Returns a random #gdouble equally distributed over the range [0..1).
Returns a random #gdouble equally distributed over the range [@begin..@end).
Returns a random #gint32 equally distributed over the range @begin..@end-1.
Sets the seed for the global random number generator, which is used by the g_random_* functions, to @seed.
Creates a new reference counted string and copies the contents of @str into it.
Creates a new reference counted string and copies the content of @str into it.
Creates a new reference counted string and copies the contents of @str into it, up to @len bytes.
Escapes the nul characters in @string to "\x00". It can be used to compile a regex with embedded nul characters.
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.
Scans for a match in @string for @pattern.
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.
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.
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.
Sets the name of the program. This name should not be localized, in contrast to g_set_application_name().
Quotes a string so that the shell (/bin/sh) will interpret the quoted string to mean @unquoted_string.
Unquotes a string as the shell (/bin/sh) would.
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.
Sets the name of a source using its ID.
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.
An old name for g_spawn_check_wait_status(), deprecated because its name is misleading.
Set @error if @wait_status indicates the child exited abnormally (e.g. with a nonzero exit code, or via a fatal signal).
A simple version of g_spawn_async() that parses a command line with g_shell_parse_argv() and passes it to g_spawn_async().
Specify the base URI for bug reports.
Attempt to disable system crash reporting infrastructure.
Indicates that a message with the given @log_domain and @log_level, with text matching @pattern, is expected to be logged.
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.
Gets the pathname of the directory containing test files of the type specified by @file_type.
Gets the test path for the test currently being run.
Indicates that a test failed because of some incomplete functionality. This function can be called multiple times from the same test.
Get a reproducible random floating point number, see g_test_rand_int() for details on test case random numbers.
Get a reproducible random floating pointer number out of a specified range, see g_test_rand_int() for details on test case random numbers.
Get a reproducible random integer number.
Get a reproducible random integer number out of a specified range, see g_test_rand_int() for details on test case random numbers.
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.
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.)
Returns true (after g_test_init() has been called) if the test program is running under g_test_trap_subprocess().
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.
Get the number of seconds since the last start of the timer with g_test_timer_start().
Report the last result of g_test_timer_elapsed().
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.
Fork the current test program to execute a test case that might not return or that might abort.
Check the result of the last g_test_trap_subprocess() call.
Check the result of the last g_test_trap_subprocess() call.
Respawns the test program to run only @test_path in a subprocess.
Respawns the test program to run only @test_path in a subprocess with the given @envp environment.
This function will return the maximum @interval that a thread will wait in the thread pool for new tasks before being stopped.
Returns the maximal allowed number of unused threads.
Returns the number of currently unused threads.
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.
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.
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().
This function returns the #GThread corresponding to the current thread. Note that this function does not increase the reference count of the returned struct.
Causes the calling thread to voluntarily relinquish the CPU, so that other threads can run.
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.
Sets a function to be called at regular intervals, with @priority.
Creates a new timeout source.
Creates a new timeout source.
Converts a string containing an ISO 8601 encoded date and time to a #GTimeVal and puts it into @time_.
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.
Determines the canonical combining class of a Unicode character.
Determines the numeric value of a character as a decimal digit.
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.
Determines whether a character is alphanumeric. Given some UTF-8 text, obtain a character value with g_utf8_get_char().
Determines whether a character is alphabetic (i.e. a letter). Given some UTF-8 text, obtain a character value with g_utf8_get_char().
Determines whether a character is a control character. Given some UTF-8 text, obtain a character value with g_utf8_get_char().
Determines if a given character is assigned in the Unicode standard.
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().
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().
Determines whether a character is a lowercase letter. Given some UTF-8 text, obtain a character value with g_utf8_get_char().
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().
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().
Determines whether a character is punctuation or a symbol. Given some UTF-8 text, obtain a character value with g_utf8_get_char().
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().
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.
Determines if a character is uppercase.
Determines if a character is typically rendered in a double-width cell.
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.
Determines if a character is a hexadecimal digit.
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.
Converts a character to lower case.
Converts a character to the titlecase.
Converts a character to uppercase.
Classifies a Unicode character by type.
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.
Determines the numeric value of a character as a hexadecimal digit.
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).
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).
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.
A convenience function for g_unix_signal_source_new(), which attaches to the default #GMainContext. You can remove the watch using g_source_remove().
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.
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.
Escapes a string for use in a URI.
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().
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).
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).
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.
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.
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.
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.
Parses @uri_ref according to @flags and, if it is a #relative-and-absolute-uris, resolves it relative to
Unescapes a segment of an escaped string as binary data.
Unescapes a segment of an escaped string.
Unescapes a whole escaped string.
Parses the string @str and verify if it is a UUID.
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.
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().
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().
Pretty-prints a message showing the context of a #GVariant parse error within the string for which parsing was attempted.
Same as g_variant_error_quark().
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.