Flags to be used to control the #GBinding Since: 2.26 The #GObject that should be used as the source of the binding Since: 2.26 The name of the property of #GBinding:source that should be used as the source of the binding Since: 2.26 The #GObject that should be used as the target of the binding Since: 2.26 The name of the property of #GBinding:target that should be used as the target of the binding Since: 2.26 Flags to be passed to g_object_bind_property() or g_object_bind_property_full(). This enumeration can be extended at later date. Since: 2.26 The default binding; if the source property changes, the target property is updated with its value. Bidirectional binding; if either the property of the source or the property of the target changes, the other is updated. Synchronize the values of the source and target properties when creating the binding; the direction of the synchronization is always from the source to the target. If the two properties being bound are booleans, setting one to %TRUE will result in the other being set to %FALSE and vice versa. This flag will only work for boolean properties, and cannot be used when passing custom transformation functions to g_object_bind_property_full(). Error codes returned by bookmark file parsing. URI was ill-formed a requested field was not found a requested application did not register a bookmark a requested URI was not found document was ill formed the text being parsed was in an unknown encoding an error occurred while writing requested file was not found The hashing algorithm to be used by #GChecksum when performing the digest of some data. Note that the #GChecksumType enumeration may be extended at a later date to include new hashing algorithm types. Since: 2.16 Use the MD5 hashing algorithm Use the SHA-1 hashing algorithm Use the SHA-256 hashing algorithm Use the SHA-512 hashing algorithm The connection flags are used to specify the behaviour of a signal's connection. whether the handler should be called before or after the default handler of the signal. whether the instance and data should be swapped when calling the handler; see g_signal_connect_swapped() for an example. Error codes returned by character set conversion routines. Conversion between the requested character sets is not supported. Invalid byte sequence in conversion input. Conversion failed for some reason. Partial character sequence at end of input. URI is invalid. Pathname is not an absolute path. No memory available. Since: 2.40 This enumeration isn't used in the API, but may be useful if you need to mark a number as a day, month, or year. a day a month a year Enumeration representing a month; values are #G_DATE_JANUARY, #G_DATE_FEBRUARY, etc. #G_DATE_BAD_MONTH is the invalid value. invalid value January February March April May June July August September October November December Enumeration representing a day of the week; #G_DATE_MONDAY, #G_DATE_TUESDAY, etc. #G_DATE_BAD_WEEKDAY is an invalid weekday. invalid value Monday Tuesday Wednesday Thursday Friday Saturday Sunday The possible errors, used in the @v_error field of #GTokenValue, when the token is a %G_TOKEN_ERROR. unknown error unexpected end of file unterminated string constant unterminated comment non-digit character in a number digit beyond radix in a number non-decimal floating point number malformed floating point number Values corresponding to @errno codes returned from file operations on UNIX. Unlike @errno codes, GFileError values are available on all systems, even Windows. The exact meaning of each code depends on what sort of file operation you were performing; the UNIX documentation gives more details. The following error code descriptions come from the GNU C Library manual, and are under the copyright of that manual. It's not very portable to make detailed assumptions about exactly which errors will be returned from a given operation. Some errors don't occur on some systems, etc., sometimes there are subtle differences in when a system will report a given error, etc. Operation not permitted; only the owner of the file (or other resource) or processes with special privileges can perform the operation. File is a directory; you cannot open a directory for writing, or create or remove hard links to it. Permission denied; the file permissions do not allow the attempted operation. Filename too long. No such file or directory. This is a "file doesn't exist" error for ordinary files that are referenced in contexts where they are expected to already exist. A file that isn't a directory was specified when a directory is required. No such device or address. The system tried to use the device represented by a file you specified, and it couldn't find the device. This can mean that the device file was installed incorrectly, or that the physical device is missing or not correctly attached to the computer. The underlying file system of the specified file does not support memory mapping. The directory containing the new link can't be modified because it's on a read-only file system. Text file busy. You passed in a pointer to bad memory. (GLib won't reliably return this, don't pass in pointers to bad memory.) Too many levels of symbolic links were encountered in looking up a file name. This often indicates a cycle of symbolic links. No space left on device; write operation on a file failed because the disk is full. No memory available. The system cannot allocate more virtual memory because its capacity is full. The current process has too many files open and can't open any more. Duplicate descriptors do count toward this limit. There are too many distinct file openings in the entire system. Bad file descriptor; for example, I/O on a descriptor that has been closed or reading from a descriptor open only for writing (or vice versa). Invalid argument. This is used to indicate various kinds of problems with passing the wrong argument to a library function. Broken pipe; there is no process reading from the other end of a pipe. Every library function that returns this error code also generates a 'SIGPIPE' signal; this signal terminates the program if not handled or blocked. Thus, your program will never actually see this code unless it has handled or blocked 'SIGPIPE'. Resource temporarily unavailable; the call might work if you try again later. Interrupted function call; an asynchronous signal occurred and prevented completion of the call. When this happens, you should try the call again. Input/output error; usually used for physical read or write errors. i.e. the disk or other physical device hardware is returning errors. Operation not permitted; only the owner of the file (or other resource) or processes with special privileges can perform the operation. Function not implemented; this indicates that the system is missing some functionality. Does not correspond to a UNIX error code; this is the standard "failed for unspecified reason" error code present in all #GError error code enumerations. Returned if no specific code applies. A test to perform on a file using g_file_test(). %TRUE if the file is a regular file (not a directory). Note that this test will also return %TRUE if the tested file is a symlink to a regular file. %TRUE if the file is a symlink. %TRUE if the file is a directory. %TRUE if the file is executable. %TRUE if the file exists. It may or may not be a regular file. Flags to modify the format of the string returned by g_format_size_full(). behave the same as g_format_size() include the exact number of bytes as part of the returned string. For example, "45.6 kB (45,612 bytes)". use IEC (base 1024) units with "KiB"-style suffixes. IEC units should only be used for reporting things with a strong "power of 2" basis, like RAM sizes or RAID stripe sizes. Network and storage sizes should be reported in the normal SI units. Flags used internally in the #GHook implementation. set if the hook has not been destroyed set if the hook is currently being run A mask covering all bits reserved for hook flags; see %G_HOOK_FLAG_USER_SHIFT Error codes returned by #GIOChannel operations. File too large. Invalid argument. IO error. File is a directory. No space left on device. No such device or address. Value too large for defined datatype. Broken pipe. Some other error. A bitwise combination representing a condition to watch for on an event source. There is data to read. Data can be written (without blocking). There is urgent data to read. Error condition. Hung up (the connection has been broken, usually for pipes and sockets). Invalid request. The file descriptor is not open. #GIOError is only used by the deprecated functions g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek(). no error an EAGAIN error occurred an EINVAL error occurred another error occurred Specifies properties of a #GIOChannel. Some of the flags can only be read with g_io_channel_get_flags(), but not changed with g_io_channel_set_flags(). turns on append mode, corresponds to %O_APPEND (see the documentation of the UNIX open() syscall) turns on nonblocking mode, corresponds to %O_NONBLOCK/%O_NDELAY (see the documentation of the UNIX open() syscall) indicates that the io channel is readable. This flag cannot be changed. indicates that the io channel is writable. This flag cannot be changed. a misspelled version of @G_IO_FLAG_IS_WRITABLE that existed before the spelling was fixed in GLib 2.30. It is kept here for compatibility reasons. Deprecated since 2.30 indicates that the io channel is seekable, i.e. that g_io_channel_seek_position() can be used on it. This flag cannot be changed. the mask that specifies all the valid flags. the mask of the flags that are returned from g_io_channel_get_flags() the mask of the flags that the user can modify with g_io_channel_set_flags() Stati returned by most of the #GIOFuncs functions. An error occurred. Success. End of file. Resource temporarily unavailable. Error codes returned by key file parsing. the text being parsed was in an unknown encoding document was ill-formed the file was not found a requested key was not found a requested group was not found a value could not be parsed Flags which influence the parsing. No flags, default behaviour Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise all comments will be lost when the key file is written back. Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise only the translations for the current language will be written back. Flags specifying the level of log messages. It is possible to change how GLib treats messages of the various levels using g_log_set_handler() and g_log_set_fatal_mask(). internal flag internal flag log level for errors, see g_error(). This level is also used for messages produced by g_assert(). log level for critical messages, see g_critical(). This level is also used for messages produced by g_return_if_fail() and g_return_val_if_fail(). log level for warnings, see g_warning() log level for messages, see g_message() log level for informational messages, see g_info() log level for debug messages, see g_debug() a mask including all log levels A mixed enumerated type and flags field. You must specify one type (string, strdup, boolean, tristate). Additionally, you may optionally bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL. It is likely that this enum will be extended in the future to support other types. used to terminate the list of attributes to collect collect the string pointer directly from the attribute_values[] array. Expects a parameter of type (const char **). If %G_MARKUP_COLLECT_OPTIONAL is specified and the attribute isn't present then the pointer will be set to %NULL as with %G_MARKUP_COLLECT_STRING, but expects a parameter of type (char **) and g_strdup()s the returned pointer. The pointer must be freed with g_free() expects a parameter of type (gboolean *) and parses the attribute value as a boolean. Sets %FALSE if the attribute isn't present. Valid boolean values consist of (case-insensitive) "false", "f", "no", "n", "0" and "true", "t", "yes", "y", "1" as with %G_MARKUP_COLLECT_BOOLEAN, but in the case of a missing attribute a value is set that compares equal to neither %FALSE nor %TRUE G_MARKUP_COLLECT_OPTIONAL is implied can be bitwise ORed with the other fields. If present, allows the attribute not to appear. A default value is set depending on what value type is used Error codes returned by markup parsing. text being parsed was not valid UTF-8 document contained nothing, or only whitespace document was ill-formed error should be set by #GMarkupParser functions; element wasn't known error should be set by #GMarkupParser functions; attribute wasn't known error should be set by #GMarkupParser functions; content was invalid error should be set by #GMarkupParser functions; a required attribute was missing Flags that affect the behaviour of the parser. flag you should not use When this flag is set, CDATA marked sections are not passed literally to the @passthrough function of the parser. Instead, the content of the section (without the `<![CDATA[` and `]]>`) is passed to the @text function. This flag was added in GLib 2.12 Normally errors caught by GMarkup itself have line/column information prefixed to them to let the caller know the location of the error. When this flag is set the location information is also prefixed to errors generated by the #GMarkupParser implementation functions Ignore (don't report) qualified attributes and tags, along with their contents. A qualified attribute or tag is one that contains ':' in its name (ie: is in another namespace). Since: 2.40. Flags passed to g_module_open(). Note that these flags are not supported on all platforms. specifies that symbols are only resolved when needed. The default action is to bind all symbols when the module is loaded. specifies that symbols in the module should not be added to the global name space. The default action on most platforms is to place symbols in the module in the global name space, which may cause conflicts with existing symbols. mask for all flags. Defines how a Unicode string is transformed in a canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character. Unicode strings should generally be normalized before comparing them. standardize differences that do not affect the text content, such as the above-mentioned accent representation another name for %G_NORMALIZE_DEFAULT like %G_NORMALIZE_DEFAULT, but with composed forms rather than a maximally decomposed form another name for %G_NORMALIZE_DEFAULT_COMPOSE beyond %G_NORMALIZE_DEFAULT also standardize the "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to the standard forms (in this case DIGIT THREE). Formatting information may be lost but for most text operations such characters should be considered the same another name for %G_NORMALIZE_ALL like %G_NORMALIZE_ALL, but with composed forms rather than a maximally decomposed form another name for %G_NORMALIZE_ALL_COMPOSE The notify signal is emitted on an object when one of its properties has been changed. Note that getting this signal doesn't guarantee that the value of the property has actually changed, it may also be emitted when the setter for the property is called to reinstate the previous value. This signal is typically used to obtain change notification for a single property, by specifying the property name as a detail in the g_signal_connect() call, like this: |[<!-- language="C" --> g_signal_connect (text_view->buffer, "notify::paste-target-list", G_CALLBACK (gtk_text_view_target_list_notify), text_view) ]| It is important to note that you must use [canonical][canonical-parameter-name] parameter names as detail strings for the notify signal. the object which received the signal. the #GParamSpec of the property which changed. The possible statuses of a one-time initialization function controlled by a #GOnce struct. Since: 2.4 the function has not been called yet. the function call is currently in progress. the function has been called. The #GOptionArg enum values determine which type of extra argument the options expect to find. If an option expects an extra argument, it can be specified in several ways; with a short option: `-x arg`, with a long option: `--name arg` or combined in a single argument: `--name=arg`. No extra argument. This is useful for simple flags. The option takes a string argument. The option takes an integer argument. The option provides a callback (of type #GOptionArgFunc) to parse the extra argument. The option takes a filename as argument. The option takes a string argument, multiple uses of the option are collected into an array of strings. The option takes a filename as argument, multiple uses of the option are collected into an array of strings. The option takes a double argument. The argument can be formatted either for the user's locale or for the "C" locale. Since 2.12 The option takes a 64-bit integer. Like %G_OPTION_ARG_INT but for larger numbers. The number can be in decimal base, or in hexadecimal (when prefixed with `0x`, for example, `0xffffffff`). Since 2.12 Error codes returned by option parsing. An option was not known to the parser. This error will only be reported, if the parser hasn't been instructed to ignore unknown options, see g_option_context_set_ignore_unknown_options(). A value couldn't be parsed. A #GOptionArgFunc callback failed. Flags which modify individual options. No flags. Since: 2.42. The option doesn't appear in `--help` output. The option appears in the main section of the `--help` output, even if it is defined in a group. For options of the %G_OPTION_ARG_NONE kind, this flag indicates that the sense of the option is reversed. For options of the %G_OPTION_ARG_CALLBACK kind, this flag indicates that the callback does not take any argument (like a %G_OPTION_ARG_NONE option). Since 2.8 For options of the %G_OPTION_ARG_CALLBACK kind, this flag indicates that the argument should be passed to the callback in the GLib filename encoding rather than UTF-8. Since 2.8 For options of the %G_OPTION_ARG_CALLBACK kind, this flag indicates that the argument supply is optional. If no argument is given then data of %GOptionParseFunc will be set to NULL. Since 2.8 This flag turns off the automatic conflict resolution which prefixes long option names with `groupname-` if there is a conflict. This option should only be used in situations where aliasing is necessary to model some legacy commandline interface. It is not safe to use this option, unless all option groups are under your direct control. Since 2.8. Through the #GParamFlags flag values, certain aspects of parameters can be configured. See also #G_PARAM_STATIC_STRINGS. the parameter is readable the parameter is writable alias for %G_PARAM_READABLE | %G_PARAM_WRITABLE the parameter will be set upon object construction the parameter can only be set upon object construction upon parameter conversion (see g_param_value_convert()) strict validation is not required the string used as name when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter. Since 2.8 the string used as nick when constructing the parameter is guaranteed to remain valid and unmmodified for the lifetime of the parameter. Since 2.8 the string used as blurb when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter. Since 2.8 calls to g_object_set_property() for this property will not automatically result in a "notify" signal being emitted: the implementation must call g_object_notify() themselves in case the property actually changes. Since: 2.42. internal the parameter is deprecated and will be removed in a future version. A warning will be generated if it is used while running with G_ENABLE_DIAGNOSTIC=1. Since 2.26 Flags specifying compile-time options. Since: 2.14 Letters in the pattern match both upper- and lowercase letters. This option can be changed within a pattern by a "(?i)" option setting. By default, GRegex treats the strings as consisting of a single line of characters (even if it actually contains newlines). The "start of line" metacharacter ("^") matches only at the start of the string, while the "end of line" metacharacter ("$") matches only at the end of the string, or before a terminating newline (unless #G_REGEX_DOLLAR_ENDONLY is set). When #G_REGEX_MULTILINE is set, the "start of line" and "end of line" constructs match immediately following or immediately before any newline in the string, respectively, as well as at the very start and end. This can be changed within a pattern by a "(?m)" option setting. A dot metacharater (".") in the pattern matches all characters, including newlines. Without it, newlines are excluded. This option can be changed within a pattern by a ("?s") option setting. Whitespace data characters in the pattern are totally ignored except when escaped or inside a character class. Whitespace does not include the VT character (code 11). In addition, characters between an unescaped "#" outside a character class and the next newline character, inclusive, are also ignored. This can be changed within a pattern by a "(?x)" option setting. The pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched. This effect can also be achieved by appropriate constructs in the pattern itself such as the "^" metacharater. A dollar metacharacter ("$") in the pattern matches only at the end of the string. Without this option, a dollar also matches immediately before the final character if it is a newline (but not before any other newlines). This option is ignored if #G_REGEX_MULTILINE is set. Inverts the "greediness" of the quantifiers so that they are not greedy by default, but become greedy if followed by "?". It can also be set by a "(?U)" option setting within the pattern. Usually strings must be valid UTF-8 strings, using this flag they are considered as a raw sequence of bytes. Disables the use of numbered capturing parentheses in the pattern. Any opening parenthesis that is not followed by "?" behaves as if it were followed by "?:" but named parentheses can still be used for capturing (and they acquire numbers in the usual way). Optimize the regular expression. If the pattern will be used many times, then it may be worth the effort to optimize it to improve the speed of matches. Limits an unanchored pattern to match before (or at) the first newline. Since: 2.34 Names used to identify capturing subpatterns need not be unique. This can be helpful for certain types of pattern when it is known that only one instance of the named subpattern can ever be matched. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character is '\r'. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character is '\n'. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character sequence is '\r\n'. Usually any newline character or character sequence is recognized. If this option is set, the only recognized newline character sequences are '\r', '\n', and '\r\n'. Since: 2.34 Usually any newline character or character sequence is recognised. If this option is set, then "\R" only recognizes the newline characters '\r', '\n' and '\r\n'. Since: 2.34 Changes behaviour so that it is compatible with JavaScript rather than PCRE. Since: 2.34 Error codes returned by regular expressions functions. Since: 2.14 Compilation of the regular expression failed. Optimization of the regular expression failed. Replacement failed due to an ill-formed replacement string. The match process failed. Internal error of the regular expression engine. Since 2.16 "\\" at end of pattern. Since 2.16 "\\c" at end of pattern. Since 2.16 Unrecognized character follows "\\". Since 2.16 Numbers out of order in "{}" quantifier. Since 2.16 Number too big in "{}" quantifier. Since 2.16 Missing terminating "]" for character class. Since 2.16 Invalid escape sequence in character class. Since 2.16 Range out of order in character class. Since 2.16 Nothing to repeat. Since 2.16 Unrecognized character after "(?", "(?<" or "(?P". Since 2.16 POSIX named classes are supported only within a class. Since 2.16 Missing terminating ")" or ")" without opening "(". Since 2.16 Reference to non-existent subpattern. Since 2.16 Missing terminating ")" after comment. Since 2.16 Regular expression too large. Since 2.16 Failed to get memory. Since 2.16 Lookbehind assertion is not fixed length. Since 2.16 Malformed number or name after "(?(". Since 2.16 Conditional group contains more than two branches. Since 2.16 Assertion expected after "(?(". Since 2.16 Unknown POSIX class name. Since 2.16 POSIX collating elements are not supported. Since 2.16 Character value in "\\x{...}" sequence is too large. Since 2.16 Invalid condition "(?(0)". Since 2.16 \\C not allowed in lookbehind assertion. Since 2.16 Recursive call could loop indefinitely. Since 2.16 Missing terminator in subpattern name. Since 2.16 Two named subpatterns have the same name. Since 2.16 Malformed "\\P" or "\\p" sequence. Since 2.16 Unknown property name after "\\P" or "\\p". Since 2.16 Subpattern name is too long (maximum 32 characters). Since 2.16 Too many named subpatterns (maximum 10,000). Since 2.16 Octal value is greater than "\\377". Since 2.16 "DEFINE" group contains more than one branch. Since 2.16 Repeating a "DEFINE" group is not allowed. This error is never raised. Since: 2.16 Deprecated: 2.34 Inconsistent newline options. Since 2.16 "\\g" is not followed by a braced, angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16 relative reference must not be zero. Since: 2.34 the backtracing control verb used does not allow an argument. Since: 2.34 unknown backtracing control verb. Since: 2.34 number is too big in escape sequence. Since: 2.34 Missing subpattern name. Since: 2.34 Missing digit. Since 2.34 In JavaScript compatibility mode, "[" is an invalid data character. Since: 2.34 different names for subpatterns of the same number are not allowed. Since: 2.34 the backtracing control verb requires an argument. Since: 2.34 "\\c" must be followed by an ASCII character. Since: 2.34 "\\k" is not followed by a braced, angle-bracketed, or quoted name. Since: 2.34 "\\N" is not supported in a class. Since: 2.34 too many forward references. Since: 2.34 the name is too long in "(*MARK)", "(*PRUNE)", "(*SKIP)", or "(*THEN)". Since: 2.34 the character value in the \\u sequence is too large. Since: 2.34 Flags specifying match-time options. Since: 2.14 The pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched. This effect can also be achieved by appropriate constructs in the pattern itself such as the "^" metacharater. Specifies that first character of the string is not the beginning of a line, so the circumflex metacharacter should not match before it. Setting this without #G_REGEX_MULTILINE (at compile time) causes circumflex never to match. This option affects only the behaviour of the circumflex metacharacter, it does not affect "\A". Specifies that the end of the subject string is not the end of a line, so the dollar metacharacter should not match it nor (except in multiline mode) a newline immediately before it. Setting this without #G_REGEX_MULTILINE (at compile time) causes dollar never to match. This option affects only the behaviour of the dollar metacharacter, it does not affect "\Z" or "\z". An empty string is not considered to be a valid match if this option is set. If there are alternatives in the pattern, they are tried. If all the alternatives match the empty string, the entire match fails. For example, if the pattern "a?b?" is applied to a string not beginning with "a" or "b", it matches the empty string at the start of the string. With this flag set, this match is not valid, so GRegex searches further into the string for occurrences of "a" or "b". Turns on the partial matching feature, for more documentation on partial matching see g_match_info_is_partial_match(). Overrides the newline definition set when creating a new #GRegex, setting the '\r' character as line terminator. Overrides the newline definition set when creating a new #GRegex, setting the '\n' character as line terminator. Overrides the newline definition set when creating a new #GRegex, setting the '\r\n' characters sequence as line terminator. Overrides the newline definition set when creating a new #GRegex, any Unicode newline sequence is recognised as a newline. These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR. Overrides the newline definition set when creating a new #GRegex; any '\r', '\n', or '\r\n' character sequence is recognized as a newline. Since: 2.34 Overrides the newline definition for "\R" set when creating a new #GRegex; only '\r', '\n', or '\r\n' character sequences are recognized as a newline by "\R". Since: 2.34 Overrides the newline definition for "\R" set when creating a new #GRegex; any Unicode newline character or character sequence are recognized as a newline by "\R". These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR. Since: 2.34 An alias for #G_REGEX_MATCH_PARTIAL. Since: 2.34 Turns on the partial matching feature. In contrast to to #G_REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match is found, without continuing to search for a possible complete match. See g_match_info_is_partial_match() for more information. Since: 2.34 Like #G_REGEX_MATCH_NOTEMPTY, but only applied to the start of the matched string. For anchored patterns this can only happen for pattern containing "\K". Since: 2.34 An enumeration specifying the base position for a g_io_channel_seek_position() operation. the current position in the file. the start of the file. the end of the file. Error codes returned by shell functions. Mismatched or otherwise mangled quoting. String to be parsed was empty. Some other error. The signal flags are used to specify a signal's behaviour, the overall signal description outlines how especially the RUN flags control the stages of a signal emission. Invoke the object method handler in the first emission stage. Invoke the object method handler in the third emission stage. Invoke the object method handler in the last emission stage. Signals being emitted for an object while currently being in emission for this very object will not be emitted recursively, but instead cause the first emission to be restarted. This signal supports "::detail" appendices to the signal name upon handler connections and emissions. Action signals are signals that may freely be emitted on alive objects from user code via g_signal_emit() and friends, without the need of being embedded into extra code that performs pre or post emission adjustments on the object. They can also be thought of as object methods which can be called generically by third-party code. No emissions hooks are supported for this signal. Varargs signal emission will always collect the arguments, even if there are no signal handlers connected. Since 2.30. The signal is deprecated and will be removed in a future version. A warning will be generated if it is connected while running with G_ENABLE_DIAGNOSTIC=1. Since 2.32. The match types specify what g_signal_handlers_block_matched(), g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched() match signals by. The signal id must be equal. The signal detail be equal. The closure must be the same. The C closure callback must be the same. The closure data must be the same. Only unblocked signals may matched. Error codes returned by spawning processes. Fork failed due to lack of memory. Read or select on pipes failed. Changing to working directory failed. execv() returned `EACCES` execv() returned `EPERM` execv() returned `E2BIG` deprecated alias for %G_SPAWN_ERROR_TOO_BIG execv() returned `ENOEXEC` execv() returned `ENAMETOOLONG` execv() returned `ENOENT` execv() returned `ENOMEM` execv() returned `ENOTDIR` execv() returned `ELOOP` execv() returned `ETXTBUSY` execv() returned `EIO` execv() returned `ENFILE` execv() returned `EMFILE` execv() returned `EINVAL` execv() returned `EISDIR` execv() returned `ELIBBAD` Some other fatal failure, `error->message` should explain. Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes(). no flags, default behaviour the parent's open file descriptors will be inherited by the child; otherwise all descriptors except stdin, stdout and stderr will be closed before calling exec() in the child. the child will not be automatically reaped; you must use g_child_watch_add() yourself (or call waitpid() or handle `SIGCHLD` yourself), or the child will become a zombie. `argv[0]` need not be an absolute path, it will be looked for in the user's `PATH`. the child's standard output will be discarded, instead of going to the same location as the parent's standard output. the child's standard error will be discarded. the child will inherit the parent's standard input (by default, the child's standard input is attached to `/dev/null`). the first element of `argv` is the file to execute, while the remaining elements are the actual argument vector to pass to the file. Normally g_spawn_async_with_pipes() uses `argv[0]` as the file to execute, and passes all of `argv` to the child. if `argv[0]` is not an abolute path, it will be looked for in the `PATH` from the passed child environment. Since: 2.34 create all pipes with the `O_CLOEXEC` flag set. Since: 2.40 The type of file to return the filename for, when used with g_test_build_filename(). These two options correspond rather directly to the 'dist' and 'built' terminology that automake uses and are explicitly used to distinguish between the 'srcdir' and 'builddir' being separate. All files in your project should either be dist (in the `DIST_EXTRA` or `dist_schema_DATA` sense, in which case they will always be in the srcdir) or built (in the `BUILT_SOURCES` sense, in which case they will always be in the builddir). Note: as a general rule of automake, files that are generated only as part of the build-from-git process (but then are distributed with the tarball) always go in srcdir (even if doing a srcdir != builddir build from git) and are considered as distributed files. Since: 2.38 a file that was included in the distribution tarball a file that was built on the compiling machine Flags to pass to g_test_trap_subprocess() to control input and output. Note that in contrast with g_test_trap_fork(), the default is to not show stdout and stderr. If this flag is given, the child process will inherit the parent's stdin. Otherwise, the child's stdin is redirected to `/dev/null`. If this flag is given, the child process will inherit the parent's stdout. Otherwise, the child's stdout will not be visible, but it will be captured to allow later tests with g_test_trap_assert_stdout(). If this flag is given, the child process will inherit the parent's stderr. Otherwise, the child's stderr will not be visible, but it will be captured to allow later tests with g_test_trap_assert_stderr(). Test traps are guards around forked tests. These flags determine what traps to set. Deprecated: #GTestTrapFlags is used only with g_test_trap_fork(), which is deprecated. g_test_trap_subprocess() uses #GTestTrapSubprocessFlags. Redirect stdout of the test child to `/dev/null` so it cannot be observed on the console during test runs. The actual output is still captured though to allow later tests with g_test_trap_assert_stdout(). Redirect stderr of the test child to `/dev/null` so it cannot be observed on the console during test runs. The actual output is still captured though to allow later tests with g_test_trap_assert_stderr(). If this flag is given, stdin of the child process is shared with stdin of its parent process. It is redirected to `/dev/null` otherwise. Possible errors of thread related functions. a thread couldn't be created due to resource shortage. Try again later. Thread priorities. Deprecated:2.32: Thread priorities no longer have any effect. a priority lower than normal the default priority a priority higher than normal the highest priority Disambiguates a given time in two ways. First, specifies if the given time is in universal or local time. Second, if the time is in local time, specifies if it is local standard time or local daylight time. This is important for the case where the same local time occurs twice (during daylight savings time transitions, for example). the time is in local standard time the time is in local daylight time the time is in UTC The possible types of token returned from each g_scanner_get_next_token() call. the end of the file a '(' character a '{' character a '[' character a '}' character a ')' character a ']' character a '=' character a ',' character not a token an error occurred a character a binary integer an octal integer an integer a hex integer a floating point number a string a symbol an identifier a null identifier one line comment multi line comment Specifies which nodes are visited during several of the tree functions, including g_node_traverse() and g_node_find(). only leaf nodes should be visited. This name has been introduced in 2.6, for older version use %G_TRAVERSE_LEAFS. only non-leaf nodes should be visited. This name has been introduced in 2.6, for older version use %G_TRAVERSE_NON_LEAFS. all nodes should be visited. a mask of all traverse flags. identical to %G_TRAVERSE_LEAVES. identical to %G_TRAVERSE_NON_LEAVES. Specifies the type of traveral performed by g_tree_traverse(), g_node_traverse() and g_node_find(). The different orders are illustrated here: - In order: A, B, C, D, E, F, G, H, I  - Pre order: F, B, A, D, C, E, G, I, H  - Post order: A, C, E, D, B, H, I, G, F  - Level order: F, B, G, A, D, I, C, E, H  vists a node's left child first, then the node itself, then its right child. This is the one to use if you want the output sorted according to the compare function. visits a node, then its children. visits the node's children, then the node itself. is not implemented for [balanced binary trees][glib-Balanced-Binary-Trees]. For [n-ary trees][glib-N-ary-Trees], it vists the root node first, then its children, then its grandchildren, and so on. Note that this is less efficient than the other orders. These flags used to be passed to g_type_init_with_debug_flags() which is now deprecated. If you need to enable debugging features, use the GOBJECT_DEBUG environment variable. Deprecated: 2.36: g_type_init() is now done automatically Print no messages Print messages about object bookkeeping Print messages about signal emissions Mask covering all debug flags Keep a count of instances of each type Bit masks used to check or determine characteristics of a type. Indicates an abstract type. No instances can be created for an abstract type Indicates an abstract value type, i.e. a type that introduces a value table, but can't be used for g_value_init() Bit masks used to check or determine specific characteristics of a fundamental type. Indicates a classed type Indicates an instantiable type (implies classed) Indicates a flat derivable type Indicates a deep derivable type (implies derivable) These are the possible line break classifications. Since new unicode versions may add new types here, applications should be ready to handle unknown values. They may be regarded as %G_UNICODE_BREAK_UNKNOWN. See <ulink url="http://www.unicode.org/unicode/reports/tr14/">http://www.unicode.org/unicode/reports/tr14/</ulink>. Mandatory Break (BK) Carriage Return (CR) Line Feed (LF) Attached Characters and Combining Marks (CM) Surrogates (SG) Zero Width Space (ZW) Inseparable (IN) Non-breaking ("Glue") (GL) Contingent Break Opportunity (CB) Space (SP) Break Opportunity After (BA) Break Opportunity Before (BB) Break Opportunity Before and After (B2) Hyphen (HY) Nonstarter (NS) Opening Punctuation (OP) Closing Punctuation (CL) Ambiguous Quotation (QU) Exclamation/Interrogation (EX) Ideographic (ID) Numeric (NU) Infix Separator (Numeric) (IS) Symbols Allowing Break After (SY) Ordinary Alphabetic and Symbol Characters (AL) Prefix (Numeric) (PR) Postfix (Numeric) (PO) Complex Content Dependent (South East Asian) (SA) Ambiguous (Alphabetic or Ideographic) (AI) Unknown (XX) Next Line (NL) Word Joiner (WJ) Hangul L Jamo (JL) Hangul V Jamo (JV) Hangul T Jamo (JT) Hangul LV Syllable (H2) Hangul LVT Syllable (H3) Closing Parenthesis (CP). Since 2.28 Conditional Japanese Starter (CJ). Since: 2.32 Hebrew Letter (HL). Since: 2.32 Regional Indicator (RI). Since: 2.36 The #GUnicodeScript enumeration identifies different writing systems. The values correspond to the names as defined in the Unicode standard. The enumeration has been added in GLib 2.14, and is interchangeable with #PangoScript. Note that new types may be added in the future. Applications should be ready to handle unknown values. See <ulink url="http://www.unicode.org/reports/tr24/">Unicode Standard Annex #24: Script names</ulink>. a value never returned from g_unichar_get_script() a character used by multiple different scripts a mark glyph that takes its script from the base glyph to which it is attached Arabic Armenian Bengali Bopomofo Cherokee Coptic Cyrillic Deseret Devanagari Ethiopic Georgian Gothic Greek Gujarati Gurmukhi Han Hangul Hebrew Hiragana Kannada Katakana Khmer Lao Latin Malayalam Mongolian Myanmar Ogham Old Italic Oriya Runic Sinhala Syriac Tamil Telugu Thaana Thai Tibetan Canadian Aboriginal Yi Tagalog Hanunoo Buhid Tagbanwa Braille Cypriot Limbu Osmanya Shavian Linear B Tai Le Ugaritic New Tai Lue Buginese Glagolitic Tifinagh Syloti Nagri Old Persian Kharoshthi an unassigned code point Balinese Cuneiform Phoenician Phags-pa N'Ko Kayah Li. Since 2.16.3 Lepcha. Since 2.16.3 Rejang. Since 2.16.3 Sundanese. Since 2.16.3 Saurashtra. Since 2.16.3 Cham. Since 2.16.3 Ol Chiki. Since 2.16.3 Vai. Since 2.16.3 Carian. Since 2.16.3 Lycian. Since 2.16.3 Lydian. Since 2.16.3 Avestan. Since 2.26 Bamum. Since 2.26 Egyptian Hieroglpyhs. Since 2.26 Imperial Aramaic. Since 2.26 Inscriptional Pahlavi. Since 2.26 Inscriptional Parthian. Since 2.26 Javanese. Since 2.26 Kaithi. Since 2.26 Lisu. Since 2.26 Meetei Mayek. Since 2.26 Old South Arabian. Since 2.26 Old Turkic. Since 2.28 Samaritan. Since 2.26 Tai Tham. Since 2.26 Tai Viet. Since 2.26 Batak. Since 2.28 Brahmi. Since 2.28 Mandaic. Since 2.28 Chakma. Since: 2.32 Meroitic Cursive. Since: 2.32 Meroitic Hieroglyphs. Since: 2.32 Miao. Since: 2.32 Sharada. Since: 2.32 Sora Sompeng. Since: 2.32 Takri. Since: 2.32 Bassa. Since: 2.42 Caucasian Albanian. Since: 2.42 Duployan. Since: 2.42 Elbasan. Since: 2.42 Grantha. Since: 2.42 Kjohki. Since: 2.42 Khudawadi, Sindhi. Since: 2.42 Linear A. Since: 2.42 Mahajani. Since: 2.42 Manichaean. Since: 2.42 Mende Kikakui. Since: 2.42 Modi. Since: 2.42 Mro. Since: 2.42 Nabataean. Since: 2.42 Old North Arabian. Since: 2.42 Old Permic. Since: 2.42 Pahawh Hmong. Since: 2.42 Palmyrene. Since: 2.42 Pau Cin Hau. Since: 2.42 Psalter Pahlavi. Since: 2.42 Siddham. Since: 2.42 Tirhuta. Since: 2.42 Warang Citi. Since: 2.42 These are the possible character classifications from the Unicode specification. See <ulink url="http://www.unicode.org/Public/UNIDATA/UnicodeData.html">http://www.unicode.org/Public/UNIDATA/UnicodeData.html</ulink>. General category "Other, Control" (Cc) General category "Other, Format" (Cf) General category "Other, Not Assigned" (Cn) General category "Other, Private Use" (Co) General category "Other, Surrogate" (Cs) General category "Letter, Lowercase" (Ll) General category "Letter, Modifier" (Lm) General category "Letter, Other" (Lo) General category "Letter, Titlecase" (Lt) General category "Letter, Uppercase" (Lu) General category "Mark, Spacing" (Mc) General category "Mark, Enclosing" (Me) General category "Mark, Nonspacing" (Mn) General category "Number, Decimal Digit" (Nd) General category "Number, Letter" (Nl) General category "Number, Other" (No) General category "Punctuation, Connector" (Pc) General category "Punctuation, Dash" (Pd) General category "Punctuation, Close" (Pe) General category "Punctuation, Final quote" (Pf) General category "Punctuation, Initial quote" (Pi) General category "Punctuation, Other" (Po) General category "Punctuation, Open" (Ps) General category "Symbol, Currency" (Sc) General category "Symbol, Modifier" (Sk) General category "Symbol, Math" (Sm) General category "Symbol, Other" (So) General category "Separator, Line" (Zl) General category "Separator, Paragraph" (Zp) General category "Separator, Space" (Zs) These are logical ids for special directories which are defined depending on the platform used. You should use g_get_user_special_dir() to retrieve the full path associated to the logical id. The #GUserDirectory enumeration can be extended at later date. Not every platform has a directory for every logical id in this enumeration. Since: 2.14 the user's Desktop directory the user's Documents directory the user's Downloads directory the user's Music directory the user's Pictures directory the user's shared directory the user's Templates directory the user's Movies directory the number of enum values The range of possible top-level types of #GVariant instances. Since: 2.24 The #GVariant is a boolean. The #GVariant is a byte. The #GVariant is a signed 16 bit integer. The #GVariant is an unsigned 16 bit integer. The #GVariant is a signed 32 bit integer. The #GVariant is an unsigned 32 bit integer. The #GVariant is a signed 64 bit integer. The #GVariant is an unsigned 64 bit integer. The #GVariant is a file handle index. The #GVariant is a double precision floating point value. The #GVariant is a normal string. The #GVariant is a D-Bus object path string. The #GVariant is a D-Bus signature string. The #GVariant is a variant. The #GVariant is a maybe-typed value. The #GVariant is an array. The #GVariant is a tuple. The #GVariant is a dictionary entry. Error codes returned by parsing text-format GVariants. generic error (unused) a non-basic #GVariantType was given where a basic type was expected cannot infer the #GVariantType an indefinite #GVariantType was given where a definite type was expected extra data after parsing finished invalid character in number or unicode escape not a valid #GVariant format string not a valid object path not a valid type signature not a valid #GVariant type string could not find a common type for array entries the numerical value is out of range of the given type the numerical value is out of range for any type cannot parse as variant of the specified type an unexpected token was encountered an unknown keyword was encountered unterminated string constant no value given Type of Windows edition to check for at run-time. The running system can be a workstation or a server edition of Windows. The type of the running system is therefore not checked. The running system is a workstation edition of Windows, such as Windows 7 Professional. The running system is a server edition of Windows, such as Windows Server 2008 R2. 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. On Windows, the file protection mechanism is not at all POSIX-like, and the underlying function in the C library only checks the FAT-style READONLY attribute, and does not look at the ACL of a file at all. This function is this in practise almost useless on Windows. Software that needs to handle file permissions on Windows more exactly should use the Win32 API. See your C library manual for more details about access(). Since: 2.8 a pathname in the GLib file name encoding (UTF-8 on Windows) as in access() zero if the pathname refers to an existing file system object that has all the tested permissions, or -1 otherwise or on error. Allocates @size bytes on the stack; these bytes will be freed when the current stack frame is cleaned up. This macro essentially just wraps the alloca() function present on most UNIX variants. Thus it provides the same advantages and pitfalls as alloca(): - alloca() is very fast, as on most systems it's implemented by just adjusting the stack pointer register. - It doesn't cause any memory fragmentation, within its scope, separate alloca() blocks just build up and are released together at function end. - Allocation sizes have to fit into the current stack frame. For instance in a threaded environment on Linux, the per-thread stack size is limited to 2 Megabytes, so be sparse with alloca() uses. - Allocation failure due to insufficient stack space is not indicated with a %NULL return like e.g. with malloc(). Instead, most systems probably handle it the same way as out of stack space situations from infinite function recursion, i.e. with a segmentation fault. - Special care has to be taken when mixing alloca() with GNU C variable sized arrays. Stack space allocated with alloca() in the same scope as a variable sized array will be freed together with the variable sized array upon exit of that scope, and not upon exit of the enclosing function scope. number of bytes to allocate. space for @size bytes, allocated on the stack Adds the value on to the end of the array. The array will grow in size automatically if necessary. g_array_append_val() is a macro which uses a reference to the value parameter @v. This means that you cannot use it with literal values such as "27". You must use variables. a #GArray the value to append to the #GArray the #GArray Adds @len elements onto the end of the array. a #GArray a pointer to the elements to append to the end of the array the number of elements to append the #GArray Frees the memory allocated for the #GArray. If @free_segment is %TRUE it frees the memory block holding the elements as well and also each element if @array has a @element_free_func set. Pass %FALSE if you want to free the #GArray wrapper but preserve the underlying array for use elsewhere. If the reference count of @array is greater than one, the #GArray wrapper is preserved but the size of @array will be set to zero. If array elements contain dynamically-allocated memory, they should be freed separately. a #GArray if %TRUE the actual element data is freed as well the element data if @free_segment is %FALSE, otherwise %NULL. The element data should be freed using g_free(). Gets the size of the elements in @array. Since: 2.22 A #GArray Size of each element, in bytes Returns the element of a #GArray at the given index. The return value is cast to the given type. This example gets a pointer to an element in a #GArray: |[<!-- language="C" --> EDayViewEvent *event; // This gets a pointer to the 4th element in the array of // EDayViewEvent structs. event = &g_array_index (events, EDayViewEvent, 3); ]| a #GArray the type of the elements the index of the element to return the element of the #GArray at the index given by @i Inserts an element into an array at the given index. g_array_insert_val() is a macro which uses a reference to the value parameter @v. This means that you cannot use it with literal values such as "27". You must use variables. a #GArray the index to place the element at the value to insert into the array the #GArray Inserts @len elements into a #GArray at the given index. a #GArray the index to place the elements at a pointer to the elements to insert the number of elements to insert the #GArray Creates a new #GArray with a reference count of 1. %TRUE if the array should have an extra element at the end which is set to 0 %TRUE if #GArray elements should be automatically cleared to 0 when they are allocated the size of each element in bytes the new #GArray Adds the value on to the start of the array. The array will grow in size automatically if necessary. This operation is slower than g_array_append_val() since the existing elements in the array have to be moved to make space for the new element. g_array_prepend_val() is a macro which uses a reference to the value parameter @v. This means that you cannot use it with literal values such as "27". You must use variables. a #GArray the value to prepend to the #GArray the #GArray Adds @len elements onto the start of the array. This operation is slower than g_array_append_vals() since the existing elements in the array have to be moved to make space for the new elements. a #GArray a pointer to the elements to prepend to the start of the array the number of elements to prepend the #GArray Atomically increments the reference count of @array by one. This function is MT-safe and may be called from any thread. Since: 2.22 A #GArray The passed in #GArray Removes the element at the given index from a #GArray. The following elements are moved down one place. a #GArray the index of the element to remove the #GArray Removes the element at the given index from a #GArray. The last element in the array is used to fill in the space, so this function does not preserve the order of the #GArray. But it is faster than g_array_remove_index(). a @GArray the index of the element to remove the #GArray Removes the given number of elements starting at the given index from a #GArray. The following elements are moved to close the gap. Since: 2.4 a @GArray the index of the first element to remove the number of elements to remove the #GArray Sets a function to clear an element of @array. The @clear_func will be called when an element in the array data segment is removed and when the array is freed and data segment is deallocated as well. Note that in contrast with other uses of #GDestroyNotify functions, @clear_func is expected to clear the contents of the array element it is given, but not free the element itself. Since: 2.32 A #GArray a function to clear an element of @array Sets the size of the array, expanding it if necessary. If the array was created with @clear_ set to %TRUE, the new elements are set to 0. a #GArray the new size of the #GArray the #GArray Creates a new #GArray with @reserved_size elements preallocated and a reference count of 1. This avoids frequent reallocation, if you are going to add many elements to the array. Note however that the size of the array is still 0. %TRUE if the array should have an extra element at the end with all bits cleared %TRUE if all bits in the array should be cleared to 0 on allocation size of each element in the array number of elements preallocated the new #GArray Sorts a #GArray using @compare_func which should be a qsort()-style comparison function (returns less than zero for first arg is less than second arg, zero for equal, greater zero if first arg is greater than second arg). This is guaranteed to be a stable sort since version 2.32. a #GArray comparison function Like g_array_sort(), but the comparison function receives an extra user data argument. This is guaranteed to be a stable sort since version 2.32. There used to be a comment here about making the sort stable by using the addresses of the elements in the comparison function. This did not actually work, so any such code should be removed. a #GArray comparison function data to pass to @compare_func Atomically decrements the reference count of @array by one. If the reference count drops to 0, all memory allocated by the array is released. This function is MT-safe and may be called from any thread. Since: 2.22 A #GArray Determines the numeric value of a character as a decimal digit. Differs from g_unichar_digit_value() because it takes a char, so there's no worry about sign extension if characters are signed. an ASCII character If @c is a decimal digit (according to g_ascii_isdigit()), its numeric value. Otherwise, -1. Converts a #gdouble to a string, using the '.' as decimal point. This function generates enough precision that converting the string back using g_ascii_strtod() gives the same machine-number (on machines with IEEE compatible 64bit doubles). It is guaranteed that the size of the resulting string will never be larger than @G_ASCII_DTOSTR_BUF_SIZE bytes, including the terminating nul character, which is always added. A buffer to place the resulting string in The length of the buffer. The #gdouble to convert The pointer to the buffer with the converted string. Converts a #gdouble to a string, using the '.' as decimal point. To format the number you pass in a printf()-style format string. Allowed conversion specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'. The returned buffer is guaranteed to be nul-terminated. If you just want to want to serialize the value into a string, use g_ascii_dtostr(). A buffer to place the resulting string in The length of the buffer. The printf()-style format to use for the code to use for converting. The #gdouble to convert The pointer to the buffer with the converted string. Determines whether a character is alphanumeric. Unlike the standard C library isalnum() function, this only recognizes standard ASCII letters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in. any character %TRUE if @c is an ASCII alphanumeric character Determines whether a character is alphabetic (i.e. a letter). Unlike the standard C library isalpha() function, this only recognizes standard ASCII letters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in. any character %TRUE if @c is an ASCII alphabetic character Determines whether a character is a control character. Unlike the standard C library iscntrl() function, this only recognizes standard ASCII control characters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in. any character %TRUE if @c is an ASCII control character. Determines whether a character is digit (0-9). Unlike the standard C library isdigit() function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in. any character %TRUE if @c is an ASCII digit. Determines whether a character is a printing character and not a space. Unlike the standard C library isgraph() function, this only recognizes standard ASCII characters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in. any character %TRUE if @c is an ASCII printing character other than space. Determines whether a character is an ASCII lower case letter. Unlike the standard C library islower() function, this only recognizes standard ASCII letters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to worry about casting to #guchar before passing a possibly non-ASCII character in. any character %TRUE if @c is an ASCII lower case letter Determines whether a character is a printing character. Unlike the standard C library isprint() function, this only recognizes standard ASCII characters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in. any character %TRUE if @c is an ASCII printing character. Determines whether a character is a punctuation character. Unlike the standard C library ispunct() function, this only recognizes standard ASCII letters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in. any character %TRUE if @c is an ASCII punctuation character. Determines whether a character is a white-space character. Unlike the standard C library isspace() function, this only recognizes standard ASCII white-space and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in. any character %TRUE if @c is an ASCII white-space character Determines whether a character is an ASCII upper case letter. Unlike the standard C library isupper() function, this only recognizes standard ASCII letters and ignores the locale, returning %FALSE for all non-ASCII characters. Also, unlike the standard library function, this takes a char, not an int, so don't call it on %EOF, but no need to worry about casting to #guchar before passing a possibly non-ASCII character in. any character %TRUE if @c is an ASCII upper case letter Determines whether a character is a hexadecimal-digit character. Unlike the standard C library isxdigit() function, this takes a char, not an int, so don't call it on %EOF, but no need to cast to #guchar before passing a possibly non-ASCII character in. any character %TRUE if @c is an ASCII hexadecimal-digit character. Compare two strings, ignoring the case of ASCII characters. Unlike the BSD strcasecmp() function, this only recognizes standard ASCII letters and ignores the locale, treating all non-ASCII bytes as if they are not letters. This function should be used only on strings that are known to be in encodings where the bytes corresponding to ASCII letters always represent themselves. This includes UTF-8 and the ISO-8859-* charsets, but not for instance double-byte encodings like the Windows Codepage 932, where the trailing bytes of double-byte characters include all ASCII letters. If you compare two CP932 strings using this function, you will get false matches. Both @s1 and @s2 must be non-%NULL. string to compare with @s2 string to compare with @s1 0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2. Converts all upper case ASCII letters to lower case ASCII letters. a string length of @str in bytes, or -1 if @str is nul-terminated a newly-allocated string, with all the upper case characters in @str converted to lower case, with semantics that exactly match g_ascii_tolower(). (Note that this is unlike the old g_strdown(), which modified the string in place.) Compare @s1 and @s2, ignoring the case of ASCII characters and any characters after the first @n in each string. Unlike the BSD strcasecmp() function, this only recognizes standard ASCII letters and ignores the locale, treating all non-ASCII characters as if they are not letters. The same warning as in g_ascii_strcasecmp() applies: Use this function only on strings known to be in encodings where bytes corresponding to ASCII letters always represent themselves. string to compare with @s2 string to compare with @s1 number of characters to compare 0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2. Converts a string to a #gdouble value. This function behaves like the standard strtod() function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. A limitation of the implementation is that this function will still accept localized versions of infinities and NANs. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive system strtod() function. To convert from a #gdouble to a string in a locale-insensitive way, use g_ascii_dtostr(). If the correct value would cause overflow, plus or minus %HUGE_VAL is returned (according to the sign of the value), and %ERANGE is stored in %errno. If the correct value would cause underflow, zero is returned and %ERANGE is stored in %errno. This function resets %errno before calling strtod() so that you can reliably detect overflow and underflow. the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion. the #gdouble value. Converts a string to a #gint64 value. This function behaves like the standard strtoll() function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive system strtoll() function. If the correct value would cause overflow, %G_MAXINT64 or %G_MININT64 is returned, and `ERANGE` is stored in `errno`. If the base is outside the valid range, zero is returned, and `EINVAL` is stored in `errno`. If the string conversion fails, zero is returned, and @endptr returns @nptr (if @endptr is non-%NULL). Since: 2.12 the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion. to be used for the conversion, 2..36 or 0 the #gint64 value or zero on error. Converts a string to a #guint64 value. This function behaves like the standard strtoull() function does in the C locale. It does this without actually changing the current locale, since that would not be thread-safe. This function is typically used when reading configuration files or other non-user input that should be locale independent. To handle input from the user you should normally use the locale-sensitive system strtoull() function. If the correct value would cause overflow, %G_MAXUINT64 is returned, and `ERANGE` is stored in `errno`. If the base is outside the valid range, zero is returned, and `EINVAL` is stored in `errno`. If the string conversion fails, zero is returned, and @endptr returns @nptr (if @endptr is non-%NULL). Since: 2.2 the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion. to be used for the conversion, 2..36 or 0 the #guint64 value or zero on error. Converts all lower case ASCII letters to upper case ASCII letters. a string length of @str in bytes, or -1 if @str is nul-terminated a newly allocated string, with all the lower case characters in @str converted to upper case, with semantics that exactly match g_ascii_toupper(). (Note that this is unlike the old g_strup(), which modified the string in place.) Convert a character to ASCII lower case. Unlike the standard C library tolower() function, this only recognizes standard ASCII letters and ignores the locale, returning all non-ASCII characters unchanged, even if they are lower case letters in a particular character set. Also unlike the standard library function, this takes and returns a char, not an int, so don't call it on %EOF but no need to worry about casting to #guchar before passing a possibly non-ASCII character in. any character the result of converting @c to lower case. If @c is not an ASCII upper case letter, @c is returned unchanged. Convert a character to ASCII upper case. Unlike the standard C library toupper() function, this only recognizes standard ASCII letters and ignores the locale, returning all non-ASCII characters unchanged, even if they are upper case letters in a particular character set. Also unlike the standard library function, this takes and returns a char, not an int, so don't call it on %EOF but no need to worry about casting to #guchar before passing a possibly non-ASCII character in. any character the result of converting @c to upper case. If @c is not an ASCII lower case letter, @c is returned unchanged. Determines the numeric value of a character as a hexidecimal digit. Differs from g_unichar_xdigit_value() because it takes a char, so there's no worry about sign extension if characters are signed. an ASCII character. If @c is a hex digit (according to g_ascii_isxdigit()), its numeric value. Otherwise, -1. Debugging macro to terminate the application if the assertion fails. If the assertion fails (i.e. the expression is not true), an error message is logged and the application is terminated. The macro can be turned off in final releases of code by defining `G_DISABLE_ASSERT` when compiling the application. the expression to check Debugging macro to compare two floating point numbers. The effect of `g_assert_cmpfloat (n1, op, n2)` is the same as `g_assert_true (n1 op n2)`. The advantage of this macro is that it can produce a message that includes the actual values of @n1 and @n2. Since: 2.16 an floating point number The comparison operator to use. One of ==, !=, <, >, <=, >=. another floating point number Debugging macro to compare to unsigned integers. This is a variant of g_assert_cmpuint() that displays the numbers in hexadecimal notation in the message. Since: 2.16 an unsigned integer The comparison operator to use. One of ==, !=, <, >, <=, >=. another unsigned integer Debugging macro to compare two integers. The effect of `g_assert_cmpint (n1, op, n2)` is the same as `g_assert_true (n1 op n2)`. The advantage of this macro is that it can produce a message that includes the actual values of @n1 and @n2. Since: 2.16 an integer The comparison operator to use. One of ==, !=, <, >, <=, >=. another integer Debugging macro to compare two strings. If the comparison fails, an error message is logged and the application is either terminated or the testcase marked as failed. The strings are compared using g_strcmp0(). The effect of `g_assert_cmpstr (s1, op, s2)` is the same as `g_assert_true (g_strcmp0 (s1, s2) op 0)`. The advantage of this macro is that it can produce a message that includes the actual values of @s1 and @s2. |[<!-- language="C" --> g_assert_cmpstr (mystring, ==, "fubar"); ]| Since: 2.16 a string (may be %NULL) The comparison operator to use. One of ==, !=, <, >, <=, >=. another string (may be %NULL) Debugging macro to compare two unsigned integers. The effect of `g_assert_cmpuint (n1, op, n2)` is the same as `g_assert_true (n1 op n2)`. The advantage of this macro is that it can produce a message that includes the actual values of @n1 and @n2. Since: 2.16 an unsigned integer The comparison operator to use. One of ==, !=, <, >, <=, >=. another unsigned integer Debugging macro to check that a method has returned the correct #GError. The effect of `g_assert_error (err, dom, c)` is the same as `g_assert_true (err != NULL && err->domain == dom && err->code == c)`. The advantage of this macro is that it can produce a message that includes the incorrect error message and code. This can only be used to test for a specific error. If you want to test that @err is set, but don't care what it's set to, just use `g_assert (err != NULL)` Since: 2.20 a #GError, possibly %NULL the expected error domain (a #GQuark) the expected error code Debugging macro to check an expression is false. If the assertion fails (i.e. the expression is not false), an error message is logged and the application is either terminated or the testcase marked as failed. See g_test_set_nonfatal_assertions(). Since: 2.38 the expression to check Debugging macro to check that a #GError is not set. The effect of `g_assert_no_error (err)` is the same as `g_assert_true (err == NULL)`. The advantage of this macro is that it can produce a message that includes the error message and code. Since: 2.20 a #GError, possibly %NULL Debugging macro to check an expression is not %NULL. If the assertion fails (i.e. the expression is %NULL), an error message is logged and the application is either terminated or the testcase marked as failed. See g_test_set_nonfatal_assertions(). Since: 2.40 the expression to check Debugging macro to terminate the application if it is ever reached. If it is reached, an error message is logged and the application is terminated. The macro can be turned off in final releases of code by defining `G_DISABLE_ASSERT` when compiling the application. Debugging macro to check an expression is %NULL. If the assertion fails (i.e. the expression is not %NULL), an error message is logged and the application is either terminated or the testcase marked as failed. See g_test_set_nonfatal_assertions(). Since: 2.38 the expression to check Debugging macro to check that an expression is true. If the assertion fails (i.e. the expression is not true), an error message is logged and the application is either terminated or the testcase marked as failed. See g_test_set_nonfatal_assertions(). Since: 2.38 the expression to check Returns the length of the queue. Actually this function returns the number of data items in the queue minus the number of waiting threads, so a negative value means waiting threads, and a positive value means available entries in the @queue. A return value of 0 could mean n entries in the queue and n threads waiting. This can happen due to locking of the queue or due to scheduling. a #GAsyncQueue. the length of the @queue Returns the length of the queue. Actually this function returns the number of data items in the queue minus the number of waiting threads, so a negative value means waiting threads, and a positive value means available entries in the @queue. A return value of 0 could mean n entries in the queue and n threads waiting. This can happen due to locking of the queue or due to scheduling. This function must be called while holding the @queue's lock. a #GAsyncQueue the length of the @queue. Acquires the @queue's lock. If another thread is already holding the lock, this call will block until the lock becomes available. Call g_async_queue_unlock() to drop the lock again. While holding the lock, you can only call the g_async_queue_*_unlocked() functions on @queue. Otherwise, deadlock may occur. a #GAsyncQueue Creates a new asynchronous queue. a new #GAsyncQueue. Free with g_async_queue_unref() Creates a new asynchronous queue and sets up a destroy notify function that is used to free any remaining queue items when the queue is destroyed after the final unref. Since: 2.16 function to free queue elements a new #GAsyncQueue. Free with g_async_queue_unref() Pops data from the @queue. If @queue is empty, this function blocks until data becomes available. a #GAsyncQueue data from the queue Pops data from the @queue. If @queue is empty, this function blocks until data becomes available. This function must be called while holding the @queue's lock. a #GAsyncQueue data from the queue. Pushes the @data into the @queue. @data must not be %NULL. a #GAsyncQueue @data to push into the @queue Pushes the @data into the @queue. @data must not be %NULL. In contrast to g_async_queue_push(), this function pushes the new item ahead of the items already in the queue, so that it will be the next one to be popped off the queue. Since: 2.46 a #GAsyncQueue @data to push into the @queue Pushes the @data into the @queue. @data must not be %NULL. In contrast to g_async_queue_push_unlocked(), this function pushes the new item ahead of the items already in the queue, so that it will be the next one to be popped off the queue. This function must be called while holding the @queue's lock. Since: 2.46 a #GAsyncQueue @data to push into the @queue Inserts @data into @queue using @func to determine the new position. This function requires that the @queue is sorted before pushing on new elements, see g_async_queue_sort(). This function will lock @queue before it sorts the queue and unlock it when it is finished. For an example of @func see g_async_queue_sort(). Since: 2.10 a #GAsyncQueue the @data to push into the @queue the #GCompareDataFunc is used to sort @queue user data passed to @func. Inserts @data into @queue using @func to determine the new position. The sort function @func is passed two elements of the @queue. It should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element. This function requires that the @queue is sorted before pushing on new elements, see g_async_queue_sort(). This function must be called while holding the @queue's lock. For an example of @func see g_async_queue_sort(). Since: 2.10 a #GAsyncQueue the @data to push into the @queue the #GCompareDataFunc is used to sort @queue user data passed to @func. Pushes the @data into the @queue. @data must not be %NULL. This function must be called while holding the @queue's lock. a #GAsyncQueue @data to push into the @queue Increases the reference count of the asynchronous @queue by 1. You do not need to hold the lock to call this function. a #GAsyncQueue the @queue that was passed in (since 2.6) Increases the reference count of the asynchronous @queue by 1. Deprecated: 2.8: Reference counting is done atomically. so g_async_queue_ref() can be used regardless of the @queue's lock. a #GAsyncQueue Remove an item from the queue. This function does not block. Since: 2.46 a #GAsyncQueue the @data to remove from the @queue %TRUE if the item was removed Remove an item from the queue. This function does not block. This function must be called while holding the @queue's lock. Since: 2.46 a #GAsyncQueue the @data to remove from the @queue %TRUE if the item was removed Sorts @queue using @func. The sort function @func is passed two elements of the @queue. It should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element. This function will lock @queue before it sorts the queue and unlock it when it is finished. If you were sorting a list of priority numbers to make sure the lowest priority would be at the top of the queue, you could use: |[<!-- language="C" --> gint32 id1; gint32 id2; id1 = GPOINTER_TO_INT (element1); id2 = GPOINTER_TO_INT (element2); return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1); ]| Since: 2.10 a #GAsyncQueue the #GCompareDataFunc is used to sort @queue user data passed to @func Sorts @queue using @func. The sort function @func is passed two elements of the @queue. It should return 0 if they are equal, a negative value if the first element should be higher in the @queue or a positive value if the first element should be lower in the @queue than the second element. This function must be called while holding the @queue's lock. Since: 2.10 a #GAsyncQueue the #GCompareDataFunc is used to sort @queue user data passed to @func Pops data from the @queue. If the queue is empty, blocks until @end_time or until data becomes available. If no data is received before @end_time, %NULL is returned. To easily calculate @end_time, a combination of g_get_current_time() and g_time_val_add() can be used. Deprecated: use g_async_queue_timeout_pop(). a #GAsyncQueue a #GTimeVal, determining the final time data from the queue or %NULL, when no data is received before @end_time. Pops data from the @queue. If the queue is empty, blocks until @end_time or until data becomes available. If no data is received before @end_time, %NULL is returned. To easily calculate @end_time, a combination of g_get_current_time() and g_time_val_add() can be used. This function must be called while holding the @queue's lock. Deprecated: use g_async_queue_timeout_pop_unlocked(). a #GAsyncQueue a #GTimeVal, determining the final time data from the queue or %NULL, when no data is received before @end_time. Pops data from the @queue. If the queue is empty, blocks for @timeout microseconds, or until data becomes available. If no data is received before the timeout, %NULL is returned. a #GAsyncQueue the number of microseconds to wait data from the queue or %NULL, when no data is received before the timeout. Pops data from the @queue. If the queue is empty, blocks for @timeout microseconds, or until data becomes available. If no data is received before the timeout, %NULL is returned. This function must be called while holding the @queue's lock. a #GAsyncQueue the number of microseconds to wait data from the queue or %NULL, when no data is received before the timeout. Tries to pop data from the @queue. If no data is available, %NULL is returned. a #GAsyncQueue data from the queue or %NULL, when no data is available immediately. Tries to pop data from the @queue. If no data is available, %NULL is returned. This function must be called while holding the @queue's lock. a #GAsyncQueue data from the queue or %NULL, when no data is available immediately. Releases the queue's lock. Calling this function when you have not acquired the with g_async_queue_lock() leads to undefined behaviour. a #GAsyncQueue Decreases the reference count of the asynchronous @queue by 1. If the reference count went to 0, the @queue will be destroyed and the memory allocated will be freed. So you are not allowed to use the @queue afterwards, as it might have disappeared. You do not need to hold the lock to call this function. a #GAsyncQueue. Decreases the reference count of the asynchronous @queue by 1 and releases the lock. This function must be called while holding the @queue's lock. If the reference count went to 0, the @queue will be destroyed and the memory allocated will be freed. Deprecated: 2.8: Reference counting is done atomically. so g_async_queue_unref() can be used regardless of the @queue's lock. a #GAsyncQueue Specifies a function to be called at normal program termination. Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor macro that maps to a call to the atexit() function in the C library. This means that in case the code that calls g_atexit(), i.e. atexit(), is in a DLL, the function will be called when the DLL is detached from the program. This typically makes more sense than that the function is called when the GLib DLL is detached, which happened earlier when g_atexit() was a function in the GLib DLL. The behaviour of atexit() in the context of dynamically loaded modules is not formally specified and varies wildly. On POSIX systems, calling g_atexit() (or atexit()) in a dynamically loaded module which is unloaded before the program terminates might well cause a crash at program exit. Some POSIX systems implement atexit() like Windows, and have each dynamically loaded module maintain an own atexit chain that is called when the module is unloaded. On other POSIX systems, before a dynamically loaded module is unloaded, the registered atexit functions (if any) residing in that module are called, regardless where the code that registered them resided. This is presumably the most robust approach. As can be seen from the above, for portability it's best to avoid calling g_atexit() (or atexit()) except in the main executable of a program. Deprecated:2.32: It is best to avoid g_atexit(). the function to call on normal program termination. Atomically adds @val to the value of @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic += val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. Before version 2.30, this function did not return a value (but g_atomic_int_exchange_and_add() did, and had the same meaning). Since: 2.4 a pointer to a #gint or #guint the value to add the value of @atomic before the add, signed Performs an atomic bitwise 'and' of the value of @atomic and @val, storing the result back in @atomic. This call acts as a full compiler and hardware memory barrier. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic &= val; return tmp; }`. Since: 2.30 a pointer to a #gint or #guint the value to 'and' the value of @atomic before the operation, unsigned Compares @atomic to @oldval and, if equal, sets it to @newval. If @atomic was not equal to @oldval then no change occurs. This compare and exchange is done atomically. Think of this operation as an atomic version of `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`. This call acts as a full compiler and hardware memory barrier. Since: 2.4 a pointer to a #gint or #guint the value to compare with the value to conditionally replace with %TRUE if the exchange took place Decrements the value of @atomic by 1. Think of this operation as an atomic version of `{ *atomic -= 1; return (*atomic == 0); }`. This call acts as a full compiler and hardware memory barrier. Since: 2.4 a pointer to a #gint or #guint %TRUE if the resultant value is zero This function existed before g_atomic_int_add() returned the prior value of the integer (which it now does). It is retained only for compatibility reasons. Don't use this function in new code. Since: 2.4 Deprecated: 2.30: Use g_atomic_int_add() instead. a pointer to a #gint the value to add the value of @atomic before the add, signed Gets the current value of @atomic. This call acts as a full compiler and hardware memory barrier (before the get). Since: 2.4 a pointer to a #gint or #guint the value of the integer Increments the value of @atomic by 1. Think of this operation as an atomic version of `{ *atomic += 1; }`. This call acts as a full compiler and hardware memory barrier. Since: 2.4 a pointer to a #gint or #guint Performs an atomic bitwise 'or' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic |= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. Since: 2.30 a pointer to a #gint or #guint the value to 'or' the value of @atomic before the operation, unsigned Sets the value of @atomic to @newval. This call acts as a full compiler and hardware memory barrier (after the set). Since: 2.4 a pointer to a #gint or #guint a new value to store Performs an atomic bitwise 'xor' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic ^= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. Since: 2.30 a pointer to a #gint or #guint the value to 'xor' the value of @atomic before the operation, unsigned Atomically adds @val to the value of @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic += val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. Since: 2.30 a pointer to a #gpointer-sized value the value to add the value of @atomic before the add, signed Performs an atomic bitwise 'and' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic &= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. Since: 2.30 a pointer to a #gpointer-sized value the value to 'and' the value of @atomic before the operation, unsigned Compares @atomic to @oldval and, if equal, sets it to @newval. If @atomic was not equal to @oldval then no change occurs. This compare and exchange is done atomically. Think of this operation as an atomic version of `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`. This call acts as a full compiler and hardware memory barrier. Since: 2.4 a pointer to a #gpointer-sized value the value to compare with the value to conditionally replace with %TRUE if the exchange took place Gets the current value of @atomic. This call acts as a full compiler and hardware memory barrier (before the get). Since: 2.4 a pointer to a #gpointer-sized value the value of the pointer Performs an atomic bitwise 'or' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic |= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. Since: 2.30 a pointer to a #gpointer-sized value the value to 'or' the value of @atomic before the operation, unsigned Sets the value of @atomic to @newval. This call acts as a full compiler and hardware memory barrier (after the set). Since: 2.4 a pointer to a #gpointer-sized value a new value to store Performs an atomic bitwise 'xor' of the value of @atomic and @val, storing the result back in @atomic. Think of this operation as an atomic version of `{ tmp = *atomic; *atomic ^= val; return tmp; }`. This call acts as a full compiler and hardware memory barrier. Since: 2.30 a pointer to a #gpointer-sized value the value to 'xor' the value of @atomic before the operation, unsigned Helper to declare a variable with automatic cleanup. The variable is cleaned up in a way appropriate to its type when the variable goes out of scope. The type must support this. This feature is only supported on GCC and clang. This macro is not defined on other compilers and should not be used in programs that are intended to be portable to those compilers. This is meant to be used with stack-allocated structures and non-pointer types. For the (more commonly used) pointer version, see g_autoptr(). This macro can be used to avoid having to do explicit cleanups of local variables when exiting functions. It often vastly simplifies handling of error conditions, removing the need for various tricks such as 'goto out' or repeating of cleanup code. It is also helpful for non-error cases. Consider the following example: |[ GVariant * my_func(void) { g_auto(GQueue) queue = G_QUEUE_INIT; g_auto(GVariantBuilder) builder; g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT); ... if (error_condition) return NULL; ... return g_variant_builder_end (&builder); } ]| You must initialise the variable in some way -- either by use of an initialiser or by ensuring that an _init function will be called on it unconditionally before it goes out of scope. Since: 2.44 a supported variable type Macro to add an attribute to pointer variable to ensure automatic cleanup using g_free(). This macro differs from g_autoptr() in that it is an attribute supplied before the type name, rather than wrapping the type definition. Instead of using a type-specific lookup, this macro always calls g_free() directly. This means it's useful for any type that is returned from g_malloc(). Otherwise, this macro has similar constraints as g_autoptr() - only supported on GCC and clang, the variable must be initialized, etc. |[ gboolean operate_on_malloc_buf (void) { g_autofree guint8* membuf = NULL; membuf = g_malloc (8192); / * Some computation on membuf * / / * membuf will be automatically freed here * / return TRUE; } ]| Since: 2.44 Helper to declare a pointer variable with automatic cleanup. The variable is cleaned up in a way appropriate to its type when the variable goes out of scope. The type must support this. This feature is only supported on GCC and clang. This macro is not defined on other compilers and should not be used in programs that are intended to be portable to those compilers. This is meant to be used to declare pointers to types with cleanup functions. The type of the variable is a pointer to @TypeName. You must not add your own '*'. This macro can be used to avoid having to do explicit cleanups of local variables when exiting functions. It often vastly simplifies handling of error conditions, removing the need for various tricks such as 'goto out' or repeating of cleanup code. It is also helpful for non-error cases. Consider the following example: |[ gboolean check_exists(GVariant *dict) { g_autoptr(GVariant) dirname; g_autoptr(GVariant) basename = NULL; g_autoptr(gchar) path = NULL; dirname = g_variant_lookup_value (dict, "dirname", G_VARIANT_TYPE_STRING); if (dirname == NULL) return FALSE; basename = g_variant_lookup_value (dict, "basename", G_VARIANT_TYPE_STRING); if (basename == NULL) return FALSE; path = g_build_filename (g_variant_get_string (dirname, NULL), g_variant_get_string (basename, NULL), NULL); return g_access (path, R_OK) == 0; } ]| You must initialise the variable in some way -- either by use of an initialiser or by ensuring that it is assigned to unconditionally before it goes out of scope. Since: 2.44 a supported variable type Decode a sequence of Base-64 encoded text into binary data. Note that the returned binary data is not necessarily zero-terminated, so it should not be used as a character string. Since: 2.12 zero-terminated string with base64 text to decode The length of the decoded data is written here newly allocated buffer containing the binary data that @text represents. The returned buffer must be freed with g_free(). Decode a sequence of Base-64 encoded text into binary data by overwriting the input data. Since: 2.20 zero-terminated string with base64 text to decode The length of the decoded data is written here The binary data that @text responds. This pointer is the same as the input @text. Incrementally decode a sequence of binary data from its Base-64 stringified representation. By calling this function multiple times you can convert data in chunks to avoid having to have the full encoded data in memory. The output buffer must be large enough to fit all the data that will be written to it. Since base64 encodes 3 bytes in 4 chars you need at least: (@len / 4) * 3 + 3 bytes (+ 3 may be needed in case of non-zero state). Since: 2.12 binary input data max length of @in data to decode output buffer Saved state between steps, initialize to 0 Saved state between steps, initialize to 0 The number of bytes of output that was written Encode a sequence of binary data into its Base-64 stringified representation. Since: 2.12 the binary data to encode the length of @data a newly allocated, zero-terminated Base-64 encoded string representing @data. The returned string must be freed with g_free(). Flush the status from a sequence of calls to g_base64_encode_step(). The output buffer must be large enough to fit all the data that will be written to it. It will need up to 4 bytes, or up to 5 bytes if line-breaking is enabled. Since: 2.12 whether to break long lines pointer to destination buffer Saved state from g_base64_encode_step() Saved state from g_base64_encode_step() The number of bytes of output that was written Incrementally encode a sequence of binary data into its Base-64 stringified representation. By calling this function multiple times you can convert data in chunks to avoid having to have the full encoded data in memory. When all of the data has been converted you must call g_base64_encode_close() to flush the saved state. The output buffer must be large enough to fit all the data that will be written to it. Due to the way base64 encodes you will need at least: (@len / 3 + 1) * 4 + 4 bytes (+ 4 may be needed in case of non-zero state). If you enable line-breaking you will need at least: ((@len / 3 + 1) * 4 + 4) / 72 + 1 bytes of extra space. @break_lines is typically used when putting base64-encoded data in emails. It breaks the lines at 72 columns instead of putting all of the text on the same line. This avoids problems with long lines in the email system. Note however that it breaks the lines with `LF` characters, not `CR LF` sequences, so the result cannot be passed directly to SMTP or certain other protocols. Since: 2.12 the binary data to encode the length of @in whether to break long lines pointer to destination buffer Saved state between steps, initialize to 0 Saved state between steps, initialize to 0 The number of bytes of output that was written Gets the name of the file without any leading directory components. It returns a pointer into the given file name string. Deprecated:2.2: Use g_path_get_basename() instead, but notice that g_path_get_basename() allocates new memory for the returned string, unlike this function which returns a pointer into the argument. the name of the file the name of the file without any leading directory components Retrieves the flags passed when constructing the #GBinding. Since: 2.26 a #GBinding the #GBindingFlags used by the #GBinding Retrieves the #GObject instance used as the source of the binding. Since: 2.26 a #GBinding the source #GObject Retrieves the name of the property of #GBinding:source used as the source of the binding. Since: 2.26 a #GBinding the name of the source property Retrieves the #GObject instance used as the target of the binding. Since: 2.26 a #GBinding the target #GObject Retrieves the name of the property of #GBinding:target used as the target of the binding. Since: 2.26 a #GBinding the name of the target property Explicitly releases the binding between the source and the target property expressed by @binding. This function will release the reference that is being held on the @binding instance; if you want to hold on to the #GBinding instance after calling g_binding_unbind(), you will need to hold a reference to it. Since: 2.38 a #GBinding Sets the indicated @lock_bit in @address. If the bit is already set, this call will block until g_bit_unlock() unsets the corresponding bit. Attempting to lock on two different bits within the same integer is not supported and will very probably cause deadlocks. The value of the bit that is set is (1u << @bit). If @bit is not between 0 and 31 then the result is undefined. This function accesses @address atomically. All other accesses to @address must be atomic in order for this function to work reliably. Since: 2.24 a pointer to an integer a bit value between 0 and 31 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. a #gulong containing flags the index of the bit to start the search from the index of the first bit set which is higher than @nth_bit 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. a #gulong containing flags the index of the bit to start the search from the index of the first bit set which is lower than @nth_bit Gets the number of bits used to hold @number, e.g. if @number is 4, 3 bits are needed. a #guint the number of bits used to hold @number Sets the indicated @lock_bit in @address, returning %TRUE if successful. If the bit is already set, returns %FALSE immediately. Attempting to lock on two different bits within the same integer is not supported. The value of the bit that is set is (1u << @bit). If @bit is not between 0 and 31 then the result is undefined. This function accesses @address atomically. All other accesses to @address must be atomic in order for this function to work reliably. Since: 2.24 a pointer to an integer a bit value between 0 and 31 %TRUE if the lock was acquired Clears the indicated @lock_bit in @address. If another thread is currently blocked in g_bit_lock() on this same bit then it will be woken up. This function accesses @address atomically. All other accesses to @address must be atomic in order for this function to work reliably. Since: 2.24 a pointer to an integer a bit value between 0 and 31 Adds the application with @name and @exec to the list of applications that have registered a bookmark for @uri into @bookmark. Every bookmark inside a #GBookmarkFile must have at least an application registered. Each application must provide a name, a command line useful for launching the bookmark, the number of times the bookmark has been registered by the application and the last time the application registered this bookmark. If @name is %NULL, the name of the application will be the same returned by g_get_application_name(); if @exec is %NULL, the command line will be a composition of the program name as returned by g_get_prgname() and the "\%u" modifier, which will be expanded to the bookmark's URI. This function will automatically take care of updating the registrations count and timestamping in case an application with the same @name had already registered a bookmark for @uri inside @bookmark. If no bookmark for @uri is found, one is created. Since: 2.12 a #GBookmarkFile a valid URI the name of the application registering the bookmark or %NULL command line to be used to launch the bookmark or %NULL Adds @group to the list of groups to which the bookmark for @uri belongs to. If no bookmark for @uri is found then it is created. Since: 2.12 a #GBookmarkFile a valid URI the group name to be added Frees a #GBookmarkFile. Since: 2.12 a #GBookmarkFile Gets the time the bookmark for @uri was added to @bookmark In the event the URI cannot be found, -1 is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. Since: 2.12 a #GBookmarkFile a valid URI return location for a #GError, or %NULL a timestamp Gets the registration informations of @app_name for the bookmark for @uri. See g_bookmark_file_set_app_info() for more informations about the returned data. The string returned in @app_exec must be freed. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that no application with name @app_name has registered a bookmark for @uri, %FALSE is returned and error is set to #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting the command line fails, an error of the #G_SHELL_ERROR domain is set and %FALSE is returned. Since: 2.12 a #GBookmarkFile a valid URI an application's name return location for the command line of the application, or %NULL return location for the registration count, or %NULL return location for the last registration time, or %NULL return location for a #GError, or %NULL %TRUE on success. Retrieves the names of the applications that have registered the bookmark for @uri. In the event the URI cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. Since: 2.12 a #GBookmarkFile a valid URI return location of the length of the returned list, or %NULL return location for a #GError, or %NULL a newly allocated %NULL-terminated array of strings. Use g_strfreev() to free it. Retrieves the description of the bookmark for @uri. In the event the URI cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. Since: 2.12 a #GBookmarkFile a valid URI return location for a #GError, or %NULL a newly allocated string or %NULL if the specified URI cannot be found. Retrieves the list of group names of the bookmark for @uri. In the event the URI cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. The returned array is %NULL terminated, so @length may optionally be %NULL. Since: 2.12 a #GBookmarkFile a valid URI return location for the length of the returned string, or %NULL return location for a #GError, or %NULL a newly allocated %NULL-terminated array of group names. Use g_strfreev() to free it. Gets the icon of the bookmark for @uri. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. Since: 2.12 a #GBookmarkFile a valid URI return location for the icon's location or %NULL return location for the icon's MIME type or %NULL return location for a #GError or %NULL %TRUE if the icon for the bookmark for the URI was found. You should free the returned strings. Gets whether the private flag of the bookmark for @uri is set. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that the private flag cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE. Since: 2.12 a #GBookmarkFile a valid URI return location for a #GError, or %NULL %TRUE if the private flag is set, %FALSE otherwise. Retrieves the MIME type of the resource pointed by @uri. In the event the URI cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that the MIME type cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE. Since: 2.12 a #GBookmarkFile a valid URI return location for a #GError, or %NULL a newly allocated string or %NULL if the specified URI cannot be found. Gets the time when the bookmark for @uri was last modified. In the event the URI cannot be found, -1 is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. Since: 2.12 a #GBookmarkFile a valid URI return location for a #GError, or %NULL a timestamp Gets the number of bookmarks inside @bookmark. Since: 2.12 a #GBookmarkFile the number of bookmarks Returns the title of the bookmark for @uri. If @uri is %NULL, the title of @bookmark is returned. In the event the URI cannot be found, %NULL is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. Since: 2.12 a #GBookmarkFile a valid URI or %NULL return location for a #GError, or %NULL a newly allocated string or %NULL if the specified URI cannot be found. Returns all URIs of the bookmarks in the bookmark file @bookmark. The array of returned URIs will be %NULL-terminated, so @length may optionally be %NULL. Since: 2.12 a #GBookmarkFile return location for the number of returned URIs, or %NULL a newly allocated %NULL-terminated array of strings. Use g_strfreev() to free it. Gets the time the bookmark for @uri was last visited. In the event the URI cannot be found, -1 is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. Since: 2.12 a #GBookmarkFile a valid URI return location for a #GError, or %NULL a timestamp. Checks whether the bookmark for @uri inside @bookmark has been registered by application @name. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. Since: 2.12 a #GBookmarkFile a valid URI the name of the application return location for a #GError or %NULL %TRUE if the application @name was found Checks whether @group appears in the list of groups to which the bookmark for @uri belongs to. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. Since: 2.12 a #GBookmarkFile a valid URI the group name to be searched return location for a #GError, or %NULL %TRUE if @group was found. Looks whether the desktop bookmark has an item with its URI set to @uri. Since: 2.12 a #GBookmarkFile a valid URI %TRUE if @uri is inside @bookmark, %FALSE otherwise Loads a bookmark file from memory into an empty #GBookmarkFile structure. If the object cannot be created then @error is set to a #GBookmarkFileError. Since: 2.12 an empty #GBookmarkFile struct desktop bookmarks loaded in memory the length of @data in bytes return location for a #GError, or %NULL %TRUE if a desktop bookmark could be loaded. This function looks for a desktop bookmark file named @file in the paths returned from g_get_user_data_dir() and g_get_system_data_dirs(), loads the file into @bookmark and returns the file's full path in @full_path. If the file could not be loaded then an %error is set to either a #GFileError or #GBookmarkFileError. Since: 2.12 a #GBookmarkFile a relative path to a filename to open and parse return location for a string containing the full path of the file, or %NULL return location for a #GError, or %NULL %TRUE if a key file could be loaded, %FALSE otherwise Loads a desktop bookmark file into an empty #GBookmarkFile structure. If the file could not be loaded then @error is set to either a #GFileError or #GBookmarkFileError. Since: 2.12 an empty #GBookmarkFile struct the path of a filename to load, in the GLib file name encoding return location for a #GError, or %NULL %TRUE if a desktop bookmark file could be loaded Changes the URI of a bookmark item from @old_uri to @new_uri. Any existing bookmark for @new_uri will be overwritten. If @new_uri is %NULL, then the bookmark is removed. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. Since: 2.12 a #GBookmarkFile a valid URI a valid URI, or %NULL return location for a #GError or %NULL %TRUE if the URI was successfully changed Creates a new empty #GBookmarkFile object. Use g_bookmark_file_load_from_file(), g_bookmark_file_load_from_data() or g_bookmark_file_load_from_data_dirs() to read an existing bookmark file. Since: 2.12 an empty #GBookmarkFile Removes application registered with @name from the list of applications that have registered a bookmark for @uri inside @bookmark. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event that no application with name @app_name has registered a bookmark for @uri, %FALSE is returned and error is set to #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. Since: 2.12 a #GBookmarkFile a valid URI the name of the application return location for a #GError or %NULL %TRUE if the application was successfully removed. Removes @group from the list of groups to which the bookmark for @uri belongs to. In the event the URI cannot be found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND. In the event no group was defined, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE. Since: 2.12 a #GBookmarkFile a valid URI the group name to be removed return location for a #GError, or %NULL %TRUE if @group was successfully removed. Removes the bookmark for @uri from the bookmark file @bookmark. Since: 2.12 a #GBookmarkFile a valid URI return location for a #GError, or %NULL %TRUE if the bookmark was removed successfully. Sets the time the bookmark for @uri was added into @bookmark. If no bookmark for @uri is found then it is created. Since: 2.12 a #GBookmarkFile a valid URI a timestamp or -1 to use the current time Sets the meta-data of application @name inside the list of applications that have registered a bookmark for @uri inside @bookmark. You should rarely use this function; use g_bookmark_file_add_application() and g_bookmark_file_remove_application() instead. @name can be any UTF-8 encoded string used to identify an application. @exec can have one of these two modifiers: "\%f", which will be expanded as the local file name retrieved from the bookmark's URI; "\%u", which will be expanded as the bookmark's URI. The expansion is done automatically when retrieving the stored command line using the g_bookmark_file_get_app_info() function. @count is the number of times the application has registered the bookmark; if is < 0, the current registration count will be increased by one, if is 0, the application with @name will be removed from the list of registered applications. @stamp is the Unix time of the last registration; if it is -1, the current time will be used. If you try to remove an application by setting its registration count to zero, and no bookmark for @uri is found, %FALSE is returned and @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND; similarly, in the event that no application @name has registered a bookmark for @uri, %FALSE is returned and error is set to #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. Otherwise, if no bookmark for @uri is found, one is created. Since: 2.12 a #GBookmarkFile a valid URI an application's name an application's command line the number of registrations done for this application the time of the last registration for this application return location for a #GError or %NULL %TRUE if the application's meta-data was successfully changed. Sets @description as the description of the bookmark for @uri. If @uri is %NULL, the description of @bookmark is set. If a bookmark for @uri cannot be found then it is created. Since: 2.12 a #GBookmarkFile a valid URI or %NULL a string Sets a list of group names for the item with URI @uri. Each previously set group name list is removed. If @uri cannot be found then an item for it is created. Since: 2.12 a #GBookmarkFile an item's URI an array of group names, or %NULL to remove all groups number of group name values in @groups Sets the icon for the bookmark for @uri. If @href is %NULL, unsets the currently set icon. @href can either be a full URL for the icon file or the icon name following the Icon Naming specification. If no bookmark for @uri is found one is created. Since: 2.12 a #GBookmarkFile a valid URI the URI of the icon for the bookmark, or %NULL the MIME type of the icon for the bookmark Sets the private flag of the bookmark for @uri. If a bookmark for @uri cannot be found then it is created. Since: 2.12 a #GBookmarkFile a valid URI %TRUE if the bookmark should be marked as private Sets @mime_type as the MIME type of the bookmark for @uri. If a bookmark for @uri cannot be found then it is created. Since: 2.12 a #GBookmarkFile a valid URI a MIME type Sets the last time the bookmark for @uri was last modified. If no bookmark for @uri is found then it is created. The "modified" time should only be set when the bookmark's meta-data was actually changed. Every function of #GBookmarkFile that modifies a bookmark also changes the modification time, except for g_bookmark_file_set_visited(). Since: 2.12 a #GBookmarkFile a valid URI a timestamp or -1 to use the current time Sets @title as the title of the bookmark for @uri inside the bookmark file @bookmark. If @uri is %NULL, the title of @bookmark is set. If a bookmark for @uri cannot be found then it is created. Since: 2.12 a #GBookmarkFile a valid URI or %NULL a UTF-8 encoded string Sets the time the bookmark for @uri was last visited. If no bookmark for @uri is found then it is created. The "visited" time should only be set if the bookmark was launched, either using the command line retrieved by g_bookmark_file_get_app_info() or by the default application for the bookmark's MIME type, retrieved using g_bookmark_file_get_mime_type(). Changing the "visited" time does not affect the "modified" time. Since: 2.12 a #GBookmarkFile a valid URI a timestamp or -1 to use the current time This function outputs @bookmark as a string. Since: 2.12 a #GBookmarkFile return location for the length of the returned string, or %NULL return location for a #GError, or %NULL a newly allocated string holding the contents of the #GBookmarkFile This function outputs @bookmark into a file. The write process is guaranteed to be atomic by using g_file_set_contents() internally. Since: 2.12 a #GBookmarkFile path of the output file return location for a #GError, or %NULL %TRUE if the file was successfully written. Provide a copy of a boxed structure @src_boxed which is of type @boxed_type. The type of @src_boxed. The boxed structure to be copied. The newly created copy of the boxed structure. Free the boxed structure @boxed which is of type @boxed_type. The type of @boxed. The boxed structure to be freed. This function creates a new %G_TYPE_BOXED derived type id for a new boxed type with name @name. Boxed type handling functions have to be provided to copy and free opaque boxed structures of this type. Name of the new boxed type. Boxed structure copy function. Boxed structure free function. New %G_TYPE_BOXED derived type id for @name. Creates a filename from a series of elements using the correct separator for filenames. On Unix, this function behaves identically to `g_build_path (G_DIR_SEPARATOR_S, first_element, ....)`. On Windows, it takes into account that either the backslash (`\` or slash (`/`) can be used as separator in filenames, but otherwise behaves as on UNIX. When file pathname separators need to be inserted, the one that last previously occurred in the parameters (reading from left to right) is used. No attempt is made to force the resulting filename to be an absolute path. If the first element is a relative path, the result will be a relative path. the first element in the path remaining elements in path, terminated by %NULL a newly-allocated string that must be freed with g_free(). Behaves exactly like g_build_filename(), but takes the path elements as a string array, instead of varargs. This function is mainly meant for language bindings. Since: 2.8 %NULL-terminated array of strings containing the path elements. a newly-allocated string that must be freed with g_free(). Creates a path from a series of elements using @separator as the separator between elements. At the boundary between two elements, any trailing occurrences of separator in the first element, or leading occurrences of separator in the second element are removed and exactly one copy of the separator is inserted. Empty elements are ignored. The number of leading copies of the separator on the result is the same as the number of leading copies of the separator on the first non-empty element. The number of trailing copies of the separator on the result is the same as the number of trailing copies of the separator on the last non-empty element. (Determination of the number of trailing copies is done without stripping leading copies, so if the separator is `ABA`, then `ABABA` has 1 trailing copy.) However, if there is only a single non-empty element, and there are no characters in that element not part of the leading or trailing separators, then the result is exactly the original value of that element. Other than for determination of the number of leading and trailing copies of the separator, elements consisting only of copies of the separator are ignored. a string used to separator the elements of the path. the first element in the path remaining elements in path, terminated by %NULL a newly-allocated string that must be freed with g_free(). Behaves exactly like g_build_path(), but takes the path elements as a string array, instead of varargs. This function is mainly meant for language bindings. Since: 2.8 a string used to separator the elements of the path. %NULL-terminated array of strings containing the path elements. a newly-allocated string that must be freed with g_free(). Adds the given bytes to the end of the #GByteArray. The array will grow in size automatically if necessary. a #GByteArray the byte data to be added the number of bytes to add the #GByteArray Frees the memory allocated by the #GByteArray. If @free_segment is %TRUE it frees the actual byte data. If the reference count of @array is greater than one, the #GByteArray wrapper is preserved but the size of @array will be set to zero. a #GByteArray if %TRUE the actual byte data is freed as well the element data if @free_segment is %FALSE, otherwise %NULL. The element data should be freed using g_free(). Transfers the data from the #GByteArray into a new immutable #GBytes. The #GByteArray is freed unless the reference count of @array is greater than one, the #GByteArray wrapper is preserved but the size of @array will be set to zero. This is identical to using g_bytes_new_take() and g_byte_array_free() together. Since: 2.32 a #GByteArray a new immutable #GBytes representing same byte data that was in the array Creates a new #GByteArray with a reference count of 1. the new #GByteArray Create byte array containing the data. The data will be owned by the array and will be freed with g_free(), i.e. it could be allocated using g_strdup(). Since: 2.32 byte data for the array length of @data a new #GByteArray Adds the given data to the start of the #GByteArray. The array will grow in size automatically if necessary. a #GByteArray the byte data to be added the number of bytes to add the #GByteArray Atomically increments the reference count of @array by one. This function is thread-safe and may be called from any thread. Since: 2.22 A #GByteArray The passed in #GByteArray Removes the byte at the given index from a #GByteArray. The following bytes are moved down one place. a #GByteArray the index of the byte to remove the #GByteArray Removes the byte at the given index from a #GByteArray. The last element in the array is used to fill in the space, so this function does not preserve the order of the #GByteArray. But it is faster than g_byte_array_remove_index(). a #GByteArray the index of the byte to remove the #GByteArray Removes the given number of bytes starting at the given index from a #GByteArray. The following elements are moved to close the gap. Since: 2.4 a @GByteArray the index of the first byte to remove the number of bytes to remove the #GByteArray Sets the size of the #GByteArray, expanding it if necessary. a #GByteArray the new size of the #GByteArray the #GByteArray Creates a new #GByteArray with @reserved_size bytes preallocated. This avoids frequent reallocation, if you are going to add many bytes to the array. Note however that the size of the array is still 0. number of bytes preallocated the new #GByteArray Sorts a byte array, using @compare_func which should be a qsort()-style comparison function (returns less than zero for first arg is less than second arg, zero for equal, greater than zero if first arg is greater than second arg). If two array elements compare equal, their order in the sorted array is undefined. If you want equal elements to keep their order (i.e. you want a stable sort) you can write a comparison function that, if two elements would otherwise compare equal, compares them by their addresses. a #GByteArray comparison function Like g_byte_array_sort(), but the comparison function takes an extra user data argument. a #GByteArray comparison function data to pass to @compare_func Atomically decrements the reference count of @array by one. If the reference count drops to 0, all memory allocated by the array is released. This function is thread-safe and may be called from any thread. Since: 2.22 A #GByteArray Compares the two #GBytes values. This function can be used to sort GBytes instances in lexographical order. Since: 2.32 a pointer to a #GBytes a pointer to a #GBytes to compare with @bytes1 a negative value if bytes2 is lesser, a positive value if bytes2 is greater, and zero if bytes2 is equal to bytes1 Compares the two #GBytes values being pointed to and returns %TRUE if they are equal. This function can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL #GBytes pointers as keys in a #GHashTable. Since: 2.32 a pointer to a #GBytes a pointer to a #GBytes to compare with @bytes1 %TRUE if the two keys match. Get the byte data in the #GBytes. This data should not be modified. This function will always return the same pointer for a given #GBytes. %NULL may be returned if @size is 0. This is not guaranteed, as the #GBytes may represent an empty string with @data non-%NULL and @size as 0. %NULL will not be returned if @size is non-zero. Since: 2.32 a #GBytes location to return size of byte data a pointer to the byte data, or %NULL Get the size of the byte data in the #GBytes. This function will always return the same value for a given #GBytes. Since: 2.32 a #GBytes the size Creates an integer hash code for the byte data in the #GBytes. This function can be passed to g_hash_table_new() as the @key_hash_func parameter, when using non-%NULL #GBytes pointers as keys in a #GHashTable. Since: 2.32 a pointer to a #GBytes key a hash value corresponding to the key. Creates a new #GBytes from @data. @data is copied. If @size is 0, @data may be %NULL. Since: 2.32 the data to be used for the bytes the size of @data a new #GBytes Creates a #GBytes which is a subsection of another #GBytes. The @offset + @length may not be longer than the size of @bytes. A reference to @bytes will be held by the newly created #GBytes until the byte data is no longer needed. Since: 2.32 a #GBytes offset which subsection starts at length of subsection a new #GBytes Creates a new #GBytes from static data. @data must be static (ie: never modified or freed). It may be %NULL if @size is 0. Since: 2.32 the data to be used for the bytes the size of @data a new #GBytes Creates a new #GBytes from @data. After this call, @data belongs to the bytes and may no longer be modified by the caller. g_free() will be called on @data when the bytes is no longer in use. Because of this @data must have been created by a call to g_malloc(), g_malloc0() or g_realloc() or by one of the many functions that wrap these calls (such as g_new(), g_strdup(), etc). For creating #GBytes with memory from other allocators, see g_bytes_new_with_free_func(). @data may be %NULL if @size is 0. Since: 2.32 the data to be used for the bytes the size of @data a new #GBytes Creates a #GBytes from @data. When the last reference is dropped, @free_func will be called with the @user_data argument. @data must not be modified after this call is made until @free_func has been called to indicate that the bytes is no longer in use. @data may be %NULL if @size is 0. Since: 2.32 the data to be used for the bytes the size of @data the function to call to release the data data to pass to @free_func a new #GBytes Increase the reference count on @bytes. Since: 2.32 a #GBytes the #GBytes Releases a reference on @bytes. This may result in the bytes being freed. Since: 2.32 a #GBytes Unreferences the bytes, and returns a new mutable #GByteArray containing the same byte data. As an optimization, the byte data is transferred to the array without copying if this was the last reference to bytes and bytes was created with g_bytes_new(), g_bytes_new_take() or g_byte_array_free_to_bytes(). In all other cases the data is copied. Since: 2.32 a #GBytes a new mutable #GByteArray containing the same byte data Unreferences the bytes, and returns a pointer the same byte data contents. As an optimization, the byte data is returned without copying if this was the last reference to bytes and bytes was created with g_bytes_new(), g_bytes_new_take() or g_byte_array_free_to_bytes(). In all other cases the data is copied. Since: 2.32 a #GBytes location to place the length of the returned data a pointer to the same byte data, which should be freed with g_free() Frees the memory allocated for the #GCache. Note that it does not destroy the keys and values which were contained in the #GCache. Deprecated:2.32: Use a #GHashTable instead a #GCache Gets the value corresponding to the given key, creating it if necessary. It first checks if the value already exists in the #GCache, by using the @key_equal_func function passed to g_cache_new(). If it does already exist it is returned, and its reference count is increased by one. If the value does not currently exist, if is created by calling the @value_new_func. The key is duplicated by calling @key_dup_func and the duplicated key and value are inserted into the #GCache. Deprecated:2.32: Use a #GHashTable instead a #GCache a key describing a #GCache object a pointer to a #GCache value Calls the given function for each of the keys in the #GCache. NOTE @func is passed three parameters, the value and key of a cache entry and the @user_data. The order of value and key is different from the order in which g_hash_table_foreach() passes key-value pairs to its callback function ! Deprecated:2.32: Use a #GHashTable instead a #GCache the function to call with each #GCache key user data to pass to the function Creates a new #GCache. Deprecated:2.32: Use a #GHashTable instead a function to create a new object given a key. This is called by g_cache_insert() if an object with the given key does not already exist a function to destroy an object. It is called by g_cache_remove() when the object is no longer needed (i.e. its reference count drops to 0) a function to copy a key. It is called by g_cache_insert() if the key does not already exist in the #GCache a function to destroy a key. It is called by g_cache_remove() when the object is no longer needed (i.e. its reference count drops to 0) a function to create a hash value from a key a function to create a hash value from a value a function to compare two keys. It should return %TRUE if the two keys are equivalent a new #GCache Decreases the reference count of the given value. If it drops to 0 then the value and its corresponding key are destroyed, using the @value_destroy_func and @key_destroy_func passed to g_cache_new(). Deprecated:2.32: Use a #GHashTable instead a #GCache the value to remove Calls the given function for each of the values in the #GCache. Deprecated:2.10: The reason is that it passes pointers to internal data structures to @func; use g_cache_key_foreach() instead a #GCache the function to call with each #GCache value user data to pass to the function A #GClosureMarshal function for use with signals with handlers that take two boxed pointers as arguments and return a boolean. If you have such a signal, you will probably also need to use an accumulator, such as g_signal_accumulator_true_handled(). A #GClosure. A #GValue to store the return value. May be %NULL if the callback of closure doesn't return a value. The length of the @param_values array. An array of #GValues holding the arguments on which to invoke the callback of closure. The invocation hint given as the last argument to g_closure_invoke(). Additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__BOXED_BOXED(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `gboolean (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes a flags type. the #GClosure to which the marshaller belongs a #GValue which can store the returned #gboolean 2 a #GValue array holding instance and arg1 the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__FLAGS(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `gboolean (*callback) (gpointer instance, GBoxed *arg1, GBoxed *arg2, gpointer user_data)`. Since: 2.26 the #GClosure to which the marshaller belongs a #GValue, which can store the returned string 3 a #GValue array holding instance, arg1 and arg2 the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller An old alias for g_cclosure_marshal_BOOLEAN__BOXED_BOXED(). A #GClosure. A #GValue to store the return value. May be %NULL if the callback of closure doesn't return a value. The length of the @param_values array. An array of #GValues holding the arguments on which to invoke the callback of closure. The invocation hint given as the last argument to g_closure_invoke(). Additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() Another name for g_cclosure_marshal_BOOLEAN__FLAGS(). A marshaller for a #GCClosure with a callback of type `gchar* (*callback) (gpointer instance, GObject *arg1, gpointer arg2, gpointer user_data)`. the #GClosure to which the marshaller belongs a #GValue, which can store the returned string 3 a #GValue array holding instance, arg1 and arg2 the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_STRING__OBJECT_POINTER(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gboolean arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gboolean parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOOLEAN(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GBoxed *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GBoxed* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOXED(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gchar arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gchar parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__CHAR(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gdouble arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gdouble parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__DOUBLE(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes an enumeration type.. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the enumeration parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ENUM(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes a flags type. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the flags parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLAGS(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gfloat arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gfloat parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLOAT(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gint parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__INT(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, glong arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #glong parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__LONG(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GObject *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GObject* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__OBJECT(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GParamSpec *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GParamSpec* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__PARAM(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gpointer arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gpointer parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__POINTER(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, const gchar *arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gchar* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__STRING(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guchar arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #guchar parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UCHAR(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guint arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #guint parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guint arg1, gpointer arg2, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 3 a #GValue array holding instance, arg1 and arg2 the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT_POINTER(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gulong arg1, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #gulong parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ULONG(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GVariant *arg1, gpointer user_data)`. Since: 2.26 the #GClosure to which the marshaller belongs ignored 2 a #GValue array holding the instance and the #GVariant* parameter the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VARIANT(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gpointer user_data)`. the #GClosure to which the marshaller belongs ignored 1 a #GValue array holding only the instance the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VOID(). the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args. A generic marshaller function implemented via [libffi](http://sourceware.org/libffi/). Normally this function is not passed explicitly to g_signal_new(), but used automatically by GLib when specifying a %NULL marshaller. Since: 2.30 A #GClosure. A #GValue to store the return value. May be %NULL if the callback of closure doesn't return a value. The length of the @param_values array. An array of #GValues holding the arguments on which to invoke the callback of closure. The invocation hint given as the last argument to g_closure_invoke(). Additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() A generic #GVaClosureMarshal function implemented via [libffi](http://sourceware.org/libffi/). Since: 2.30 the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the instance on which the closure is invoked. va_list of arguments to be passed to the closure. additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() the length of the @param_types array the #GType of each argument from @args_list. Creates a new closure which invokes @callback_func with @user_data as the last parameter. the function to invoke user data to pass to @callback_func destroy notify to be called when @user_data is no longer used a new #GCClosure A variant of g_cclosure_new() which uses @object as @user_data and calls g_object_watch_closure() on @object and the created closure. This function is useful when you have a callback closely associated with a #GObject, and want the callback to no longer run after the object is is freed. the function to invoke a #GObject pointer to pass to @callback_func a new #GCClosure A variant of g_cclosure_new_swap() which uses @object as @user_data and calls g_object_watch_closure() on @object and the created closure. This function is useful when you have a callback closely associated with a #GObject, and want the callback to no longer run after the object is is freed. the function to invoke a #GObject pointer to pass to @callback_func a new #GCClosure Creates a new closure which invokes @callback_func with @user_data as the first parameter. the function to invoke user data to pass to @callback_func destroy notify to be called when @user_data is no longer used a new #GCClosure A wrapper for the POSIX chdir() function. The function changes the current directory of the process to @path. See your C library manual for more details about chdir(). Since: 2.8 a pathname in the GLib file name encoding (UTF-8 on Windows) 0 on success, -1 if an error occurred. Copies a #GChecksum. If @checksum has been closed, by calling g_checksum_get_string() or g_checksum_get_digest(), the copied checksum will be closed as well. Since: 2.16 the #GChecksum to copy the copy of the passed #GChecksum. Use g_checksum_free() when finished using it. Frees the memory allocated for @checksum. Since: 2.16 a #GChecksum Gets the digest from @checksum as a raw binary vector and places it into @buffer. The size of the digest depends on the type of checksum. Once this function has been called, the #GChecksum is closed and can no longer be updated with g_checksum_update(). Since: 2.16 a #GChecksum output buffer an inout parameter. The caller initializes it to the size of @buffer. After the call it contains the length of the digest. Gets the digest as an hexadecimal string. Once this function has been called the #GChecksum can no longer be updated with g_checksum_update(). The hexadecimal characters will be lower case. Since: 2.16 a #GChecksum the hexadecimal representation of the checksum. The returned string is owned by the checksum and should not be modified or freed. Creates a new #GChecksum, using the checksum algorithm @checksum_type. If the @checksum_type is not known, %NULL is returned. A #GChecksum can be used to compute the checksum, or digest, of an arbitrary binary blob, using different hashing algorithms. A #GChecksum works by feeding a binary blob through g_checksum_update() until there is data to be checked; the digest can then be extracted using g_checksum_get_string(), which will return the checksum as a hexadecimal string; or g_checksum_get_digest(), which will return a vector of raw bytes. Once either g_checksum_get_string() or g_checksum_get_digest() have been called on a #GChecksum, the checksum will be closed and it won't be possible to call g_checksum_update() on it anymore. Since: 2.16 the desired type of checksum the newly created #GChecksum, or %NULL. Use g_checksum_free() to free the memory allocated by it. Resets the state of the @checksum back to its initial state. Since: 2.18 the #GChecksum to reset Gets the length in bytes of digests of type @checksum_type Since: 2.16 a #GChecksumType the checksum length, or -1 if @checksum_type is not supported. Feeds @data into an existing #GChecksum. The checksum must still be open, that is g_checksum_get_string() or g_checksum_get_digest() must not have been called on @checksum. Since: 2.16 a #GChecksum buffer used to compute the checksum size of the buffer, or -1 if it is a null-terminated string. Sets a function to be called when the child indicated by @pid exits, at a default priority, #G_PRIORITY_DEFAULT. If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes() you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to the spawn function for the child watching to work. Note that on platforms where #GPid must be explicitly closed (see g_spawn_close_pid()) @pid must not be closed while the source is still active. Typically, you will want to call g_spawn_close_pid() in the callback function for the source. GLib supports only a single callback per process id. This internally creates a main loop source using g_child_watch_source_new() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. Since: 2.4 process id to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child). function to call data to pass to @function the ID (greater than 0) of the event source. Sets a function to be called when the child indicated by @pid exits, at the priority @priority. If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes() you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to the spawn function for the child watching to work. In many programs, you will want to call g_spawn_check_exit_status() in the callback to determine whether or not the child exited successfully. Also, note that on platforms where #GPid must be explicitly closed (see g_spawn_close_pid()) @pid must not be closed while the source is still active. Typically, you should invoke g_spawn_close_pid() in the callback function for the source. GLib supports only a single callback per process id. This internally creates a main loop source using g_child_watch_source_new() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. Since: 2.4 the priority of the idle source. Typically this will be in the range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE. process to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child). function to call data to pass to @function function to call when the idle is removed, or %NULL the ID (greater than 0) of the event source. Creates a new child_watch source. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. Note that child watch sources can only be used in conjunction with `g_spawn...` when the %G_SPAWN_DO_NOT_REAP_CHILD flag is used. Note that on platforms where #GPid must be explicitly closed (see g_spawn_close_pid()) @pid must not be closed while the source is still active. Typically, you will want to call g_spawn_close_pid() in the callback function for the source. Note further that using g_child_watch_source_new() is not compatible with calling `waitpid` with a nonpositive first argument in the application. Calling waitpid() for individual pids will still work fine. Similarly, on POSIX platforms, the @pid passed to this function must be greater than 0 (i.e. this function must wait for a specific child, and cannot wait for one of many children by using a nonpositive argument). Since: 2.4 process to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child). the newly-created child watch source A wrapper for the POSIX chmod() function. The chmod() function is used to set the permissions of a file system object. On Windows the file protection mechanism is not at all POSIX-like, and the underlying chmod() function in the C library just sets or clears the FAT-style READONLY attribute. It does not touch any ACL. Software that needs to manage file permissions on Windows exactly should use the Win32 API. See your C library manual for more details about chmod(). Since: 2.8 a pathname in the GLib file name encoding (UTF-8 on Windows) as in chmod() 0 if the operation succeeded, -1 on error If @err is %NULL, does nothing. If @err is non-%NULL, calls g_error_free() on *@err and sets *@err to %NULL. a #GError return location Clears a reference to a #GObject. @object_ptr must not be %NULL. If the reference is %NULL then this function does nothing. Otherwise, the reference count of the object is decreased and the pointer is set to %NULL. A macro is also included that allows this function to be used without pointer casts. Since: 2.28 a pointer to a #GObject reference Clears a reference to a variable. @pp must not be %NULL. If the reference is %NULL then this function does nothing. Otherwise, the variable is destroyed using @destroy and the pointer is set to %NULL. A macro is also included that allows this function to be used without pointer casts. Since: 2.34 a pointer to a variable, struct member etc. holding a pointer a function to which a gpointer can be passed, to destroy *@pp 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. Besides using #GError, there is another major reason to prefer this function over the call provided by the system; on Unix, it will attempt to correctly handle %EINTR, which has platform-specific semantics. Since: 2.36 A file descriptor a #GError %TRUE on success, %FALSE if there was an error. Registers a finalization notifier which will be called when the reference count of @closure goes down to 0. Multiple finalization notifiers on a single closure are invoked in unspecified order. If a single call to g_closure_unref() results in the closure being both invalidated and finalized, then the invalidate notifiers will be run before the finalize notifiers. a #GClosure data to pass to @notify_func the callback function to register Registers an invalidation notifier which will be called when the @closure is invalidated with g_closure_invalidate(). Invalidation notifiers are invoked before finalization notifiers, in an unspecified order. a #GClosure data to pass to @notify_func the callback function to register Adds a pair of notifiers which get invoked before and after the closure callback, respectively. This is typically used to protect the extra arguments for the duration of the callback. See g_object_watch_closure() for an example of marshal guards. a #GClosure data to pass to @pre_marshal_notify a function to call before the closure callback data to pass to @post_marshal_notify a function to call after the closure callback Sets a flag on the closure to indicate that its calling environment has become invalid, and thus causes any future invocations of g_closure_invoke() on this @closure to be ignored. Also, invalidation notifiers installed on the closure will be called at this point. Note that unless you are holding a reference to the closure yourself, the invalidation notifiers may unref the closure and cause it to be destroyed, so if you need to access the closure after calling g_closure_invalidate(), make sure that you've previously called g_closure_ref(). Note that g_closure_invalidate() will also be called when the reference count of a closure drops to zero (unless it has already been invalidated before). GClosure to invalidate Invokes the closure, i.e. executes the callback represented by the @closure. a #GClosure a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the length of the @param_values array an array of #GValues holding the arguments on which to invoke the callback of @closure a context-dependent invocation hint A variant of g_closure_new_simple() which stores @object in the @data field of the closure and calls g_object_watch_closure() on @object and the created closure. This function is mainly useful when implementing new types of closures. the size of the structure to allocate, must be at least `sizeof (GClosure)` a #GObject pointer to store in the @data field of the newly allocated #GClosure a newly allocated #GClosure Allocates a struct of the given size and initializes the initial part as a #GClosure. This function is mainly useful when implementing new types of closures. |[<!-- language="C" --> typedef struct _MyClosure MyClosure; struct _MyClosure { GClosure closure; // extra data goes here }; static void my_closure_finalize (gpointer notify_data, GClosure *closure) { MyClosure *my_closure = (MyClosure *)closure; // free extra data here } MyClosure *my_closure_new (gpointer data) { GClosure *closure; MyClosure *my_closure; closure = g_closure_new_simple (sizeof (MyClosure), data); my_closure = (MyClosure *) closure; // initialize extra data here g_closure_add_finalize_notifier (closure, notify_data, my_closure_finalize); return my_closure; } ]| the size of the structure to allocate, must be at least `sizeof (GClosure)` data to store in the @data field of the newly allocated #GClosure a newly allocated #GClosure Increments the reference count on a closure to force it staying alive while the caller holds a pointer to it. #GClosure to increment the reference count on The @closure passed in, for convenience Removes a finalization notifier. Notice that notifiers are automatically removed after they are run. a #GClosure data which was passed to g_closure_add_finalize_notifier() when registering @notify_func the callback function to remove Removes an invalidation notifier. Notice that notifiers are automatically removed after they are run. a #GClosure data which was passed to g_closure_add_invalidate_notifier() when registering @notify_func the callback function to remove Sets the marshaller of @closure. The `marshal_data` of @marshal provides a way for a meta marshaller to provide additional information to the marshaller. (See g_closure_set_meta_marshal().) For GObject's C predefined marshallers (the g_cclosure_marshal_*() functions), what it provides is a callback function to use instead of @closure->callback. a #GClosure a #GClosureMarshal function Sets the meta marshaller of @closure. A meta marshaller wraps @closure->marshal and modifies the way it is called in some fashion. The most common use of this facility is for C callbacks. The same marshallers (generated by [glib-genmarshal][glib-genmarshal]), are used everywhere, but the way that we get the callback function differs. In most cases we want to use @closure->callback, but in other cases we want to use some different technique to retrieve the callback function. For example, class closures for signals (see g_signal_type_cclosure_new()) retrieve the callback function from a fixed offset in the class structure. The meta marshaller retrieves the right callback and passes it to the marshaller as the @marshal_data argument. a #GClosure context-dependent data to pass to @meta_marshal a #GClosureMarshal function Takes over the initial ownership of a closure. Each closure is initially created in a "floating" state, which means that the initial reference count is not owned by any caller. g_closure_sink() checks to see if the object is still floating, and if so, unsets the floating state and decreases the reference count. If the closure is not floating, g_closure_sink() does nothing. The reason for the existence of the floating state is to prevent cumbersome code sequences like: |[<!-- language="C" --> closure = g_cclosure_new (cb_func, cb_data); g_source_set_closure (source, closure); g_closure_unref (closure); // GObject doesn't really need this ]| Because g_source_set_closure() (and similar functions) take ownership of the initial reference count, if it is unowned, we instead can write: |[<!-- language="C" --> g_source_set_closure (source, g_cclosure_new (cb_func, cb_data)); ]| Generally, this function is used together with g_closure_ref(). Ane example of storing a closure for later notification looks like: |[<!-- language="C" --> static GClosure *notify_closure = NULL; void foo_notify_set_closure (GClosure *closure) { if (notify_closure) g_closure_unref (notify_closure); notify_closure = closure; if (notify_closure) { g_closure_ref (notify_closure); g_closure_sink (notify_closure); } } ]| Because g_closure_sink() may decrement the reference count of a closure (if it hasn't been called on @closure yet) just like g_closure_unref(), g_closure_ref() should be called prior to this function. #GClosure to decrement the initial reference count on, if it's still being held Decrements the reference count of a closure after it was previously incremented by the same caller. If no other callers are using the closure, then the closure will be destroyed and freed. #GClosure to decrement the reference count on Adds items to the #GCompletion. Deprecated: 2.26: Rarely used API the #GCompletion. the list of items to add. Removes all items from the #GCompletion. The items are not freed, so if the memory was dynamically allocated, it should be freed after calling this function. Deprecated: 2.26: Rarely used API the #GCompletion. Attempts to complete the string @prefix using the #GCompletion target items. Deprecated: 2.26: Rarely used API the #GCompletion. the prefix string, typically typed by the user, which is compared with each of the items. if non-%NULL, returns the longest prefix which is common to all items that matched @prefix, or %NULL if no items matched @prefix. This string should be freed when no longer needed. the list of items whose strings begin with @prefix. This should not be changed. Attempts to complete the string @prefix using the #GCompletion target items. In contrast to g_completion_complete(), this function returns the largest common prefix that is a valid UTF-8 string, omitting a possible common partial character. You should use this function instead of g_completion_complete() if your items are UTF-8 strings. Since: 2.4 Deprecated: 2.26: Rarely used API the #GCompletion the prefix string, typically used by the user, which is compared with each of the items if non-%NULL, returns the longest prefix which is common to all items that matched @prefix, or %NULL if no items matched @prefix. This string should be freed when no longer needed. the list of items whose strings begin with @prefix. This should not be changed. Frees all memory used by the #GCompletion. The items are not freed, so if the memory was dynamically allocated, it should be freed after calling this function. Deprecated: 2.26: Rarely used API the #GCompletion. Creates a new #GCompletion. the function to be called to return the string representing an item in the #GCompletion, or %NULL if strings are going to be used as the #GCompletion items. the new #GCompletion. Removes items from a #GCompletion. The items are not freed, so if the memory was dynamically allocated, free @items with g_list_free_full() after calling this function. Deprecated: 2.26: Rarely used API the #GCompletion. the items to remove. Sets the function to use for string comparisons. The default string comparison function is strncmp(). Deprecated: 2.26: Rarely used API a #GCompletion. the string comparison function. Computes the checksum for a binary @data. This is a convenience wrapper for g_checksum_new(), g_checksum_get_string() and g_checksum_free(). The hexadecimal string returned will be in lower case. Since: 2.34 a #GChecksumType binary blob to compute the digest of the digest of the binary data as a string in hexadecimal. The returned string should be freed with g_free() when done using it. Computes the checksum for a binary @data of @length. This is a convenience wrapper for g_checksum_new(), g_checksum_get_string() and g_checksum_free(). The hexadecimal string returned will be in lower case. Since: 2.16 a #GChecksumType binary blob to compute the digest of length of @data the digest of the binary data as a string in hexadecimal. The returned string should be freed with g_free() when done using it. Computes the checksum of a string. The hexadecimal string returned will be in lower case. Since: 2.16 a #GChecksumType the string to compute the checksum of the length of the string, or -1 if the string is null-terminated. the checksum as a hexadecimal string. The returned string should be freed with g_free() when done using it. Computes the HMAC for a binary @data of @length. This is a convenience wrapper for g_hmac_new(), g_hmac_get_string() and g_hmac_unref(). The hexadecimal string returned will be in lower case. Since: 2.30 a #GChecksumType to use for the HMAC the key to use in the HMAC the length of the key binary blob to compute the HMAC of length of @data the HMAC of the binary data as a string in hexadecimal. The returned string should be freed with g_free() when done using it. Computes the HMAC for a string. The hexadecimal string returned will be in lower case. Since: 2.30 a #GChecksumType to use for the HMAC the key to use in the HMAC the length of the key the string to compute the HMAC for the length of the string, or -1 if the string is nul-terminated the HMAC as a hexadecimal string. The returned string should be freed with g_free() when done using it. If threads are waiting for @cond, all of them are unblocked. If no threads are waiting for @cond, this function has no effect. It is good practice to lock the same mutex as the waiting threads while calling this function, though not required. a #GCond Frees the resources allocated to a #GCond with g_cond_init(). This function should not be used with a #GCond that has been statically allocated. Calling g_cond_clear() for a #GCond on which threads are blocking leads to undefined behaviour. Since: 2.32 an initialised #GCond Destroys a #GCond that has been created with g_cond_new(). Calling g_cond_free() for a #GCond on which threads are blocking leads to undefined behaviour. Deprecated: 2.32: GCond can now be statically allocated, or embedded in structures and initialised with g_cond_init(). a #GCond Initialises a #GCond so that it can be used. This function is useful to initialise a #GCond that has been allocated as part of a larger structure. It is not necessary to initialise a #GCond that has been statically allocated. To undo the effect of g_cond_init() when a #GCond is no longer needed, use g_cond_clear(). Calling g_cond_init() on an already-initialised #GCond leads to undefined behaviour. Since: 2.32 an uninitialized #GCond Allocates and initializes a new #GCond. Deprecated: 2.32: GCond can now be statically allocated, or embedded in structures and initialised with g_cond_init(). a newly allocated #GCond. Free with g_cond_free() If threads are waiting for @cond, at least one of them is unblocked. If no threads are waiting for @cond, this function has no effect. It is good practice to hold the same lock as the waiting thread while calling this function, though not required. a #GCond Waits until this thread is woken up on @cond, but not longer than until the time specified by @abs_time. The @mutex is unlocked before falling asleep and locked again before resuming. If @abs_time is %NULL, g_cond_timed_wait() acts like g_cond_wait(). This function can be used even if g_thread_init() has not yet been called, and, in that case, will immediately return %TRUE. To easily calculate @abs_time a combination of g_get_current_time() and g_time_val_add() can be used. Deprecated:2.32: Use g_cond_wait_until() instead. a #GCond a #GMutex that is currently locked a #GTimeVal, determining the final time %TRUE if @cond was signalled, or %FALSE on timeout Atomically releases @mutex and waits until @cond is signalled. When this function returns, @mutex is locked again and owned by the calling thread. When using condition variables, it is possible that a spurious wakeup may occur (ie: g_cond_wait() returns even though g_cond_signal() was not called). It's also possible that a stolen wakeup may occur. This is when g_cond_signal() is called, but another thread acquires @mutex before this thread and modifies the state of the program in such a way that when g_cond_wait() is able to return, the expected condition is no longer met. For this reason, g_cond_wait() must always be used in a loop. See the documentation for #GCond for a complete example. a #GCond a #GMutex that is currently locked Waits until either @cond is signalled or @end_time has passed. As with g_cond_wait() it is possible that a spurious or stolen wakeup could occur. For that reason, waiting on a condition variable should always be in a loop, based on an explicitly-checked predicate. %TRUE is returned if the condition variable was signalled (or in the case of a spurious wakeup). %FALSE is returned if @end_time has passed. The following code shows how to correctly perform a timed wait on a condition variable (extending the example presented in the documentation for #GCond): |[<!-- language="C" --> gpointer pop_data_timed (void) { gint64 end_time; gpointer data; g_mutex_lock (&data_mutex); end_time = g_get_monotonic_time () + 5 * G_TIME_SPAN_SECOND; while (!current_data) if (!g_cond_wait_until (&data_cond, &data_mutex, end_time)) { // timeout has passed. g_mutex_unlock (&data_mutex); return NULL; } // there is data for us data = current_data; current_data = NULL; g_mutex_unlock (&data_mutex); return data; } ]| Notice that the end time is calculated once, before entering the loop and reused. This is the motivation behind the use of absolute time on this API -- if a relative time of 5 seconds were passed directly to the call and a spurious wakeup occurred, the program would have to start over waiting again (which would lead to a total wait time of more than 5 seconds). Since: 2.32 a #GCond a #GMutex that is currently locked the monotonic time to wait until %TRUE on a signal, %FALSE on a timeout Converts a string from one character set to another. Note that you should use g_iconv() for streaming conversions. Despite the fact that @byes_read can return information about partial characters, the g_convert_... functions are not generally suitable for streaming. If the underlying converter maintains internal state, then this won't be preserved across successive calls to g_convert(), g_convert_with_iconv() or g_convert_with_fallback(). (An example of this is the GNU C converter for CP1255 which does not emit a base character until it knows that the next character is not a mark that could combine with the base character.) Using extensions such as "//TRANSLIT" may not work (or may not work well) on many platforms. Consider using g_str_to_ascii() instead. the string to convert the length of the string in bytes, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) name of character set into which to convert @str character set of @str. location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError may occur. If the conversion was successful, a newly allocated nul-terminated string, which must be freed with g_free(). Otherwise %NULL and @error will be set. Converts a string from one character set to another, possibly including fallback sequences for characters not representable in the output. Note that it is not guaranteed that the specification for the fallback sequences in @fallback will be honored. Some systems may do an approximate conversion from @from_codeset to @to_codeset in their iconv() functions, in which case GLib will simply return that approximate conversion. Note that you should use g_iconv() for streaming conversions. Despite the fact that @byes_read can return information about partial characters, the g_convert_... functions are not generally suitable for streaming. If the underlying converter maintains internal state, then this won't be preserved across successive calls to g_convert(), g_convert_with_iconv() or g_convert_with_fallback(). (An example of this is the GNU C converter for CP1255 which does not emit a base character until it knows that the next character is not a mark that could combine with the base character.) the string to convert the length of the string in bytes, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) name of character set into which to convert @str character set of @str. UTF-8 string to use in place of character not present in the target encoding. (The string must be representable in the target encoding). If %NULL, characters not in the target encoding will be represented as Unicode escapes \uxxxx or \Uxxxxyyyy. location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. the number of bytes stored in the output buffer (not including the terminating nul). location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError may occur. If the conversion was successful, a newly allocated nul-terminated string, which must be freed with g_free(). Otherwise %NULL and @error will be set. Converts a string from one character set to another. Note that you should use g_iconv() for streaming conversions. Despite the fact that @byes_read can return information about partial characters, the g_convert_... functions are not generally suitable for streaming. If the underlying converter maintains internal state, then this won't be preserved across successive calls to g_convert(), g_convert_with_iconv() or g_convert_with_fallback(). (An example of this is the GNU C converter for CP1255 which does not emit a base character until it knows that the next character is not a mark that could combine with the base character.) the string to convert the length of the string in bytes, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) conversion descriptor from g_iconv_open() location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError may occur. If the conversion was successful, a newly allocated nul-terminated string, which must be freed with g_free(). Otherwise %NULL and @error will be set. A wrapper for the POSIX creat() function. The creat() function is used to convert a pathname into a file descriptor, creating a file if necessary. On POSIX systems file descriptors are implemented by the operating system. On Windows, it's the C library that implements creat() and file descriptors. The actual Windows API for opening files is different, see MSDN documentation for CreateFile(). The Win32 API uses file handles, which are more randomish integers, not small integers like file descriptors. Because file descriptors are specific to the C library on Windows, the file descriptor returned by this function makes sense only to functions in the same C library. Thus if the GLib-using code uses a different C library than GLib does, the file descriptor returned by this function cannot be passed to C library functions like write() or read(). See your C library manual for more details about creat(). Since: 2.8 a pathname in the GLib file name encoding (UTF-8 on Windows) as in creat() a new file descriptor, or -1 if an error occurred. The return value can be used exactly like the return value from creat(). Logs a "critical warning" (#G_LOG_LEVEL_CRITICAL). It's more or less application-defined what constitutes a critical vs. a regular warning. You could call g_log_set_always_fatal() to make critical warnings exit the program, then use g_critical() for fatal errors, for example. You can also make critical warnings fatal at runtime by setting the `G_DEBUG` environment variable (see [Running GLib Applications](glib-running.html)). If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. format string, followed by parameters to insert into the format string (as with printf()) Frees all the data elements of the datalist. The data elements' destroy functions are called if they have been set. a datalist. Calls the given function for each data element of the datalist. The function is called with each data element's #GQuark id and data, together with the given @user_data parameter. Note that this function is NOT thread-safe. So unless @datalist can be protected from any modifications during invocation of this function, it should not be called. a datalist. the function to call for each data element. user data to pass to the function. Gets a data element, using its string identifier. This is slower than g_datalist_id_get_data() because it compares strings. a datalist. the string identifying a data element. the data element, or %NULL if it is not found. Gets flags values packed in together with the datalist. See g_datalist_set_flags(). Since: 2.8 pointer to the location that holds a list the flags of the datalist This is a variant of g_datalist_id_get_data() which returns a 'duplicate' of the value. @dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object. If the @key_id is not set in the datalist then @dup_func will be called with a %NULL argument. Note that @dup_func is called while the datalist is locked, so it is not allowed to read or modify the datalist. This function can be useful to avoid races when multiple threads are using the same datalist and the same key. Since: 2.34 location of a datalist the #GQuark identifying a data element function to duplicate the old value passed as user_data to @dup_func the result of calling @dup_func on the value associated with @key_id in @datalist, or %NULL if not set. If @dup_func is %NULL, the value is returned unmodified. Retrieves the data element corresponding to @key_id. a datalist. the #GQuark identifying a data element. the data element, or %NULL if it is not found. Removes an element, using its #GQuark identifier. a datalist. the #GQuark identifying the data element. Removes an element, without calling its destroy notification function. a datalist. the #GQuark identifying a data element. the data previously stored at @key_id, or %NULL if none. Compares the member that is associated with @key_id in @datalist to @oldval, and if they are the same, replace @oldval with @newval. This is like a typical atomic compare-and-exchange operation, for a member of @datalist. If the previous value was replaced then ownership of the old value (@oldval) is passed to the caller, including the registred destroy notify for it (passed out in @old_destroy). Its up to the caller to free this as he wishes, which may or may not include using @old_destroy as sometimes replacement should not destroy the object in the normal way. Since: 2.34 location of a datalist the #GQuark identifying a data element the old value to compare against the new value to replace it with destroy notify for the new value destroy notify for the existing value %TRUE if the existing value for @key_id was replaced by @newval, %FALSE otherwise. Sets the data corresponding to the given #GQuark id. Any previous data with the same key is removed, and its destroy function is called. a datalist. the #GQuark to identify the data element. the data element, or %NULL to remove any previous element corresponding to @q. Sets the data corresponding to the given #GQuark id, and the function to be called when the element is removed from the datalist. Any previous data with the same key is removed, and its destroy function is called. a datalist. the #GQuark to identify the data element. the data element or %NULL to remove any previous element corresponding to @key_id. the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it. If @data is %NULL, then @destroy_func must also be %NULL. Resets the datalist to %NULL. It does not free any memory or call any destroy functions. a pointer to a pointer to a datalist. Removes an element using its string identifier. The data element's destroy function is called if it has been set. a datalist. the string identifying the data element. Removes an element, without calling its destroy notifier. a datalist. the string identifying the data element. Sets the data element corresponding to the given string identifier. a datalist. the string to identify the data element. the data element, or %NULL to remove any previous element corresponding to @k. Sets the data element corresponding to the given string identifier, and the function to be called when the data element is removed. a datalist. the string to identify the data element. the data element, or %NULL to remove any previous element corresponding to @k. the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it. If @d is %NULL, then @f must also be %NULL. Turns on flag values for a data list. This function is used to keep a small number of boolean flags in an object with a data list without using any additional space. It is not generally useful except in circumstances where space is very tight. (It is used in the base #GObject type, for example.) Since: 2.8 pointer to the location that holds a list the flags to turn on. The values of the flags are restricted by %G_DATALIST_FLAGS_MASK (currently 3; giving two possible boolean flags). A value for @flags that doesn't fit within the mask is an error. Turns off flag values for a data list. See g_datalist_unset_flags() Since: 2.8 pointer to the location that holds a list the flags to turn off. The values of the flags are restricted by %G_DATALIST_FLAGS_MASK (currently 3: giving two possible boolean flags). A value for @flags that doesn't fit within the mask is an error. Destroys the dataset, freeing all memory allocated, and calling any destroy functions set for data elements. the location identifying the dataset. Calls the given function for each data element which is associated with the given location. Note that this function is NOT thread-safe. So unless @datalist can be protected from any modifications during invocation of this function, it should not be called. the location identifying the dataset. the function to call for each data element. user data to pass to the function. Gets the data element corresponding to a string. the location identifying the dataset. the string identifying the data element. the data element corresponding to the string, or %NULL if it is not found. Gets the data element corresponding to a #GQuark. the location identifying the dataset. the #GQuark id to identify the data element. the data element corresponding to the #GQuark, or %NULL if it is not found. Removes a data element from a dataset. The data element's destroy function is called if it has been set. the location identifying the dataset. the #GQuark id identifying the data element. Removes an element, without calling its destroy notification function. the location identifying the dataset. the #GQuark ID identifying the data element. the data previously stored at @key_id, or %NULL if none. Sets the data element associated with the given #GQuark id. Any previous data with the same key is removed, and its destroy function is called. the location identifying the dataset. the #GQuark id to identify the data element. the data element. Sets the data element associated with the given #GQuark id, and also the function to call when the data element is destroyed. Any previous data with the same key is removed, and its destroy function is called. the location identifying the dataset. the #GQuark id to identify the data element. the data element. the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it. Removes a data element corresponding to a string. Its destroy function is called if it has been set. the location identifying the dataset. the string identifying the data element. Removes an element, without calling its destroy notifier. the location identifying the dataset. the string identifying the data element. Sets the data corresponding to the given string identifier. the location identifying the dataset. the string to identify the data element. the data element. Sets the data corresponding to the given string identifier, and the function to call when the data element is destroyed. the location identifying the dataset. the string to identify the data element. the data element. the function to call when the data element is removed. This function will be called with the data element and can be used to free any memory allocated for it. Increments a date some number of days. To move forward by weeks, add weeks*7 days. The date must be valid. a #GDate to increment number of days to move the date forward Increments a date by some number of months. If the day of the month is greater than 28, this routine may change the day of the month (because the destination month may not have the current day in it). The date must be valid. a #GDate to increment number of months to move forward Increments a date by some number of years. If the date is February 29, and the destination year is not a leap year, the date will be changed to February 28. The date must be valid. a #GDate to increment number of years to move forward If @date is prior to @min_date, sets @date equal to @min_date. If @date falls after @max_date, sets @date equal to @max_date. Otherwise, @date is unchanged. Either of @min_date and @max_date may be %NULL. All non-%NULL dates must be valid. a #GDate to clamp minimum accepted value for @date maximum accepted value for @date Initializes one or more #GDate structs to a sane but invalid state. The cleared dates will not represent an existing date, but will not contain garbage. Useful to init a date declared on the stack. Validity can be tested with g_date_valid(). pointer to one or more dates to clear number of dates to clear qsort()-style comparison function for dates. Both dates must be valid. first date to compare second date to compare 0 for equal, less than zero if @lhs is less than @rhs, greater than zero if @lhs is greater than @rhs Computes the number of days between two dates. If @date2 is prior to @date1, the returned value is negative. Both dates must be valid. the first date the second date the number of days between @date1 and @date2 Frees a #GDate returned from g_date_new(). a #GDate to free Returns the day of the month. The date must be valid. a #GDate to extract the day of the month from day of the month Returns the day of the year, where Jan 1 is the first day of the year. The date must be valid. a #GDate to extract day of year from day of the year Returns the number of days in a month, taking leap years into account. month year number of days in @month during the @year Returns the week of the year, where weeks are interpreted according to ISO 8601. Since: 2.6 a valid #GDate ISO 8601 week number of the year. Returns the Julian day or "serial number" of the #GDate. The Julian day is simply the number of days since January 1, Year 1; i.e., January 1, Year 1 is Julian day 1; January 2, Year 1 is Julian day 2, etc. The date must be valid. a #GDate to extract the Julian day from Julian day Returns the week of the year, where weeks are understood to start on Monday. If the date is before the first Monday of the year, return 0. The date must be valid. a #GDate week of the year Returns the number of weeks in the year, where weeks are taken to start on Monday. Will be 52 or 53. The date must be valid. (Years always have 52 7-day periods, plus 1 or 2 extra days depending on whether it's a leap year. This function is basically telling you how many Mondays are in the year, i.e. there are 53 Mondays if one of the extra days happens to be a Monday.) a year number of Mondays in the year Returns the month of the year. The date must be valid. a #GDate to get the month from month of the year as a #GDateMonth Returns the week of the year during which this date falls, if weeks are understood to being on Sunday. The date must be valid. Can return 0 if the day is before the first Sunday of the year. a #GDate week number Returns the number of weeks in the year, where weeks are taken to start on Sunday. Will be 52 or 53. The date must be valid. (Years always have 52 7-day periods, plus 1 or 2 extra days depending on whether it's a leap year. This function is basically telling you how many Sundays are in the year, i.e. there are 53 Sundays if one of the extra days happens to be a Sunday.) year to count weeks in the number of weeks in @year Returns the day of the week for a #GDate. The date must be valid. a #GDate day of the week as a #GDateWeekday. Returns the year of a #GDate. The date must be valid. a #GDate year in which the date falls Returns %TRUE if the date is on the first of a month. The date must be valid. a #GDate to check %TRUE if the date is the first of the month Returns %TRUE if the date is the last day of the month. The date must be valid. a #GDate to check %TRUE if the date is the last day of the month Returns %TRUE if the year is a leap year. For the purposes of this function, leap year is every year divisible by 4 unless that year is divisible by 100. If it is divisible by 100 it would be a leap year only if that year is also divisible by 400. year to check %TRUE if the year is a leap year Allocates a #GDate and initializes it to a sane state. The new date will be cleared (as if you'd called g_date_clear()) but invalid (it won't represent an existing day). Free the return value with g_date_free(). a newly-allocated #GDate Like g_date_new(), but also sets the value of the date. Assuming the day-month-year triplet you pass in represents an existing day, the returned date will be valid. day of the month month of the year year a newly-allocated #GDate initialized with @day, @month, and @year Like g_date_new(), but also sets the value of the date. Assuming the Julian day number you pass in is valid (greater than 0, less than an unreasonably large number), the returned date will be valid. days since January 1, Year 1 a newly-allocated #GDate initialized with @julian_day Checks if @date1 is less than or equal to @date2, and swap the values if this is not the case. the first date the second date Sets the day of the month for a #GDate. If the resulting day-month-year triplet is invalid, the date will be invalid. a #GDate day to set Sets the value of a #GDate from a day, month, and year. The day-month-year triplet must be valid; if you aren't sure it is, call g_date_valid_dmy() to check before you set it. a #GDate day month year Sets the value of a #GDate from a Julian day number. a #GDate Julian day number (days since January 1, Year 1) Sets the month of the year for a #GDate. If the resulting day-month-year triplet is invalid, the date will be invalid. a #GDate month to set Parses a user-inputted string @str, and try to figure out what date it represents, taking the [current locale][setlocale] into account. If the string is successfully parsed, the date will be valid after the call. Otherwise, it will be invalid. You should check using g_date_valid() to see whether the parsing succeeded. This function is not appropriate for file formats and the like; it isn't very precise, and its exact behavior varies with the locale. It's intended to be a heuristic routine that guesses what the user means by a given string (and it does work pretty well in that capacity). a #GDate to fill in string to parse Sets the value of a date from a #GTime value. The time to date conversion is done using the user's current timezone. Deprecated: 2.10: Use g_date_set_time_t() instead. a #GDate. #GTime value to set. Sets the value of a date to the date corresponding to a time specified as a time_t. The time to date conversion is done using the user's current timezone. To set the value of a date to the current day, you could write: |[<!-- language="C" --> g_date_set_time_t (date, time (NULL)); ]| Since: 2.10 a #GDate time_t value to set Sets the value of a date from a #GTimeVal value. Note that the @tv_usec member is ignored, because #GDate can't make use of the additional precision. The time to date conversion is done using the user's current timezone. Since: 2.10 a #GDate #GTimeVal value to set Sets the year for a #GDate. If the resulting day-month-year triplet is invalid, the date will be invalid. a #GDate year to set Generates a printed representation of the date, in a [locale][setlocale]-specific way. Works just like the platform's C library strftime() function, but only accepts date-related formats; time-related formats give undefined results. Date must be valid. Unlike strftime() (which uses the locale encoding), works on a UTF-8 format string and stores a UTF-8 result. This function does not provide any conversion specifiers in addition to those implemented by the platform's C library. For example, don't expect that using g_date_strftime() would make the \%F provided by the C99 strftime() work on Windows where the C library only complies to C89. destination buffer buffer size format string valid #GDate number of characters written to the buffer, or 0 the buffer was too small Moves a date some number of days into the past. To move by weeks, just move by weeks*7 days. The date must be valid. a #GDate to decrement number of days to move Moves a date some number of months into the past. If the current day of the month doesn't exist in the destination month, the day of the month may change. The date must be valid. a #GDate to decrement number of months to move Moves a date some number of years into the past. If the current day doesn't exist in the destination year (i.e. it's February 29 and you move to a non-leap-year) then the day is changed to February 29. The date must be valid. a #GDate to decrement number of years to move Creates a copy of @datetime and adds the specified timespan to the copy. Since: 2.26 a #GDateTime a #GTimeSpan the newly created #GDateTime which should be freed with g_date_time_unref(). Creates a copy of @datetime and adds the specified number of days to the copy. Add negative values to subtract days. Since: 2.26 a #GDateTime the number of days the newly created #GDateTime which should be freed with g_date_time_unref(). Creates a new #GDateTime adding the specified values to the current date and time in @datetime. Add negative values to subtract. Since: 2.26 a #GDateTime the number of years to add the number of months to add the number of days to add the number of hours to add the number of minutes to add the number of seconds to add the newly created #GDateTime that should be freed with g_date_time_unref(). Creates a copy of @datetime and adds the specified number of hours. Add negative values to subtract hours. Since: 2.26 a #GDateTime the number of hours to add the newly created #GDateTime which should be freed with g_date_time_unref(). Creates a copy of @datetime adding the specified number of minutes. Add negative values to subtract minutes. Since: 2.26 a #GDateTime the number of minutes to add the newly created #GDateTime which should be freed with g_date_time_unref(). Creates a copy of @datetime and adds the specified number of months to the copy. Add negative values to subtract months. Since: 2.26 a #GDateTime the number of months the newly created #GDateTime which should be freed with g_date_time_unref(). Creates a copy of @datetime and adds the specified number of seconds. Add negative values to subtract seconds. Since: 2.26 a #GDateTime the number of seconds to add the newly created #GDateTime which should be freed with g_date_time_unref(). Creates a copy of @datetime and adds the specified number of weeks to the copy. Add negative values to subtract weeks. Since: 2.26 a #GDateTime the number of weeks the newly created #GDateTime which should be freed with g_date_time_unref(). Creates a copy of @datetime and adds the specified number of years to the copy. Add negative values to subtract years. Since: 2.26 a #GDateTime the number of years the newly created #GDateTime which should be freed with g_date_time_unref(). A comparison function for #GDateTimes that is suitable as a #GCompareFunc. Both #GDateTimes must be non-%NULL. Since: 2.26 first #GDateTime to compare second #GDateTime to compare -1, 0 or 1 if @dt1 is less than, equal to or greater than @dt2. Calculates the difference in time between @end and @begin. The #GTimeSpan that is returned is effectively @end - @begin (ie: positive if the first parameter is larger). Since: 2.26 a #GDateTime a #GDateTime the difference between the two #GDateTime, as a time span expressed in microseconds. Checks to see if @dt1 and @dt2 are equal. Equal here means that they represent the same moment after converting them to the same time zone. Since: 2.26 a #GDateTime a #GDateTime %TRUE if @dt1 and @dt2 are equal Creates a newly allocated string representing the requested @format. The format strings understood by this function are a subset of the strftime() format language as specified by C99. The \%D, \%U and \%W conversions are not supported, nor is the 'E' modifier. The GNU extensions \%k, \%l, \%s and \%P are supported, however, as are the '0', '_' and '-' modifiers. In contrast to strftime(), this function always produces a UTF-8 string, regardless of the current locale. Note that the rendering of many formats is locale-dependent and may not match the strftime() output exactly. The following format specifiers are supported: - \%a: the abbreviated weekday name according to the current locale - \%A: the full weekday name according to the current locale - \%b: the abbreviated month name according to the current locale - \%B: the full month name according to the current locale - \%c: the preferred date and time representation for the current locale - \%C: the century number (year/100) as a 2-digit integer (00-99) - \%d: the day of the month as a decimal number (range 01 to 31) - \%e: the day of the month as a decimal number (range 1 to 31) - \%F: equivalent to `%Y-%m-%d` (the ISO 8601 date format) - \%g: the last two digits of the ISO 8601 week-based year as a decimal number (00-99). This works well with \%V and \%u. - \%G: the ISO 8601 week-based year as a decimal number. This works well with \%V and \%u. - \%h: equivalent to \%b - \%H: the hour as a decimal number using a 24-hour clock (range 00 to 23) - \%I: the hour as a decimal number using a 12-hour clock (range 01 to 12) - \%j: the day of the year as a decimal number (range 001 to 366) - \%k: the hour (24-hour clock) as a decimal number (range 0 to 23); single digits are preceded by a blank - \%l: the hour (12-hour clock) as a decimal number (range 1 to 12); single digits are preceded by a blank - \%m: the month as a decimal number (range 01 to 12) - \%M: the minute as a decimal number (range 00 to 59) - \%p: either "AM" or "PM" according to the given time value, or the corresponding strings for the current locale. Noon is treated as "PM" and midnight as "AM". - \%P: like \%p but lowercase: "am" or "pm" or a corresponding string for the current locale - \%r: the time in a.m. or p.m. notation - \%R: the time in 24-hour notation (\%H:\%M) - \%s: the number of seconds since the Epoch, that is, since 1970-01-01 00:00:00 UTC - \%S: the second as a decimal number (range 00 to 60) - \%t: a tab character - \%T: the time in 24-hour notation with seconds (\%H:\%M:\%S) - \%u: the ISO 8601 standard day of the week as a decimal, range 1 to 7, Monday being 1. This works well with \%G and \%V. - \%V: the ISO 8601 standard week number of the current year as a decimal number, range 01 to 53, where week 1 is the first week that has at least 4 days in the new year. See g_date_time_get_week_of_year(). This works well with \%G and \%u. - \%w: the day of the week as a decimal, range 0 to 6, Sunday being 0. This is not the ISO 8601 standard format -- use \%u instead. - \%x: the preferred date representation for the current locale without the time - \%X: the preferred time representation for the current locale without the date - \%y: the year as a decimal number without the century - \%Y: the year as a decimal number including the century - \%z: the time zone as an offset from UTC (+hhmm) - \%:z: the time zone as an offset from UTC (+hh:mm). This is a gnulib strftime() extension. Since: 2.38 - \%::z: the time zone as an offset from UTC (+hh:mm:ss). This is a gnulib strftime() extension. Since: 2.38 - \%:::z: the time zone as an offset from UTC, with : to necessary precision (e.g., -04, +05:30). This is a gnulib strftime() extension. Since: 2.38 - \%Z: the time zone or name or abbreviation - \%\%: a literal \% character Some conversion specifications can be modified by preceding the conversion specifier by one or more modifier characters. The following modifiers are supported for many of the numeric conversions: - O: Use alternative numeric symbols, if the current locale supports those. - _: Pad a numeric result with spaces. This overrides the default padding for the specifier. - -: Do not pad a numeric result. This overrides the default padding for the specifier. - 0: Pad a numeric result with zeros. This overrides the default padding for the specifier. Since: 2.26 A #GDateTime a valid UTF-8 string, containing the format for the #GDateTime a newly allocated string formatted to the requested format or %NULL in the case that there was an error. The string should be freed with g_free(). Retrieves the day of the month represented by @datetime in the gregorian calendar. Since: 2.26 a #GDateTime the day of the month Retrieves the ISO 8601 day of the week on which @datetime falls (1 is Monday, 2 is Tuesday... 7 is Sunday). Since: 2.26 a #GDateTime the day of the week Retrieves the day of the year represented by @datetime in the Gregorian calendar. Since: 2.26 a #GDateTime the day of the year Retrieves the hour of the day represented by @datetime Since: 2.26 a #GDateTime the hour of the day Retrieves the microsecond of the date represented by @datetime Since: 2.26 a #GDateTime the microsecond of the second Retrieves the minute of the hour represented by @datetime Since: 2.26 a #GDateTime the minute of the hour Retrieves the month of the year represented by @datetime in the Gregorian calendar. Since: 2.26 a #GDateTime the month represented by @datetime Retrieves the second of the minute represented by @datetime Since: 2.26 a #GDateTime the second represented by @datetime Retrieves the number of seconds since the start of the last minute, including the fractional part. Since: 2.26 a #GDateTime the number of seconds Determines the time zone abbreviation to be used at the time and in the time zone of @datetime. For example, in Toronto this is currently "EST" during the winter months and "EDT" during the summer months when daylight savings time is in effect. Since: 2.26 a #GDateTime the time zone abbreviation. The returned string is owned by the #GDateTime and it should not be modified or freed Determines the offset to UTC in effect at the time and in the time zone of @datetime. The offset is the number of microseconds that you add to UTC time to arrive at local time for the time zone (ie: negative numbers for time zones west of GMT, positive numbers for east). If @datetime represents UTC time, then the offset is always zero. Since: 2.26 a #GDateTime the number of microseconds that should be added to UTC to get the local time Returns the ISO 8601 week-numbering year in which the week containing @datetime falls. This function, taken together with g_date_time_get_week_of_year() and g_date_time_get_day_of_week() can be used to determine the full ISO week date on which @datetime falls. This is usually equal to the normal Gregorian year (as returned by g_date_time_get_year()), except as detailed below: For Thursday, the week-numbering year is always equal to the usual calendar year. For other days, the number is such that every day within a complete week (Monday to Sunday) is contained within the same week-numbering year. For Monday, Tuesday and Wednesday occurring near the end of the year, this may mean that the week-numbering year is one greater than the calendar year (so that these days have the same week-numbering year as the Thursday occurring early in the next year). For Friday, Saturday and Sunday occurring near the start of the year, this may mean that the week-numbering year is one less than the calendar year (so that these days have the same week-numbering year as the Thursday occurring late in the previous year). An equivalent description is that the week-numbering year is equal to the calendar year containing the majority of the days in the current week (Monday to Sunday). Note that January 1 0001 in the proleptic Gregorian calendar is a Monday, so this function never returns 0. Since: 2.26 a #GDateTime the ISO 8601 week-numbering year for @datetime Returns the ISO 8601 week number for the week containing @datetime. The ISO 8601 week number is the same for every day of the week (from Moday through Sunday). That can produce some unusual results (described below). The first week of the year is week 1. This is the week that contains the first Thursday of the year. Equivalently, this is the first week that has more than 4 of its days falling within the calendar year. The value 0 is never returned by this function. Days contained within a year but occurring before the first ISO 8601 week of that year are considered as being contained in the last week of the previous year. Similarly, the final days of a calendar year may be considered as being part of the first ISO 8601 week of the next year if 4 or more days of that week are contained within the new year. Since: 2.26 a #GDateTime the ISO 8601 week number for @datetime. Retrieves the year represented by @datetime in the Gregorian calendar. Since: 2.26 A #GDateTime the year represented by @datetime Retrieves the Gregorian day, month, and year of a given #GDateTime. Since: 2.26 a #GDateTime. the return location for the gregorian year, or %NULL. the return location for the month of the year, or %NULL. the return location for the day of the month, or %NULL. Hashes @datetime into a #guint, suitable for use within #GHashTable. Since: 2.26 a #GDateTime a #guint containing the hash Determines if daylight savings time is in effect at the time and in the time zone of @datetime. Since: 2.26 a #GDateTime %TRUE if daylight savings time is in effect Creates a new #GDateTime corresponding to the given date and time in the time zone @tz. The @year must be between 1 and 9999, @month between 1 and 12 and @day between 1 and 28, 29, 30 or 31 depending on the month and the year. @hour must be between 0 and 23 and @minute must be between 0 and 59. @seconds must be at least 0.0 and must be strictly less than 60.0. It will be rounded down to the nearest microsecond. If the given time is not representable in the given time zone (for example, 02:30 on March 14th 2010 in Toronto, due to daylight savings time) then the time will be rounded up to the nearest existing time (in this case, 03:00). If this matters to you then you should verify the return value for containing the same as the numbers you gave. In the case that the given time is ambiguous in the given time zone (for example, 01:30 on November 7th 2010 in Toronto, due to daylight savings time) then the time falling within standard (ie: non-daylight) time is taken. It not considered a programmer error for the values to this function to be out of range, but in the case that they are, the function will return %NULL. You should release the return value by calling g_date_time_unref() when you are done with it. Since: 2.26 a #GTimeZone the year component of the date the month component of the date the day component of the date the hour component of the date the minute component of the date the number of seconds past the minute a new #GDateTime, or %NULL Creates a #GDateTime corresponding to the given #GTimeVal @tv in the local time zone. The time contained in a #GTimeVal is always stored in the form of seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the local time offset. This call can fail (returning %NULL) if @tv represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it. Since: 2.26 a #GTimeVal a new #GDateTime, or %NULL Creates a #GDateTime corresponding to the given #GTimeVal @tv in UTC. The time contained in a #GTimeVal is always stored in the form of seconds elapsed since 1970-01-01 00:00:00 UTC. This call can fail (returning %NULL) if @tv represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it. Since: 2.26 a #GTimeVal a new #GDateTime, or %NULL Creates a #GDateTime corresponding to the given Unix time @t in the local time zone. Unix time is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC, regardless of the local time offset. This call can fail (returning %NULL) if @t represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it. Since: 2.26 the Unix time a new #GDateTime, or %NULL Creates a #GDateTime corresponding to the given Unix time @t in UTC. Unix time is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC. This call can fail (returning %NULL) if @t represents a time outside of the supported range of #GDateTime. You should release the return value by calling g_date_time_unref() when you are done with it. Since: 2.26 the Unix time a new #GDateTime, or %NULL Creates a new #GDateTime corresponding to the given date and time in the local time zone. This call is equivalent to calling g_date_time_new() with the time zone returned by g_time_zone_new_local(). Since: 2.26 the year component of the date the month component of the date the day component of the date the hour component of the date the minute component of the date the number of seconds past the minute a #GDateTime, or %NULL Creates a #GDateTime corresponding to this exact instant in the given time zone @tz. The time is as accurate as the system allows, to a maximum accuracy of 1 microsecond. This function will always succeed unless the system clock is set to truly insane values (or unless GLib is still being used after the year 9999). You should release the return value by calling g_date_time_unref() when you are done with it. Since: 2.26 a #GTimeZone a new #GDateTime, or %NULL Creates a #GDateTime corresponding to this exact instant in the local time zone. This is equivalent to calling g_date_time_new_now() with the time zone returned by g_time_zone_new_local(). Since: 2.26 a new #GDateTime, or %NULL Creates a #GDateTime corresponding to this exact instant in UTC. This is equivalent to calling g_date_time_new_now() with the time zone returned by g_time_zone_new_utc(). Since: 2.26 a new #GDateTime, or %NULL Creates a new #GDateTime corresponding to the given date and time in UTC. This call is equivalent to calling g_date_time_new() with the time zone returned by g_time_zone_new_utc(). Since: 2.26 the year component of the date the month component of the date the day component of the date the hour component of the date the minute component of the date the number of seconds past the minute a #GDateTime, or %NULL Atomically increments the reference count of @datetime by one. Since: 2.26 a #GDateTime the #GDateTime with the reference count increased Creates a new #GDateTime corresponding to the same instant in time as @datetime, but in the local time zone. This call is equivalent to calling g_date_time_to_timezone() with the time zone returned by g_time_zone_new_local(). Since: 2.26 a #GDateTime the newly created #GDateTime Stores the instant in time that @datetime represents into @tv. The time contained in a #GTimeVal is always stored in the form of seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the time zone associated with @datetime. On systems where 'long' is 32bit (ie: all 32bit systems and all Windows systems), a #GTimeVal is incapable of storing the entire range of values that #GDateTime is capable of expressing. On those systems, this function returns %FALSE to indicate that the time is out of range. On systems where 'long' is 64bit, this function never fails. Since: 2.26 a #GDateTime a #GTimeVal to modify %TRUE if successful, else %FALSE Create a new #GDateTime corresponding to the same instant in time as @datetime, but in the time zone @tz. This call can fail in the case that the time goes out of bounds. For example, converting 0001-01-01 00:00:00 UTC to a time zone west of Greenwich will fail (due to the year 0 being out of range). You should release the return value by calling g_date_time_unref() when you are done with it. Since: 2.26 a #GDateTime the new #GTimeZone a new #GDateTime, or %NULL Gives the Unix time corresponding to @datetime, rounding down to the nearest second. Unix time is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC, regardless of the time zone associated with @datetime. Since: 2.26 a #GDateTime the Unix time corresponding to @datetime Creates a new #GDateTime corresponding to the same instant in time as @datetime, but in UTC. This call is equivalent to calling g_date_time_to_timezone() with the time zone returned by g_time_zone_new_utc(). Since: 2.26 a #GDateTime the newly created #GDateTime Atomically decrements the reference count of @datetime by one. When the reference count reaches zero, the resources allocated by @datetime are freed Since: 2.26 a #GDateTime Fills in the date-related bits of a struct tm using the @date value. Initializes the non-date parts with something sane but meaningless. a #GDate to set the struct tm from struct tm to fill Returns %TRUE if the #GDate represents an existing day. The date must not contain garbage; it should have been initialized with g_date_clear() if it wasn't allocated by one of the g_date_new() variants. a #GDate to check Whether the date is valid Returns %TRUE if the day of the month is valid (a day is valid if it's between 1 and 31 inclusive). day to check %TRUE if the day is valid Returns %TRUE if the day-month-year triplet forms a valid, existing day in the range of days #GDate understands (Year 1 or later, no more than a few thousand years in the future). day month year %TRUE if the date is a valid one Returns %TRUE if the Julian day is valid. Anything greater than zero is basically a valid Julian, though there is a 32-bit limit. Julian day to check %TRUE if the Julian day is valid Returns %TRUE if the month value is valid. The 12 #GDateMonth enumeration values are the only valid months. month %TRUE if the month is valid Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration values are the only valid weekdays. weekday %TRUE if the weekday is valid Returns %TRUE if the year is valid. Any year greater than 0 is valid, though there is a 16-bit limit to what #GDate will understand. year %TRUE if the year is valid 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. Since: 2.26 the translation domain to use, or %NULL to use the domain set with textdomain() message to translate a locale category the translated string for the given locale category A convenience function/macro to log a debug message. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. Such messages are suppressed by the g_log_default_handler() unless the G_MESSAGES_DEBUG environment variable is set appropriately. Since: 2.6 format string, followed by parameters to insert into the format string (as with printf()) 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. The advantage of using this function over dgettext() proper is that libraries using this function (like GTK+) will not use translations if the application using the library does not have translations for the current locale. This results in a consistent English-only interface instead of one having partial translations. For this feature to work, the call to textdomain() and setlocale() should precede any g_dgettext() invocations. For GTK+, it means calling textdomain() before gtk_init or its variants. This function disables translations if and only if upon its first call all the following conditions hold: - @domain is not %NULL - textdomain() has been called to set a default text domain - there is no translations available for the default text domain and the current locale - current locale is not "C" or any English locales (those starting with "en_") Note that this behavior may not be desired for example if an application has its untranslated messages in a language other than English. In those cases the application should call textdomain() after initializing GTK+. Applications should normally not use this function directly, but use the _() macro for translations. Since: 2.18 the translation domain to use, or %NULL to use the domain set with textdomain() message to translate The translated string Closes the directory and deallocates all related resources. a #GDir* created by g_dir_open() Creates a subdirectory in the preferred directory for temporary files (as returned by g_get_tmp_dir()). @tmpl should be a string in the GLib file name encoding containing a sequence of six 'X' characters, as the parameter to g_mkstemp(). However, unlike these functions, the template should only be a basename, no directory components are allowed. If template is %NULL, a default template is used. Note that in contrast to g_mkdtemp() (and mkdtemp()) @tmpl is not modified, and might thus be a read-only literal string. Since: 2.30 Template for directory name, as in g_mkdtemp(), basename only, or %NULL for a default template return location for a #GError The actual name used. This string should be freed with g_free() when not needed any longer and is is in the GLib file name encoding. In case of errors, %NULL is returned and @error will be set. Opens a directory for reading. The names of the files in the directory can then be retrieved using g_dir_read_name(). Note that the ordering is not defined. the path to the directory you are interested in. On Unix in the on-disk encoding. On Windows in UTF-8 Currently must be set to 0. Reserved for future use. return location for a #GError, or %NULL. If non-%NULL, an error will be set if and only if g_dir_open() fails. a newly allocated #GDir on success, %NULL on failure. If non-%NULL, you must free the result with g_dir_close() when you are finished with it. Retrieves the name of another entry in the directory, or %NULL. The order of entries returned from this function is not defined, and may vary by file system or other operating-system dependent factors. %NULL may also be returned in case of errors. On Unix, you can check `errno` to find out if %NULL was returned because of an error. On Unix, the '.' and '..' entries are omitted, and the returned name is in the on-disk encoding. On Windows, as is true of all GLib functions which operate on filenames, the returned name is in UTF-8. a #GDir* created by g_dir_open() The entry's name or %NULL if there are no more entries. The return value is owned by GLib and must not be modified or freed. Resets the given directory. The next call to g_dir_read_name() will return the first entry again. a #GDir* created by g_dir_open() Compares two #gpointer arguments and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using opaque pointers compared by pointer value as keys in a #GHashTable. This equality function is also appropriate for keys that are integers stored in pointers, such as `GINT_TO_POINTER (n)`. a key a key to compare with @v1 %TRUE if the two keys match. Converts a gpointer to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, when using opaque pointers compared by pointer value as keys in a #GHashTable. This hash function is also appropriate for keys that are integers stored in pointers, such as `GINT_TO_POINTER (n)`. a #gpointer key a hash value corresponding to the key. Gets the directory components of a file name. If the file name has no directory components "." is returned. The returned string should be freed when no longer needed. Deprecated: use g_path_get_dirname() instead the name of the file the directory components of the file 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. See g_dgettext() for details of how this differs from dngettext() proper. Since: 2.18 the translation domain to use, or %NULL to use the domain set with textdomain() message to translate plural form of the message the quantity for which translation is needed The translated string Compares the two #gdouble values being pointed to and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL pointers to doubles as keys in a #GHashTable. Since: 2.22 a pointer to a #gdouble key a pointer to a #gdouble key to compare with @v1 %TRUE if the two keys match. Converts a pointer to a #gdouble to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL pointers to doubles as keys in a #GHashTable. Since: 2.22 a pointer to a #gdouble key a hash value corresponding to the key. 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 uses g_dgettext() internally. See that functions for differences with dgettext() proper. Applications should normally not use this function directly, but use the C_() macro for translations with context. Since: 2.16 the translation domain to use, or %NULL to use the domain set with textdomain() a combined message context and message id, separated by a \004 character the offset of the message id in @msgctxid The translated 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. This uses g_dgettext() internally. See that functions for differences with dgettext() proper. This function differs from C_() in that it is not a macro and thus you may use non-string-literals as context and msgid arguments. Since: 2.18 the translation domain to use, or %NULL to use the domain set with textdomain() the message context the message The translated string This function is meant to be called from the `complete_type_info` function of a #GTypePlugin implementation, as in the following example: |[<!-- language="C" --> static void my_enum_complete_type_info (GTypePlugin *plugin, GType g_type, GTypeInfo *info, GTypeValueTable *value_table) { static const GEnumValue values[] = { { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" }, { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" }, { 0, NULL, NULL } }; g_enum_complete_type_info (type, info, values); } ]| the type identifier of the type being completed the #GTypeInfo struct to be filled in An array of #GEnumValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. Returns the #GEnumValue for a value. a #GEnumClass the value to look up the #GEnumValue for @value, or %NULL if @value is not a member of the enumeration Looks up a #GEnumValue by name. a #GEnumClass the name to look up the #GEnumValue with name @name, or %NULL if the enumeration doesn't have a member with that name Looks up a #GEnumValue by nickname. a #GEnumClass the nickname to look up the #GEnumValue with nickname @nick, or %NULL if the enumeration doesn't have a member with that nickname Registers a new static enumeration type with the name @name. It is normally more convenient to let [glib-mkenums][glib-mkenums], generate a my_enum_get_type() function from a usual C enumeration definition than to write one yourself using g_enum_register_static(). A nul-terminated string used as the name of the new type. An array of #GEnumValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. GObject keeps a reference to the data, so it cannot be stack-allocated. The new type identifier. Returns the value of the environment variable @variable in the provided list @envp. Since: 2.32 an environment list (eg, as returned from g_get_environ()), or %NULL for an empty environment list the environment variable to get the value of the environment variable, or %NULL if the environment variable is not set in @envp. The returned string is owned by @envp, and will be freed if @variable is set or unset again. Sets the environment variable @variable in the provided list @envp to @value. Since: 2.32 an environment list that can be freed using g_strfreev() (e.g., as returned from g_get_environ()), or %NULL for an empty environment list the environment variable to set, must not contain '=' the value for to set the variable to whether to change the variable if it already exists the updated environment list. Free it using g_strfreev(). Removes the environment variable @variable from the provided environment @envp. Since: 2.32 an environment list that can be freed using g_strfreev() (e.g., as returned from g_get_environ()), or %NULL for an empty environment list the environment variable to remove, must not contain '=' the updated environment list. Free it using g_strfreev(). A convenience function/macro to log an error message. Error messages are always fatal, resulting in a call to abort() to terminate the application. This function will result in a core dump; don't use it for errors you expect. Using this function indicates a bug in your program, i.e. an assertion failure. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. format string, followed by parameters to insert into the format string (as with printf()) Makes a copy of @error. a #GError a new #GError Frees a #GError and associated resources. a #GError Returns %TRUE if @error matches @domain and @code, %FALSE otherwise. In particular, when @error is %NULL, %FALSE will be returned. If @domain contains a `FAILED` (or otherwise generic) error code, you should generally not check for it explicitly, but should instead treat any not-explicitly-recognized error code as being equivalent to the `FAILED` code. This way, if the domain is extended in the future to provide a more specific error code for a certain case, your code will still work. a #GError or %NULL an error domain an error code whether @error has @domain and @code Creates a new #GError with the given @domain and @code, and a message formatted with @format. error domain error code printf()-style format for error message parameters for message format a new #GError Creates a new #GError; unlike g_error_new(), @message is not a printf()-style format string. Use this function if @message contains text you don't have control over, that could include printf() escape sequences. error domain error code error message a new #GError Creates a new #GError with the given @domain and @code, and a message formatted with @format. Since: 2.22 error domain error code printf()-style format for error message #va_list of parameters for the message format a new #GError Gets a #GFileError constant based on the passed-in @err_no. For example, if you pass in `EEXIST` this function returns #G_FILE_ERROR_EXIST. Unlike `errno` values, you can portably assume that all #GFileError values will exist. Normally a #GFileError value goes into a #GError returned from a function that manipulates files. So you would use g_file_error_from_errno() when constructing a #GError. an "errno" value #GFileError corresponding to the given @errno Reads an entire file into allocated memory, with good error checking. If the call was successful, it returns %TRUE and sets @contents to the file contents and @length to the length of the file contents in bytes. The string stored in @contents will be nul-terminated, so for text files you can pass %NULL for the @length argument. If the call was not successful, it returns %FALSE and sets @error. The error domain is #G_FILE_ERROR. Possible error codes are those in the #GFileError enumeration. In the error case, @contents is set to %NULL and @length is set to zero. name of a file to read contents from, in the GLib file name encoding location to store an allocated string, use g_free() to free the returned string location to store length in bytes of the contents, or %NULL return location for a #GError, or %NULL %TRUE on success, %FALSE if an error occurred Opens a file for writing in the preferred directory for temporary files (as returned by g_get_tmp_dir()). @tmpl should be a string in the GLib file name encoding containing a sequence of six 'X' characters, as the parameter to g_mkstemp(). However, unlike these functions, the template should only be a basename, no directory components are allowed. If template is %NULL, a default template is used. Note that in contrast to g_mkstemp() (and mkstemp()) @tmpl is not modified, and might thus be a read-only literal string. Upon success, and if @name_used is non-%NULL, the actual name used is returned in @name_used. This string should be freed with g_free() when not needed any longer. The returned name is in the GLib file name encoding. Template for file name, as in g_mkstemp(), basename only, or %NULL for a default template location to store actual name used, or %NULL return location for a #GError A file handle (as from open()) to the file opened for reading and writing. The file is opened in binary mode on platforms where there is a difference. The file handle should be closed with close(). In case of errors, -1 is returned and @error will be set. Reads the contents of the symbolic link @filename like the POSIX readlink() function. The returned string is in the encoding used for filenames. Use g_filename_to_utf8() to convert it to UTF-8. Since: 2.4 the symbolic link return location for a #GError A newly-allocated string with the contents of the symbolic link, or %NULL if an error occurred. Writes all of @contents to a file named @filename, with good error checking. If a file called @filename already exists it will be overwritten. This write is atomic in the sense that it is first written to a temporary file which is then renamed to the final name. Notes: - On UNIX, if @filename already exists hard links to @filename will break. Also since the file is recreated, existing permissions, access control lists, metadata etc. may be lost. If @filename is a symbolic link, the link itself will be replaced, not the linked file. - On Windows renaming a file will not remove an existing file with the new name, so on Windows there is a race condition between the existing file being removed and the temporary file being renamed. - On Windows there is no way to remove a file that is open to some process, or mapped into memory. Thus, this function will fail if @filename already exists and is open. If the call was successful, it returns %TRUE. If the call was not successful, it returns %FALSE and sets @error. The error domain is #G_FILE_ERROR. Possible error codes are those in the #GFileError enumeration. Note that the name for the temporary file is constructed by appending up to 7 characters to @filename. Since: 2.8 name of a file to write @contents to, in the GLib file name encoding string to write to the file length of @contents, or -1 if @contents is a nul-terminated string return location for a #GError, or %NULL %TRUE on success, %FALSE if an error occurred 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. Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links, so for a symbolic link to a regular file g_file_test() will return %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR. Note, that for a dangling symbolic link g_file_test() will return %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags. You should never use g_file_test() to test whether it is safe to perform an operation, because there is always the possibility of the condition changing before you actually perform the operation. For example, you might think you could use %G_FILE_TEST_IS_SYMLINK to know whether it is safe to write to a file without being tricked into writing into a different location. It doesn't work! |[<!-- language="C" --> // DON'T DO THIS if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK)) { fd = g_open (filename, O_WRONLY); // write to fd } ]| Another thing to note is that %G_FILE_TEST_EXISTS and %G_FILE_TEST_IS_EXECUTABLE are implemented using the access() system call. This usually doesn't matter, but if your program is setuid or setgid it means that these tests will give you the answer for the real user ID and group ID, rather than the effective user ID and group ID. On Windows, there are no symlinks, so testing for %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and its name indicates that it is executable, checking for well-known extensions and those listed in the `PATHEXT` environment variable. a filename to test in the GLib file name encoding bitfield of #GFileTest flags whether a test was %TRUE 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. If GLib cannot make sense of the encoding of @filename, as a last resort it replaces unknown characters with U+FFFD, the Unicode replacement character. You can search the result for the UTF-8 encoding of this character (which is "\357\277\275" in octal notation) to find out if @filename was in an invalid encoding. You must pass the whole absolute pathname to this functions so that translation of well known locations can be done. This function is preferred over g_filename_display_name() if you know the whole path, as it allows translation. Since: 2.6 an absolute pathname in the GLib file name encoding a newly allocated string containing a rendition of the basename of the filename in valid UTF-8 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. If GLib cannot make sense of the encoding of @filename, as a last resort it replaces unknown characters with U+FFFD, the Unicode replacement character. You can search the result for the UTF-8 encoding of this character (which is "\357\277\275" in octal notation) to find out if @filename was in an invalid encoding. If you know the whole pathname of the file you should use g_filename_display_basename(), since that allows location-based translation of filenames. Since: 2.6 a pathname hopefully in the GLib file name encoding a newly allocated string containing a rendition of the filename in valid UTF-8 Converts an escaped ASCII-encoded URI to a local filename in the encoding used for filenames. a uri describing a filename (escaped, encoded in ASCII). Location to store hostname for the URI, or %NULL. If there is no hostname in the URI, %NULL will be stored in this location. location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError may occur. a newly-allocated string holding the resulting filename, or %NULL on an error. Converts a string from UTF-8 to the encoding GLib uses for filenames. Note that on Windows GLib uses UTF-8 for filenames; on other platforms, this function indirectly depends on the [current locale][setlocale]. a UTF-8 encoded string. the length of the string, or -1 if the string is nul-terminated. location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError may occur. The converted string, or %NULL on an error. Converts an absolute filename to an escaped ASCII-encoded URI, with the path component following Section 3.3. of RFC 2396. an absolute filename specified in the GLib file name encoding, which is the on-disk file name bytes on Unix, and UTF-8 on Windows A UTF-8 encoded hostname, or %NULL for none. location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError may occur. a newly-allocated string holding the resulting URI, or %NULL on an error. Converts a string which is in the encoding used by GLib for filenames into a UTF-8 string. Note that on Windows GLib uses UTF-8 for filenames; on other platforms, this function indirectly depends on the [current locale][setlocale]. a string in the encoding for filenames the length of the string, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError may occur. The converted string, or %NULL on an error. 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 @program if @program exists and is executable, and %NULL otherwise. On Windows, if @program does not have a file type suffix, tries with the suffixes .exe, .cmd, .bat and .com, and the suffixes in the `PATHEXT` environment variable. On Windows, it looks for the file in the same way as CreateProcess() would. This means first in the directory where the executing program was loaded from, then in the current directory, then in the Windows 32-bit system directory, then in the Windows directory, and finally in the directories in the `PATH` environment variable. If the program is found, the return value contains the full name including the type suffix. a program name in the GLib file name encoding a newly-allocated string with the absolute path, or %NULL This function is meant to be called from the complete_type_info() function of a #GTypePlugin implementation, see the example for g_enum_complete_type_info() above. the type identifier of the type being completed the #GTypeInfo struct to be filled in An array of #GFlagsValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. Returns the first #GFlagsValue which is set in @value. a #GFlagsClass the value the first #GFlagsValue which is set in @value, or %NULL if none is set Looks up a #GFlagsValue by name. a #GFlagsClass the name to look up the #GFlagsValue with name @name, or %NULL if there is no flag with that name Looks up a #GFlagsValue by nickname. a #GFlagsClass the nickname to look up the #GFlagsValue with nickname @nick, or %NULL if there is no flag with that nickname Registers a new static flags type with the name @name. It is normally more convenient to let [glib-mkenums][glib-mkenums] generate a my_flags_get_type() function from a usual C enumeration definition than to write one yourself using g_flags_register_static(). A nul-terminated string used as the name of the new type. An array of #GFlagsValue structs for the possible flags values. The array is terminated by a struct with all members being 0. GObject keeps a reference to the data, so it cannot be stack-allocated. The new type identifier. A wrapper for the stdio fopen() function. The fopen() function opens a file and associates a new stream with it. Because file descriptors are specific to the C library on Windows, and a file descriptor is part of the FILE struct, the FILE* returned by this function makes sense only to functions in the same C library. Thus if the GLib-using code uses a different C library than GLib does, the FILE* returned by this function cannot be passed to C library functions like fprintf() or fread(). See your C library manual for more details about fopen(). Since: 2.6 a pathname in the GLib file name encoding (UTF-8 on Windows) a string describing the mode in which the file should be opened A FILE* if the file was successfully opened, or %NULL if an error occurred 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 prefix units base is 1000 (i.e. 1 kB is 1000 bytes). This string should be freed with g_free() when not needed any longer. See g_format_size_full() for more options about how the size might be formatted. Since: 2.30 a size in bytes a newly-allocated formatted string containing a human readable file size 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". The prefix units base is 1024 (i.e. 1 KB is 1024 bytes). This string should be freed with g_free() when not needed any longer. Since: 2.16 Deprecated:2.30: This function is broken due to its use of SI suffixes to denote IEC units. Use g_format_size() instead. a size in bytes a newly-allocated formatted string containing a human readable file size Formats a size. This function is similar to g_format_size() but allows for flags that modify the output. See #GFormatSizeFlags. Since: 2.30 a size in bytes #GFormatSizeFlags to modify the output a newly-allocated formatted string containing a human readable file size An implementation of the standard fprintf() function which supports positional parameters, as specified in the Single Unix Specification. Since: 2.2 the stream to write to. a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output. the number of bytes printed. Frees the memory pointed to by @mem. If @mem is %NULL it simply returns, so there is no need to check @mem against %NULL before calling this function. the memory to free A wrapper for the POSIX freopen() function. The freopen() function opens a file and associates it with an existing stream. See your C library manual for more details about freopen(). Since: 2.6 a pathname in the GLib file name encoding (UTF-8 on Windows) a string describing the mode in which the file should be opened an existing stream which will be reused, or %NULL A FILE* if the file was successfully opened, or %NULL if an error occurred. 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). Since: 2.2 human-readable application name. may return %NULL Obtains the character set for the [current locale][setlocale]; you might use this character set as an argument to g_convert(), to convert from the current locale's encoding to some other encoding. (Frequently g_locale_to_utf8() and g_locale_from_utf8() are nice shortcuts, though.) On Windows the character set returned by this function is the so-called system default ANSI code-page. That is the character set used by the "narrow" versions of C library and Win32 functions that handle file names. It might be different from the character set used by the C library's current locale. The return value is %TRUE if the locale's encoding is UTF-8, in that case you can perhaps avoid calling g_convert(). The string returned in @charset is not allocated, and should not be freed. return location for character set name, or %NULL. %TRUE if the returned charset is UTF-8 Gets the character set for the current locale. a newly allocated string containing the name of the character set. This string must be freed with g_free(). Gets the current directory. The returned string should be freed when no longer needed. The encoding of the returned string is system defined. On Windows, it is always UTF-8. Since GLib 2.40, this function will return the value of the "PWD" environment variable if it is set and it happens to be the same as the current directory. This can make a difference in the case that the current directory is the target of a symbolic link. the current directory Equivalent to the UNIX gettimeofday() function, but portable. You may find g_get_real_time() to be more convenient. #GTimeVal structure in which to store current time. Gets the list of environment variables for the current process. The list is %NULL terminated and each item in the list is of the form 'NAME=VALUE'. This is equivalent to direct access to the 'environ' global variable, except portable. The return value is freshly allocated and it should be freed with g_strfreev() when it is no longer needed. Since: 2.28 the list of environment variables Determines the preferred character sets used for filenames. The first character set from the @charsets is the filename encoding, the subsequent character sets are used when trying to generate a displayable representation of a filename, see g_filename_display_name(). On Unix, the character sets are determined by consulting the environment variables `G_FILENAME_ENCODING` and `G_BROKEN_FILENAMES`. On Windows, the character set used in the GLib API is always UTF-8 and said environment variables have no effect. `G_FILENAME_ENCODING` may be set to a comma-separated list of character set names. The special token "@locale" is taken to mean the character set for the [current locale][setlocale]. If `G_FILENAME_ENCODING` is not set, but `G_BROKEN_FILENAMES` is, the character set of the current locale is taken as the filename encoding. If neither environment variable is set, UTF-8 is taken as the filename encoding, but the character set of the current locale is also put in the list of encodings. The returned @charsets belong to GLib and must not be freed. Note that on Unix, regardless of the locale character set or `G_FILENAME_ENCODING` value, the actual file names present on a system might be in any random encoding or just gibberish. Since: 2.6 return location for the %NULL-terminated list of encoding names %TRUE if the filename encoding is UTF-8. Gets the current user's home directory. As with most UNIX tools, this function will return the value of the `HOME` environment variable if it is set to an existing absolute path name, falling back to the `passwd` file in the case that it is unset. If the path given in `HOME` is non-absolute, does not exist, or is not a directory, the result is undefined. Before version 2.36 this function would ignore the `HOME` environment variable, taking the value from the `passwd` database instead. This was changed to increase the compatibility of GLib with other programs (and the XDG basedir specification) and to increase testability of programs based on GLib (by making it easier to run them from test frameworks). If your program has a strong requirement for either the new or the old behaviour (and if you don't wish to increase your GLib dependency to ensure that the new behaviour is in effect) then you should either directly check the `HOME` environment variable yourself or unset it before calling any functions in GLib. the current user's home directory Return a name for the machine. The returned name is not necessarily a fully-qualified domain name, or even present in DNS or some other name service at all. It need not even be unique on your local network or site, but usually it is. Callers should not rely on the return value having any specific properties like uniqueness for security purposes. Even if the name of the machine is changed while an application is running, the return value from this function does not change. The returned string is owned by GLib and should not be modified or freed. If no name can be determined, a default fixed string "localhost" is returned. Since: 2.8 the host name of 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". For example, if LANGUAGE=de:en_US, then the returned list is "de", "en_US", "en", "C". This function consults the environment variables `LANGUAGE`, `LC_ALL`, `LC_MESSAGES` and `LANG` to find the list of locales specified by the user. Since: 2.6 a %NULL-terminated array of strings owned by GLib that must not be modified or freed. 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. For example, if @locale is "fr_BE", then the returned list is "fr_BE", "fr". If you need the list of variants for the current locale, use g_get_language_names(). Since: 2.28 a locale identifier a newly allocated array of newly allocated strings with the locale variants. Free with g_strfreev(). Queries the system monotonic time. The monotonic clock will always increase and doesn't suffer discontinuities when the user (or NTP) changes the system time. It may or may not continue to tick during times where the machine is suspended. We try to use the clock that corresponds as closely as possible to the passage of time as measured by system calls such as poll() but it may not always be possible to do this. Since: 2.28 the monotonic time, in microseconds 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. Since: 2.36 Number of schedulable threads, always greater than 0 Gets the name of the program. This name should not be localized, in contrast to g_get_application_name(). If you are using GDK or GTK+ the program name is set in gdk_init(), which is called by gtk_init(). The program name is found by taking the last component of @argv[0]. the name of the program. The returned string belongs to GLib and must not be modified or freed. 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. the user's real name. Queries the system wall-clock time. This call is functionally equivalent to g_get_current_time() except that the return value is often more convenient than dealing with a #GTimeVal. You should only use this call if you are actually interested in the real wall-clock time. g_get_monotonic_time() is probably more useful for measuring intervals. Since: 2.28 the number of microseconds since January 1, 1970 UTC. Returns an ordered list of base directories in which to access system-wide configuration information. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the list of directories retrieved will be `XDG_CONFIG_DIRS`. On Windows is the directory that contains application data for all users. A typical path is C:\Documents and Settings\All Users\Application Data. This folder is used for application data that is not user specific. For example, an application can store a spell-check dictionary, a database of clip art, or a log file in the CSIDL_COMMON_APPDATA folder. This information will not roam and is available to anyone using the computer. Since: 2.6 a %NULL-terminated array of strings owned by GLib that must not be modified or freed. Returns an ordered list of base directories in which to access system-wide application data. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec) In this case the list of directories retrieved will be XDG_DATA_DIRS. On Windows the first elements in the list are the Application Data and Documents folders for All Users. (These can be determined only on Windows 2000 or later and are not present in the list on other Windows versions.) See documentation for CSIDL_COMMON_APPDATA and CSIDL_COMMON_DOCUMENTS. Then follows the "share" subfolder in the installation folder for the package containing the DLL that calls this function, if it can be determined. Finally the list contains the "share" subfolder in the installation folder for GLib, and in the installation folder for the package the application's .exe file belongs to. The installation folders above are determined by looking up the folder where the module (DLL or EXE) in question is located. If the folder's name is "bin", its parent is used, otherwise the folder itself. Note that on Windows the returned list can vary depending on where this function is called. Since: 2.6 a %NULL-terminated array of strings owned by GLib that must not be modified or freed. Gets the directory to use for temporary files. On UNIX, this is taken from the `TMPDIR` environment variable. If the variable is not set, `P_tmpdir` is used, as defined by the system C library. Failing that, a hard-coded default of "/tmp" is returned. On Windows, the `TEMP` environment variable is used, with the root directory of the Windows installation (eg: "C:\") used as a default. The encoding of the returned string is system-defined. On Windows, it is always UTF-8. The return value is never %NULL or the empty string. the directory to use for temporary files. Returns a base directory in which to store non-essential, cached data specific to particular user. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the directory retrieved will be XDG_CACHE_HOME. On Windows is the directory that serves as a common repository for temporary Internet files. A typical path is C:\Documents and Settings\username\Local Settings\Temporary Internet Files. See documentation for CSIDL_INTERNET_CACHE. Since: 2.6 a string owned by GLib that must not be modified or freed. Returns a base directory in which to store user-specific application configuration information such as user preferences and settings. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the directory retrieved will be `XDG_CONFIG_HOME`. On Windows this is the folder to use for local (as opposed to roaming) application data. See documentation for CSIDL_LOCAL_APPDATA. Note that on Windows it thus is the same as what g_get_user_data_dir() returns. Since: 2.6 a string owned by GLib that must not be modified or freed. Returns a base directory in which to access application data such as icons that is customized for a particular user. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). In this case the directory retrieved will be `XDG_DATA_HOME`. On Windows this is the folder to use for local (as opposed to roaming) application data. See documentation for CSIDL_LOCAL_APPDATA. Note that on Windows it thus is the same as what g_get_user_config_dir() returns. Since: 2.6 a string owned by GLib that must not be modified or freed. 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. the user name of the current user. Returns a directory that is unique to the current user on the local system. On UNIX platforms this is determined using the mechanisms described in the [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec). This is the directory specified in the `XDG_RUNTIME_DIR` environment variable. In the case that this variable is not set, GLib will issue a warning message to stderr and return the value of g_get_user_cache_dir(). On Windows this is the folder to use for local (as opposed to roaming) application data. See documentation for CSIDL_LOCAL_APPDATA. Note that on Windows it thus is the same as what g_get_user_config_dir() returns. Since: 2.28 a string owned by GLib that must not be modified or freed. Returns the full path of a special directory using its logical id. On UNIX this is done using the XDG special user directories. For compatibility with existing practise, %G_USER_DIRECTORY_DESKTOP falls back to `$HOME/Desktop` when XDG special user directories have not been set up. Depending on the platform, the user might be able to change the path of the special directory without requiring the session to restart; GLib will not reflect any change once the special directories are loaded. Since: 2.14 the logical id of special directory the path to the specified special directory, or %NULL if the logical id was not found. The returned string is owned by GLib and should not be modified or freed. Returns the value of an environment variable. On UNIX, the name and value are byte strings which might or might not be in some consistent character set and encoding. On Windows, they are in UTF-8. On Windows, in case the environment variable's value contains references to other environment variables, they are expanded. the environment variable to get the value of the environment variable, or %NULL if the environment variable is not found. The returned string may be overwritten by the next call to g_getenv(), g_setenv() or g_unsetenv(). This is a convenience function for using a #GHashTable as a set. It is equivalent to calling g_hash_table_replace() with @key as both the key and the value. When a hash table only ever contains keys that have themselves as the corresponding value it is able to be stored more efficiently. See the discussion in the section description. Since: 2.32 a #GHashTable a key to insert %TRUE if the key did not exist yet Checks if @key is in @hash_table. Since: 2.32 a #GHashTable a key to check %TRUE if @key is in @hash_table, %FALSE otherwise. 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. a #GHashTable Calls the given function for key/value pairs in the #GHashTable until @predicate returns %TRUE. 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). Note, that hash tables are really only optimized for forward lookups, i.e. g_hash_table_lookup(). So code that frequently issues g_hash_table_find() or g_hash_table_foreach() (e.g. in the order of once per every entry in a hash table) should probably be reworked to use additional or different data structures for reverse lookups (keep in mind that an O(n) find/foreach operation issued for all n values in a hash table ends up needing O(n*n) operations). Since: 2.4 a #GHashTable function to test the key/value pairs for a certain property user data to pass to the function The value of the first key/value pair is returned, for which @predicate evaluates to %TRUE. If no pair with the requested property is found, %NULL is returned. 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(). See g_hash_table_find() for performance caveats for linear order searches in contrast to g_hash_table_lookup(). a #GHashTable the function to call for each key/value pair user data to pass to the function 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. See #GHashTableIter for an alternative way to loop over the key/value pairs in the hash table. a #GHashTable the function to call for each key/value pair user data to pass to the function the number of key/value pairs removed 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. See #GHashTableIter for an alternative way to loop over the key/value pairs in the hash table. a #GHashTable the function to call for each key/value pair user data to pass to the function the number of key/value pairs removed. This function is deprecated and will be removed in the next major release of GLib. It does nothing. a #GHashTable Retrieves every key inside @hash_table. The returned data is valid until changes to the hash release those keys. This iterates over every entry in the hash table to build its return value. To iterate over the entries in a #GHashTable more efficiently, use a #GHashTableIter. Since: 2.14 a #GHashTable a #GList containing all the keys inside the hash table. The content of the list is owned by the hash table and should not be modified or freed. Use g_list_free() when done using the list. Retrieves every key inside @hash_table, as an array. The returned array is %NULL-terminated but may contain %NULL as a key. Use @length to determine the true length if it's possible that %NULL was used as the value for a key. Note: in the common case of a string-keyed #GHashTable, the return value of this function can be conveniently cast to (const gchar **). This iterates over every entry in the hash table to build its return value. To iterate over the entries in a #GHashTable more efficiently, use a #GHashTableIter. You should always free the return result with g_free(). In the above-mentioned case of a string-keyed hash table, it may be appropriate to use g_strfreev() if you call g_hash_table_steal_all() first to transfer ownership of the keys. Since: 2.40 a #GHashTable the length of the returned array a %NULL-terminated array containing each key from the table. Retrieves every value inside @hash_table. The returned data is valid until @hash_table is modified. This iterates over every entry in the hash table to build its return value. To iterate over the entries in a #GHashTable more efficiently, use a #GHashTableIter. Since: 2.14 a #GHashTable a #GList containing all the values inside the hash table. The content of the list is owned by the hash table and should not be modified or freed. Use g_list_free() when done using the list. Inserts a new key and value into a #GHashTable. If the key already exists in the #GHashTable its current value is replaced with the new value. If you supplied a @value_destroy_func when creating the #GHashTable, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GHashTable, the passed key is freed using that function. a #GHashTable a key to insert the value to associate with the key %TRUE if the key did not exist yet Returns the #GHashTable associated with @iter. Since: 2.16 an initialized #GHashTableIter the #GHashTable associated with @iter. Initializes a key/value pair iterator and associates it with @hash_table. Modifying the hash table after calling this function invalidates the returned iterator. |[<!-- language="C" --> GHashTableIter iter; gpointer key, value; g_hash_table_iter_init (&iter, hash_table); while (g_hash_table_iter_next (&iter, &key, &value)) { // do something with key and value } ]| Since: 2.16 an uninitialized #GHashTableIter a #GHashTable Advances @iter and retrieves the key and/or value that are now pointed to as a result of this advancement. If %FALSE is returned, @key and @value are not set, and the iterator becomes invalid. Since: 2.16 an initialized #GHashTableIter a location to store the key, or %NULL a location to store the value, or %NULL %FALSE if the end of the #GHashTable has been reached. Removes the key/value pair currently pointed to by the iterator from its associated #GHashTable. Can only be called after g_hash_table_iter_next() returned %TRUE, and cannot be called more than once for the same key/value pair. If the #GHashTable was created using g_hash_table_new_full(), the key and value are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. It is safe to continue iterating the #GHashTable afterward: |[<!-- language="C" --> while (g_hash_table_iter_next (&iter, &key, &value)) { if (condition) g_hash_table_iter_remove (&iter); } ]| Since: 2.16 an initialized #GHashTableIter Replaces the value currently pointed to by the iterator from its associated #GHashTable. Can only be called after g_hash_table_iter_next() returned %TRUE. If you supplied a @value_destroy_func when creating the #GHashTable, the old value is freed using that function. Since: 2.30 an initialized #GHashTableIter the value to replace with Removes the key/value pair currently pointed to by the iterator from its associated #GHashTable, without calling the key and value destroy functions. Can only be called after g_hash_table_iter_next() returned %TRUE, and cannot be called more than once for the same key/value pair. Since: 2.16 an initialized #GHashTableIter Looks up a key in a #GHashTable. Note that this function cannot distinguish between a key that is not present and one which is present and has the value %NULL. If you need this distinction, use g_hash_table_lookup_extended(). a #GHashTable the key to look up the associated value, or %NULL if the key is not found Looks up a key in the #GHashTable, returning the original key and the associated value and a #gboolean which is %TRUE if the key was found. This is useful if you need to free the memory allocated for the original key, for example before calling g_hash_table_remove(). You can actually pass %NULL for @lookup_key to test whether the %NULL key exists, provided the hash and equal functions of @hash_table are %NULL-safe. a #GHashTable the key to look up return location for the original key, or %NULL return location for the value associated with the key, or %NULL %TRUE if the key was found in the #GHashTable Creates a new #GHashTable with a reference count of 1. Hash values returned by @hash_func are used to determine where keys are stored within the #GHashTable data structure. The g_direct_hash(), g_int_hash(), g_int64_hash(), g_double_hash() and g_str_hash() functions are provided for some common types of keys. If @hash_func is %NULL, g_direct_hash() is used. @key_equal_func is used when looking up keys in the #GHashTable. The g_direct_equal(), g_int_equal(), g_int64_equal(), g_double_equal() and g_str_equal() functions are provided for the most common types of keys. If @key_equal_func is %NULL, keys are compared directly in a similar fashion to g_direct_equal(), but without the overhead of a function call. a function to create a hash value from a key a function to check two keys for equality a new #GHashTable Creates a new #GHashTable like g_hash_table_new() with a reference count of 1 and allows to specify functions to free the memory allocated for the key and value that get called when removing the entry from the #GHashTable. Since version 2.42 it is permissible for destroy notify functions to recursively remove further items from the hash table. This is only permissible if the application still holds a reference to the hash table. This means that you may need to ensure that the hash table is empty by calling g_hash_table_remove_all before releasing the last reference using g_hash_table_unref(). a function to create a hash value from a key a function to check two keys for equality a function to free the memory allocated for the key used when removing the entry from the #GHashTable, or %NULL if you don't want to supply such a function. a function to free the memory allocated for the value used when removing the entry from the #GHashTable, or %NULL if you don't want to supply such a function. a new #GHashTable Atomically increments the reference count of @hash_table by one. This function is MT-safe and may be called from any thread. Since: 2.10 a valid #GHashTable the passed in #GHashTable Removes a key and its associated value from a #GHashTable. If the #GHashTable was created using g_hash_table_new_full(), the key and value are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. a #GHashTable the key to remove %TRUE if the key was found and removed from the #GHashTable Removes all keys and their associated values from a #GHashTable. If the #GHashTable was created using g_hash_table_new_full(), the keys and values are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. Since: 2.12 a #GHashTable Inserts a new key and value into a #GHashTable similar to g_hash_table_insert(). The difference is that if the key already exists in the #GHashTable, it gets replaced by the new key. If you supplied a @value_destroy_func when creating the #GHashTable, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GHashTable, the old key is freed using that function. a #GHashTable a key to insert the value to associate with the key %TRUE of the key did not exist yet Returns the number of elements contained in the #GHashTable. a #GHashTable the number of key/value pairs in the #GHashTable. Removes a key and its associated value from a #GHashTable without calling the key and value destroy functions. a #GHashTable the key to remove %TRUE if the key was found and removed from the #GHashTable Removes all keys and their associated values from a #GHashTable without calling the key and value destroy functions. Since: 2.12 a #GHashTable This function is deprecated and will be removed in the next major release of GLib. It does nothing. a #GHashTable 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. Since: 2.10 a valid #GHashTable Copies a #GHmac. If @hmac has been closed, by calling g_hmac_get_string() or g_hmac_get_digest(), the copied HMAC will be closed as well. Since: 2.30 the #GHmac to copy the copy of the passed #GHmac. Use g_hmac_unref() when finished using it. Gets the digest from @checksum as a raw binary array and places it into @buffer. The size of the digest depends on the type of checksum. Once this function has been called, the #GHmac is closed and can no longer be updated with g_checksum_update(). Since: 2.30 a #GHmac output buffer an inout parameter. The caller initializes it to the size of @buffer. After the call it contains the length of the digest Gets the HMAC as an hexadecimal string. Once this function has been called the #GHmac can no longer be updated with g_hmac_update(). The hexadecimal characters will be lower case. Since: 2.30 a #GHmac the hexadecimal representation of the HMAC. The returned string is owned by the HMAC and should not be modified or freed. Creates a new #GHmac, using the digest algorithm @digest_type. If the @digest_type is not known, %NULL is returned. A #GHmac can be used to compute the HMAC of a key and an arbitrary binary blob, using different hashing algorithms. A #GHmac works by feeding a binary blob through g_hmac_update() until the data is complete; the digest can then be extracted using g_hmac_get_string(), which will return the checksum as a hexadecimal string; or g_hmac_get_digest(), which will return a array of raw bytes. Once either g_hmac_get_string() or g_hmac_get_digest() have been called on a #GHmac, the HMAC will be closed and it won't be possible to call g_hmac_update() on it anymore. Support for digests of type %G_CHECKSUM_SHA512 has been added in GLib 2.42. Since: 2.30 the desired type of digest the key for the HMAC the length of the keys the newly created #GHmac, or %NULL. Use g_hmac_unref() to free the memory allocated by it. Atomically increments the reference count of @hmac by one. This function is MT-safe and may be called from any thread. Since: 2.30 a valid #GHmac the passed in #GHmac. Atomically decrements the reference count of @hmac 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. Frees the memory allocated for @hmac. Since: 2.30 a #GHmac Feeds @data into an existing #GHmac. The HMAC must still be open, that is g_hmac_get_string() or g_hmac_get_digest() must not have been called on @hmac. Since: 2.30 a #GHmac buffer used to compute the checksum size of the buffer, or -1 if it is a nul-terminated string Allocates space for a #GHook and initializes it. a #GHookList a new #GHook Appends a #GHook onto the end of a #GHookList. a #GHookList the #GHook to add to the end of @hook_list Compares the ids of two #GHook elements, returning a negative value if the second id is greater than the first. a #GHook a #GHook to compare with @new_hook a value <= 0 if the id of @sibling is >= the id of @new_hook Destroys a #GHook, given its ID. a #GHookList a hook ID %TRUE if the #GHook was found in the #GHookList and destroyed Removes one #GHook from a #GHookList, marking it inactive and calling g_hook_unref() on it. a #GHookList the #GHook to remove Finds a #GHook in a #GHookList using the given function to test for a match. a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the function to call for each #GHook, which should return %TRUE when the #GHook has been found the data to pass to @func the found #GHook or %NULL if no matching #GHook is found Finds a #GHook in a #GHookList with the given data. a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the data to find the #GHook with the given @data or %NULL if no matching #GHook is found Finds a #GHook in a #GHookList with the given function. a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the function to find the #GHook with the given @func or %NULL if no matching #GHook is found Finds a #GHook in a #GHookList with the given function and data. a #GHookList %TRUE if #GHook elements which have been destroyed should be skipped the function to find the data to find the #GHook with the given @func and @data or %NULL if no matching #GHook is found Returns the first #GHook in a #GHookList which has not been destroyed. The reference count for the #GHook is incremented, so you must call g_hook_unref() to restore it when no longer needed. (Or call g_hook_next_valid() if you are stepping through the #GHookList.) a #GHookList %TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped the first valid #GHook, or %NULL if none are valid Calls the #GHookList @finalize_hook function if it exists, and frees the memory allocated for the #GHook. a #GHookList the #GHook to free Returns the #GHook with the given id, or %NULL if it is not found. a #GHookList a hook id the #GHook with the given id, or %NULL if it is not found Inserts a #GHook into a #GHookList, before a given #GHook. a #GHookList the #GHook to insert the new #GHook before the #GHook to insert Inserts a #GHook into a #GHookList, sorted by the given function. a #GHookList the #GHook to insert the comparison function used to sort the #GHook elements Removes all the #GHook elements from a #GHookList. a #GHookList Initializes a #GHookList. This must be called before the #GHookList is used. a #GHookList the size of each element in the #GHookList, typically `sizeof (GHook)`. Calls all of the #GHook functions in a #GHookList. a #GHookList %TRUE if functions which are already running (e.g. in another thread) can be called. If set to %FALSE, these are skipped Calls all of the #GHook functions in a #GHookList. Any function which returns %FALSE is removed from the #GHookList. a #GHookList %TRUE if functions which are already running (e.g. in another thread) can be called. If set to %FALSE, these are skipped Calls a function on each valid #GHook. a #GHookList %TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped the function to call for each #GHook data to pass to @marshaller Calls a function on each valid #GHook and destroys it if the function returns %FALSE. a #GHookList %TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped the function to call for each #GHook data to pass to @marshaller Returns the next #GHook in a #GHookList which has not been destroyed. The reference count for the #GHook is incremented, so you must call g_hook_unref() to restore it when no longer needed. (Or continue to call g_hook_next_valid() until %NULL is returned.) a #GHookList the current #GHook %TRUE if hooks which are currently running (e.g. in another thread) are considered valid. If set to %FALSE, these are skipped the next valid #GHook, or %NULL if none are valid Prepends a #GHook on the start of a #GHookList. a #GHookList the #GHook to add to the start of @hook_list Increments the reference count for a #GHook. a #GHookList the #GHook to increment the reference count of the @hook that was passed in (since 2.6) 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. a #GHookList the #GHook to unref 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. Note that a hostname might contain a mix of encoded and unencoded segments, and so it is possible for g_hostname_is_non_ascii() and g_hostname_is_ascii_encoded() to both return %TRUE for a name. Since: 2.22 a hostname %TRUE if @hostname contains any ASCII-encoded segments. Tests if @hostname is the string form of an IPv4 or IPv6 address. (Eg, "192.168.0.1".) Since: 2.22 a hostname (or IP address in string form) %TRUE if @hostname is an IP address 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. Note that a hostname might contain a mix of encoded and unencoded segments, and so it is possible for g_hostname_is_non_ascii() and g_hostname_is_ascii_encoded() to both return %TRUE for a name. Since: 2.22 a hostname %TRUE if @hostname contains any non-ASCII characters Converts @hostname to its canonical ASCII form; an ASCII-only string containing no uppercase letters and not ending with a trailing dot. Since: 2.22 a valid UTF-8 or ASCII hostname an ASCII hostname, which must be freed, or %NULL if @hostname is in some way invalid. 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. Of course if @hostname is not an internationalized hostname, then the canonical presentation form will be entirely ASCII. Since: 2.22 a valid UTF-8 or ASCII hostname a UTF-8 hostname, which must be freed, or %NULL if @hostname is in some way invalid. Converts a 32-bit integer value from host to network byte order. a 32-bit integer value in host byte order @val converted to network byte order Converts a 16-bit integer value from host to network byte order. a 16-bit integer value in host byte order @val converted to network byte order Same as the standard UNIX routine iconv(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers. conversion descriptor from g_iconv_open() bytes to convert inout parameter, bytes remaining to convert in @inbuf converted output bytes inout parameter, bytes available to fill in @outbuf count of non-reversible conversions, or -1 on error Same as the standard UNIX routine iconv_close(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. Should be called to clean up the conversion descriptor from g_iconv_open() when you are done converting things. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers. a conversion descriptor from g_iconv_open() -1 on error, 0 on success Same as the standard UNIX routine iconv_open(), but may be implemented via libiconv on UNIX flavors that lack a native implementation. GLib provides g_convert() and g_locale_to_utf8() which are likely more convenient than the raw iconv wrappers. destination codeset source codeset a "conversion descriptor", or (GIConv)-1 if opening the converter failed. Adds a function to be called whenever there are no higher priority events pending to the default main loop. The function is given the default idle priority, #G_PRIORITY_DEFAULT_IDLE. If the function returns %FALSE it is automatically removed from the list of event sources and will not be called again. This internally creates a main loop source using g_idle_source_new() and attaches it to the global #GMainContext using g_source_attach(), so the callback will be invoked in whichever thread is running that main context. You can do these steps manually if you need greater control or to use a custom main context. function to call data to pass to @function. the ID (greater than 0) of the event source. Adds a function to be called whenever there are no higher priority events pending. If the function returns %FALSE it is automatically removed from the list of event sources and will not be called again. This internally creates a main loop source using g_idle_source_new() and attaches it to the global #GMainContext using g_source_attach(), so the callback will be invoked in whichever thread is running that main context. You can do these steps manually if you need greater control or to use a custom main context. the priority of the idle source. Typically this will be in the range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE. function to call data to pass to @function function to call when the idle is removed, or %NULL the ID (greater than 0) of the event source. Removes the idle function with the given data. the data for the idle source's callback. %TRUE if an idle source was found and removed. Creates a new idle source. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. Note that the default priority for idle sources is %G_PRIORITY_DEFAULT_IDLE, as compared to other sources which have a default priority of %G_PRIORITY_DEFAULT. the newly-created idle source A convenience function/macro to log an informational message. Seldom used. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. Such messages are suppressed by the g_log_default_handler() unless the G_MESSAGES_DEBUG environment variable is set appropriately. Since: 2.40 format string, followed by parameters to insert into the format string (as with printf()) Compares the two #gint64 values being pointed to and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL pointers to 64-bit integers as keys in a #GHashTable. Since: 2.22 a pointer to a #gint64 key a pointer to a #gint64 key to compare with @v1 %TRUE if the two keys match. Converts a pointer to a #gint64 to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL pointers to 64-bit integer values as keys in a #GHashTable. Since: 2.22 a pointer to a #gint64 key a hash value corresponding to the key. Compares the two #gint values being pointed to and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL pointers to integers as keys in a #GHashTable. Note that this function acts on pointers to #gint, not on #gint directly: if your hash table's keys are of the form `GINT_TO_POINTER (n)`, use g_direct_equal() instead. a pointer to a #gint key a pointer to a #gint key to compare with @v1 %TRUE if the two keys match. Converts a pointer to a #gint to a hash value. It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL pointers to integer values as keys in a #GHashTable. Note that this function acts on pointers to #gint, not on #gint directly: if your hash table's keys are of the form `GINT_TO_POINTER (n)`, use g_direct_hash() instead. a pointer to a #gint key a hash value corresponding to the key. 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. Since: 2.10 a static string a canonical representation for the string Returns a canonical representation for @string. Interned strings can be compared for equality by comparing the pointers, instead of using strcmp(). Since: 2.10 a string a canonical representation for the string Adds the #GIOChannel into the default main loop context with the default priority. a #GIOChannel the condition to watch for the function to call when the condition is satisfied user data to pass to @func the event source id Adds the #GIOChannel into the default main loop context with the given priority. This internally creates a main loop source using g_io_create_watch() and attaches it to the main loop context with g_source_attach(). You can do these steps manually if you need greater control. a #GIOChannel the priority of the #GIOChannel source the condition to watch for the function to call when the condition is satisfied user data to pass to @func the function to call when the source is removed the event source id Close an IO channel. Any pending data to be written will be flushed, ignoring errors. The channel will not be freed until the last reference is dropped using g_io_channel_unref(). Deprecated:2.2: Use g_io_channel_shutdown() instead. A #GIOChannel Converts an `errno` error number to a #GIOChannelError. an `errno` error number, e.g. `EINVAL` a #GIOChannelError error number, e.g. %G_IO_CHANNEL_ERROR_INVAL. Flushes the write buffer for the GIOChannel. a #GIOChannel location to store an error of type #GIOChannelError the status of the operation: One of #G_IO_STATUS_NORMAL, #G_IO_STATUS_AGAIN, or #G_IO_STATUS_ERROR. This function returns a #GIOCondition depending on whether there is data to be read/space to write data in the internal buffers in the #GIOChannel. Only the flags %G_IO_IN and %G_IO_OUT may be set. A #GIOChannel A #GIOCondition Gets the buffer size. a #GIOChannel the size of the buffer. Returns whether @channel is buffered. a #GIOChannel %TRUE if the @channel is buffered. Returns whether the file/socket/whatever associated with @channel will be closed when @channel receives its final unref and is destroyed. The default value of this is %TRUE for channels created by g_io_channel_new_file (), and %FALSE for all other channels. a #GIOChannel. Whether the channel will be closed on the final unref of the GIOChannel data structure. Gets the encoding for the input/output of the channel. The internal encoding is always UTF-8. The encoding %NULL makes the channel safe for binary data. a #GIOChannel A string containing the encoding, this string is owned by GLib and must not be freed. Gets the current flags for a #GIOChannel, including read-only flags such as %G_IO_FLAG_IS_READABLE. The values of the flags %G_IO_FLAG_IS_READABLE and %G_IO_FLAG_IS_WRITABLE are cached for internal use by the channel when it is created. If they should change at some later point (e.g. partial shutdown of a socket with the UNIX shutdown() function), the user should immediately call g_io_channel_get_flags() to update the internal values of these flags. a #GIOChannel the flags which are set on the channel This returns the string that #GIOChannel uses to determine where in the file a line break occurs. A value of %NULL indicates autodetection. a #GIOChannel a location to return the length of the line terminator The line termination string. This value is owned by GLib and must not be freed. Initializes a #GIOChannel struct. This is called by each of the above functions when creating a #GIOChannel, and so is not often needed by the application programmer (unless you are creating a new type of #GIOChannel). a #GIOChannel Open a file @filename as a #GIOChannel using mode @mode. This channel will be closed when the last reference to it is dropped, so there is no need to call g_io_channel_close() (though doing so will not cause problems, as long as no attempt is made to access the channel after it is closed). A string containing the name of a file One of "r", "w", "a", "r+", "w+", "a+". These have the same meaning as in fopen() A location to return an error of type %G_FILE_ERROR A #GIOChannel on success, %NULL on failure. Reads data from a #GIOChannel. Deprecated:2.2: Use g_io_channel_read_chars() instead. a #GIOChannel a buffer to read the data into (which should be at least count bytes long) the number of bytes to read from the #GIOChannel returns the number of bytes actually read %G_IO_ERROR_NONE if the operation was successful. Replacement for g_io_channel_read() with the new API. a #GIOChannel a buffer to read data into the size of the buffer. Note that the buffer may not be complelely filled even if there is data in the buffer if the remaining data is not a complete character. The number of bytes read. This may be zero even on success if count < 6 and the channel's encoding is non-%NULL. This indicates that the next UTF-8 character is too wide for the buffer. a location to return an error of type #GConvertError or #GIOChannelError. the status of the operation. Reads a line, including the terminating character(s), from a #GIOChannel into a newly-allocated string. @str_return will contain allocated memory if the return is %G_IO_STATUS_NORMAL. a #GIOChannel The line read from the #GIOChannel, including the line terminator. This data should be freed with g_free() when no longer needed. This is a nul-terminated string. If a @length of zero is returned, this will be %NULL instead. location to store length of the read data, or %NULL location to store position of line terminator, or %NULL A location to return an error of type #GConvertError or #GIOChannelError the status of the operation. Reads a line from a #GIOChannel, using a #GString as a buffer. a #GIOChannel a #GString into which the line will be written. If @buffer already contains data, the old data will be overwritten. location to store position of line terminator, or %NULL a location to store an error of type #GConvertError or #GIOChannelError the status of the operation. Reads all the remaining data from the file. a #GIOChannel Location to store a pointer to a string holding the remaining data in the #GIOChannel. This data should be freed with g_free() when no longer needed. This data is terminated by an extra nul character, but there may be other nuls in the intervening data. location to store length of the data location to return an error of type #GConvertError or #GIOChannelError %G_IO_STATUS_NORMAL on success. This function never returns %G_IO_STATUS_EOF. Reads a Unicode character from @channel. This function cannot be called on a channel with %NULL encoding. a #GIOChannel a location to return a character a location to return an error of type #GConvertError or #GIOChannelError a #GIOStatus Increments the reference count of a #GIOChannel. a #GIOChannel the @channel that was passed in (since 2.6) Sets the current position in the #GIOChannel, similar to the standard library function fseek(). Deprecated:2.2: Use g_io_channel_seek_position() instead. a #GIOChannel an offset, in bytes, which is added to the position specified by @type the position in the file, which can be %G_SEEK_CUR (the current position), %G_SEEK_SET (the start of the file), or %G_SEEK_END (the end of the file) %G_IO_ERROR_NONE if the operation was successful. Replacement for g_io_channel_seek() with the new API. a #GIOChannel The offset in bytes from the position specified by @type a #GSeekType. The type %G_SEEK_CUR is only allowed in those cases where a call to g_io_channel_set_encoding () is allowed. See the documentation for g_io_channel_set_encoding () for details. A location to return an error of type #GIOChannelError the status of the operation. Sets the buffer size. a #GIOChannel the size of the buffer, or 0 to let GLib pick a good size The buffering state can only be set if the channel's encoding is %NULL. For any other encoding, the channel must be buffered. A buffered channel can only be set unbuffered if the channel's internal buffers have been flushed. Newly created channels or channels which have returned %G_IO_STATUS_EOF not require such a flush. For write-only channels, a call to g_io_channel_flush () is sufficient. For all other channels, the buffers may be flushed by a call to g_io_channel_seek_position (). This includes the possibility of seeking with seek type %G_SEEK_CUR and an offset of zero. Note that this means that socket-based channels cannot be set unbuffered once they have had data read from them. On unbuffered channels, it is safe to mix read and write calls from the new and old APIs, if this is necessary for maintaining old code. The default state of the channel is buffered. a #GIOChannel whether to set the channel buffered or unbuffered Setting this flag to %TRUE for a channel you have already closed can cause problems. a #GIOChannel Whether to close the channel on the final unref of the GIOChannel data structure. The default value of this is %TRUE for channels created by g_io_channel_new_file (), and %FALSE for all other channels. Sets the encoding for the input/output of the channel. The internal encoding is always UTF-8. The default encoding for the external file is UTF-8. The encoding %NULL is safe to use with binary data. The encoding can only be set if one of the following conditions is true: - The channel was just created, and has not been written to or read from yet. - The channel is write-only. - The channel is a file, and the file pointer was just repositioned by a call to g_io_channel_seek_position(). (This flushes all the internal buffers.) - The current encoding is %NULL or UTF-8. - One of the (new API) read functions has just returned %G_IO_STATUS_EOF (or, in the case of g_io_channel_read_to_end(), %G_IO_STATUS_NORMAL). - One of the functions g_io_channel_read_chars() or g_io_channel_read_unichar() has returned %G_IO_STATUS_AGAIN or %G_IO_STATUS_ERROR. This may be useful in the case of %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. Returning one of these statuses from g_io_channel_read_line(), g_io_channel_read_line_string(), or g_io_channel_read_to_end() does not guarantee that the encoding can be changed. Channels which do not meet one of the above conditions cannot call g_io_channel_seek_position() with an offset of %G_SEEK_CUR, and, if they are "seekable", cannot call g_io_channel_write_chars() after calling one of the API "read" functions. a #GIOChannel the encoding type location to store an error of type #GConvertError %G_IO_STATUS_NORMAL if the encoding was successfully set Sets the (writeable) flags in @channel to (@flags & %G_IO_FLAG_SET_MASK). a #GIOChannel the flags to set on the IO channel A location to return an error of type #GIOChannelError the status of the operation. This sets the string that #GIOChannel uses to determine where in the file a line break occurs. a #GIOChannel The line termination string. Use %NULL for autodetect. Autodetection breaks on "\n", "\r\n", "\r", "\0", and the Unicode paragraph separator. Autodetection should not be used for anything other than file-based channels. The length of the termination string. If -1 is passed, the string is assumed to be nul-terminated. This option allows termination strings with embedded nuls. Close an IO channel. Any pending data to be written will be flushed if @flush is %TRUE. The channel will not be freed until the last reference is dropped using g_io_channel_unref(). a #GIOChannel if %TRUE, flush pending location to store a #GIOChannelError the status of the operation. Returns the file descriptor of the #GIOChannel. On Windows this function returns the file descriptor or socket of the #GIOChannel. a #GIOChannel, created with g_io_channel_unix_new(). the file descriptor of the #GIOChannel. Creates a new #GIOChannel given a file descriptor. On UNIX systems this works for plain files, pipes, and sockets. The returned #GIOChannel has a reference count of 1. The default encoding for #GIOChannel is UTF-8. If your application is reading output from a command using via pipe, you may need to set the encoding to the encoding of the current locale (see g_get_charset()) with the g_io_channel_set_encoding() function. If you want to read raw binary data without interpretation, then call the g_io_channel_set_encoding() function with %NULL for the encoding argument. This function is available in GLib on Windows, too, but you should avoid using it on Windows. The domain of file descriptors and sockets overlap. There is no way for GLib to know which one you mean in case the argument you pass to this function happens to be both a valid file descriptor and socket. If that happens a warning is issued, and GLib assumes that it is the file descriptor you mean. a file descriptor. a new #GIOChannel. Decrements the reference count of a #GIOChannel. a #GIOChannel Creates a new #GIOChannel given a file descriptor on Windows. This works for file descriptors from the C runtime. This function works for file descriptors as returned by the open(), creat(), pipe() and fileno() calls in the Microsoft C runtime. In order to meaningfully use this function your code should use the same C runtime as GLib uses, which is msvcrt.dll. Note that in current Microsoft compilers it is near impossible to convince it to build code that would use msvcrt.dll. The last Microsoft compiler version that supported using msvcrt.dll as the C runtime was version 6. The GNU compiler and toolchain for Windows, also known as Mingw, fully supports msvcrt.dll. If you have created a #GIOChannel for a file descriptor and started watching (polling) it, you shouldn't call read() on the file descriptor. This is because adding polling for a file descriptor is implemented in GLib on Windows by starting a thread that sits blocked in a read() from the file descriptor most of the time. All reads from the file descriptor should be done by this internal GLib thread. Your code should call only g_io_channel_read(). This function is available only in GLib on Windows. a C library file descriptor. a new #GIOChannel. Creates a new #GIOChannel given a window handle on Windows. This function creates a #GIOChannel that can be used to poll for Windows messages for the window in question. a window handle. a new #GIOChannel. Creates a new #GIOChannel given a socket on Windows. This function works for sockets created by Winsock. It's available only in GLib on Windows. Polling a #GSource created to watch a channel for a socket puts the socket in non-blocking mode. This is a side-effect of the implementation and unavoidable. a Winsock socket a new #GIOChannel Writes data to a #GIOChannel. Deprecated:2.2: Use g_io_channel_write_chars() instead. a #GIOChannel the buffer containing the data to write the number of bytes to write the number of bytes actually written %G_IO_ERROR_NONE if the operation was successful. Replacement for g_io_channel_write() with the new API. On seekable channels with encodings other than %NULL or UTF-8, generic mixing of reading and writing is not allowed. A call to g_io_channel_write_chars () may only be made on a channel from which data has been read in the cases described in the documentation for g_io_channel_set_encoding (). a #GIOChannel a buffer to write data from the size of the buffer. If -1, the buffer is taken to be a nul-terminated string. The number of bytes written. This can be nonzero even if the return value is not %G_IO_STATUS_NORMAL. If the return value is %G_IO_STATUS_NORMAL and the channel is blocking, this will always be equal to @count if @count >= 0. a location to return an error of type #GConvertError or #GIOChannelError the status of the operation. Writes a Unicode character to @channel. This function cannot be called on a channel with %NULL encoding. a #GIOChannel a character location to return an error of type #GConvertError or #GIOChannelError a #GIOStatus Creates a #GSource that's dispatched when @condition is met for the given @channel. For example, if condition is #G_IO_IN, the source will be dispatched when there's data available for reading. g_io_add_watch() is a simpler interface to this same functionality, for the case where you want to add the source to the default main loop context at the default priority. On Windows, polling a #GSource created to watch a channel for a socket puts the socket in non-blocking mode. This is a side-effect of the implementation and unavoidable. a #GIOChannel to watch conditions to watch for a new #GSource Clears all keys and groups from @key_file, and decreases the reference count by 1. If the reference count reaches zero, frees the key file and all its allocated memory. Since: 2.6 a #GKeyFile Returns the value associated with @key under @group_name as a boolean. If @key cannot be found then %FALSE is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated with @key cannot be interpreted as a boolean then %FALSE is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. Since: 2.6 a #GKeyFile a group name a key return location for a #GError the value associated with the key as a boolean, or %FALSE if the key was not found or could not be parsed. Returns the values associated with @key under @group_name as booleans. If @key cannot be found then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated with @key cannot be interpreted as booleans then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. Since: 2.6 a #GKeyFile a group name a key the number of booleans returned return location for a #GError the values associated with the key as a list of booleans, or %NULL if the key was not found or could not be parsed. The returned list of booleans should be freed with g_free() when no longer needed. Retrieves a comment above @key from @group_name. If @key is %NULL then @comment will be read from above @group_name. If both @key and @group_name are %NULL, then @comment will be read from above the first group in the file. Note that the returned string includes the '#' comment markers. Since: 2.6 a #GKeyFile a group name, or %NULL a key return location for a #GError a comment that should be freed with g_free() Returns the value associated with @key under @group_name as a double. If @group_name is %NULL, the start_group is used. If @key cannot be found then 0.0 is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated with @key cannot be interpreted as a double then 0.0 is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. Since: 2.12 a #GKeyFile a group name a key return location for a #GError the value associated with the key as a double, or 0.0 if the key was not found or could not be parsed. Returns the values associated with @key under @group_name as doubles. If @key cannot be found then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated with @key cannot be interpreted as doubles then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. Since: 2.12 a #GKeyFile a group name a key the number of doubles returned return location for a #GError the values associated with the key as a list of doubles, or %NULL if the key was not found or could not be parsed. The returned list of doubles should be freed with g_free() when no longer needed. Returns all groups in the key file loaded with @key_file. The array of returned groups will be %NULL-terminated, so @length may optionally be %NULL. Since: 2.6 a #GKeyFile return location for the number of returned groups, or %NULL a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it. Returns the value associated with @key under @group_name as a signed 64-bit integer. This is similar to g_key_file_get_integer() but can return 64-bit results without truncation. Since: 2.26 a non-%NULL #GKeyFile a non-%NULL group name a non-%NULL key return location for a #GError the value associated with the key as a signed 64-bit integer, or 0 if the key was not found or could not be parsed. Returns the value associated with @key under @group_name as an integer. If @key cannot be found then 0 is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated with @key cannot be interpreted as an integer then 0 is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. Since: 2.6 a #GKeyFile a group name a key return location for a #GError the value associated with the key as an integer, or 0 if the key was not found or could not be parsed. Returns the values associated with @key under @group_name as integers. If @key cannot be found then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated with @key cannot be interpreted as integers then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE. Since: 2.6 a #GKeyFile a group name a key the number of integers returned return location for a #GError the values associated with the key as a list of integers, or %NULL if the key was not found or could not be parsed. The returned list of integers should be freed with g_free() when no longer needed. Returns all keys for the group name @group_name. The array of returned keys will be %NULL-terminated, so @length may optionally be %NULL. In the event that the @group_name cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND. Since: 2.6 a #GKeyFile a group name return location for the number of keys returned, or %NULL return location for a #GError, or %NULL a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it. Returns the value associated with @key under @group_name translated in the given @locale if available. If @locale is %NULL then the current locale is assumed. If @key cannot be found then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the value associated with @key cannot be interpreted or no suitable translation can be found then the untranslated value is returned. Since: 2.6 a #GKeyFile a group name a key a locale identifier or %NULL return location for a #GError, or %NULL a newly allocated string or %NULL if the specified key cannot be found. Returns the values associated with @key under @group_name translated in the given @locale if available. If @locale is %NULL then the current locale is assumed. If @key cannot be found then %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the values associated with @key cannot be interpreted or no suitable translations can be found then the untranslated values are returned. The returned array is %NULL-terminated, so @length may optionally be %NULL. Since: 2.6 a #GKeyFile a group name a key a locale identifier or %NULL return location for the number of returned strings or %NULL return location for a #GError or %NULL a newly allocated %NULL-terminated string array or %NULL if the key isn't found. The string array should be freed with g_strfreev(). Returns the name of the start group of the file. Since: 2.6 a #GKeyFile The start group of the key file. Returns the string value associated with @key under @group_name. Unlike g_key_file_get_value(), this function handles escape sequences like \s. In the event the key cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the event that the @group_name cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND. Since: 2.6 a #GKeyFile a group name a key return location for a #GError, or %NULL a newly allocated string or %NULL if the specified key cannot be found. Returns the values associated with @key under @group_name. In the event the key cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the event that the @group_name cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND. Since: 2.6 a #GKeyFile a group name a key return location for the number of returned strings, or %NULL return location for a #GError, or %NULL a %NULL-terminated string array or %NULL if the specified key cannot be found. The array should be freed with g_strfreev(). Returns the value associated with @key under @group_name as an unsigned 64-bit integer. This is similar to g_key_file_get_integer() but can return large positive results without truncation. Since: 2.26 a non-%NULL #GKeyFile a non-%NULL group name a non-%NULL key return location for a #GError the value associated with the key as an unsigned 64-bit integer, or 0 if the key was not found or could not be parsed. Returns the raw value associated with @key under @group_name. Use g_key_file_get_string() to retrieve an unescaped UTF-8 string. In the event the key cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. In the event that the @group_name cannot be found, %NULL is returned and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND. Since: 2.6 a #GKeyFile a group name a key return location for a #GError, or %NULL a newly allocated string or %NULL if the specified key cannot be found. Looks whether the key file has the group @group_name. Since: 2.6 a #GKeyFile a group name %TRUE if @group_name is a part of @key_file, %FALSE otherwise. Looks whether the key file has the key @key in the group @group_name. Note that this function does not follow the rules for #GError strictly; the return value both carries meaning and signals an error. To use this function, you must pass a #GError pointer in @error, and check whether it is not %NULL to see if an error occurred. Language bindings should use g_key_file_get_value() to test whether or not a key exists. Since: 2.6 a #GKeyFile a group name a key name return location for a #GError %TRUE if @key is a part of @group_name, %FALSE otherwise Loads a key file from memory into an empty #GKeyFile structure. If the object cannot be created then %error is set to a #GKeyFileError. Since: 2.6 an empty #GKeyFile struct key file loaded in memory the length of @data in bytes (or (gsize)-1 if data is nul-terminated) flags from #GKeyFileFlags return location for a #GError, or %NULL %TRUE if a key file could be loaded, %FALSE otherwise This function looks for a key file named @file in the paths returned from g_get_user_data_dir() and g_get_system_data_dirs(), loads the file into @key_file and returns the file's full path in @full_path. If the file could not be loaded then an %error is set to either a #GFileError or #GKeyFileError. Since: 2.6 an empty #GKeyFile struct a relative path to a filename to open and parse return location for a string containing the full path of the file, or %NULL flags from #GKeyFileFlags return location for a #GError, or %NULL %TRUE if a key file could be loaded, %FALSE othewise This function looks for a key file named @file in the paths specified in @search_dirs, loads the file into @key_file and returns the file's full path in @full_path. If the file could not be loaded then an %error is set to either a #GFileError or #GKeyFileError. Since: 2.14 an empty #GKeyFile struct a relative path to a filename to open and parse %NULL-terminated array of directories to search return location for a string containing the full path of the file, or %NULL flags from #GKeyFileFlags return location for a #GError, or %NULL %TRUE if a key file could be loaded, %FALSE otherwise Loads a key file into an empty #GKeyFile structure. If the file could not be loaded then @error is set to either a #GFileError or #GKeyFileError. Since: 2.6 an empty #GKeyFile struct the path of a filename to load, in the GLib filename encoding flags from #GKeyFileFlags return location for a #GError, or %NULL %TRUE if a key file could be loaded, %FALSE otherwise Creates a new empty #GKeyFile object. Use g_key_file_load_from_file(), g_key_file_load_from_data(), g_key_file_load_from_dirs() or g_key_file_load_from_data_dirs() to read an existing key file. Since: 2.6 an empty #GKeyFile. Increases the reference count of @key_file. Since: 2.32 a #GKeyFile the same @key_file. Removes a comment above @key from @group_name. If @key is %NULL then @comment will be removed above @group_name. If both @key and @group_name are %NULL, then @comment will be removed above the first group in the file. Since: 2.6 a #GKeyFile a group name, or %NULL a key return location for a #GError %TRUE if the comment was removed, %FALSE otherwise Removes the specified group, @group_name, from the key file. Since: 2.6 a #GKeyFile a group name return location for a #GError or %NULL %TRUE if the group was removed, %FALSE otherwise Removes @key in @group_name from the key file. Since: 2.6 a #GKeyFile a group name a key name to remove return location for a #GError or %NULL %TRUE if the key was removed, %FALSE otherwise Writes the contents of @key_file to @filename using g_file_set_contents(). This function can fail for any of the reasons that g_file_set_contents() may fail. Since: 2.40 a #GKeyFile the name of the file to write to a pointer to a %NULL #GError, or %NULL %TRUE if successful, else %FALSE with @error set Associates a new boolean value with @key under @group_name. If @key cannot be found then it is created. Since: 2.6 a #GKeyFile a group name a key %TRUE or %FALSE Associates a list of boolean values with @key under @group_name. If @key cannot be found then it is created. If @group_name is %NULL, the start_group is used. Since: 2.6 a #GKeyFile a group name a key an array of boolean values length of @list Places a comment above @key from @group_name. If @key is %NULL then @comment will be written above @group_name. If both @key and @group_name are %NULL, then @comment will be written above the first group in the file. Note that this function prepends a '#' comment marker to each line of @comment. Since: 2.6 a #GKeyFile a group name, or %NULL a key a comment return location for a #GError %TRUE if the comment was written, %FALSE otherwise Associates a new double value with @key under @group_name. If @key cannot be found then it is created. Since: 2.12 a #GKeyFile a group name a key an double value Associates a list of double values with @key under @group_name. If @key cannot be found then it is created. Since: 2.12 a #GKeyFile a group name a key an array of double values number of double values in @list Associates a new integer value with @key under @group_name. If @key cannot be found then it is created. Since: 2.26 a #GKeyFile a group name a key an integer value Associates a new integer value with @key under @group_name. If @key cannot be found then it is created. Since: 2.6 a #GKeyFile a group name a key an integer value Associates a list of integer values with @key under @group_name. If @key cannot be found then it is created. Since: 2.6 a #GKeyFile a group name a key an array of integer values number of integer values in @list Sets the character which is used to separate values in lists. Typically ';' or ',' are used as separators. The default list separator is ';'. Since: 2.6 a #GKeyFile the separator Associates a string value for @key and @locale under @group_name. If the translation for @key cannot be found then it is created. Since: 2.6 a #GKeyFile a group name a key a locale identifier a string Associates a list of string values for @key and @locale under @group_name. If the translation for @key cannot be found then it is created. Since: 2.6 a #GKeyFile a group name a key a locale identifier a %NULL-terminated array of locale string values the length of @list Associates a new string value with @key under @group_name. If @key cannot be found then it is created. If @group_name cannot be found then it is created. Unlike g_key_file_set_value(), this function handles characters that need escaping, such as newlines. Since: 2.6 a #GKeyFile a group name a key a string Associates a list of string values for @key under @group_name. If @key cannot be found then it is created. If @group_name cannot be found then it is created. Since: 2.6 a #GKeyFile a group name a key an array of string values number of string values in @list Associates a new integer value with @key under @group_name. If @key cannot be found then it is created. Since: 2.26 a #GKeyFile a group name a key an integer value Associates a new value with @key under @group_name. If @key cannot be found then it is created. If @group_name cannot be found then it is created. To set an UTF-8 string which may contain characters that need escaping (such as newlines or spaces), use g_key_file_set_string(). Since: 2.6 a #GKeyFile a group name a key a string This function outputs @key_file as a string. Note that this function never reports an error, so it is safe to pass %NULL as @error. Since: 2.6 a #GKeyFile return location for the length of the returned string, or %NULL return location for a #GError, or %NULL a newly allocated string holding the contents of the #GKeyFile Decreases the reference count of @key_file by 1. If the reference count reaches zero, frees the key file and all its allocated memory. Since: 2.32 a #GKeyFile Allocates space for one #GList element. It is called by g_list_append(), g_list_prepend(), g_list_insert() and g_list_insert_sorted() and so is rarely used on its own. a pointer to the newly-allocated #GList element Adds a new element on to the end of the list. Note that the return value is the new start of the list, if @list was empty; make sure you store the new value. g_list_append() has to traverse the entire list to find the end, which is inefficient when adding multiple elements. A common idiom to avoid the inefficiency is to use g_list_prepend() and reverse the list with g_list_reverse() when all elements have been added. |[<!-- language="C" --> // Notice that these are initialized to the empty list. GList *string_list = NULL, *number_list = NULL; // This is a list of strings. string_list = g_list_append (string_list, "first"); string_list = g_list_append (string_list, "second"); // This is a list of integers. number_list = g_list_append (number_list, GINT_TO_POINTER (27)); number_list = g_list_append (number_list, GINT_TO_POINTER (14)); ]| a pointer to a #GList the data for the new element either @list or the new start of the #GList if @list was %NULL Adds the second #GList onto the end of the first #GList. Note that the elements of the second #GList are not copied. They are used directly. This function is for example used to move an element in the list. The following example moves an element to the top of the list: |[<!-- language="C" --> list = g_list_remove_link (list, llink); list = g_list_concat (llink, list); ]| a #GList, this must point to the top of the list the #GList to add to the end of the first #GList, this must point to the top of the list the start of the new #GList, which equals @list1 if not %NULL Copies a #GList. Note that this is a "shallow" copy. If the list elements consist of pointers to data, the pointers are copied but the actual data is not. See g_list_copy_deep() if you need to copy the data as well. a #GList, this must point to the top of the list the start of the new list that holds the same data as @list Makes a full (deep) copy of a #GList. In contrast with g_list_copy(), this function uses @func to make a copy of each list element, in addition to copying the list container itself. @func, as a #GCopyFunc, takes two arguments, the data to be copied and a @user_data pointer. It's safe to pass %NULL as user_data, if the copy function takes only one argument. For instance, if @list holds a list of GObjects, you can do: |[<!-- language="C" --> another_list = g_list_copy_deep (list, (GCopyFunc) g_object_ref, NULL); ]| And, to entirely free the new list, you could do: |[<!-- language="C" --> g_list_free_full (another_list, g_object_unref); ]| Since: 2.34 a #GList, this must point to the top of the list a copy function used to copy every element in the list user data passed to the copy function @func, or %NULL the start of the new list that holds a full copy of @list, use g_list_free_full() to free it Removes the node link_ from the list and frees it. Compare this to g_list_remove_link() which removes the node without freeing it. a #GList, this must point to the top of the list node to delete from @list the (possibly changed) start of the #GList Finds the element in a #GList which contains the given data. a #GList, this must point to the top of the list the element data to find the found #GList element, or %NULL if it is not found Finds an element in a #GList, using a supplied function to find the desired element. It iterates over the list, calling the given function which should return 0 when the desired element is found. The function takes two #gconstpointer arguments, the #GList element's data as the first argument and the given user data. a #GList, this must point to the top of the list user data passed to the function the function to call for each element. It should return 0 when the desired element is found the found #GList element, or %NULL if it is not found Gets the first element in a #GList. any #GList element the first element in the #GList, or %NULL if the #GList has no elements Calls a function for each element of a #GList. a #GList, this must point to the top of the list the function to call with each element's data user data to pass to the function Frees all of the memory used by a #GList. The freed elements are returned to the slice allocator. If list elements contain dynamically-allocated memory, you should either use g_list_free_full() or free them manually first. a #GList Another name for g_list_free_1(). Frees one #GList element, but does not update links from the next and previous elements in the list, so you should not call this function on an element that is currently part of a list. It is usually used after g_list_remove_link(). a #GList element Convenience method, which frees all the memory used by a #GList, and calls @free_func on every element's data. Since: 2.28 a pointer to a #GList the function to be called to free each element's data Gets the position of the element containing the given data (starting from 0). a #GList, this must point to the top of the list the data to find the index of the element containing the data, or -1 if the data is not found Inserts a new element into the list at the given position. a pointer to a #GList, this must point to the top of the list the data for the new element the position to insert the element. If this is negative, or is larger than the number of elements in the list, the new element is added on to the end of the list. the (possibly changed) start of the #GList Inserts a new element into the list before the given position. a pointer to a #GList, this must point to the top of the list the list element before which the new element is inserted or %NULL to insert at the end of the list the data for the new element the (possibly changed) start of the #GList Inserts a new element into the list, using the given comparison function to determine its position. If you are adding many new elements to a list, and the number of new elements is much larger than the length of the list, use g_list_prepend() to add the new items and sort the list afterwards with g_list_sort(). a pointer to a #GList, this must point to the top of the already sorted list the data for the new element the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order. the (possibly changed) start of the #GList Inserts a new element into the list, using the given comparison function to determine its position. If you are adding many new elements to a list, and the number of new elements is much larger than the length of the list, use g_list_prepend() to add the new items and sort the list afterwards with g_list_sort(). Since: 2.10 a pointer to a #GList, this must point to the top of the already sorted list the data for the new element the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order. user data to pass to comparison function the (possibly changed) start of the #GList Gets the last element in a #GList. any #GList element the last element in the #GList, or %NULL if the #GList has no elements Gets the number of elements in a #GList. This function iterates over the whole list to count its elements. Use a #GQueue instead of a GList if you regularly need the number of items. To check whether the list is non-empty, it is faster to check @list against %NULL. a #GList, this must point to the top of the list the number of elements in the #GList A convenience macro to get the next element in a #GList. Note that it is considered perfectly acceptable to access @list->next directly. an element in a #GList the next element, or %NULL if there are no more elements Gets the element at the given position in a #GList. This iterates over the list until it reaches the @n-th position. If you intend to iterate over every element, it is better to use a for-loop as described in the #GList introduction. a #GList, this must point to the top of the list the position of the element, counting from 0 the element, or %NULL if the position is off the end of the #GList Gets the data of the element at the given position. This iterates over the list until it reaches the @n-th position. If you intend to iterate over every element, it is better to use a for-loop as described in the #GList introduction. a #GList, this must point to the top of the list the position of the element the element's data, or %NULL if the position is off the end of the #GList Gets the element @n places before @list. a #GList the position of the element, counting from 0 the element, or %NULL if the position is off the end of the #GList Gets the position of the given element in the #GList (starting from 0). a #GList, this must point to the top of the list an element in the #GList the position of the element in the #GList, or -1 if the element is not found Prepends a new element on to the start of the list. Note that the return value is the new start of the list, which will have changed, so make sure you store the new value. |[<!-- language="C" --> // Notice that it is initialized to the empty list. GList *list = NULL; list = g_list_prepend (list, "last"); list = g_list_prepend (list, "first"); ]| Do not use this function to prepend a new element to a different element than the start of the list. Use g_list_insert_before() instead. a pointer to a #GList, this must point to the top of the list the data for the new element a pointer to the newly prepended element, which is the new start of the #GList A convenience macro to get the previous element in a #GList. Note that it is considered perfectly acceptable to access @list->previous directly. an element in a #GList the previous element, or %NULL if there are no previous elements Removes an element from a #GList. If two elements contain the same data, only the first is removed. If none of the elements contain the data, the #GList is unchanged. a #GList, this must point to the top of the list the data of the element to remove the (possibly changed) start of the #GList Removes all list nodes with data equal to @data. Returns the new head of the list. Contrast with g_list_remove() which removes only the first node matching the given data. a #GList, this must point to the top of the list data to remove the (possibly changed) start of the #GList Removes an element from a #GList, without freeing the element. The removed element's prev and next links are set to %NULL, so that it becomes a self-contained list with one element. This function is for example used to move an element in the list (see the example for g_list_concat()) or to remove an element in the list before freeing its data: |[<!-- language="C" --> list = g_list_remove_link (list, llink); free_some_data_that_may_access_the_list_again (llink->data); g_list_free (llink); ]| a #GList, this must point to the top of the list an element in the #GList the (possibly changed) start of the #GList Reverses a #GList. It simply switches the next and prev pointers of each element. a #GList, this must point to the top of the list the start of the reversed #GList Sorts a #GList using the given comparison function. The algorithm used is a stable sort. a #GList, this must point to the top of the list the comparison function used to sort the #GList. This function is passed the data from 2 elements of the #GList and should return 0 if they are equal, a negative value if the first element comes before the second, or a positive value if the first element comes after the second. the (possibly changed) start of the #GList Like g_list_sort(), but the comparison function accepts a user data argument. a #GList, this must point to the top of the list comparison function user data to pass to comparison function the (possibly changed) start of the #GList Gets the names of all variables set in the environment. Programs that want to be portable to Windows should typically use this function and g_getenv() instead of using the environ array from the C library directly. On Windows, the strings in the environ array are in system codepage encoding, while in most of the typical use cases for environment variables in GLib-using programs you want the UTF-8 encoding that this function and g_getenv() provide. Since: 2.8 a %NULL-terminated list of strings which must be freed with g_strfreev(). Converts a string from UTF-8 to the encoding used for strings by the C runtime (usually the same as that used by the operating system) in the [current locale][setlocale]. On Windows this means the system codepage. a UTF-8 encoded string the length of the string, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError may occur. A newly-allocated buffer containing the converted string, or %NULL on an error, and error will be set. Converts a string which is in the encoding used for strings by the C runtime (usually the same as that used by the operating system) in the [current locale][setlocale] into a UTF-8 string. a string in the encoding of the current locale. On Windows this means the system codepage. the length of the string, or -1 if the string is nul-terminated (Note that some encodings may allow nul bytes to occur inside strings. In that case, using -1 for the @len parameter is unsafe) location to store the number of bytes in the input string that were successfully converted, or %NULL. Even if the conversion was successful, this may be less than @len if there were partial characters at the end of the input. If the error #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value stored will the byte offset after the last valid input sequence. the number of bytes stored in the output buffer (not including the terminating nul). location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError may occur. A newly-allocated buffer containing the converted string, or %NULL on an error, and error will be set. Logs an error or debugging message. If the log level has been set as fatal, the abort() function is called to terminate the program. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. the log domain, usually #G_LOG_DOMAIN the log level, either from #GLogLevelFlags or a user-defined level the message format. See the printf() documentation the parameters to insert into the format string The default log handler set up by GLib; g_log_set_default_handler() allows to install an alternate default log handler. This is used if no log handler has been set for the particular log domain and log level combination. It outputs the message to stderr or stdout and if the log level is fatal it calls abort(). It automatically prints a new-line character after the message, so one does not need to be manually included in @message. The behavior of this log handler can be influenced by a number of environment variables: - `G_MESSAGES_PREFIXED`: A :-separated list of log levels for which messages should be prefixed by the program name and PID of the aplication. - `G_MESSAGES_DEBUG`: A space-separated list of log domains for which debug and informational messages are printed. By default these messages are not printed. stderr is used for levels %G_LOG_LEVEL_ERROR, %G_LOG_LEVEL_CRITICAL, %G_LOG_LEVEL_WARNING and %G_LOG_LEVEL_MESSAGE. stdout is used for the rest. the log domain of the message the level of the message the message data passed from g_log() which is unused Removes the log handler. the log domain the id of the handler, which was returned in g_log_set_handler() Sets the message levels which are always fatal, in any log domain. When a message with any of these levels is logged the program terminates. You can only set the levels defined by GLib to be fatal. %G_LOG_LEVEL_ERROR is always fatal. You can also make some message levels fatal at runtime by setting the `G_DEBUG` environment variable (see [Running GLib Applications](glib-running.html)). the mask containing bits set for each level of error which is to be fatal the old fatal mask Installs a default log handler which is used if no log handler has been set for the particular log domain and log level combination. By default, GLib uses g_log_default_handler() as default log handler. Since: 2.6 the log handler function data passed to the log handler the previous default log handler Sets the log levels which are fatal in the given domain. %G_LOG_LEVEL_ERROR is always fatal. the log domain the new fatal mask the old fatal mask for the log domain Sets the log handler for a domain and a set of log levels. To handle fatal and recursive messages the @log_levels parameter must be combined with the #G_LOG_FLAG_FATAL and #G_LOG_FLAG_RECURSION bit flags. Note that since the #G_LOG_LEVEL_ERROR log level is always fatal, if you want to set a handler for this log level you must combine it with #G_LOG_FLAG_FATAL. Here is an example for adding a log handler for all warning messages in the default domain: |[<!-- language="C" --> g_log_set_handler (NULL, G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL); ]| This example adds a log handler for all critical messages from GTK+: |[<!-- language="C" --> g_log_set_handler ("Gtk", G_LOG_LEVEL_CRITICAL | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL); ]| This example adds a log handler for all messages from GLib: |[<!-- language="C" --> g_log_set_handler ("GLib", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, my_log_handler, NULL); ]| the log domain, or %NULL for the default "" application domain the log levels to apply the log handler for. To handle fatal and recursive messages as well, combine the log levels with the #G_LOG_FLAG_FATAL and #G_LOG_FLAG_RECURSION bit flags. the log handler function data passed to the log handler the id of the new handler Like g_log_sets_handler(), but takes a destroy notify for the @user_data. Since: 2.46 the log domain, or %NULL for the default "" application domain the log levels to apply the log handler for. To handle fatal and recursive messages as well, combine the log levels with the #G_LOG_FLAG_FATAL and #G_LOG_FLAG_RECURSION bit flags. the log handler function data passed to the log handler destroy notify for @user_data, or %NULL the id of the new handler Logs an error or debugging message. If the log level has been set as fatal, the abort() function is called to terminate the program. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. the log domain the log level the message format. See the printf() documentation the parameters to insert into the format string A wrapper for the POSIX lstat() function. The lstat() function is like stat() except that in the case of symbolic links, it returns information about the symbolic link itself and not the file that it refers to. If the system does not support symbolic links g_lstat() is identical to g_stat(). See your C library manual for more details about lstat(). Since: 2.6 a pathname in the GLib file name encoding (UTF-8 on Windows) a pointer to a stat struct, which will be filled with the file information 0 if the information was successfully retrieved, -1 if an error occurred Tries to become the owner of the specified context. If some other thread is the owner of the context, returns %FALSE immediately. Ownership is properly recursive: the owner can require ownership again and will release ownership when g_main_context_release() is called as many times as g_main_context_acquire(). You must be the owner of a context before you can call g_main_context_prepare(), g_main_context_query(), g_main_context_check(), g_main_context_dispatch(). a #GMainContext %TRUE if the operation succeeded, and this thread is now the owner of @context. Adds a file descriptor to the set of file descriptors polled for this context. This will very seldom be used directly. Instead a typical event source will use g_source_add_unix_fd() instead. a #GMainContext (or %NULL for the default context) a #GPollFD structure holding information about a file descriptor to watch. the priority for this file descriptor which should be the same as the priority used for g_source_attach() to ensure that the file descriptor is polled whenever the results may be needed. Passes the results of polling back to the main loop. You must have successfully acquired the context with g_main_context_acquire() before you may call this function. a #GMainContext the maximum numerical priority of sources to check array of #GPollFD's that was passed to the last call to g_main_context_query() return value of g_main_context_query() %TRUE if some sources are ready to be dispatched. 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 g_main_context_get_thread_default(). the global default main context. Dispatches all pending sources. You must have successfully acquired the context with g_main_context_acquire() before you may call this function. a #GMainContext Finds a source with the given source functions and user data. If multiple sources exist with the same source function and user data, the first one found will be returned. a #GMainContext (if %NULL, the default context will be used). the @source_funcs passed to g_source_new(). the user data from the callback. the source, if one was found, otherwise %NULL Finds a #GSource given a pair of context and ID. It is a programmer error to attempt to lookup a non-existent source. More specifically: source IDs can be reissued after a source has been destroyed and therefore it is never valid to use this function with a source ID which may have already been removed. An example is when scheduling an idle to run in another thread with g_idle_add(): the idle may already have run and been removed by the time this function is called on its (now invalid) source ID. This source ID may have been reissued, leading to the operation being performed against the wrong source. a #GMainContext (if %NULL, the default context will be used) the source ID, as returned by g_source_get_id(). the #GSource Finds a source with the given user data for the callback. If multiple sources exist with the same user data, the first one found will be returned. a #GMainContext the user_data for the callback. the source, if one was found, otherwise %NULL Gets the poll function set by g_main_context_set_poll_func(). a #GMainContext the poll function 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 g_main_context_ref_thread_default() to get a #GMainContext to add their #GSources 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.) If you need to hold a reference on the context, use g_main_context_ref_thread_default() instead. Since: 2.22 the thread-default #GMainContext, or %NULL if the thread-default context is the global default context. Invokes a function in such a way that @context is owned during the invocation of @function. If @context is %NULL then the global default main context — as returned by g_main_context_default() — is used. If @context is owned by the current thread, @function is called directly. Otherwise, if @context is the thread-default main context of the current thread and g_main_context_acquire() succeeds, then @function is called and g_main_context_release() is called afterwards. In any other case, an idle source is created to call @function and that source is attached to @context (presumably to be run in another thread). The idle source is attached with #G_PRIORITY_DEFAULT priority. If you want a different priority, use g_main_context_invoke_full(). Note that, as with normal idle functions, @function should probably return %FALSE. If it returns %TRUE, it will be continuously run in a loop (and may prevent this call from returning). Since: 2.28 a #GMainContext, or %NULL function to call data to pass to @function Invokes a function in such a way that @context is owned during the invocation of @function. This function is the same as g_main_context_invoke() except that it lets you specify the priority incase @function ends up being scheduled as an idle and also lets you give a #GDestroyNotify for @data. @notify should not assume that it is called from any particular thread or with any particular context acquired. Since: 2.28 a #GMainContext, or %NULL the priority at which to run @function function to call data to pass to @function a function to call when @data is no longer in use, or %NULL. Determines whether this thread holds the (recursive) ownership of this #GMainContext. This is useful to know before waiting on another thread that may be blocking to get ownership of @context. Since: 2.10 a #GMainContext %TRUE if current thread is owner of @context. Runs a single iteration for the given main loop. This involves checking to see if any event sources are ready to be processed, then if no events sources are ready and @may_block is %TRUE, waiting for a source to become ready, then dispatching the highest priority events sources that are ready. Otherwise, if @may_block is %FALSE sources are not waited to become ready, only those highest priority events sources will be dispatched (if any), that are ready at this given moment without further waiting. Note that even when @may_block is %TRUE, it is still possible for g_main_context_iteration() to return %FALSE, since the wait may be interrupted for other reasons than an event source becoming ready. a #GMainContext (if %NULL, the default context will be used) whether the call may block. %TRUE if events were dispatched. Creates a new #GMainContext structure. the new #GMainContext Checks if any sources have pending events for the given context. a #GMainContext (if %NULL, the default context will be used) %TRUE if events are pending. Pops @context off the thread-default context stack (verifying that it was on the top of the stack). Since: 2.22 a #GMainContext object, or %NULL Prepares to poll sources within a main loop. The resulting information for polling is determined by calling g_main_context_query (). You must have successfully acquired the context with g_main_context_acquire() before you may call this function. a #GMainContext location to store priority of highest priority source already ready. %TRUE if some source is ready to be dispatched prior to polling. Acquires @context and sets it as the thread-default context for the current thread. This will cause certain asynchronous operations (such as most [gio][gio]-based I/O) which are started in this thread to run under @context and deliver their results to its main loop, rather than running under the global default context in the main thread. Note that calling this function changes the context returned by g_main_context_get_thread_default(), not the one returned by g_main_context_default(), so it does not affect the context used by functions like g_idle_add(). Normally you would call this function shortly after creating a new thread, passing it a #GMainContext which will be run by a #GMainLoop in that thread, to set a new default context for all async operations in that thread. (In this case, you don't need to ever call g_main_context_pop_thread_default().) In some cases however, you may want to schedule a single operation in a non-default context, or temporarily use a non-default context in the main thread. In that case, you can wrap the call to the asynchronous operation inside a g_main_context_push_thread_default() / g_main_context_pop_thread_default() pair, but it is up to you to ensure that no other asynchronous operations accidentally get started while the non-default context is active. Beware that libraries that predate this function may not correctly handle being used from a thread with a thread-default context. Eg, see g_file_supports_thread_contexts(). Since: 2.22 a #GMainContext, or %NULL for the global default context Determines information necessary to poll this main loop. You must have successfully acquired the context with g_main_context_acquire() before you may call this function. a #GMainContext maximum priority source to check location to store timeout to be used in polling location to store #GPollFD records that need to be polled. length of @fds. the number of records actually stored in @fds, or, if more than @n_fds records need to be stored, the number of records that need to be stored. Increases the reference count on a #GMainContext object by one. a #GMainContext the @context that was passed in (since 2.6) Gets the thread-default #GMainContext for this thread, as with g_main_context_get_thread_default(), but also adds a reference to it with g_main_context_ref(). In addition, unlike g_main_context_get_thread_default(), if the thread-default context is the global default context, this will return that #GMainContext (with a ref added to it) rather than returning %NULL. Since: 2.32 the thread-default #GMainContext. Unref with g_main_context_unref() when you are done with it. Releases ownership of a context previously acquired by this thread with g_main_context_acquire(). If the context was acquired multiple times, the ownership will be released only when g_main_context_release() is called as many times as it was acquired. a #GMainContext Removes file descriptor from the set of file descriptors to be polled for a particular context. a #GMainContext a #GPollFD descriptor previously added with g_main_context_add_poll() Sets the function to use to handle polling of file descriptors. It will be used instead of the poll() system call (or GLib's replacement function, which is used where poll() isn't available). This function could possibly be used to integrate the GLib event loop with an external event loop. a #GMainContext the function to call to poll all file descriptors Decreases the reference count on a #GMainContext object by one. If the result is zero, free the context and free all associated memory. a #GMainContext Tries to become the owner of the specified context, as with g_main_context_acquire(). But if another thread is the owner, atomically drop @mutex and wait on @cond until that owner releases ownership or until @cond is signaled, then try again (once) to become the owner. a #GMainContext a condition variable a mutex, currently held %TRUE if the operation succeeded, and this thread is now the owner of @context. If @context is currently blocking in g_main_context_iteration() waiting for a source to become ready, cause it to stop blocking and return. Otherwise, cause the next invocation of g_main_context_iteration() to return without blocking. This API is useful for low-level control over #GMainContext; for example, integrating it with main loop implementations such as #GMainLoop. Another related use for this function is when implementing a main loop with a termination condition, computed from multiple threads: |[<!-- language="C" --> #define NUM_TASKS 10 static volatile gint tasks_remaining = NUM_TASKS; ... while (g_atomic_int_get (&tasks_remaining) != 0) g_main_context_iteration (NULL, TRUE); ]| Then in a thread: |[<!-- language="C" --> perform_work(); if (g_atomic_int_dec_and_test (&tasks_remaining)) g_main_context_wakeup (NULL); ]| a #GMainContext Returns the currently firing source for this thread. Since: 2.12 The currently firing source or %NULL. Returns the depth of the stack of calls to g_main_context_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 g_main_context_iteration() (or g_main_loop_run(), etc.) it returns 1. When called from within a callback to a recursive call to g_main_context_iteration(), it returns 2. And so forth. This function is useful in a situation like the following: Imagine an extremely simple "garbage collected" system. |[<!-- language="C" --> static GList *free_list; gpointer allocate_memory (gsize size) { gpointer result = g_malloc (size); free_list = g_list_prepend (free_list, result); return result; } void free_allocated_memory (void) { GList *l; for (l = free_list; l; l = l->next); g_free (l->data); g_list_free (free_list); free_list = NULL; } [...] while (TRUE); { g_main_context_iteration (NULL, TRUE); free_allocated_memory(); } ]| This works from an application, however, if you want to do the same thing from a library, it gets more difficult, since you no longer control the main loop. You might think you can simply use an idle function to make the call to free_allocated_memory(), but that doesn't work, since the idle function could be called from a recursive callback. This can be fixed by using g_main_depth() |[<!-- language="C" --> gpointer allocate_memory (gsize size) { FreeListBlock *block = g_new (FreeListBlock, 1); block->mem = g_malloc (size); block->depth = g_main_depth (); free_list = g_list_prepend (free_list, block); return block->mem; } void free_allocated_memory (void) { GList *l; int depth = g_main_depth (); for (l = free_list; l; ); { GList *next = l->next; FreeListBlock *block = l->data; if (block->depth > depth) { g_free (block->mem); g_free (block); free_list = g_list_delete_link (free_list, l); } l = next; } } ]| There is a temptation to use g_main_depth() to solve problems with reentrancy. For instance, while waiting for data to be received from the network in response to a menu item, the menu item might be selected again. It might seem that one could make the menu item's callback return immediately and do nothing if g_main_depth() returns a value greater than 1. However, this should be avoided since the user then sees selecting the menu item do nothing. Furthermore, you'll find yourself adding these checks all over your code, since there are doubtless many, many things that the user could do. Instead, you can use the following techniques: 1. Use gtk_widget_set_sensitive() or modal dialogs to prevent the user from interacting with elements while the main loop is recursing. 2. Avoid main loop recursion in situations where you can't handle arbitrary callbacks. Instead, structure your code so that you simply return to the main loop and then get called again when there is more work to do. The main loop recursion level in the current thread Frees the memory allocated for the #GMainLoop. Deprecated: 2.2: Use g_main_loop_unref() instead a #GMainLoop Checks if the main loop is running. Deprecated: 2.2: Use g_main_loop_is_running() instead a #GMainLoop %TRUE if the main loop is running Runs a single iteration for the default #GMainContext. Deprecated: 2.2: Use g_main_context_iteration() instead. set to %TRUE if it should block (i.e. wait) until an event source becomes ready. It will return after an event source has been processed. If set to %FALSE it will return immediately if no event source is ready to be processed. %TRUE if more events are pending. Returns the #GMainContext of @loop. a #GMainLoop. the #GMainContext of @loop Checks to see if the main loop is currently being run via g_main_loop_run(). a #GMainLoop. %TRUE if the mainloop is currently being run. Creates a new #GMainLoop structure. a #GMainContext (if %NULL, the default context will be used). set to %TRUE to indicate that the loop is running. This is not very important since calling g_main_loop_run() will set this to %TRUE anyway. a new #GMainLoop. Stops a #GMainLoop from running. Any calls to g_main_loop_run() for the loop will return. Note that sources that have already been dispatched when g_main_loop_quit() is called will still be executed. a #GMainLoop Increases the reference count on a #GMainLoop object by one. a #GMainLoop @loop Runs a main loop until g_main_loop_quit() is called on the loop. If this is called for the thread of the loop's #GMainContext, it will process events from the loop, otherwise it will simply wait. a #GMainLoop Decreases the reference count on a #GMainLoop object by one. If the result is zero, free the loop and free all associated memory. a #GMainLoop Creates a new #GMainLoop for th default main context. Deprecated: 2.2: Use g_main_loop_new() instead set to %TRUE to indicate that the loop is running. This is not very important since calling g_main_run() will set this to %TRUE anyway. a new #GMainLoop Checks if any events are pending for the default #GMainContext (i.e. ready to be processed). %TRUE if any events are pending. Deprected: 2.2: Use g_main_context_pending() instead. Stops the #GMainLoop. If g_main_run() was called to run the #GMainLoop, it will now return. Deprecated: 2.2: Use g_main_loop_quit() instead a #GMainLoop Runs a main loop until it stops running. Deprecated: 2.2: Use g_main_loop_run() instead a #GMainLoop Sets the function to use for the handle polling of file descriptors for the default main context. Deprecated: 2.2: Use g_main_context_set_poll_func() again the function to call to poll all file descriptors Allocates @n_bytes bytes of memory. If @n_bytes is 0 it returns %NULL. the number of bytes to allocate a pointer to the allocated memory Allocates @n_bytes bytes of memory, initialized to 0's. If @n_bytes is 0 it returns %NULL. the number of bytes to allocate a pointer to the allocated memory This function is similar to g_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. Since: 2.24 the number of blocks to allocate the size of each block in bytes a pointer to the allocated memory This function is similar to g_malloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. Since: 2.24 the number of blocks to allocate the size of each block in bytes a pointer to the allocated memory This call existed before #GMappedFile had refcounting and is currently exactly the same as g_mapped_file_unref(). Since: 2.8 Deprecated:2.22: Use g_mapped_file_unref() instead. a #GMappedFile Creates a new #GBytes which references the data mapped from @file. The mapped contents of the file must not be modified after creating this bytes object, because a #GBytes should be immutable. Since: 2.34 a #GMappedFile A newly allocated #GBytes referencing data from @file Returns the contents of a #GMappedFile. Note that the contents may not be zero-terminated, even if the #GMappedFile is backed by a text file. If the file is empty then %NULL is returned. Since: 2.8 a #GMappedFile the contents of @file, or %NULL. Returns the length of the contents of a #GMappedFile. Since: 2.8 a #GMappedFile the length of the contents of @file. Maps a file into memory. On UNIX, this is using the mmap() function. If @writable is %TRUE, the mapped buffer may be modified, otherwise it is an error to modify the mapped buffer. Modifications to the buffer are not visible to other processes mapping the same file, and are not written back to the file. Note that modifications of the underlying file might affect the contents of the #GMappedFile. Therefore, mapping should only be used if the file will not be modified, or if all modifications of the file are done atomically (e.g. using g_file_set_contents()). If @filename is the name of an empty, regular file, the function will successfully return an empty #GMappedFile. In other cases of size 0 (e.g. device files such as /dev/null), @error will be set to the #GFileError value #G_FILE_ERROR_INVAL. Since: 2.8 The path of the file to load, in the GLib filename encoding whether the mapping should be writable return location for a #GError, or %NULL a newly allocated #GMappedFile which must be unref'd with g_mapped_file_unref(), or %NULL if the mapping failed. Maps a file into memory. On UNIX, this is using the mmap() function. If @writable is %TRUE, the mapped buffer may be modified, otherwise it is an error to modify the mapped buffer. Modifications to the buffer are not visible to other processes mapping the same file, and are not written back to the file. Note that modifications of the underlying file might affect the contents of the #GMappedFile. Therefore, mapping should only be used if the file will not be modified, or if all modifications of the file are done atomically (e.g. using g_file_set_contents()). Since: 2.32 The file descriptor of the file to load whether the mapping should be writable return location for a #GError, or %NULL a newly allocated #GMappedFile which must be unref'd with g_mapped_file_unref(), or %NULL if the mapping failed. Increments the reference count of @file by one. It is safe to call this function from any thread. Since: 2.22 a #GMappedFile the passed in #GMappedFile. Decrements the reference count of @file by one. If the reference count drops to 0, unmaps the buffer of @file and frees it. It is safe to call this function from any thread. Since 2.22 a #GMappedFile Collects the attributes of the element from the data passed to the #GMarkupParser start_element function, dealing with common error conditions and supporting boolean values. This utility function is not required to write a parser but can save a lot of typing. The @element_name, @attribute_names, @attribute_values and @error parameters passed to the start_element callback should be passed unmodified to this function. Following these arguments is a list of "supported" attributes to collect. It is an error to specify multiple attributes with the same name. If any attribute not in the list appears in the @attribute_names array then an unknown attribute error will result. The #GMarkupCollectType field allows specifying the type of collection to perform and if a given attribute must appear or is optional. The attribute name is simply the name of the attribute to collect. The pointer should be of the appropriate type (see the descriptions under #GMarkupCollectType) and may be %NULL in case a particular attribute is to be allowed but ignored. This function deals with issuing errors for missing attributes (of type %G_MARKUP_ERROR_MISSING_ATTRIBUTE), unknown attributes (of type %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE) and duplicate attributes (of type %G_MARKUP_ERROR_INVALID_CONTENT) as well as parse errors for boolean-valued attributes (again of type %G_MARKUP_ERROR_INVALID_CONTENT). In all of these cases %FALSE will be returned and @error will be set as appropriate. Since: 2.16 the current tag name the attribute names the attribute values a pointer to a #GError or %NULL the #GMarkupCollectType of the first attribute the name of the first attribute a pointer to the storage location of the first attribute (or %NULL), followed by more types names and pointers, ending with %G_MARKUP_COLLECT_INVALID %TRUE if successful 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. Note that this function doesn't protect whitespace and line endings from being processed according to the XML rules for normalization of line endings and attribute values. Note also that this function will produce character references in the range of &#x1; ... &#x1f; for all control sequences except for tabstop, newline and carriage return. The character references in this range are not valid XML 1.0, but they are valid XML 1.1 and will be accepted by the GMarkup parser. some valid UTF-8 text length of @text in bytes, or -1 if the text is nul-terminated a newly allocated string with the escaped text Signals to the #GMarkupParseContext that all data has been fed into the parse context with g_markup_parse_context_parse(). This function reports an error if the document isn't complete, for example if elements are still open. a #GMarkupParseContext return location for a #GError %TRUE on success, %FALSE if an error was set Frees a #GMarkupParseContext. This function can't be called from inside one of the #GMarkupParser functions or while a subparser is pushed. a #GMarkupParseContext Retrieves the name of the currently open element. If called from the start_element or end_element handlers this will give the element_name as passed to those functions. For the parent elements, see g_markup_parse_context_get_element_stack(). Since: 2.2 a #GMarkupParseContext the name of the currently open element, or %NULL Retrieves the element stack from the internal state of the parser. The returned #GSList is a list of strings where the first item is the currently open tag (as would be returned by g_markup_parse_context_get_element()) and the next item is its immediate parent. This function is intended to be used in the start_element and end_element handlers where g_markup_parse_context_get_element() would merely return the name of the element that is being processed. Since: 2.16 a #GMarkupParseContext the element stack, which must not be modified Retrieves the current line number and the number of the character on that line. Intended for use in error messages; there are no strict semantics for what constitutes the "current" line number other than "the best number we could come up with for error messages." a #GMarkupParseContext return location for a line number, or %NULL return location for a char-on-line number, or %NULL Returns the user_data associated with @context. This will either be the user_data that was provided to g_markup_parse_context_new() or to the most recent call of g_markup_parse_context_push(). Since: 2.18 a #GMarkupParseContext the provided user_data. The returned data belongs to the markup context and will be freed when g_markup_parse_context_free() is called. Creates a new parse context. A parse context is used to parse marked-up documents. You can feed any number of documents into a context, as long as no errors occur; once an error occurs, the parse context can't continue to parse text (you have to free it and create a new parse context). a #GMarkupParser one or more #GMarkupParseFlags user data to pass to #GMarkupParser functions user data destroy notifier called when the parse context is freed a new #GMarkupParseContext Feed some data to the #GMarkupParseContext. The data need not be valid UTF-8; an error will be signaled if it's invalid. The data need not be an entire document; you can feed a document into the parser incrementally, via multiple calls to this function. Typically, as you receive data from a network connection or file, you feed each received chunk of data into this function, aborting the process if an error occurs. Once an error is reported, no further data may be fed to the #GMarkupParseContext; all errors are fatal. a #GMarkupParseContext chunk of text to parse length of @text in bytes return location for a #GError %FALSE if an error occurred, %TRUE on success Completes the process of a temporary sub-parser redirection. This function exists to collect the user_data allocated by a matching call to g_markup_parse_context_push(). It must be called in the end_element handler corresponding to the start_element handler during which g_markup_parse_context_push() was called. You must not call this function from the error callback -- the @user_data is provided directly to the callback in that case. This function is not intended to be directly called by users interested in invoking subparsers. Instead, it is intended to be used by the subparsers themselves to implement a higher-level interface. Since: 2.18 a #GMarkupParseContext the user data passed to g_markup_parse_context_push() Temporarily redirects markup data to a sub-parser. This function may only be called from the start_element handler of a #GMarkupParser. It must be matched with a corresponding call to g_markup_parse_context_pop() in the matching end_element handler (except in the case that the parser aborts due to an error). All tags, text and other data between the matching tags is redirected to the subparser given by @parser. @user_data is used as the user_data for that parser. @user_data is also passed to the error callback in the event that an error occurs. This includes errors that occur in subparsers of the subparser. The end tag matching the start tag for which this call was made is handled by the previous parser (which is given its own user_data) which is why g_markup_parse_context_pop() is provided to allow "one last access" to the @user_data provided to this function. In the case of error, the @user_data provided here is passed directly to the error callback of the subparser and g_markup_parse_context_pop() should not be called. In either case, if @user_data was allocated then it ought to be freed from both of these locations. This function is not intended to be directly called by users interested in invoking subparsers. Instead, it is intended to be used by the subparsers themselves to implement a higher-level interface. As an example, see the following implementation of a simple parser that counts the number of tags encountered. |[<!-- language="C" --> typedef struct { gint tag_count; } CounterData; static void counter_start_element (GMarkupParseContext *context, const gchar *element_name, const gchar **attribute_names, const gchar **attribute_values, gpointer user_data, GError **error) { CounterData *data = user_data; data->tag_count++; } static void counter_error (GMarkupParseContext *context, GError *error, gpointer user_data) { CounterData *data = user_data; g_slice_free (CounterData, data); } static GMarkupParser counter_subparser = { counter_start_element, NULL, NULL, NULL, counter_error }; ]| In order to allow this parser to be easily used as a subparser, the following interface is provided: |[<!-- language="C" --> void start_counting (GMarkupParseContext *context) { CounterData *data = g_slice_new (CounterData); data->tag_count = 0; g_markup_parse_context_push (context, &counter_subparser, data); } gint end_counting (GMarkupParseContext *context) { CounterData *data = g_markup_parse_context_pop (context); int result; result = data->tag_count; g_slice_free (CounterData, data); return result; } ]| The subparser would then be used as follows: |[<!-- language="C" --> static void start_element (context, element_name, ...) { if (strcmp (element_name, "count-these") == 0) start_counting (context); // else, handle other tags... } static void end_element (context, element_name, ...) { if (strcmp (element_name, "count-these") == 0) g_print ("Counted %d tags\n", end_counting (context)); // else, handle other tags... } ]| Since: 2.18 a #GMarkupParseContext a #GMarkupParser user data to pass to #GMarkupParser functions Increases the reference count of @context. Since: 2.36 a #GMarkupParseContext the same @context Decreases the reference count of @context. When its reference count drops to 0, it is freed. Since: 2.36 a #GMarkupParseContext Formats arguments according to @format, escaping all string and character arguments in the fashion of g_markup_escape_text(). This is useful when you want to insert literal strings into XML-style markup output, without having to worry that the strings might themselves contain markup. |[<!-- language="C" --> const char *store = "Fortnum & Mason"; const char *item = "Tea"; char *output; output = g_markup_printf_escaped ("<purchase>" "<store>%s</store>" "<item>%s</item>" "</purchase>", store, item); ]| Since: 2.4 printf() style format string the arguments to insert in the format string newly allocated result from formatting operation. Free with g_free(). Formats the data in @args according to @format, escaping all string and character arguments in the fashion of g_markup_escape_text(). See g_markup_printf_escaped(). Since: 2.4 printf() style format string variable argument list, similar to vprintf() newly allocated result from formatting operation. Free with g_free(). Returns a new string containing the text in @string_to_expand with references and escape sequences expanded. References refer to the last match done with @string against @regex and have the same syntax used by g_regex_replace(). The @string_to_expand must be UTF-8 encoded even if #G_REGEX_RAW was passed to g_regex_new(). The backreferences are extracted from the string passed to the match function, so you cannot call this function after freeing the string. @match_info may be %NULL in which case @string_to_expand must not contain references. For instance "foo\n" does not refer to an actual pattern and '\n' merely will be replaced with \n character, while to expand "\0" (whole match) one needs the result of a match. Use g_regex_check_replacement() to find out whether @string_to_expand contains references. Since: 2.14 a #GMatchInfo or %NULL the string to expand location to store the error occurring, or %NULL to ignore errors the expanded string, or %NULL if an error occurred Retrieves the text matching the @match_num'th capturing parentheses. 0 is the full text of the match, 1 is the first paren set, 2 the second, and so on. If @match_num is a valid sub pattern but it didn't match anything (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty string is returned. If the match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved string is not that of a set of parentheses but that of a matched substring. Substrings are matched in reverse order of length, so 0 is the longest match. The string is fetched from the string passed to the match function, so you cannot call this function after freeing the string. Since: 2.14 #GMatchInfo structure number of the sub expression The matched substring, or %NULL if an error occurred. You have to free the string yourself Bundles up pointers to each of the matching substrings from a match and stores them in an array of gchar pointers. The first element in the returned array is the match number 0, i.e. the entire matched text. If a sub pattern didn't match anything (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty string is inserted. If the last match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved strings are not that matched by sets of parentheses but that of the matched substring. Substrings are matched in reverse order of length, so the first one is the longest match. The strings are fetched from the string passed to the match function, so you cannot call this function after freeing the string. Since: 2.14 a #GMatchInfo structure a %NULL-terminated array of gchar * pointers. It must be freed using g_strfreev(). If the previous match failed %NULL is returned Retrieves the text matching the capturing parentheses named @name. If @name is a valid sub pattern name but it didn't match anything (e.g. sub pattern "X", matching "b" against "(?P<X>a)?b") then an empty string is returned. The string is fetched from the string passed to the match function, so you cannot call this function after freeing the string. Since: 2.14 #GMatchInfo structure name of the subexpression The matched substring, or %NULL if an error occurred. You have to free the string yourself Retrieves the position in bytes of the capturing parentheses named @name. If @name is a valid sub pattern name but it didn't match anything (e.g. sub pattern "X", matching "b" against "(?P<X>a)?b") then @start_pos and @end_pos are set to -1 and %TRUE is returned. Since: 2.14 #GMatchInfo structure name of the subexpression pointer to location where to store the start position, or %NULL pointer to location where to store the end position, or %NULL %TRUE if the position was fetched, %FALSE otherwise. If the position cannot be fetched, @start_pos and @end_pos are left unchanged. Retrieves the position in bytes of the @match_num'th capturing parentheses. 0 is the full text of the match, 1 is the first paren set, 2 the second, and so on. If @match_num is a valid sub pattern but it didn't match anything (e.g. sub pattern 1, matching "b" against "(a)?b") then @start_pos and @end_pos are set to -1 and %TRUE is returned. If the match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved position is not that of a set of parentheses but that of a matched substring. Substrings are matched in reverse order of length, so 0 is the longest match. Since: 2.14 #GMatchInfo structure number of the sub expression pointer to location where to store the start position, or %NULL pointer to location where to store the end position, or %NULL %TRUE if the position was fetched, %FALSE otherwise. If the position cannot be fetched, @start_pos and @end_pos are left unchanged If @match_info is not %NULL, calls g_match_info_unref(); otherwise does nothing. Since: 2.14 a #GMatchInfo, or %NULL Retrieves the number of matched substrings (including substring 0, that is the whole matched text), so 1 is returned if the pattern has no substrings in it and 0 is returned if the match failed. If the last match was obtained using the DFA algorithm, that is using g_regex_match_all() or g_regex_match_all_full(), the retrieved count is not that of the number of capturing parentheses but that of the number of matched substrings. Since: 2.14 a #GMatchInfo structure Number of matched substrings, or -1 if an error occurred Returns #GRegex object used in @match_info. It belongs to Glib and must not be freed. Use g_regex_ref() if you need to keep it after you free @match_info object. Since: 2.14 a #GMatchInfo #GRegex object used in @match_info Returns the string searched with @match_info. This is the string passed to g_regex_match() or g_regex_replace() so you may not free it before calling this function. Since: 2.14 a #GMatchInfo the string searched with @match_info Usually if the string passed to g_regex_match*() matches as far as it goes, but is too short to match the entire pattern, %FALSE is returned. There are circumstances where it might be helpful to distinguish this case from other cases in which there is no match. Consider, for example, an application where a human is required to type in data for a field with specific formatting requirements. An example might be a date in the form ddmmmyy, defined by the pattern "^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$". If the application sees the user’s keystrokes one by one, and can check that what has been typed so far is potentially valid, it is able to raise an error as soon as a mistake is made. GRegex supports the concept of partial matching by means of the #G_REGEX_MATCH_PARTIAL_SOFT and #G_REGEX_MATCH_PARTIAL_HARD flags. When they are used, the return code for g_regex_match() or g_regex_match_full() is, as usual, %TRUE for a complete match, %FALSE otherwise. But, when these functions return %FALSE, you can check if the match was partial calling g_match_info_is_partial_match(). The difference between #G_REGEX_MATCH_PARTIAL_SOFT and #G_REGEX_MATCH_PARTIAL_HARD is that when a partial match is encountered with #G_REGEX_MATCH_PARTIAL_SOFT, matching continues to search for a possible complete match, while with #G_REGEX_MATCH_PARTIAL_HARD matching stops at the partial match. When both #G_REGEX_MATCH_PARTIAL_SOFT and #G_REGEX_MATCH_PARTIAL_HARD are set, the latter takes precedence. There were formerly some restrictions on the pattern for partial matching. The restrictions no longer apply. See pcrepartial(3) for more information on partial matching. Since: 2.14 a #GMatchInfo structure %TRUE if the match was partial, %FALSE otherwise Returns whether the previous match operation succeeded. Since: 2.14 a #GMatchInfo structure %TRUE if the previous match operation succeeded, %FALSE otherwise Scans for the next match using the same parameters of the previous call to g_regex_match_full() or g_regex_match() that returned @match_info. The match is done on the string passed to the match function, so you cannot free it before calling this function. Since: 2.14 a #GMatchInfo structure location to store the error occurring, or %NULL to ignore errors %TRUE is the string matched, %FALSE otherwise Increases reference count of @match_info by 1. Since: 2.30 a #GMatchInfo @match_info Decreases reference count of @match_info by 1. When reference count drops to zero, it frees all the memory associated with the match_info structure. Since: 2.30 a #GMatchInfo This variable is %TRUE if the `G_DEBUG` environment variable includes the key `gc-friendly`. 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 interchangeable 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. A different allocator can be set using g_mem_set_vtable(). if %TRUE, malloc() and g_malloc() can be mixed. Outputs a summary of memory usage. It outputs the frequency of allocations of different sizes, the total number of bytes which have been allocated, the total number of bytes which have been freed, and the difference between the previous two values, i.e. the number of bytes still in use. Note that this function will not output anything unless you have previously installed the #glib_mem_profiler_table with g_mem_set_vtable(). Sets the #GMemVTable to use for memory allocation. You can use this to provide custom memory allocation routines. The @vtable only needs to provide malloc(), realloc(), and free() functions; GLib can provide default implementations of the others. The malloc() and realloc() implementations should return %NULL on failure, GLib will handle error-checking for you. @vtable is copied, so need not persist after this function has been called. Note that this function must be called before using any other GLib functions. table of memory allocation routines. Allocates @byte_size bytes of memory, and copies @byte_size bytes into it from @mem. If @mem is %NULL it returns %NULL. the memory to copy. the number of bytes to copy. a pointer to the newly-allocated copy of the memory, or %NULL if @mem is %NULL. Copies a block of memory @len bytes long, from @src to @dest. The source and destination areas may overlap. Deprecated:2.40: Just use memmove(). the destination address to copy the bytes to. the source address to copy the bytes from. the number of bytes to copy. A convenience function/macro to log a normal message. If g_log_default_handler() is used as the log handler function, a new-line character will automatically be appended to @..., and need not be entered manually. format string, followed by parameters to insert into the format string (as with printf()) A wrapper for the POSIX mkdir() function. The mkdir() function attempts to create a directory with the given name and permissions. The mode argument is ignored on Windows. See your C library manual for more details about mkdir(). Since: 2.6 a pathname in the GLib file name encoding (UTF-8 on Windows) permissions to use for the newly created directory 0 if the directory was successfully created, -1 if an error occurred Create a directory if it doesn't already exist. Create intermediate parent directories as needed, too. Since: 2.8 a pathname in the GLib file name encoding permissions to use for newly created directories 0 if the directory already exists, or was successfully created. Returns -1 if an error occurred, with errno set. Creates a temporary directory. See the mkdtemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkdtemp() templates, i.e. contain the string "XXXXXX". g_mkdtemp() is slightly more flexible than mkdtemp() in that the sequence does not have to occur at the very end of the template and you can pass a @mode and additional @flags. The X string will be modified to form the name of a directory that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8. Since: 2.30 template directory name A pointer to @tmpl, which has been modified to hold the directory name. In case of errors, %NULL is returned and %errno will be set. Creates a temporary directory. See the mkdtemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkdtemp() templates, i.e. contain the string "XXXXXX". g_mkdtemp() is slightly more flexible than mkdtemp() in that the sequence does not have to occur at the very end of the template and you can pass a @mode. The X string will be modified to form the name of a directory that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8. Since: 2.30 template directory name permissions to create the temporary directory with A pointer to @tmpl, which has been modified to hold the directory name. In case of errors, %NULL is returned, and %errno will be set. Opens a temporary file. See the mkstemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkstemp() templates, i.e. contain the string "XXXXXX". g_mkstemp() is slightly more flexible than mkstemp() in that the sequence does not have to occur at the very end of the template. The X string will be modified to form the name of a file that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8. template filename A file handle (as from open()) to the file opened for reading and writing. The file is opened in binary mode on platforms where there is a difference. The file handle should be closed with close(). In case of errors, -1 is returned and %errno will be set. Opens a temporary file. See the mkstemp() documentation on most UNIX-like systems. The parameter is a string that should follow the rules for mkstemp() templates, i.e. contain the string "XXXXXX". g_mkstemp_full() is slightly more flexible than mkstemp() in that the sequence does not have to occur at the very end of the template and you can pass a @mode and additional @flags. The X string will be modified to form the name of a file that didn't exist. The string should be in the GLib file name encoding. Most importantly, on Windows it should be in UTF-8. Since: 2.22 template filename flags to pass to an open() call in addition to O_EXCL and O_CREAT, which are passed automatically permissions to create the temporary file with A file handle (as from open()) to the file opened for reading and writing. The file handle should be closed with close(). In case of errors, -1 is returned and %errno will be set. A portable way to build the filename of a module. The platform-specific prefix and suffix are added to the filename, if needed, and the result is added to the directory, using the correct separator character. The directory should specify the directory where the module can be found. It can be %NULL or an empty string to indicate that the module is in a standard platform-specific directory, though this is not recommended since the wrong module may be found. For example, calling g_module_build_path() on a Linux system with a @directory of `/lib` and a @module_name of "mylibrary" will return `/lib/libmylibrary.so`. On a Windows system, using `\Windows` as the directory it will return `\Windows\mylibrary.dll`. the directory where the module is. This can be %NULL or the empty string to indicate that the standard platform-specific directories will be used, though that is not recommended the name of the module the complete path of the module, including the standard library prefix and suffix. This should be freed when no longer needed Closes a module. a #GModule to close %TRUE on success Gets a string describing the last module error. a string describing the last module error Ensures that a module will never be unloaded. Any future g_module_close() calls on the module will be ignored. a #GModule to make permanently resident Returns the filename that the module was opened with. If @module refers to the application itself, "main" is returned. a #GModule the filename of the module Opens a module. If the module has already been opened, its reference count is incremented. First of all g_module_open() tries to open @file_name as a module. If that fails and @file_name has the ".la"-suffix (and is a libtool archive) it tries to open the corresponding module. If that fails and it doesn't have the proper module suffix for the platform (#G_MODULE_SUFFIX), this suffix will be appended and the corresponding module will be opended. If that fails and @file_name doesn't have the ".la"-suffix, this suffix is appended and g_module_open() tries to open the corresponding module. If eventually that fails as well, %NULL is returned. the name of the file containing the module, or %NULL to obtain a #GModule representing the main program itself the flags used for opening the module. This can be the logical OR of any of the #GModuleFlags a #GModule on success, or %NULL on failure Checks if modules are supported on the current platform. %TRUE if modules are supported Gets a symbol pointer from a module, such as one exported by #G_MODULE_EXPORT. Note that a valid symbol can be %NULL. a #GModule the name of the symbol to find returns the pointer to the symbol value %TRUE on success Frees the resources allocated to a mutex with g_mutex_init(). This function should not be used with a #GMutex that has been statically allocated. Calling g_mutex_clear() on a locked mutex leads to undefined behaviour. Sine: 2.32 an initialized #GMutex Destroys a @mutex that has been created with g_mutex_new(). Calling g_mutex_free() on a locked mutex may result in undefined behaviour. Deprecated: 2.32: GMutex can now be statically allocated, or embedded in structures and initialised with g_mutex_init(). a #GMutex Initializes a #GMutex so that it can be used. This function is useful to initialize a mutex that has been allocated on the stack, or as part of a larger structure. It is not necessary to initialize a mutex that has been statically allocated. |[<!-- language="C" --> typedef struct { GMutex m; ... } Blob; Blob *b; b = g_new (Blob, 1); g_mutex_init (&b->m); ]| To undo the effect of g_mutex_init() when a mutex is no longer needed, use g_mutex_clear(). Calling g_mutex_init() on an already initialized #GMutex leads to undefined behaviour. Since: 2.32 an uninitialized #GMutex Locks @mutex. If @mutex is already locked by another thread, the current thread will block until @mutex is unlocked by the other thread. #GMutex is neither guaranteed to be recursive nor to be non-recursive. As such, calling g_mutex_lock() on a #GMutex that has already been locked by the same thread results in undefined behaviour (including but not limited to deadlocks). a #GMutex Unlock @locker's mutex. See g_mutex_locker_new() for details. Since: 2.44 a GMutexLocker Lock @mutex and return a new #GMutexLocker. Unlock with g_mutex_locker_free(). Using g_mutex_unlock() on @mutex while a #GMutexLocker exists can lead to undefined behaviour. This is intended to be used with g_autoptr(). Note that g_autoptr() is only available when using GCC or clang, so the following example will only work with those compilers: |[ typedef struct { ... GMutex mutex; ... } MyObject; static void my_object_do_stuff (MyObject *self) { g_autoptr(GMutexLocker) locker = g_mutex_locker_new (&self->mutex); // Code with mutex locked here if (cond) // No need to unlock return; // Optionally early unlock g_clear_pointer (&locker, g_mutex_locker_free); // Code with mutex unlocked here } ]| Since: 2.44 a mutex to lock a #GMutexLocker Allocates and initializes a new #GMutex. Deprecated: 2.32: GMutex can now be statically allocated, or embedded in structures and initialised with g_mutex_init(). a newly allocated #GMutex. Use g_mutex_free() to free Tries to lock @mutex. If @mutex is already locked by another thread, it immediately returns %FALSE. Otherwise it locks @mutex and returns %TRUE. #GMutex is neither guaranteed to be recursive nor to be non-recursive. As such, calling g_mutex_lock() on a #GMutex that has already been locked by the same thread results in undefined behaviour (including but not limited to deadlocks or arbitrary return values). a #GMutex %TRUE if @mutex could be locked Unlocks @mutex. If another thread is blocked in a g_mutex_lock() call for @mutex, it will become unblocked and can lock @mutex itself. Calling g_mutex_unlock() on a mutex that is not locked by the current thread leads to undefined behaviour. a #GMutex Allocates @n_structs elements of type @struct_type. The returned pointer is cast to a pointer to the given type. If @n_structs is 0 it returns %NULL. Care is taken to avoid overflow when calculating the size of the allocated block. Since the returned pointer is already casted to the right type, it is normally unnecessary to cast it explicitly, and doing so might hide memory allocation errors. the type of the elements to allocate the number of elements to allocate a pointer to the allocated memory, cast to a pointer to @struct_type Allocates @n_structs elements of type @struct_type, initialized to 0's. The returned pointer is cast to a pointer to the given type. If @n_structs is 0 it returns %NULL. Care is taken to avoid overflow when calculating the size of the allocated block. Since the returned pointer is already casted to the right type, it is normally unnecessary to cast it explicitly, and doing so might hide memory allocation errors. the type of the elements to allocate. the number of elements to allocate. a pointer to the allocated memory, cast to a pointer to @struct_type. Wraps g_alloca() in a more typesafe manner. Type of memory chunks to be allocated Number of chunks to be allocated Pointer to stack space for @n_structs chunks of type @struct_type Inserts a #GNode as the last child of the given parent. the #GNode to place the new #GNode under the #GNode to insert the inserted #GNode Inserts a new #GNode as the last child of the given parent. the #GNode to place the new #GNode under the data for the new #GNode the new #GNode Gets the position of the first child of a #GNode which contains the given data. a #GNode the data to find the index of the child of @node which contains @data, or -1 if the data is not found Gets the position of a #GNode with respect to its siblings. @child must be a child of @node. The first child is numbered 0, the second 1, and so on. a #GNode a child of @node the position of @child with respect to its siblings Calls a function for each of the children of a #GNode. Note that it doesn't descend beneath the child nodes. a #GNode which types of children are to be visited, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the function to call for each visited node user data to pass to the function Recursively copies a #GNode (but does not deep-copy the data inside the nodes, see g_node_copy_deep() if you need that). a #GNode a new #GNode containing the same data pointers Recursively copies a #GNode and its data. Since: 2.4 a #GNode the function which is called to copy the data inside each node, or %NULL to use the original data. data to pass to @copy_func a new #GNode containing copies of the data in @node. Gets the depth of a #GNode. If @node is %NULL the depth is 0. The root node has a depth of 1. For the children of the root node the depth is 2. And so on. a #GNode the depth of the #GNode Removes @root and its children from the tree, freeing any memory allocated. the root of the tree/subtree to destroy Finds a #GNode in a tree. the root #GNode of the tree to search the order in which nodes are visited - %G_IN_ORDER, %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER which types of children are to be searched, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the data to find the found #GNode, or %NULL if the data is not found Finds the first child of a #GNode with the given data. a #GNode which types of children are to be searched, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the data to find the found child #GNode, or %NULL if the data is not found Gets the first child of a #GNode. a #GNode the first child of @node, or %NULL if @node is %NULL or has no children Gets the first sibling of a #GNode. This could possibly be the node itself. a #GNode the first sibling of @node Gets the root of a tree. a #GNode the root of the tree Inserts a #GNode beneath the parent at the given position. the #GNode to place @node under the position to place @node at, with respect to its siblings If position is -1, @node is inserted as the last child of @parent the #GNode to insert the inserted #GNode Inserts a #GNode beneath the parent after the given sibling. the #GNode to place @node under the sibling #GNode to place @node after. If sibling is %NULL, the node is inserted as the first child of @parent. the #GNode to insert the inserted #GNode Inserts a #GNode beneath the parent before the given sibling. the #GNode to place @node under the sibling #GNode to place @node before. If sibling is %NULL, the node is inserted as the last child of @parent. the #GNode to insert the inserted #GNode Inserts a new #GNode at the given position. the #GNode to place the new #GNode under the position to place the new #GNode at. If position is -1, the new #GNode is inserted as the last child of @parent the data for the new #GNode the new #GNode Inserts a new #GNode after the given sibling. the #GNode to place the new #GNode under the sibling #GNode to place the new #GNode after the data for the new #GNode the new #GNode Inserts a new #GNode before the given sibling. the #GNode to place the new #GNode under the sibling #GNode to place the new #GNode before the data for the new #GNode the new #GNode Returns %TRUE if @node is an ancestor of @descendant. This is true if node is the parent of @descendant, or if node is the grandparent of @descendant etc. a #GNode a #GNode %TRUE if @node is an ancestor of @descendant Gets the last child of a #GNode. a #GNode (must not be %NULL) the last child of @node, or %NULL if @node has no children Gets the last sibling of a #GNode. This could possibly be the node itself. a #GNode the last sibling of @node Gets the maximum height of all branches beneath a #GNode. This is the maximum distance from the #GNode to all leaf nodes. If @root is %NULL, 0 is returned. If @root has no children, 1 is returned. If @root has children, 2 is returned. And so on. a #GNode the maximum height of the tree beneath @root Gets the number of children of a #GNode. a #GNode the number of children of @node Gets the number of nodes in a tree. a #GNode which types of children are to be counted, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the number of nodes in the tree Creates a new #GNode containing the given data. Used to create the first node in a tree. the data of the new node a new #GNode Gets the next sibling of a #GNode. a #GNode the next sibling of @node, or %NULL if @node is the last node or %NULL Gets a child of a #GNode, using the given index. The first child is at index 0. If the index is too big, %NULL is returned. a #GNode the index of the desired child the child of @node at index @n Inserts a #GNode as the first child of the given parent. the #GNode to place the new #GNode under the #GNode to insert the inserted #GNode Inserts a new #GNode as the first child of the given parent. the #GNode to place the new #GNode under the data for the new #GNode the new #GNode Gets the previous sibling of a #GNode. a #GNode the previous sibling of @node, or %NULL if @node is the first node or %NULL Reverses the order of the children of a #GNode. (It doesn't change the order of the grandchildren.) a #GNode. Traverses a tree starting at the given root #GNode. It calls the given function for each node visited. The traversal can be halted at any point by returning %TRUE from @func. the root #GNode of the tree to traverse the order in which nodes are visited - %G_IN_ORDER, %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER. which types of children are to be visited, one of %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES the maximum depth of the traversal. Nodes below this depth will not be visited. If max_depth is -1 all nodes in the tree are visited. If depth is 1, only the root is visited. If depth is 2, the root and its children are visited. And so on. the function to call for each visited #GNode user data to pass to the function Unlinks a #GNode from a tree, resulting in two separate trees. the #GNode to unlink, which becomes the root of a new tree Converts a 32-bit integer value from network to host byte order. a 32-bit integer value in network byte order @val converted to host byte order. Converts a 16-bit integer value from network to host byte order. a 16-bit integer value in network byte order @val converted to host byte order Set the pointer at the specified location to %NULL. the memory address of the pointer. Increases the reference count of the object by one and sets a callback to be called when all other references to the object are dropped, or when this is already the last reference to the object and another reference is established. This functionality is intended for binding @object to a proxy object managed by another memory manager. This is done with two paired references: the strong reference added by g_object_add_toggle_ref() and a reverse reference to the proxy object which is either a strong reference or weak reference. The setup is that when there are no other references to @object, only a weak reference is held in the reverse direction from @object to the proxy object, but when there are other references held to @object, a strong reference is held. The @notify callback is called when the reference from @object to the proxy object should be "toggled" from strong to weak (@is_last_ref true) or weak to strong (@is_last_ref false). Since a (normal) reference must be held to the object before calling g_object_add_toggle_ref(), the initial state of the reverse link is always strong. Multiple toggle references may be added to the same gobject, however if there are multiple toggle references to an object, none of them will ever be notified until all but one are removed. For this reason, you should only ever use a toggle reference if there is important state in the proxy object. Since: 2.8 a #GObject a function to call when this reference is the last reference to the object, or is no longer the last reference. data to pass to @notify Adds a weak reference from weak_pointer to @object to indicate that the pointer located at @weak_pointer_location is only valid during the lifetime of @object. When the @object is finalized, @weak_pointer will be set to %NULL. Note that as with g_object_weak_ref(), the weak references created by this method are not thread-safe: they cannot safely be used in one thread if the object's last g_object_unref() might happen in another thread. Use #GWeakRef if thread-safety is required. The object that should be weak referenced. The memory address of a pointer. Creates a binding between @source_property on @source and @target_property on @target. Whenever the @source_property is changed the @target_property is updated using the same value. For instance: |[ g_object_bind_property (action, "active", widget, "sensitive", 0); ]| Will result in the "sensitive" property of the widget #GObject instance to be updated with the same value of the "active" property of the action #GObject instance. If @flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual: if @target_property on @target changes then the @source_property on @source will be updated as well. The binding will automatically be removed when either the @source or the @target instances are finalized. To remove the binding without affecting the @source and the @target you can just call g_object_unref() on the returned #GBinding instance. A #GObject can have multiple bindings. Since: 2.26 the source #GObject the property on @source to bind the target #GObject the property on @target to bind flags to pass to #GBinding the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero. Complete version of g_object_bind_property(). Creates a binding between @source_property on @source and @target_property on @target, allowing you to set the transformation functions to be used by the binding. If @flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual: if @target_property on @target changes then the @source_property on @source will be updated as well. The @transform_from function is only used in case of bidirectional bindings, otherwise it will be ignored The binding will automatically be removed when either the @source or the @target instances are finalized. To remove the binding without affecting the @source and the @target you can just call g_object_unref() on the returned #GBinding instance. A #GObject can have multiple bindings. The same @user_data parameter will be used for both @transform_to and @transform_from transformation functions; the @notify function will be called once, when the binding is removed. If you need different data for each transformation function, please use g_object_bind_property_with_closures() instead. Since: 2.26 the source #GObject the property on @source to bind the target #GObject the property on @target to bind flags to pass to #GBinding the transformation function from the @source to the @target, or %NULL to use the default the transformation function from the @target to the @source, or %NULL to use the default custom data to be passed to the transformation functions, or %NULL function to be called when disposing the binding, to free the resources used by the transformation functions the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero. Creates a binding between @source_property on @source and @target_property on @target, allowing you to set the transformation functions to be used by the binding. This function is the language bindings friendly version of g_object_bind_property_full(), using #GClosures instead of function pointers. Since: 2.26 the source #GObject the property on @source to bind the target #GObject the property on @target to bind flags to pass to #GBinding a #GClosure wrapping the transformation function from the @source to the @target, or %NULL to use the default a #GClosure wrapping the transformation function from the @target to the @source, or %NULL to use the default the #GBinding instance representing the binding between the two #GObject instances. The binding is released whenever the #GBinding reference count reaches zero. Looks up the #GParamSpec for a property of a class. a #GObjectClass the name of the property to look up the #GParamSpec for the property, or %NULL if the class doesn't have a property of that name Installs new properties from an array of #GParamSpecs. All properties should be installed during the class initializer. It is possible to install properties after that, but doing so is not recommend, and specifically, is not guaranteed to be thread-safe vs. use of properties on the same type on other threads. The property id of each property is the index of each #GParamSpec in the @pspecs array. The property id of 0 is treated specially by #GObject and it should not be used to store a #GParamSpec. This function should be used if you plan to use a static array of #GParamSpecs and g_object_notify_by_pspec(). For instance, this class initialization: |[<!-- language="C" --> enum { PROP_0, PROP_FOO, PROP_BAR, N_PROPERTIES }; static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, }; static void my_object_class_init (MyObjectClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); obj_properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "Foo", -1, G_MAXINT, 0, G_PARAM_READWRITE); obj_properties[PROP_BAR] = g_param_spec_string ("bar", "Bar", "Bar", NULL, G_PARAM_READWRITE); gobject_class->set_property = my_object_set_property; gobject_class->get_property = my_object_get_property; g_object_class_install_properties (gobject_class, N_PROPERTIES, obj_properties); } ]| allows calling g_object_notify_by_pspec() to notify of property changes: |[<!-- language="C" --> void my_object_set_foo (MyObject *self, gint foo) { if (self->foo != foo) { self->foo = foo; g_object_notify_by_pspec (G_OBJECT (self), obj_properties[PROP_FOO]); } } ]| Since: 2.26 a #GObjectClass the length of the #GParamSpecs array the #GParamSpecs array defining the new properties Installs a new property. All properties should be installed during the class initializer. It is possible to install properties after that, but doing so is not recommend, and specifically, is not guaranteed to be thread-safe vs. use of properties on the same type on other threads. Note that it is possible to redefine a property in a derived class, by installing a property with the same name. This can be useful at times, e.g. to change the range of allowed values or the default value. a #GObjectClass the id for the new property the #GParamSpec for the new property Get an array of #GParamSpec* for all properties of a class. a #GObjectClass return location for the length of the returned array an array of #GParamSpec* which should be freed after use Registers @property_id as referring to a property with the name @name in a parent class or in an interface implemented by @oclass. This allows this class to "override" a property implementation in a parent class or to provide the implementation of a property from an interface. Internally, overriding is implemented by creating a property of type #GParamSpecOverride; generally operations that query the properties of the object class, such as g_object_class_find_property() or g_object_class_list_properties() will return the overridden property. However, in one case, the @construct_properties argument of the @constructor virtual function, the #GParamSpecOverride is passed instead, so that the @param_id field of the #GParamSpec will be correct. For virtually all uses, this makes no difference. If you need to get the overridden property, you can call g_param_spec_get_redirect_target(). Since: 2.4 a #GObjectClass the new property ID the name of a property registered in a parent class or in an interface of this class. A convenience function to connect multiple signals at once. The signal specs expected by this function have the form "modifier::signal_name", where modifier can be one of the following: * - signal: equivalent to g_signal_connect_data (..., NULL, 0) - object-signal, object_signal: equivalent to g_signal_connect_object (..., 0) - swapped-signal, swapped_signal: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_SWAPPED) - swapped_object_signal, swapped-object-signal: equivalent to g_signal_connect_object (..., G_CONNECT_SWAPPED) - signal_after, signal-after: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_AFTER) - object_signal_after, object-signal-after: equivalent to g_signal_connect_object (..., G_CONNECT_AFTER) - swapped_signal_after, swapped-signal-after: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_SWAPPED | G_CONNECT_AFTER) - swapped_object_signal_after, swapped-object-signal-after: equivalent to g_signal_connect_object (..., G_CONNECT_SWAPPED | G_CONNECT_AFTER) |[<!-- language="C" --> menu->toplevel = g_object_connect (g_object_new (GTK_TYPE_WINDOW, "type", GTK_WINDOW_POPUP, "child", menu, NULL), "signal::event", gtk_menu_window_event, menu, "signal::size_request", gtk_menu_window_size_request, menu, "signal::destroy", gtk_widget_destroyed, &menu->toplevel, NULL); ]| a #GObject the spec for the first signal #GCallback for the first signal, followed by data for the first signal, followed optionally by more signal spec/callback/data triples, followed by %NULL @object A convenience function to disconnect multiple signals at once. The signal specs expected by this function have the form "any_signal", which means to disconnect any signal with matching callback and data, or "any_signal::signal_name", which only disconnects the signal named "signal_name". a #GObject the spec for the first signal #GCallback for the first signal, followed by data for the first signal, followed optionally by more signal spec/callback/data triples, followed by %NULL This is a variant of g_object_get_data() which returns a 'duplicate' of the value. @dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object. If the @key is not set on the object then @dup_func will be called with a %NULL argument. Note that @dup_func is called while user data of @object is locked. This function can be useful to avoid races when multiple threads are using object data on the same key on the same object. Since: 2.34 the #GObject to store user data on a string, naming the user data pointer function to dup the value passed as user_data to @dup_func the result of calling @dup_func on the value associated with @key on @object, or %NULL if not set. If @dup_func is %NULL, the value is returned unmodified. This is a variant of g_object_get_qdata() which returns a 'duplicate' of the value. @dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object. If the @quark is not set on the object then @dup_func will be called with a %NULL argument. Note that @dup_func is called while user data of @object is locked. This function can be useful to avoid races when multiple threads are using object data on the same key on the same object. Since: 2.34 the #GObject to store user data on a #GQuark, naming the user data pointer function to dup the value passed as user_data to @dup_func the result of calling @dup_func on the value associated with @quark on @object, or %NULL if not set. If @dup_func is %NULL, the value is returned unmodified. This function is intended for #GObject implementations to re-enforce a [floating][floating-ref] object reference. Doing this is seldom required: all #GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling g_object_ref_sink(). Since: 2.10 a #GObject Increases the freeze count on @object. If the freeze count is non-zero, the emission of "notify" signals on @object is stopped. The signals are queued until the freeze count is decreased to zero. Duplicate notifications are squashed so that at most one #GObject::notify signal is emitted for each property modified while the object is frozen. This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified. a #GObject Gets properties of an object. In general, a copy is made of the property contents and the caller is responsible for freeing the memory in the appropriate manner for the type, for instance by calling g_free() or g_object_unref(). Here is an example of using g_object_get() to get the contents of three properties: an integer, a string and an object: |[<!-- language="C" --> gint intval; gchar *strval; GObject *objval; g_object_get (my_object, "int-property", &intval, "str-property", &strval, "obj-property", &objval, NULL); // Do something with intval, strval, objval g_free (strval); g_object_unref (objval); ]| a #GObject name of the first property to get return location for the first property, followed optionally by more name/return location pairs, followed by %NULL Gets a named field from the objects table of associations (see g_object_set_data()). #GObject containing the associations name of the key for that association the data if found, or %NULL if no such data exists. Gets a property of an object. @value must have been initialized to the expected type of the property (or a type to which the expected type can be transformed) using g_value_init(). In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling g_value_unset(). Note that g_object_get_property() is really intended for language bindings, g_object_get() is much more convenient for C programming. a #GObject the name of the property to get return location for the property value This function gets back user data pointers stored via g_object_set_qdata(). The GObject to get a stored user data pointer from A #GQuark, naming the user data pointer The user data pointer set, or %NULL Gets properties of an object. In general, a copy is made of the property contents and the caller is responsible for freeing the memory in the appropriate manner for the type, for instance by calling g_free() or g_object_unref(). See g_object_get(). a #GObject name of the first property to get return location for the first property, followed optionally by more name/return location pairs, followed by %NULL Find the #GParamSpec with the given name for an interface. Generally, the interface vtable passed in as @g_iface will be the default vtable from g_type_default_interface_ref(), or, if you know the interface has already been loaded, g_type_default_interface_peek(). Since: 2.4 any interface vtable for the interface, or the default vtable for the interface name of a property to lookup. the #GParamSpec for the property of the interface with the name @property_name, or %NULL if no such property exists. Add a property to an interface; this is only useful for interfaces that are added to GObject-derived types. Adding a property to an interface forces all objects classes with that interface to have a compatible property. The compatible property could be a newly created #GParamSpec, but normally g_object_class_override_property() will be used so that the object class only needs to provide an implementation and inherits the property description, default value, bounds, and so forth from the interface property. This function is meant to be called from the interface's default vtable initialization function (the @class_init member of #GTypeInfo.) It must not be called after after @class_init has been called for any object types implementing this interface. Since: 2.4 any interface vtable for the interface, or the default vtable for the interface. the #GParamSpec for the new property Lists the properties of an interface.Generally, the interface vtable passed in as @g_iface will be the default vtable from g_type_default_interface_ref(), or, if you know the interface has already been loaded, g_type_default_interface_peek(). Since: 2.4 any interface vtable for the interface, or the default vtable for the interface location to store number of properties returned. a pointer to an array of pointers to #GParamSpec structures. The paramspecs are owned by GLib, but the array should be freed with g_free() when you are done with it. Checks whether @object has a [floating][floating-ref] reference. Since: 2.10 a #GObject %TRUE if @object has a floating reference Creates a new instance of a #GObject subtype and sets its properties. Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values. the type id of the #GObject subtype to instantiate the name of the first property the value of the first property, followed optionally by more name/value pairs, followed by %NULL a new instance of @object_type Creates a new instance of a #GObject subtype and sets its properties. Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values. the type id of the #GObject subtype to instantiate the name of the first property the value of the first property, followed optionally by more name/value pairs, followed by %NULL a new instance of @object_type Creates a new instance of a #GObject subtype and sets its properties. Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values. the type id of the #GObject subtype to instantiate the length of the @parameters array an array of #GParameter a new instance of @object_type Emits a "notify" signal for the property @property_name on @object. When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead. Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called. a #GObject the name of a property installed on the class of @object. Emits a "notify" signal for the property specified by @pspec on @object. This function omits the property name lookup, hence it is faster than g_object_notify(). One way to avoid using g_object_notify() from within the class that registered the properties, and using g_object_notify_by_pspec() instead, is to store the GParamSpec used with g_object_class_install_property() inside a static array, e.g.: |[<!-- language="C" --> enum { PROP_0, PROP_FOO, PROP_LAST }; static GParamSpec *properties[PROP_LAST]; static void my_object_class_init (MyObjectClass *klass) { properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo", 0, 100, 50, G_PARAM_READWRITE); g_object_class_install_property (gobject_class, PROP_FOO, properties[PROP_FOO]); } ]| and then notify a change on the "foo" property with: |[<!-- language="C" --> g_object_notify_by_pspec (self, properties[PROP_FOO]); ]| Since: 2.26 a #GObject the #GParamSpec of a property installed on the class of @object. Increases the reference count of @object. a #GObject the same @object Increase the reference count of @object, and possibly remove the [floating][floating-ref] reference, if @object has a floating reference. In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one. Since: 2.10 a #GObject @object Removes a reference added with g_object_add_toggle_ref(). The reference count of the object is decreased by one. Since: 2.8 a #GObject a function to call when this reference is the last reference to the object, or is no longer the last reference. data to pass to @notify Removes a weak reference from @object that was previously added using g_object_add_weak_pointer(). The @weak_pointer_location has to match the one used with g_object_add_weak_pointer(). The object that is weak referenced. The memory address of a pointer. Compares the user data for the key @key on @object with @oldval, and if they are the same, replaces @oldval with @newval. This is like a typical atomic compare-and-exchange operation, for user data on an object. If the previous value was replaced then ownership of the old value (@oldval) is passed to the caller, including the registered destroy notify for it (passed out in @old_destroy). Its up to the caller to free this as he wishes, which may or may not include using @old_destroy as sometimes replacement should not destroy the object in the normal way. Since: 2.34 the #GObject to store user data on a string, naming the user data pointer the old value to compare against the new value a destroy notify for the new value destroy notify for the existing value %TRUE if the existing value for @key was replaced by @newval, %FALSE otherwise. Compares the user data for the key @quark on @object with @oldval, and if they are the same, replaces @oldval with @newval. This is like a typical atomic compare-and-exchange operation, for user data on an object. If the previous value was replaced then ownership of the old value (@oldval) is passed to the caller, including the registered destroy notify for it (passed out in @old_destroy). Its up to the caller to free this as he wishes, which may or may not include using @old_destroy as sometimes replacement should not destroy the object in the normal way. Since: 2.34 the #GObject to store user data on a #GQuark, naming the user data pointer the old value to compare against the new value a destroy notify for the new value destroy notify for the existing value %TRUE if the existing value for @quark was replaced by @newval, %FALSE otherwise. Releases all references to other objects. This can be used to break reference cycles. This function should only be called from object system implementations. a #GObject Sets properties on an object. Note that the "notify" signals are queued and only emitted (in reverse order) after all properties have been set. See g_object_freeze_notify(). a #GObject name of the first property to set value for the first property, followed optionally by more name/value pairs, followed by %NULL Each object carries around a table of associations from strings to pointers. This function lets you set an association. If the object already had an association with that name, the old association will be destroyed. #GObject containing the associations. name of the key data to associate with that key Like g_object_set_data() except it adds notification for when the association is destroyed, either by setting it to a different value or when the object is destroyed. Note that the @destroy callback is not called if @data is %NULL. #GObject containing the associations name of the key data to associate with that key function to call when the association is destroyed Sets a property on an object. a #GObject the name of the property to set the value This sets an opaque, named pointer on an object. The name is specified through a #GQuark (retrived e.g. via g_quark_from_static_string()), and the pointer can be gotten back from the @object with g_object_get_qdata() until the @object is finalized. Setting a previously set user data pointer, overrides (frees) the old pointer set, using #NULL as pointer essentially removes the data stored. The GObject to set store a user data pointer A #GQuark, naming the user data pointer An opaque user data pointer This function works like g_object_set_qdata(), but in addition, a void (*destroy) (gpointer) function may be specified which is called with @data as argument when the @object is finalized, or the data is being overwritten by a call to g_object_set_qdata() with the same @quark. The GObject to set store a user data pointer A #GQuark, naming the user data pointer An opaque user data pointer Function to invoke with @data as argument, when @data needs to be freed Sets properties on an object. a #GObject name of the first property to set value for the first property, followed optionally by more name/value pairs, followed by %NULL Remove a specified datum from the object's data associations, without invoking the association's destroy handler. #GObject containing the associations name of the key the data if found, or %NULL if no such data exists. This function gets back user data pointers stored via g_object_set_qdata() and removes the @data from object without invoking its destroy() function (if any was set). Usually, calling this function is only required to update user data pointers with a destroy notifier, for example: |[<!-- language="C" --> void object_add_to_user_list (GObject *object, const gchar *new_string) { // the quark, naming the object data GQuark quark_string_list = g_quark_from_static_string ("my-string-list"); // retrive the old string list GList *list = g_object_steal_qdata (object, quark_string_list); // prepend new string list = g_list_prepend (list, g_strdup (new_string)); // this changed 'list', so we need to set it again g_object_set_qdata_full (object, quark_string_list, list, free_string_list); } static void free_string_list (gpointer data) { GList *node, *list = data; for (node = list; node; node = node->next) g_free (node->data); g_list_free (list); } ]| Using g_object_get_qdata() in the above example, instead of g_object_steal_qdata() would have left the destroy function set, and thus the partial string list would have been freed upon g_object_set_qdata_full(). The GObject to get a stored user data pointer from A #GQuark, naming the user data pointer The user data pointer set, or %NULL Reverts the effect of a previous call to g_object_freeze_notify(). The freeze count is decreased on @object and when it reaches zero, queued "notify" signals are emitted. Duplicate notifications for each property are squashed so that at most one #GObject::notify signal is emitted for each property, in the reverse order in which they have been queued. It is an error to call this function when the freeze count is zero. a #GObject Decreases the reference count of @object. When its reference count drops to 0, the object is finalized (i.e. its memory is freed). If the pointer to the #GObject may be reused in future (for example, if it is an instance variable of another object), it is recommended to clear the pointer to %NULL rather than retain a dangling pointer to a potentially invalid #GObject instance. Use g_clear_object() for this. a #GObject This function essentially limits the life time of the @closure to the life time of the object. That is, when the object is finalized, the @closure is invalidated by calling g_closure_invalidate() on it, in order to prevent invocations of the closure with a finalized (nonexisting) object. Also, g_object_ref() and g_object_unref() are added as marshal guards to the @closure, to ensure that an extra reference count is held on @object during invocation of the @closure. Usually, this function will be called on closures that use this @object as closure data. GObject restricting lifetime of @closure GClosure to watch Adds a weak reference callback to an object. Weak references are used for notification when an object is finalized. They are called "weak references" because they allow you to safely hold a pointer to an object without calling g_object_ref() (g_object_ref() adds a strong reference, that is, forces the object to stay alive). Note that the weak references created by this method are not thread-safe: they cannot safely be used in one thread if the object's last g_object_unref() might happen in another thread. Use #GWeakRef if thread-safety is required. #GObject to reference weakly callback to invoke before the object is freed extra data to pass to notify Removes a weak reference callback to an object. #GObject to remove a weak reference from callback to search for data to search for 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. |[<!-- language="C" --> #include <glib.h> static void log_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data) { g_log_default_handler (log_domain, log_level, message, user_data); g_on_error_query (MY_PROGRAM_NAME); } int main (int argc, char *argv[]) { g_log_set_handler (MY_LOG_DOMAIN, G_LOG_LEVEL_WARNING | G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL, log_handler, NULL); ... ]| If "[E]xit" is selected, the application terminates with a call to _exit(0). If "[S]tack" trace is selected, g_on_error_stack_trace() is called. This invokes gdb, which attaches to the current process and shows a stack trace. The prompt is then shown again. If "[P]roceed" is selected, the function returns. This function may cause different actions on non-UNIX platforms. the program name, needed by gdb for the "[S]tack trace" option. If @prg_name is %NULL, g_get_prgname() is called to get the program name (which will work correctly if gdk_init() or gtk_init() has been called) Invokes gdb, which attaches to the current process and shows a stack trace. Called by g_on_error_query() when the "[S]tack 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(). This function may cause different actions on non-UNIX platforms. the program name, needed by gdb for the "[S]tack trace" option The first call to this routine by a process with a given #GOnce struct calls @func with the given argument. Thereafter, subsequent calls to g_once() with the same #GOnce struct do not call @func again, but return the stored result of the first call. On return from g_once(), the status of @once will be %G_ONCE_STATUS_READY. For example, a mutex or a thread-specific data key must be created exactly once. In a threaded environment, calling g_once() ensures that the initialization is serialized across multiple threads. Calling g_once() recursively on the same #GOnce struct in @func will lead to a deadlock. |[<!-- language="C" --> gpointer get_debug_flags (void) { static GOnce my_once = G_ONCE_INIT; g_once (&my_once, parse_debug_flags, NULL); return my_once.retval; } ]| Since: 2.4 a #GOnce structure the #GThreadFunc function associated to @once. This function is called only once, regardless of the number of times it and its associated #GOnce struct are passed to g_once(). data to be passed to @func Function to be called when starting a critical initialization section. The argument @location must point to a static 0-initialized variable that will be set to a value other than 0 at the end of the initialization section. In combination with g_once_init_leave() and the unique address @value_location, it can be ensured that an initialization section will be executed only once during a program's life time, and that concurrent threads are blocked until initialization completed. To be used in constructs like this: |[<!-- language="C" --> static gsize initialization_value = 0; if (g_once_init_enter (&initialization_value)) { gsize setup_value = 42; // initialization code here g_once_init_leave (&initialization_value, setup_value); } // use initialization_value here ]| Since: 2.14 location of a static initializable variable containing 0 %TRUE if the initialization section should be entered, %FALSE and blocks otherwise Counterpart to g_once_init_enter(). Expects a location of a static 0-initialized initialization variable, and an initialization value other than 0. Sets the variable to the initialization value, and releases concurrent threads blocking in g_once_init_enter() on this initialization variable. Since: 2.14 location of a static initializable variable containing 0 new non-0 value for *@value_location A wrapper for the POSIX open() function. The open() function is used to convert a pathname into a file descriptor. On POSIX systems file descriptors are implemented by the operating system. On Windows, it's the C library that implements open() and file descriptors. The actual Win32 API for opening files is quite different, see MSDN documentation for CreateFile(). The Win32 API uses file handles, which are more randomish integers, not small integers like file descriptors. Because file descriptors are specific to the C library on Windows, the file descriptor returned by this function makes sense only to functions in the same C library. Thus if the GLib-using code uses a different C library than GLib does, the file descriptor returned by this function cannot be passed to C library functions like write() or read(). See your C library manual for more details about open(). Since: 2.6 a pathname in the GLib file name encoding (UTF-8 on Windows) as in open() as in open() a new file descriptor, or -1 if an error occurred. The return value can be used exactly like the return value from open(). Adds a #GOptionGroup to the @context, so that parsing with @context will recognize the options in the group. Note that this will take ownership of the @group and thus the @group should not be freed. Since: 2.6 a #GOptionContext the group to add A convenience function which creates a main group if it doesn't exist, adds the @entries to it and sets the translation domain. Since: 2.6 a #GOptionContext a %NULL-terminated array of #GOptionEntrys a translation domain to use for translating the `--help` output for the options in @entries with gettext(), or %NULL Frees context and all the groups which have been added to it. Please note that parsed arguments need to be freed separately (see #GOptionEntry). Since: 2.6 a #GOptionContext Returns the description. See g_option_context_set_description(). Since: 2.12 a #GOptionContext the description Returns a formatted, translated help text for the given context. To obtain the text produced by `--help`, call `g_option_context_get_help (context, TRUE, NULL)`. To obtain the text produced by `--help-all`, call `g_option_context_get_help (context, FALSE, NULL)`. To obtain the help text for an option group, call `g_option_context_get_help (context, FALSE, group)`. Since: 2.14 a #GOptionContext if %TRUE, only include the main group the #GOptionGroup to create help for, or %NULL A newly allocated string containing the help text Returns whether automatic `--help` generation is turned on for @context. See g_option_context_set_help_enabled(). Since: 2.6 a #GOptionContext %TRUE if automatic help generation is turned on. Returns whether unknown options are ignored or not. See g_option_context_set_ignore_unknown_options(). Since: 2.6 a #GOptionContext %TRUE if unknown options are ignored. Returns a pointer to the main group of @context. Since: 2.6 a #GOptionContext the main group of @context, or %NULL if @context doesn't have a main group. Note that group belongs to @context and should not be modified or freed. Returns whether strict POSIX code is enabled. See g_option_context_set_strict_posix() for more information. Since: 2.44 a #GoptionContext %TRUE if strict POSIX is enabled, %FALSE otherwise. Returns the summary. See g_option_context_set_summary(). Since: 2.12 a #GOptionContext the summary Creates a new option context. The @parameter_string can serve multiple purposes. It can be used to add descriptions for "rest" arguments, which are not parsed by the #GOptionContext, typically something like "FILES" or "FILE1 FILE2...". If you are using #G_OPTION_REMAINING for collecting "rest" arguments, GLib handles this automatically by using the @arg_description of the corresponding #GOptionEntry in the usage summary. Another usage is to give a short summary of the program functionality, like " - frob the strings", which will be displayed in the same line as the usage. For a longer description of the program functionality that should be displayed as a paragraph below the usage line, use g_option_context_set_summary(). Note that the @parameter_string is translated using the function set with g_option_context_set_translate_func(), so it should normally be passed untranslated. Since: 2.6 a string which is displayed in the first line of `--help` output, after the usage summary `programname [OPTION...]` a newly created #GOptionContext, which must be freed with g_option_context_free() after use. Parses the command line arguments, recognizing options which have been added to @context. A side-effect of calling this function is that g_set_prgname() will be called. If the parsing is successful, any parsed arguments are removed from the array and @argc and @argv are updated accordingly. A '--' option is stripped from @argv unless there are unparsed options before and after it, or some of the options after it start with '-'. In case of an error, @argc and @argv are left unmodified. If automatic `--help` support is enabled (see g_option_context_set_help_enabled()), and the @argv array contains one of the recognized help options, this function will produce help output to stdout and call `exit (0)`. Note that function depends on the [current locale][setlocale] for automatic character set conversion of string and filename arguments. Since: 2.6 a #GOptionContext a pointer to the number of command line arguments a pointer to the array of command line arguments a return location for errors %TRUE if the parsing was successful, %FALSE if an error occurred Parses the command line arguments. This function is similar to g_option_context_parse() except that it respects the normal memory rules when dealing with a strv instead of assuming that the passed-in array is the argv of the main function. In particular, strings that are removed from the arguments list will be freed using g_free(). On Windows, the strings are expected to be in UTF-8. This is in contrast to g_option_context_parse() which expects them to be in the system codepage, which is how they are passed as @argv to main(). See g_win32_get_command_line() for a solution. This function is useful if you are trying to use #GOptionContext with #GApplication. Since: 2.40 a #GOptionContext a pointer to the command line arguments (which must be in UTF-8 on Windows) a return location for errors %TRUE if the parsing was successful, %FALSE if an error occurred Adds a string to be displayed in `--help` output after the list of options. This text often includes a bug reporting address. Note that the summary is translated (see g_option_context_set_translate_func()). Since: 2.12 a #GOptionContext a string to be shown in `--help` output after the list of options, or %NULL Enables or disables automatic generation of `--help` output. By default, g_option_context_parse() recognizes `--help`, `-h`, `-?`, `--help-all` and `--help-groupname` and creates suitable output to stdout. Since: 2.6 a #GOptionContext %TRUE to enable `--help`, %FALSE to disable it Sets whether to ignore unknown options or not. If an argument is ignored, it is left in the @argv array after parsing. By default, g_option_context_parse() treats unknown options as error. This setting does not affect non-option arguments (i.e. arguments which don't start with a dash). But note that GOption cannot reliably determine whether a non-option belongs to a preceding unknown option. Since: 2.6 a #GOptionContext %TRUE to ignore unknown options, %FALSE to produce an error when unknown options are met Sets a #GOptionGroup as main group of the @context. This has the same effect as calling g_option_context_add_group(), the only difference is that the options in the main group are treated differently when generating `--help` output. Since: 2.6 a #GOptionContext the group to set as main group Sets strict POSIX mode. By default, this mode is disabled. In strict POSIX mode, the first non-argument parameter encountered (eg: filename) terminates argument processing. Remaining arguments are treated as non-options and are not attempted to be parsed. If strict POSIX mode is disabled then parsing is done in the GNU way where option arguments can be freely mixed with non-options. As an example, consider "ls foo -l". With GNU style parsing, this will list "foo" in long mode. In strict POSIX style, this will list the files named "foo" and "-l". It may be useful to force strict POSIX mode when creating "verb style" command line tools. For example, the "gsettings" command line tool supports the global option "--schemadir" as well as many subcommands ("get", "set", etc.) which each have their own set of arguments. Using strict POSIX mode will allow parsing the global options up to the verb name while leaving the remaining options to be parsed by the relevant subcommand (which can be determined by examining the verb name, which should be present in argv[1] after parsing). Since: 2.44 a #GoptionContext the new value Adds a string to be displayed in `--help` output before the list of options. This is typically a summary of the program functionality. Note that the summary is translated (see g_option_context_set_translate_func() and g_option_context_set_translation_domain()). Since: 2.12 a #GOptionContext a string to be shown in `--help` output before the list of options, or %NULL Sets the function which is used to translate the contexts user-visible strings, for `--help` output. If @func is %NULL, strings are not translated. Note that option groups have their own translation functions, this function only affects the @parameter_string (see g_option_context_new()), the summary (see g_option_context_set_summary()) and the description (see g_option_context_set_description()). If you are using gettext(), you only need to set the translation domain, see g_option_context_set_translation_domain(). Since: 2.12 a #GOptionContext the #GTranslateFunc, or %NULL user data to pass to @func, or %NULL a function which gets called to free @data, or %NULL A convenience function to use gettext() for translating user-visible strings. Since: 2.12 a #GOptionContext the domain to use Adds the options specified in @entries to @group. Since: 2.6 a #GOptionGroup a %NULL-terminated array of #GOptionEntrys Frees a #GOptionGroup. Note that you must not free groups which have been added to a #GOptionContext. Since: 2.6 Deprecated: 2.44: Use g_option_group_unref() instead. a #GOptionGroup Creates a new #GOptionGroup. Since: 2.6 the name for the option group, this is used to provide help for the options in this group with `--help-`@name a description for this group to be shown in `--help`. This string is translated using the translation domain or translation function of the group a description for the `--help-`@name option. This string is translated using the translation domain or translation function of the group user data that will be passed to the pre- and post-parse hooks, the error hook and to callbacks of %G_OPTION_ARG_CALLBACK options, or %NULL a function that will be called to free @user_data, or %NULL a newly created option group. It should be added to a #GOptionContext or freed with g_option_group_unref(). Increments the reference count of @group by one. Since: 2.44 a #GOptionGroup a #GoptionGroup Associates a function with @group which will be called from g_option_context_parse() when an error occurs. Note that the user data to be passed to @error_func can be specified when constructing the group with g_option_group_new(). Since: 2.6 a #GOptionGroup a function to call when an error occurs Associates two functions with @group which will be called from g_option_context_parse() before the first option is parsed and after the last option has been parsed, respectively. Note that the user data to be passed to @pre_parse_func and @post_parse_func can be specified when constructing the group with g_option_group_new(). Since: 2.6 a #GOptionGroup a function to call before parsing, or %NULL a function to call after parsing, or %NULL Sets the function which is used to translate user-visible strings, for `--help` output. Different groups can use different #GTranslateFuncs. If @func is %NULL, strings are not translated. If you are using gettext(), you only need to set the translation domain, see g_option_group_set_translation_domain(). Since: 2.6 a #GOptionGroup the #GTranslateFunc, or %NULL user data to pass to @func, or %NULL a function which gets called to free @data, or %NULL A convenience function to use gettext() for translating user-visible strings. Since: 2.6 a #GOptionGroup the domain to use Decrements the reference count of @group by one. If the reference count drops to 0, the @group will be freed. and all memory allocated by the @group is released. Since: 2.44 a #GOptionGroup Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN property. In many cases, it may be more appropriate to use an enum with g_param_spec_enum(), both to improve code clarity by using explicitly named values, and to allow for more values to be added in future without breaking API. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED derived property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified %G_TYPE_BOXED derived type of this property flags for the property specified a newly created parameter specification Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property. canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified a #GType derived from %G_TYPE_ENUM default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified a #GType derived from %G_TYPE_FLAGS default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified a newly created parameter specification Get the short description of a #GParamSpec. a valid #GParamSpec the short description of @pspec. Gets the default value of @param as a pointer to a #GValue. The #GValue will remain value for the life of @param. Since: 2.38 a #GParamSpec a pointer to a #GValue which must not be modified Get the name of a #GParamSpec. The name is always an "interned" string (as per g_intern_string()). This allows for pointer-value comparisons. a valid #GParamSpec the name of @pspec. Get the nickname of a #GParamSpec. a valid #GParamSpec the nickname of @pspec. Gets back user data pointers stored via g_param_spec_set_qdata(). a valid #GParamSpec a #GQuark, naming the user data pointer the user data pointer set, or %NULL If the paramspec redirects operations to another paramspec, returns that paramspec. Redirect is used typically for providing a new implementation of a property in a derived type while preserving all the properties from the parent type. Redirection is established by creating a property of type #GParamSpecOverride. See g_object_class_override_property() for an example of the use of this capability. Since: 2.4 a #GParamSpec paramspec to which requests on this paramspec should be redirected, or %NULL if none. Creates a new #GParamSpecGType instance specifying a %G_TYPE_GTYPE property. See g_param_spec_internal() for details on property names. Since: 2.10 canonical name of the property specified nick name for the property specified description of the property specified a #GType whose subtypes are allowed as values of the property (use %G_TYPE_NONE for any type) flags for the property specified a newly created parameter specification Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpec instance. A property name consists of segments consisting of ASCII letters and digits, separated by either the '-' or '_' character. The first character of a property name must be a letter. Names which violate these rules lead to undefined behaviour. When creating and looking up a #GParamSpec, either separator can be used, but they cannot be mixed. Using '-' is considerably more efficient and in fact required when using property names as detail strings for signals. Beyond the name, #GParamSpecs have two more descriptive strings associated with them, the @nick, which should be suitable for use as a label for the property in a property editor, and the @blurb, which should be a somewhat longer description, suitable for e.g. a tooltip. The @nick and @blurb should ideally be localized. the #GType for the property; must be derived from #G_TYPE_PARAM the canonical name of the property the nickname of the property a short description of the property a combination of #GParamFlags a newly allocated #GParamSpec instance Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT derived property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified %G_TYPE_OBJECT derived type of this property flags for the property specified a newly created parameter specification Creates a new property of type #GParamSpecOverride. This is used to direct operations to another paramspec, and will not be directly useful unless you are implementing a new base type similar to GObject. Since: 2.4 the name of the property. The property that is being overridden the newly created #GParamSpec Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified a #GType derived from %G_TYPE_PARAM flags for the property specified a newly created parameter specification Creates a new #GParamSpecPointer instance specifying a pointer property. Where possible, it is better to use g_param_spec_object() or g_param_spec_boxed() to expose memory management information. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified flags for the property specified a newly created parameter specification Inserts a #GParamSpec in the pool. a #GParamSpecPool. the #GParamSpec to insert a #GType identifying the owner of @pspec Gets an array of all #GParamSpecs owned by @owner_type in the pool. a #GParamSpecPool the owner to look for return location for the length of the returned array a newly allocated array containing pointers to all #GParamSpecs owned by @owner_type in the pool Gets an #GList of all #GParamSpecs owned by @owner_type in the pool. a #GParamSpecPool the owner to look for a #GList of all #GParamSpecs owned by @owner_type in the pool#GParamSpecs. Looks up a #GParamSpec in the pool. a #GParamSpecPool the name to look for the owner to look for If %TRUE, also try to find a #GParamSpec with @param_name owned by an ancestor of @owner_type. The found #GParamSpec, or %NULL if no matching #GParamSpec was found. Creates a new #GParamSpecPool. If @type_prefixing is %TRUE, lookups in the newly created pool will allow to specify the owner as a colon-separated prefix of the property name, like "GtkContainer:border-width". This feature is deprecated, so you should always set @type_prefixing to %FALSE. Whether the pool will support type-prefixed property names. a newly allocated #GParamSpecPool. Removes a #GParamSpec from the pool. a #GParamSpecPool the #GParamSpec to remove Increments the reference count of @pspec. a valid #GParamSpec the #GParamSpec that was passed into this function Convenience function to ref and sink a #GParamSpec. Since: 2.10 a valid #GParamSpec the #GParamSpec that was passed into this function Sets an opaque, named pointer on a #GParamSpec. The name is specified through a #GQuark (retrieved e.g. via g_quark_from_static_string()), and the pointer can be gotten back from the @pspec with g_param_spec_get_qdata(). Setting a previously set user data pointer, overrides (frees) the old pointer set, using %NULL as pointer essentially removes the data stored. the #GParamSpec to set store a user data pointer a #GQuark, naming the user data pointer an opaque user data pointer This function works like g_param_spec_set_qdata(), but in addition, a `void (*destroy) (gpointer)` function may be specified which is called with @data as argument when the @pspec is finalized, or the data is being overwritten by a call to g_param_spec_set_qdata() with the same @quark. the #GParamSpec to set store a user data pointer a #GQuark, naming the user data pointer an opaque user data pointer function to invoke with @data as argument, when @data needs to be freed The initial reference count of a newly created #GParamSpec is 1, even though no one has explicitly called g_param_spec_ref() on it yet. So the initial reference count is flagged as "floating", until someone calls `g_param_spec_ref (pspec); g_param_spec_sink (pspec);` in sequence on it, taking over the initial reference count (thus ending up with a @pspec that has a reference count of 1 still, but is not flagged "floating" anymore). a valid #GParamSpec Gets back user data pointers stored via g_param_spec_set_qdata() and removes the @data from @pspec without invoking its destroy() function (if any was set). Usually, calling this function is only required to update user data pointers with a destroy notifier. the #GParamSpec to get a stored user data pointer from a #GQuark, naming the user data pointer the user data pointer set, or %NULL Creates a new #GParamSpecString instance. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property. canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64 property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG property. See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified minimum value for the property specified maximum value for the property specified default value for the property specified flags for the property specified a newly created parameter specification Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT property. #GValue structures for this property can be accessed with g_value_set_uint() and g_value_get_uint(). See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified default value for the property specified flags for the property specified a newly created parameter specification Decrements the reference count of a @pspec. a valid #GParamSpec Creates a new #GParamSpecValueArray instance specifying a %G_TYPE_VALUE_ARRAY property. %G_TYPE_VALUE_ARRAY is a %G_TYPE_BOXED type, as such, #GValue structures for this property can be accessed with g_value_set_boxed() and g_value_get_boxed(). See g_param_spec_internal() for details on property names. canonical name of the property specified nick name for the property specified description of the property specified a #GParamSpec describing the elements contained in arrays of this property, may be %NULL flags for the property specified a newly created parameter specification Creates a new #GParamSpecVariant instance specifying a #GVariant property. If @default_value is floating, it is consumed. See g_param_spec_internal() for details on property names. Since: 2.26 canonical name of the property specified nick name for the property specified description of the property specified a #GVariantType a #GVariant of type @type to use as the default value, or %NULL flags for the property specified the newly created #GParamSpec Registers @name as the name of a new static type derived from #G_TYPE_PARAM. The type system uses the information contained in the #GParamSpecTypeInfo structure pointed to by @info to manage the #GParamSpec type and its instances. 0-terminated string used as the name of the new #GParamSpec type. The #GParamSpecTypeInfo for this #GParamSpec type. The new type identifier. Transforms @src_value into @dest_value if possible, and then validates @dest_value, in order for it to conform to @pspec. If @strict_validation is %TRUE this function will only succeed if the transformed @dest_value complied to @pspec without modifications. See also g_value_type_transformable(), g_value_transform() and g_param_value_validate(). a valid #GParamSpec souce #GValue destination #GValue of correct type for @pspec %TRUE requires @dest_value to conform to @pspec without modifications %TRUE if transformation and validation were successful, %FALSE otherwise and @dest_value is left untouched. Checks whether @value contains the default value as specified in @pspec. a valid #GParamSpec a #GValue of correct type for @pspec whether @value contains the canonical default for this @pspec Sets @value to its default value as specified in @pspec. a valid #GParamSpec a #GValue of correct type for @pspec Ensures that the contents of @value comply with the specifications set out by @pspec. For example, a #GParamSpecInt might require that integers stored in @value may not be smaller than -42 and not be greater than +42. If @value contains an integer outside of this range, it is modified accordingly, so the resulting value will fit into the range -42 .. +42. a valid #GParamSpec a #GValue of correct type for @pspec whether modifying @value was necessary to ensure validity Compares @value1 with @value2 according to @pspec, and return -1, 0 or +1, if @value1 is found to be less than, equal to or greater than @value2, respectively. a valid #GParamSpec a #GValue of correct type for @pspec a #GValue of correct type for @pspec -1, 0 or +1, for a less than, equal to or greater than result Parses a string containing debugging options into a %guint containing bit flags. This is used within GDK and GTK+ to parse the debug options passed on the command line or through environment variables. If @string is equal to "all", all flags are set. Any flags specified along with "all" in @string are inverted; thus, "all,foo,bar" or "foo,bar,all" sets all flags except those corresponding to "foo" and "bar". If @string is equal to "help", all the available keys in @keys are printed out to standard error. a list of debug options separated by colons, spaces, or commas, or %NULL. pointer to an array of #GDebugKey which associate strings with bit flags. the number of #GDebugKeys in the array. the combined set of bit flags. Gets the last component of the filename. If @file_name ends with a directory separator it gets the component before the last slash. If @file_name consists only of directory separators (and on Windows, possibly a drive letter), a single separator is returned. If @file_name is empty, it gets ".". the name of the file a newly allocated string containing the last component of the filename Gets the directory components of a file name. If the file name has no directory components "." is returned. The returned string should be freed when no longer needed. the name of the file the directory components of the file Returns %TRUE if the given @file_name is an absolute file name. Note that this is a somewhat vague concept on Windows. On POSIX systems, an absolute file name is well-defined. It always starts from the single root directory. For example "/usr/local". On Windows, the concepts of current drive and drive-specific current directory introduce vagueness. This function interprets as an absolute file name one that either begins with a directory separator such as "\Users\tml" or begins with the root on a drive, for example "C:\Windows". The first case also includes UNC paths such as "\\myserver\docs\foo". In all cases, either slashes or backslashes are accepted. Note that a file name relative to the current drive root does not truly specify a file uniquely over time and across processes, as the current drive is a per-process value and can be changed. File names relative the current directory on some specific drive, such as "D:foo/bar", are not interpreted as absolute by this function, but they obviously are not relative to the normal current directory as returned by getcwd() or g_get_current_dir() either. Such paths should be avoided, or need to be handled using Windows-specific code. a file name %TRUE if @file_name is absolute 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. a file name a pointer into @file_name after the root component Matches a string against a compiled pattern. Passing the correct length of the string given is mandatory. The reversed string can be omitted by passing %NULL, this is more efficient if the reversed version of the string to be matched is not at hand, as g_pattern_match() will only construct it if the compiled pattern requires reverse matches. Note that, if the user code will (possibly) match a string against a multitude of patterns containing wildcards, chances are high that some patterns will require a reversed string. In this case, it's more efficient to provide the reversed string to avoid multiple constructions thereof in the various calls to g_pattern_match(). Note also that the reverse of a UTF-8 encoded string can in general not be obtained by g_strreverse(). This works only if the string does not contain any multibyte characters. GLib offers the g_utf8_strreverse() function to reverse UTF-8 encoded strings. a #GPatternSpec the length of @string (in bytes, i.e. strlen(), not g_utf8_strlen()) the UTF-8 encoded string to match the reverse of @string or %NULL %TRUE if @string matches @pspec Matches a string against a pattern given as a string. If this function is to be called in a loop, it's more efficient to compile the pattern once with g_pattern_spec_new() and call g_pattern_match_string() repeatedly. the UTF-8 encoded pattern the UTF-8 encoded string to match %TRUE if @string matches @pspec Matches a string against a compiled pattern. If the string is to be matched against more than one pattern, consider using g_pattern_match() instead while supplying the reversed string. a #GPatternSpec the UTF-8 encoded string to match %TRUE if @string matches @pspec Compares two compiled pattern specs and returns whether they will match the same set of strings. a #GPatternSpec another #GPatternSpec Whether the compiled patterns are equal Frees the memory allocated for the #GPatternSpec. a #GPatternSpec Compiles a pattern to a #GPatternSpec. a zero-terminated UTF-8 encoded string a newly-allocated #GPatternSpec This is equivalent to g_bit_lock, but working on pointers (or other pointer-sized values). For portability reasons, you may only lock on the bottom 32 bits of the pointer. Since: 2.30 a pointer to a #gpointer-sized value a bit value between 0 and 31 This is equivalent to g_bit_trylock, but working on pointers (or other pointer-sized values). For portability reasons, you may only lock on the bottom 32 bits of the pointer. Since: 2.30 a pointer to a #gpointer-sized value a bit value between 0 and 31 %TRUE if the lock was acquired This is equivalent to g_bit_unlock, but working on pointers (or other pointer-sized values). For portability reasons, you may only lock on the bottom 32 bits of the pointer. Since: 2.30 a pointer to a #gpointer-sized value a bit value between 0 and 31 Creates a new %G_TYPE_POINTER derived type id for a new pointer type with name @name. the name of the new pointer type. a new %G_TYPE_POINTER derived type id for @name. 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. Each element of @fds is a #GPollFD describing a single file descriptor to poll. The %fd field indicates the file descriptor, and the %events field indicates the events to poll for. On return, the %revents fields will be filled with the events that actually occurred. On POSIX systems, the file descriptors in @fds can be any sort of file descriptor, but the situation is much more complicated on Windows. If you need to use g_poll() in code that has to run on Windows, the easiest solution is to construct all of your #GPollFDs with g_io_channel_win32_make_pollfd(). Since: 2.20 file descriptors to poll the number of file descriptors in @fds amount of time to wait, in milliseconds, or -1 to wait forever the number of entries in @fds whose %revents fields were filled in, or 0 if the operation timed out, or -1 on error or if the call was interrupted. Formats a string according to @format and prefix it to an existing error message. If @err is %NULL (ie: no error variable) then do nothing. If *@err is %NULL (ie: an error variable is present but there is no error condition) then also do nothing. Whether or not it makes sense to take advantage of this feature is up to you. Since: 2.16 a return location for a #GError, or %NULL printf()-style format string arguments to @format Outputs a formatted message via the print handler. The default print handler simply outputs the message to stdout, without appending a trailing new-line character. Typically, @format should end with its own new-line character. g_print() should not be used from within libraries for debugging messages, since it may be redirected by applications to special purpose message windows or even files. Instead, libraries should use g_log(), or the convenience functions g_message(), g_warning() and g_error(). the message format. See the printf() documentation the parameters to insert into the format string Outputs a formatted message via the error message handler. The default handler simply outputs the message to stderr, without appending a trailing new-line character. Typically, @format should end with its own new-line character. g_printerr() should not be used from within libraries. Instead g_log() should be used, or the convenience functions g_message(), g_warning() and g_error(). the message format. See the printf() documentation the parameters to insert into the format string An implementation of the standard printf() function which supports positional parameters, as specified in the Single Unix Specification. As with the standard printf(), this does not automatically append a trailing new-line character to the message, so typically @format should end with its own new-line character. Since: 2.2 a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output. the number of bytes printed. Calculates the maximum space needed to store the output of the sprintf() function. the format string. See the printf() documentation the parameters to be inserted into the format string the maximum space needed to store the formatted string Returns the current value of the thread local variable @key. If the value has not yet been set in this thread, %NULL is returned. Values are never copied between threads (when a new thread is created, for example). a #GPrivate the thread-local value Creates a new #GPrivate. Deprecated:2.32: dynamic allocation of #GPrivate is a bad idea. Use static storage and G_PRIVATE_INIT() instead. a #GDestroyNotify a newly allocated #GPrivate (which can never be destroyed) Sets the thread local variable @key to have the value @value in the current thread. This function differs from g_private_set() in the following way: if the previous value was non-%NULL then the #GDestroyNotify handler for @key is run on it. Since: 2.32 a #GPrivate the new value Sets the thread local variable @key to have the value @value in the current thread. This function differs from g_private_replace() in the following way: the #GDestroyNotify for @key is not called on the old value. a #GPrivate the new value If @dest is %NULL, free @src; otherwise, moves @src into *@dest. The error variable @dest points to must be %NULL. Note that @src is no longer valid after this call. If you want to keep using the same GError*, you need to set it to %NULL after calling this function on it. error return location error to move into the return location If @dest is %NULL, free @src; otherwise, moves @src into *@dest. *@dest must be %NULL. After the move, add a prefix as with g_prefix_error(). Since: 2.16 error return location error to move into the return location printf()-style format string arguments to @format Adds a pointer to the end of the pointer array. The array will grow in size automatically if necessary. a #GPtrArray the pointer to add Calls a function for each element of a #GPtrArray. Since: 2.4 a #GPtrArray the function to call for each array element user data to pass to the function Frees the memory allocated for the #GPtrArray. If @free_seg is %TRUE it frees the memory block holding the elements as well. Pass %FALSE if you want to free the #GPtrArray wrapper but preserve the underlying array for use elsewhere. If the reference count of @array is greater than one, the #GPtrArray wrapper is preserved but the size of @array will be set to zero. If array contents point to dynamically-allocated memory, they should be freed separately if @free_seg is %TRUE and no #GDestroyNotify function has been set for @array. a #GPtrArray if %TRUE the actual pointer array is freed as well the pointer array if @free_seg is %FALSE, otherwise %NULL. The pointer array should be freed using g_free(). Returns the pointer at the given index of the pointer array. This does not perform bounds checking on the given @index_, so you are responsible for checking it against the array length. a #GPtrArray the index of the pointer to return the pointer at the given index Inserts an element into the pointer array at the given index. The array will grow in size automatically if necessary. Since: 2.40 a #GPtrArray the index to place the new element at, or -1 to append the pointer to add. Creates a new #GPtrArray with a reference count of 1. the new #GPtrArray Creates a new #GPtrArray with @reserved_size pointers preallocated and a reference count of 1. This avoids frequent reallocation, if you are going to add many pointers to the array. Note however that the size of the array is still 0. It also set @element_free_func for freeing each element when the array is destroyed either via g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment set to %TRUE or when removing elements. Since: 2.30 number of pointers preallocated A function to free elements with destroy @array or %NULL A new #GPtrArray Creates a new #GPtrArray with a reference count of 1 and use @element_free_func for freeing each element when the array is destroyed either via g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment set to %TRUE or when removing elements. Since: 2.22 A function to free elements with destroy @array or %NULL A new #GPtrArray Atomically increments the reference count of @array by one. This function is thread-safe and may be called from any thread. Since: 2.22 a #GPtrArray The passed in #GPtrArray Removes the first occurrence of the given pointer from the pointer array. The following elements are moved down one place. If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. It returns %TRUE if the pointer was removed, or %FALSE if the pointer was not found. a #GPtrArray the pointer to remove %TRUE if the pointer is removed, %FALSE if the pointer is not found in the array Removes the first occurrence of the given pointer from the pointer array. The last element in the array is used to fill in the space, so this function does not preserve the order of the array. But it is faster than g_ptr_array_remove(). If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. It returns %TRUE if the pointer was removed, or %FALSE if the pointer was not found. a #GPtrArray the pointer to remove %TRUE if the pointer was found in the array Removes the pointer at the given index from the pointer array. The following elements are moved down one place. If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. a #GPtrArray the index of the pointer to remove the pointer which was removed Removes the pointer at the given index from the pointer array. The last element in the array is used to fill in the space, so this function does not preserve the order of the array. But it is faster than g_ptr_array_remove_index(). If @array has a non-%NULL #GDestroyNotify function it is called for the removed element. a #GPtrArray the index of the pointer to remove the pointer which was removed Removes the given number of pointers starting at the given index from a #GPtrArray. The following elements are moved to close the gap. If @array has a non-%NULL #GDestroyNotify function it is called for the removed elements. Since: 2.4 a @GPtrArray the index of the first pointer to remove the number of pointers to remove the @array Sets a function for freeing each element when @array is destroyed either via g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment set to %TRUE or when removing elements. Since: 2.22 A #GPtrArray A function to free elements with destroy @array or %NULL Sets the size of the array. When making the array larger, newly-added elements will be set to %NULL. When making it smaller, if @array has a non-%NULL #GDestroyNotify function then it will be called for the removed elements. a #GPtrArray the new length of the pointer array Creates a new #GPtrArray with @reserved_size pointers preallocated and a reference count of 1. This avoids frequent reallocation, if you are going to add many pointers to the array. Note however that the size of the array is still 0. number of pointers preallocated the new #GPtrArray Sorts the array, using @compare_func which should be a qsort()-style comparison function (returns less than zero for first arg is less than second arg, zero for equal, greater than zero if irst arg is greater than second arg). Note that the comparison function for g_ptr_array_sort() doesn't take the pointers from the array as arguments, it takes pointers to the pointers in the array. This is guaranteed to be a stable sort since version 2.32. a #GPtrArray comparison function Like g_ptr_array_sort(), but the comparison function has an extra user data argument. Note that the comparison function for g_ptr_array_sort_with_data() doesn't take the pointers from the array as arguments, it takes pointers to the pointers in the array. This is guaranteed to be a stable sort since version 2.32. a #GPtrArray comparison function data to pass to @compare_func Atomically decrements the reference count of @array by one. If the reference count drops to 0, the effect is the same as calling g_ptr_array_free() with @free_segment set to %TRUE. This function is MT-safe and may be called from any thread. Since: 2.22 A #GPtrArray This is just like the standard C qsort() function, but the comparison routine accepts a user data argument. This is guaranteed to be a stable sort since version 2.32. start of array to sort elements in the array size of each element function to compare elements data to pass to @compare_func 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. Note that this function is identical to g_quark_from_string() except that if a new #GQuark is created the string itself is used rather than a copy. This saves memory, but can only be used if the string will continue to exist until the program terminates. It can be used with statically allocated strings in the main program, but not with statically allocated memory in dynamically loaded modules, if you expect to ever unload the module again (e.g. do not use this function in GTK+ theme engines). a string the #GQuark identifying the string, or 0 if @string is %NULL 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. a string the #GQuark identifying the string, or 0 if @string is %NULL Gets the string associated with the given #GQuark. a #GQuark. the string associated with the #GQuark Gets the #GQuark associated with the given string, or 0 if string is %NULL or it has no associated #GQuark. If you want the GQuark to be created if it doesn't already exist, use g_quark_from_string() or g_quark_from_static_string(). a string the #GQuark associated with the string, or 0 if @string is %NULL or there is no #GQuark associated with it Removes all the elements in @queue. If queue elements contain dynamically-allocated memory, they should be freed first. Since: 2.14 a #GQueue Copies a @queue. Note that is a shallow copy. If the elements in the queue consist of pointers to data, the pointers are copied, but the actual data is not. Since: 2.4 a #GQueue a copy of @queue Removes @link_ from @queue and frees it. @link_ must be part of @queue. Since: 2.4 a #GQueue a #GList link that must be part of @queue Finds the first link in @queue which contains @data. Since: 2.4 a #GQueue data to find the first link in @queue which contains @data Finds an element in a #GQueue, using a supplied function to find the desired element. It iterates over the queue, calling the given function which should return 0 when the desired element is found. The function takes two gconstpointer arguments, the #GQueue element's data as the first argument and the given user data as the second argument. Since: 2.4 a #GQueue user data passed to @func a #GCompareFunc to call for each element. It should return 0 when the desired element is found the found link, or %NULL if it wasn't found Calls @func for each element in the queue passing @user_data to the function. Since: 2.4 a #GQueue the function to call for each element's data user data to pass to @func Frees the memory allocated for the #GQueue. Only call this function if @queue was created with g_queue_new(). If queue elements contain dynamically-allocated memory, they should be freed first. If queue elements contain dynamically-allocated memory, you should either use g_queue_free_full() or free them manually first. a #GQueue Convenience method, which frees all the memory used by a #GQueue, and calls the specified destroy function on every element's data. Since: 2.32 a pointer to a #GQueue the function to be called to free each element's data Returns the number of items in @queue. Since: 2.4 a #GQueue the number of items in @queue Returns the position of the first element in @queue which contains @data. Since: 2.4 a #GQueue the data to find the position of the first element in @queue which contains @data, or -1 if no element in @queue contains @data A statically-allocated #GQueue must be initialized with this function before it can be used. Alternatively you can initialize it with #G_QUEUE_INIT. It is not necessary to initialize queues created with g_queue_new(). Since: 2.14 an uninitialized #GQueue Inserts @data into @queue after @sibling. @sibling must be part of @queue. Since GLib 2.44 a %NULL sibling pushes the data at the head of the queue. Since: 2.4 a #GQueue a #GList link that must be part of @queue, or %NULL to push at the head of the queue. the data to insert Inserts @data into @queue before @sibling. @sibling must be part of @queue. Since GLib 2.44 a %NULL sibling pushes the data at the tail of the queue. Since: 2.4 a #GQueue a #GList link that must be part of @queue, or %NULL to push at the tail of the queue. the data to insert Inserts @data into @queue using @func to determine the new position. Since: 2.4 a #GQueue the data to insert the #GCompareDataFunc used to compare elements in the queue. It is called with two elements of the @queue and @user_data. It should return 0 if the elements are equal, a negative value if the first element comes before the second, and a positive value if the second element comes before the first. user data passed to @func Returns %TRUE if the queue is empty. a #GQueue. %TRUE if the queue is empty Returns the position of @link_ in @queue. Since: 2.4 a #GQueue a #GList link the position of @link_, or -1 if the link is not part of @queue Creates a new #GQueue. a newly allocated #GQueue Returns the first element of the queue. a #GQueue the data of the first element in the queue, or %NULL if the queue is empty Returns the first link in @queue. Since: 2.4 a #GQueue the first link in @queue, or %NULL if @queue is empty Returns the @n'th element of @queue. Since: 2.4 a #GQueue the position of the element the data for the @n'th element of @queue, or %NULL if @n is off the end of @queue Returns the link at the given position Since: 2.4 a #GQueue the position of the link the link at the @n'th position, or %NULL if @n is off the end of the list Returns the last element of the queue. a #GQueue the data of the last element in the queue, or %NULL if the queue is empty Returns the last link in @queue. Since: 2.4 a #GQueue the last link in @queue, or %NULL if @queue is empty Removes the first element of the queue and returns its data. a #GQueue the data of the first element in the queue, or %NULL if the queue is empty Removes and returns the first element of the queue. a #GQueue the #GList element at the head of the queue, or %NULL if the queue is empty Removes the @n'th element of @queue and returns its data. Since: 2.4 a #GQueue the position of the element the element's data, or %NULL if @n is off the end of @queue Removes and returns the link at the given position. Since: 2.4 a #GQueue the link's position the @n'th link, or %NULL if @n is off the end of @queue Removes the last element of the queue and returns its data. a #GQueue the data of the last element in the queue, or %NULL if the queue is empty Removes and returns the last element of the queue. a #GQueue the #GList element at the tail of the queue, or %NULL if the queue is empty Adds a new element at the head of the queue. a #GQueue. the data for the new element. Adds a new element at the head of the queue. a #GQueue a single #GList element, not a list with more than one element Inserts a new element into @queue at the given position. Since: 2.4 a #GQueue the data for the new element the position to insert the new element. If @n is negative or larger than the number of elements in the @queue, the element is added to the end of the queue. Inserts @link into @queue at the given position. Since: 2.4 a #GQueue the position to insert the link. If this is negative or larger than the number of elements in @queue, the link is added to the end of @queue. the link to add to @queue Adds a new element at the tail of the queue. a #GQueue the data for the new element Adds a new element at the tail of the queue. a #GQueue a single #GList element, not a list with more than one element Removes the first element in @queue that contains @data. Since: 2.4 a #GQueue the data to remove %TRUE if @data was found and removed from @queue Remove all elements whose data equals @data from @queue. Since: 2.4 a #GQueue the data to remove the number of elements removed from @queue Reverses the order of the items in @queue. Since: 2.4 a #GQueue Sorts @queue using @compare_func. Since: 2.4 a #GQueue the #GCompareDataFunc used to sort @queue. This function is passed two elements of the queue and should return 0 if they are equal, a negative value if the first comes before the second, and a positive value if the second comes before the first. user data passed to @compare_func Unlinks @link_ so that it will no longer be part of @queue. The link is not freed. @link_ must be part of @queue. Since: 2.4 a #GQueue a #GList link that must be part of @queue Returns a random #gboolean from @rand_. This corresponds to a unbiased coin toss. a #GRand a random #gboolean Copies a #GRand into a new one with the same exact state as before. This way you can take a snapshot of the random number generator for replaying later. Since: 2.4 a #GRand the new #GRand Returns the next random #gdouble from @rand_ equally distributed over the range [0..1). a #GRand a random number Returns the next random #gdouble from @rand_ equally distributed over the range [@begin..@end). a #GRand lower closed bound of the interval upper open bound of the interval a random number Frees the memory allocated for the #GRand. a #GRand Returns the next random #guint32 from @rand_ equally distributed over the range [0..2^32-1]. a #GRand a random number Returns the next random #gint32 from @rand_ equally distributed over the range [@begin..@end-1]. a #GRand lower closed bound of the interval upper open bound of the interval a random number Creates a new random number generator initialized with a seed taken either from `/dev/urandom` (if existing) or from the current time (as a fallback). On Windows, the seed is taken from rand_s(). the new #GRand Creates a new random number generator initialized with @seed. a value to initialize the random number generator the new #GRand Creates a new random number generator initialized with @seed. Since: 2.4 an array of seeds to initialize the random number generator an array of seeds to initialize the random number generator the new #GRand Sets the seed for the random number generator #GRand to @seed. a #GRand a value to reinitialize the random number generator Initializes the random number generator by an array of longs. Array can be of arbitrary size, though only the first 624 values are taken. This function is useful if you have many low entropy seeds, or if you require more then 32 bits of actual entropy for your application. Since: 2.4 a #GRand array to initialize with length of array Returns a random #gboolean. This corresponds to a unbiased coin toss. a random #gboolean Returns a random #gdouble equally distributed over the range [0..1). a random number Returns a random #gdouble equally distributed over the range [@begin..@end). lower closed bound of the interval upper open bound of the interval a random number Return a random #guint32 equally distributed over the range [0..2^32-1]. a random number Returns a random #gint32 equally distributed over the range [@begin..@end-1]. lower closed bound of the interval upper open bound of the interval a random number Sets the seed for the global random number generator, which is used by the g_random_* functions, to @seed. a value to reinitialize the global random number generator Reallocates the memory pointed to by @mem, so that it now has space for @n_bytes bytes of memory. It returns the new address of the memory, which may have been moved. @mem may be %NULL, in which case it's considered to have zero-length. @n_bytes may be 0, in which case %NULL will be returned and @mem will be freed unless it is %NULL. the memory to reallocate new size of the memory in bytes the new address of the allocated memory This function is similar to g_realloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. Since: 2.24 the memory to reallocate the number of blocks to allocate the size of each block in bytes the new address of the allocated memory Frees the resources allocated to a recursive mutex with g_rec_mutex_init(). This function should not be used with a #GRecMutex that has been statically allocated. Calling g_rec_mutex_clear() on a locked recursive mutex leads to undefined behaviour. Sine: 2.32 an initialized #GRecMutex Initializes a #GRecMutex so that it can be used. This function is useful to initialize a recursive mutex that has been allocated on the stack, or as part of a larger structure. It is not necessary to initialise a recursive mutex that has been statically allocated. |[<!-- language="C" --> typedef struct { GRecMutex m; ... } Blob; Blob *b; b = g_new (Blob, 1); g_rec_mutex_init (&b->m); ]| Calling g_rec_mutex_init() on an already initialized #GRecMutex leads to undefined behaviour. To undo the effect of g_rec_mutex_init() when a recursive mutex is no longer needed, use g_rec_mutex_clear(). Since: 2.32 an uninitialized #GRecMutex Locks @rec_mutex. If @rec_mutex is already locked by another thread, the current thread will block until @rec_mutex is unlocked by the other thread. If @rec_mutex is already locked by the current thread, the 'lock count' of @rec_mutex is increased. The mutex will only become available again when it is unlocked as many times as it has been locked. Since: 2.32 a #GRecMutex Tries to lock @rec_mutex. If @rec_mutex is already locked by another thread, it immediately returns %FALSE. Otherwise it locks @rec_mutex and returns %TRUE. Since: 2.32 a #GRecMutex %TRUE if @rec_mutex could be locked Unlocks @rec_mutex. If another thread is blocked in a g_rec_mutex_lock() call for @rec_mutex, it will become unblocked and can lock @rec_mutex itself. Calling g_rec_mutex_unlock() on a recursive mutex that is not locked by the current thread leads to undefined behaviour. Since: 2.32 a #GRecMutex Checks whether @replacement is a valid replacement string (see g_regex_replace()), i.e. that all escape sequences in it are valid. If @has_references is not %NULL then @replacement is checked for pattern references. For instance, replacement text 'foo\n' does not contain references and may be evaluated without information about actual match, but '\0\1' (whole match followed by first subpattern) requires valid #GMatchInfo object. Since: 2.14 the replacement string location to store information about references in @replacement or %NULL location to store error whether @replacement is a valid replacement string Escapes the nul characters in @string to "\x00". It can be used to compile a regex with embedded nul characters. For completeness, @length can be -1 for a nul-terminated string. In this case the output string will be of course equal to @string. Since: 2.30 the string to escape the length of @string a newly-allocated escaped 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. @string can contain nul characters that are replaced with "\0", in this case remember to specify the correct length of @string in @length. Since: 2.14 the string to escape the length of @string, or -1 if @string is nul-terminated a newly-allocated escaped string Returns the number of capturing subpatterns in the pattern. Since: 2.14 a #GRegex the number of capturing subpatterns Returns the compile options that @regex was created with. Since: 2.26 a #GRegex flags from #GRegexCompileFlags Checks whether the pattern contains explicit CR or LF references. Since: 2.34 a #GRegex structure %TRUE if the pattern contains explicit CR or LF references Returns the match options that @regex was created with. Since: 2.26 a #GRegex flags from #GRegexMatchFlags Returns the number of the highest back reference in the pattern, or 0 if the pattern does not contain back references. Since: 2.14 a #GRegex the number of the highest back reference Gets the number of characters in the longest lookbehind assertion in the pattern. This information is useful when doing multi-segment matching using the partial matching facilities. Since: 2.38 a #GRegex structure the number of characters in the longest lookbehind assertion. Gets the pattern string associated with @regex, i.e. a copy of the string passed to g_regex_new(). Since: 2.14 a #GRegex structure the pattern of @regex Retrieves the number of the subexpression named @name. Since: 2.14 #GRegex structure name of the subexpression The number of the subexpression or -1 if @name does not exists Scans for a match in string for the pattern in @regex. The @match_options are combined with the match options specified when the @regex structure was created, letting you have more flexibility in reusing #GRegex structures. A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. To retrieve all the non-overlapping matches of the pattern in string you can use g_match_info_next(). |[<!-- language="C" --> static void print_uppercase_words (const gchar *string) { // Print all uppercase-only words. GRegex *regex; GMatchInfo *match_info; regex = g_regex_new ("[A-Z]+", 0, 0, NULL); g_regex_match (regex, string, 0, &match_info); while (g_match_info_matches (match_info)) { gchar *word = g_match_info_fetch (match_info, 0); g_print ("Found: %s\n", word); g_free (word); g_match_info_next (match_info, NULL); } g_match_info_free (match_info); g_regex_unref (regex); } ]| @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined. Since: 2.14 a #GRegex structure from g_regex_new() the string to scan for matches match options pointer to location where to store the #GMatchInfo, or %NULL if you do not need it %TRUE is the string matched, %FALSE otherwise Using the standard algorithm for regular expression matching only the longest match in the string is retrieved. This function uses a different algorithm so it can retrieve all the possible matches. For more documentation see g_regex_match_all_full(). A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined. Since: 2.14 a #GRegex structure from g_regex_new() the string to scan for matches match options pointer to location where to store the #GMatchInfo, or %NULL if you do not need it %TRUE is the string matched, %FALSE otherwise Using the standard algorithm for regular expression matching only the longest match in the string is retrieved, it is not possible to obtain all the available matches. For instance matching "<a> <b> <c>" against the pattern "<.*>" you get "<a> <b> <c>". This function uses a different algorithm (called DFA, i.e. deterministic finite automaton), so it can retrieve all the possible matches, all starting at the same point in the string. For instance matching "<a> <b> <c>" against the pattern "<.*>;" you would obtain three matches: "<a> <b> <c>", "<a> <b>" and "<a>". The number of matched strings is retrieved using g_match_info_get_match_count(). To obtain the matched strings and their position you can use, respectively, g_match_info_fetch() and g_match_info_fetch_pos(). Note that the strings are returned in reverse order of length; that is, the longest matching string is given first. Note that the DFA algorithm is slower than the standard one and it is not able to capture substrings, so backreferences do not work. Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined. Since: 2.14 a #GRegex structure from g_regex_new() the string to scan for matches the length of @string, or -1 if @string is nul-terminated starting index of the string to match match options pointer to location where to store the #GMatchInfo, or %NULL if you do not need it location to store the error occurring, or %NULL to ignore errors %TRUE is the string matched, %FALSE otherwise Scans for a match in string for the pattern in @regex. The @match_options are combined with the match options specified when the @regex structure was created, letting you have more flexibility in reusing #GRegex structures. Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". A #GMatchInfo structure, used to get information on the match, is stored in @match_info if not %NULL. Note that if @match_info is not %NULL then it is created even if the function returns %FALSE, i.e. you must free it regardless if regular expression actually matched. @string is not copied and is used in #GMatchInfo internally. If you use any #GMatchInfo method (except g_match_info_free()) after freeing or modifying @string then the behaviour is undefined. To retrieve all the non-overlapping matches of the pattern in string you can use g_match_info_next(). |[<!-- language="C" --> static void print_uppercase_words (const gchar *string) { // Print all uppercase-only words. GRegex *regex; GMatchInfo *match_info; GError *error = NULL; regex = g_regex_new ("[A-Z]+", 0, 0, NULL); g_regex_match_full (regex, string, -1, 0, 0, &match_info, &error); while (g_match_info_matches (match_info)) { gchar *word = g_match_info_fetch (match_info, 0); g_print ("Found: %s\n", word); g_free (word); g_match_info_next (match_info, &error); } g_match_info_free (match_info); g_regex_unref (regex); if (error != NULL) { g_printerr ("Error while matching: %s\n", error->message); g_error_free (error); } } ]| Since: 2.14 a #GRegex structure from g_regex_new() the string to scan for matches the length of @string, or -1 if @string is nul-terminated starting index of the string to match match options pointer to location where to store the #GMatchInfo, or %NULL if you do not need it location to store the error occurring, or %NULL to ignore errors %TRUE is the string matched, %FALSE otherwise Scans for a match in @string for @pattern. This function is equivalent to g_regex_match() but it does not require to compile the pattern with g_regex_new(), avoiding some lines of code when you need just to do a match without extracting substrings, capture counts, and so on. If this function is to be called on the same @pattern more than once, it's more efficient to compile the pattern once with g_regex_new() and then use g_regex_match(). Since: 2.14 the regular expression the string to scan for matches compile options for the regular expression, or 0 match options, or 0 %TRUE if the string matched, %FALSE otherwise Compiles the regular expression to an internal form, and does the initial setup of the #GRegex structure. Since: 2.14 the regular expression compile options for the regular expression, or 0 match options for the regular expression, or 0 return location for a #GError a #GRegex structure. Call g_regex_unref() when you are done with it Increases reference count of @regex by 1. Since: 2.14 a #GRegex @regex Replaces all occurrences of the pattern in @regex with the replacement text. Backreferences of the form '\number' or '\g<number>' in the replacement text are interpolated by the number-th captured subexpression of the match, '\g<name>' refers to the captured subexpression with the given name. '\0' refers to the complete match, but '\0' followed by a number is the octal representation of a character. To include a literal '\' in the replacement, write '\\'. There are also escapes that changes the case of the following text: - \l: Convert to lower case the next character - \u: Convert to upper case the next character - \L: Convert to lower case till \E - \U: Convert to upper case till \E - \E: End case modification If you do not need to use backreferences use g_regex_replace_literal(). The @replacement string must be UTF-8 encoded even if #G_REGEX_RAW was passed to g_regex_new(). If you want to use not UTF-8 encoded stings you can use g_regex_replace_literal(). Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". Since: 2.14 a #GRegex structure the string to perform matches against the length of @string, or -1 if @string is nul-terminated starting index of the string to match text to replace each match with options for the match location to store the error occurring, or %NULL to ignore errors a newly allocated string containing the replacements Replaces occurrences of the pattern in regex with the output of @eval for that occurrence. Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". The following example uses g_regex_replace_eval() to replace multiple strings at once: |[<!-- language="C" --> static gboolean eval_cb (const GMatchInfo *info, GString *res, gpointer data) { gchar *match; gchar *r; match = g_match_info_fetch (info, 0); r = g_hash_table_lookup ((GHashTable *)data, match); g_string_append (res, r); g_free (match); return FALSE; } ... GRegex *reg; GHashTable *h; gchar *res; h = g_hash_table_new (g_str_hash, g_str_equal); g_hash_table_insert (h, "1", "ONE"); g_hash_table_insert (h, "2", "TWO"); g_hash_table_insert (h, "3", "THREE"); g_hash_table_insert (h, "4", "FOUR"); reg = g_regex_new ("1|2|3|4", 0, 0, NULL); res = g_regex_replace_eval (reg, text, -1, 0, 0, eval_cb, h, NULL); g_hash_table_destroy (h); ... ]| Since: 2.14 a #GRegex structure from g_regex_new() string to perform matches against the length of @string, or -1 if @string is nul-terminated starting index of the string to match options for the match a function to call for each match user data to pass to the function location to store the error occurring, or %NULL to ignore errors a newly allocated string containing the replacements Replaces all occurrences of the pattern in @regex with the replacement text. @replacement is replaced literally, to include backreferences use g_regex_replace(). Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". Since: 2.14 a #GRegex structure the string to perform matches against the length of @string, or -1 if @string is nul-terminated starting index of the string to match text to replace each match with options for the match location to store the error occurring, or %NULL to ignore errors a newly allocated string containing the replacements 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. As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent a empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling this function. A pattern that can match empty strings splits @string into separate characters wherever it matches the empty string between characters. For example splitting "ab c" using as a separator "\s*", you will get "a", "b" and "c". Since: 2.14 a #GRegex structure the string to split with the pattern match time option flags a %NULL-terminated gchar ** array. Free it using g_strfreev() 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. As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent a empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling this function. A pattern that can match empty strings splits @string into separate characters wherever it matches the empty string between characters. For example splitting "ab c" using as a separator "\s*", you will get "a", "b" and "c". Setting @start_position differs from just passing over a shortened string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that begins with any kind of lookbehind assertion, such as "\b". Since: 2.14 a #GRegex structure the string to split with the pattern the length of @string, or -1 if @string is nul-terminated starting index of the string to match match time option flags the maximum number of tokens to split @string into. If this is less than 1, the string is split completely return location for a #GError a %NULL-terminated gchar ** array. Free it using g_strfreev() 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. This function is equivalent to g_regex_split() but it does not require to compile the pattern with g_regex_new(), avoiding some lines of code when you need just to do a split without extracting substrings, capture counts, and so on. If this function is to be called on the same @pattern more than once, it's more efficient to compile the pattern once with g_regex_new() and then use g_regex_split(). As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent a empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling this function. A pattern that can match empty strings splits @string into separate characters wherever it matches the empty string between characters. For example splitting "ab c" using as a separator "\s*", you will get "a", "b" and "c". Since: 2.14 the regular expression the string to scan for matches compile options for the regular expression, or 0 match options, or 0 a %NULL-terminated array of strings. Free it using g_strfreev() Decreases reference count of @regex by 1. When reference count drops to zero, it frees all the memory associated with the regex structure. Since: 2.14 a #GRegex Returns the number of tuples in a #GRelation that have the given value in the given field. Deprecated: 2.26: Rarely used API a #GRelation. the value to compare with. the field of each record to match. the number of matches. Deletes any records from a #GRelation that have the given key value in the given field. Deprecated: 2.26: Rarely used API a #GRelation. the value to compare with. the field of each record to match. the number of records deleted. Destroys the #GRelation, freeing all memory allocated. However, it does not free memory allocated for the tuple data, so you should free that first if appropriate. Deprecated: 2.26: Rarely used API a #GRelation. Returns %TRUE if a record with the given values exists in a #GRelation. Note that the values are compared directly, so that, for example, two copies of the same string will not match. Deprecated: 2.26: Rarely used API a #GRelation. the fields of the record to compare. The number must match the number of fields in the #GRelation. %TRUE if a record matches. Creates an index on the given field. Note that this must be called before any records are added to the #GRelation. Deprecated: 2.26: Rarely used API a #GRelation. the field to index, counting from 0. a function to produce a hash value from the field data. a function to compare two values of the given field. Inserts a record into a #GRelation. Deprecated: 2.26: Rarely used API a #GRelation. the fields of the record to add. These must match the number of fields in the #GRelation, and of type #gpointer or #gconstpointer. Creates a new #GRelation with the given number of fields. Note that currently the number of fields must be 2. Deprecated: 2.26: Rarely used API the number of fields. a new #GRelation. Outputs information about all records in a #GRelation, as well as the indexes. It is for debugging. Deprecated: 2.26: Rarely used API a #GRelation. Returns all of the tuples which have the given key in the given field. Use g_tuples_index() to access the returned records. The returned records should be freed with g_tuples_destroy(). Deprecated: 2.26: Rarely used API a #GRelation. the value to compare with. the field of each record to match. the records (tuples) that matched. 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. Due to threadsafety issues this may cause leaking of strings that were previously returned from g_get_user_special_dir() that can't be freed. We ensure to only leak the data for the directories that actually changed value though. Since: 2.22 A wrapper for the POSIX remove() function. The remove() function deletes a name from the filesystem. See your C library manual for more details about how remove() works on your system. On Unix, remove() removes also directories, as it calls unlink() for files and rmdir() for directories. On Windows, although remove() in the C library only works for files, this function tries first remove() and then if that fails rmdir(), and thus works for both files and directories. Note however, that on Windows, it is in general not possible to remove a file that is open to some process, or mapped into memory. If this function fails on Windows you can't infer too much from the errno value. rmdir() is tried regardless of what caused remove() to fail. Any errno value set by remove() will be overwritten by that set by rmdir(). Since: 2.6 a pathname in the GLib file name encoding (UTF-8 on Windows) 0 if the file was successfully removed, -1 if an error occurred A wrapper for the POSIX rename() function. The rename() function renames a file, moving it between directories if required. See your C library manual for more details about how rename() works on your system. It is not possible in general on Windows to rename a file that is open to some process. Since: 2.6 a pathname in the GLib file name encoding (UTF-8 on Windows) a pathname in the GLib file name encoding 0 if the renaming succeeded, -1 if an error occurred Reallocates the memory pointed to by @mem, so that it now has space for @n_structs elements of type @struct_type. It returns the new address of the memory, which may have been moved. Care is taken to avoid overflow when calculating the size of the allocated block. the type of the elements to allocate the currently allocated memory the number of elements to allocate a pointer to the new allocated memory, cast to a pointer to @struct_type Verifies that the expression @expr, usually representing a precondition, evaluates to %TRUE. If the function returns a value, use g_return_val_if_fail() instead. If @expr evaluates to %FALSE, the current function should be considered to have undefined behaviour (a programmer error). The only correct solution to such an error is to change the module that is calling the current function, so that it avoids this incorrect call. To make this undefined behaviour visible, if @expr evaluates to %FALSE, the result is usually that a critical message is logged and the current function returns. If G_DISABLE_CHECKS is defined then the check is not performed. You should therefore not depend on any side effects of @expr. the expression to check Logs a critical message and returns from the current function. This can only be used in functions which do not return a value. Verifies that the expression @expr, usually representing a precondition, evaluates to %TRUE. If the function does not return a value, use g_return_if_fail() instead. If @expr evaluates to %FALSE, the current function should be considered to have undefined behaviour (a programmer error). The only correct solution to such an error is to change the module that is calling the current function, so that it avoids this incorrect call. To make this undefined behaviour visible, if @expr evaluates to %FALSE, the result is usually that a critical message is logged and @val is returned from the current function. If G_DISABLE_CHECKS is defined then the check is not performed. You should therefore not depend on any side effects of @expr. the expression to check the value to return from the current function if the expression is not true Logs a critical message and returns @val. the value to return from the current function A wrapper for the POSIX rmdir() function. The rmdir() function deletes a directory from the filesystem. See your C library manual for more details about how rmdir() works on your system. Since: 2.6 a pathname in the GLib file name encoding (UTF-8 on Windows) 0 if the directory was successfully removed, -1 if an error occurred Frees the resources allocated to a lock with g_rw_lock_init(). This function should not be used with a #GRWLock that has been statically allocated. Calling g_rw_lock_clear() when any thread holds the lock leads to undefined behaviour. Sine: 2.32 an initialized #GRWLock Initializes a #GRWLock so that it can be used. This function is useful to initialize a lock that has been allocated on the stack, or as part of a larger structure. It is not necessary to initialise a reader-writer lock that has been statically allocated. |[<!-- language="C" --> typedef struct { GRWLock l; ... } Blob; Blob *b; b = g_new (Blob, 1); g_rw_lock_init (&b->l); ]| To undo the effect of g_rw_lock_init() when a lock is no longer needed, use g_rw_lock_clear(). Calling g_rw_lock_init() on an already initialized #GRWLock leads to undefined behaviour. Since: 2.32 an uninitialized #GRWLock Obtain a read lock on @rw_lock. If another thread currently holds the write lock on @rw_lock or blocks waiting for it, the current thread will block. Read locks can be taken recursively. It is implementation-defined how many threads are allowed to hold read locks on the same lock simultaneously. Since: 2.32 a #GRWLock Tries to obtain a read lock on @rw_lock and returns %TRUE if the read lock was successfully obtained. Otherwise it returns %FALSE. Since: 2.32 a #GRWLock %TRUE if @rw_lock could be locked Release a read lock on @rw_lock. Calling g_rw_lock_reader_unlock() on a lock that is not held by the current thread leads to undefined behaviour. Since: 2.32 a #GRWLock Obtain a write lock on @rw_lock. If any thread already holds a read or write lock on @rw_lock, the current thread will block until all other threads have dropped their locks on @rw_lock. Since: 2.32 a #GRWLock Tries to obtain a write lock on @rw_lock. If any other thread holds a read or write lock on @rw_lock, it immediately returns %FALSE. Otherwise it locks @rw_lock and returns %TRUE. Since: 2.32 a #GRWLock %TRUE if @rw_lock could be locked Release a write lock on @rw_lock. Calling g_rw_lock_writer_unlock() on a lock that is not held by the current thread leads to undefined behaviour. Since: 2.32 a #GRWLock Adds a symbol to the default scope. Deprecated: 2.2: Use g_scanner_scope_add_symbol() instead. a #GScanner the symbol to add the value of the symbol Returns the current line in the input stream (counting from 1). This is the line of the last token parsed via g_scanner_get_next_token(). a #GScanner the current line Returns the current position in the current line (counting from 0). This is the position of the last token parsed via g_scanner_get_next_token(). a #GScanner the current position on the line Gets the current token type. This is simply the @token field in the #GScanner structure. a #GScanner the current token type Gets the current token value. This is simply the @value field in the #GScanner structure. a #GScanner the current token value Frees all memory used by the #GScanner. a #GScanner Returns %TRUE if the scanner has reached the end of the file or text buffer. a #GScanner %TRUE if the scanner has reached the end of the file or text buffer Outputs an error message, via the #GScanner message handler. a #GScanner the message format. See the printf() documentation the parameters to insert into the format string Calls a function for each symbol in the default scope. Deprecated: 2.2: Use g_scanner_scope_foreach_symbol() instead. a #GScanner the function to call with each symbol data to pass to the function There is no reason to use this macro, since it does nothing. Deprecated: 2.2: This macro does nothing. a #GScanner Parses the next token just like g_scanner_peek_next_token() and also removes it from the input stream. The token data is placed in the @token, @value, @line, and @position fields of the #GScanner structure. a #GScanner the type of the token Prepares to scan a file. a #GScanner a file descriptor Prepares to scan a text buffer. a #GScanner the text buffer to scan the length of the text buffer Looks up a symbol in the current scope and return its value. If the symbol is not bound in the current scope, %NULL is returned. a #GScanner the symbol to look up the value of @symbol in the current scope, or %NULL if @symbol is not bound in the current scope Creates a new #GScanner. The @config_templ structure specifies the initial settings of the scanner, which are copied into the #GScanner @config field. If you pass %NULL then the default settings are used. the initial scanner settings the new #GScanner Parses the next token, without removing it from the input stream. The token data is placed in the @next_token, @next_value, @next_line, and @next_position fields of the #GScanner structure. Note that, while the token is not removed from the input stream (i.e. the next call to g_scanner_get_next_token() will return the same token), it will not be reevaluated. This can lead to surprising results when changing scope or the scanner configuration after peeking the next token. Getting the next token after switching the scope or configuration will return whatever was peeked before, regardless of any symbols that may have been added or removed in the new scope. a #GScanner the type of the token Removes a symbol from the default scope. Deprecated: 2.2: Use g_scanner_scope_remove_symbol() instead. a #GScanner the symbol to remove Adds a symbol to the given scope. a #GScanner the scope id the symbol to add the value of the symbol Calls the given function for each of the symbol/value pairs in the given scope of the #GScanner. The function is passed the symbol and value of each pair, and the given @user_data parameter. a #GScanner the scope id the function to call for each symbol/value pair user data to pass to the function Looks up a symbol in a scope and return its value. If the symbol is not bound in the scope, %NULL is returned. a #GScanner the scope id the symbol to look up the value of @symbol in the given scope, or %NULL if @symbol is not bound in the given scope. Removes a symbol from a scope. a #GScanner the scope id the symbol to remove Sets the current scope. a #GScanner the new scope id the old scope id Rewinds the filedescriptor to the current buffer position and blows the file read ahead buffer. This is useful for third party uses of the scanners filedescriptor, which hooks onto the current scanning position. a #GScanner There is no reason to use this macro, since it does nothing. Deprecated: 2.2: This macro does nothing. a #GScanner Outputs a message through the scanner's msg_handler, resulting from an unexpected token in the input stream. Note that you should not call g_scanner_peek_next_token() followed by g_scanner_unexp_token() without an intermediate call to g_scanner_get_next_token(), as g_scanner_unexp_token() evaluates the scanner's current token (not the peeked token) to construct part of the message. a #GScanner the expected token a string describing how the scanner's user refers to identifiers (%NULL defaults to "identifier"). This is used if @expected_token is %G_TOKEN_IDENTIFIER or %G_TOKEN_IDENTIFIER_NULL. a string describing how the scanner's user refers to symbols (%NULL defaults to "symbol"). This is used if @expected_token is %G_TOKEN_SYMBOL or any token value greater than %G_TOKEN_LAST. the name of the symbol, if the scanner's current token is a symbol. a message string to output at the end of the warning/error, or %NULL. if %TRUE it is output as an error. If %FALSE it is output as a warning. Outputs a warning message, via the #GScanner message handler. a #GScanner the message format. See the printf() documentation the parameters to insert into the format string Adds a new item to the end of @seq. Since: 2.14 a #GSequence the data for the new item an iterator pointing to the new item Calls @func for each item in the sequence passing @user_data to the function. Since: 2.14 a #GSequence the function to call for each item in @seq user data passed to @func Calls @func for each item in the range (@begin, @end) passing @user_data to the function. Since: 2.14 a #GSequenceIter a #GSequenceIter a #GFunc user data passed to @func Frees the memory allocated for @seq. If @seq has a data destroy function associated with it, that function is called on all items in @seq. Since: 2.14 a #GSequence Returns the data that @iter points to. Since: 2.14 a #GSequenceIter the data that @iter points to Returns the begin iterator for @seq. Since: 2.14 a #GSequence the begin iterator for @seq. Returns the end iterator for @seg Since: 2.14 a #GSequence the end iterator for @seq Returns the iterator at position @pos. If @pos is negative or larger than the number of items in @seq, the end iterator is returned. Since: 2.14 a #GSequence a position in @seq, or -1 for the end The #GSequenceIter at position @pos Returns the length of @seq Since: 2.14 a #GSequence the length of @seq Inserts a new item just before the item pointed to by @iter. Since: 2.14 a #GSequenceIter the data for the new item an iterator pointing to the new item Inserts @data into @sequence using @func to determine the new position. The sequence must already be sorted according to @cmp_func; otherwise the new position of @data is undefined. @cmp_func is called with two items of the @seq and @user_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first. Since: 2.14 a #GSequence the data to insert the function used to compare items in the sequence user data passed to @cmp_func. a #GSequenceIter pointing to the new item. Like g_sequence_insert_sorted(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. It is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. Since: 2.14 a #GSequence data for the new item the function used to compare iterators in the sequence user data passed to @cmp_func a #GSequenceIter pointing to the new item Returns a negative number if @a comes before @b, 0 if they are equal, and a positive number if @a comes after @b. The @a and @b iterators must point into the same sequence. Since: 2.14 a #GSequenceIter a #GSequenceIter a negative number if @a comes before @b, 0 if they are equal, and a positive number if @a comes after @b Returns the position of @iter Since: 2.14 a #GSequenceIter the position of @iter Returns the #GSequence that @iter points into. Since: 2.14 a #GSequenceIter the #GSequence that @iter points into Returns whether @iter is the begin iterator Since: 2.14 a #GSequenceIter whether @iter is the begin iterator Returns whether @iter is the end iterator Since: 2.14 a #GSequenceIter Whether @iter is the end iterator Returns the #GSequenceIter which is @delta positions away from @iter. If @iter is closer than -@delta positions to the beginning of the sequence, the begin iterator is returned. If @iter is closer than @delta positions to the end of the sequence, the end iterator is returned. Since: 2.14 a #GSequenceIter A positive or negative number indicating how many positions away from @iter the returned #GSequenceIter will be a #GSequenceIter which is @delta positions away from @iter Returns an iterator pointing to the next position after @iter. If @iter is the end iterator, the end iterator is returned. Since: 2.14 a #GSequenceIter a #GSequenceIter pointing to the next position after @iter Returns an iterator pointing to the previous position before @iter. If @iter is the begin iterator, the begin iterator is returned. Since: 2.14 a #GSequenceIter a #GSequenceIter pointing to the previous position before @iter Returns an iterator pointing to the position of the first item found equal to @data according to @cmp_func and @cmp_data. If more than one item is equal, it is not guaranteed that it is the first which is returned. In that case, you can use g_sequence_iter_next() and g_sequence_iter_prev() to get others. @cmp_func is called with two items of the @seq and @user_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first. This function will fail if the data contained in the sequence is unsorted. Use g_sequence_insert_sorted() or g_sequence_insert_sorted_iter() to add data to your sequence or, if you want to add a large amount of data, call g_sequence_sort() after doing unsorted insertions. Since: 2.28 a #GSequence data to lookup the function used to compare items in the sequence user data passed to @cmp_func an #GSequenceIter pointing to the position of the first item found equal to @data according to @cmp_func and @cmp_data, or %NULL if no such item exists Like g_sequence_lookup(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. This function will fail if the data contained in the sequence is unsorted. Use g_sequence_insert_sorted() or g_sequence_insert_sorted_iter() to add data to your sequence or, if you want to add a large amount of data, call g_sequence_sort() after doing unsorted insertions. Since: 2.28 a #GSequence data to lookup the function used to compare iterators in the sequence user data passed to @iter_cmp an #GSequenceIter pointing to the position of the first item found equal to @data according to @cmp_func and @cmp_data, or %NULL if no such item exists Moves the item pointed to by @src to the position indicated by @dest. After calling this function @dest will point to the position immediately after @src. It is allowed for @src and @dest to point into different sequences. Since: 2.14 a #GSequenceIter pointing to the item to move a #GSequenceIter pointing to the position to which the item is moved Inserts the (@begin, @end) range at the destination pointed to by ptr. The @begin and @end iters must point into the same sequence. It is allowed for @dest to point to a different sequence than the one pointed into by @begin and @end. If @dest is NULL, the range indicated by @begin and @end is removed from the sequence. If @dest iter points to a place within the (@begin, @end) range, the range does not move. Since: 2.14 a #GSequenceIter a #GSequenceIter a #GSequenceIter Creates a new GSequence. The @data_destroy function, if non-%NULL will be called on all items when the sequence is destroyed and on items that are removed from the sequence. Since: 2.14 a #GDestroyNotify function, or %NULL a new #GSequence Adds a new item to the front of @seq Since: 2.14 a #GSequence the data for the new item an iterator pointing to the new item Finds an iterator somewhere in the range (@begin, @end). This iterator will be close to the middle of the range, but is not guaranteed to be exactly in the middle. The @begin and @end iterators must both point to the same sequence and @begin must come before or be equal to @end in the sequence. Since: 2.14 a #GSequenceIter a #GSequenceIter a #GSequenceIter pointing somewhere in the (@begin, @end) range Removes the item pointed to by @iter. It is an error to pass the end iterator to this function. If the sequence has a data destroy function associated with it, this function is called on the data for the removed item. Since: 2.14 a #GSequenceIter Removes all items in the (@begin, @end) range. If the sequence has a data destroy function associated with it, this function is called on the data for the removed items. Since: 2.14 a #GSequenceIter a #GSequenceIter Returns an iterator pointing to the position where @data would be inserted according to @cmp_func and @cmp_data. @cmp_func is called with two items of the @seq and @user_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first. If you are simply searching for an existing element of the sequence, consider using g_sequence_lookup(). This function will fail if the data contained in the sequence is unsorted. Use g_sequence_insert_sorted() or g_sequence_insert_sorted_iter() to add data to your sequence or, if you want to add a large amount of data, call g_sequence_sort() after doing unsorted insertions. Since: 2.14 a #GSequence data for the new item the function used to compare items in the sequence user data passed to @cmp_func an #GSequenceIter pointing to the position where @data would have been inserted according to @cmp_func and @cmp_data Like g_sequence_search(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. If you are simply searching for an existing element of the sequence, consider using g_sequence_lookup_iter(). This function will fail if the data contained in the sequence is unsorted. Use g_sequence_insert_sorted() or g_sequence_insert_sorted_iter() to add data to your sequence or, if you want to add a large amount of data, call g_sequence_sort() after doing unsorted insertions. Since: 2.14 a #GSequence data for the new item the function used to compare iterators in the sequence user data passed to @iter_cmp a #GSequenceIter pointing to the position in @seq where @data would have been inserted according to @iter_cmp and @cmp_data Changes the data for the item pointed to by @iter to be @data. If the sequence has a data destroy function associated with it, that function is called on the existing data that @iter pointed to. Since: 2.14 a #GSequenceIter new data for the item Sorts @seq using @cmp_func. @cmp_func is passed two items of @seq and should return 0 if they are equal, a negative value if the first comes before the second, and a positive value if the second comes before the first. Since: 2.14 a #GSequence the function used to sort the sequence user data passed to @cmp_func Moves the data pointed to a new position as indicated by @cmp_func. This function should be called for items in a sequence already sorted according to @cmp_func whenever some aspect of an item changes so that @cmp_func may return different values for that item. @cmp_func is called with two items of the @seq and @user_data. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first. Since: 2.14 A #GSequenceIter the function used to compare items in the sequence user data passed to @cmp_func. Like g_sequence_sort_changed(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function. @iter_cmp is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. Since: 2.14 a #GSequenceIter the function used to compare iterators in the sequence user data passed to @cmp_func Like g_sequence_sort(), but uses a #GSequenceIterCompareFunc instead of a GCompareDataFunc as the compare function @cmp_func is called with two iterators pointing into @seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first. Since: 2.14 a #GSequence the function used to compare iterators in the sequence user data passed to @cmp_func Swaps the items pointed to by @a and @b. It is allowed for @a and @b to point into difference sequences. Since: 2.14 a #GSequenceIter a #GSequenceIter 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. Note that for thread safety reasons, this function can only be called once. The application name will be used in contexts such as error messages, or when displaying an application's name in the task list. Since: 2.2 localized name of the application Does nothing if @err is %NULL; if @err is non-%NULL, then *@err must be %NULL. A new #GError is created and assigned to *@err. a return location for a #GError, or %NULL error domain error code printf()-style format args for @format Does nothing if @err is %NULL; if @err is non-%NULL, then *@err must be %NULL. A new #GError is created and assigned to *@err. Unlike g_set_error(), @message is not a printf()-style format string. Use this function if @message contains text you don't have control over, that could include printf() escape sequences. Since: 2.18 a return location for a #GError, or %NULL error domain error code error message Updates a #GObject pointer to refer to @new_object. It increments the reference count of @new_object (if non-%NULL), decrements the reference count of the current value of @object_ptr (if non-%NULL), and assigns @new_object to @object_ptr. The assignment is not atomic. @object_ptr must not be %NULL. A macro is also included that allows this function to be used without pointer casts. The function itself is static inline, so its address may vary between compilation units. One convenient usage of this function is in implementing property setters: |[ void foo_set_bar (Foo *foo, Bar *new_bar) { g_return_if_fail (IS_FOO (foo)); g_return_if_fail (new_bar == NULL || IS_BAR (new_bar)); if (g_set_object (&foo->bar, new_bar)) g_object_notify (foo, "bar"); } ]| Since: 2.44 a pointer to a #GObject reference a pointer to the new #GObject to assign to it, or %NULL to clear the pointer %TRUE if the value of @object_ptr changed, %FALSE otherwise Sets the name of the program. This name should not be localized, in contrast to g_set_application_name(). Note that for thread-safety reasons this function can only be called once. the name of the program. Sets the print handler. Any messages passed to g_print() will be output via the new handler. The default handler simply outputs the message to stdout. By providing your own handler you can redirect the output, to a GTK+ widget or a log file for example. the new print handler the old print handler Sets the handler for printing error messages. Any messages passed to g_printerr() will be output via the new handler. The default handler simply outputs the message to stderr. By providing your own handler you can redirect the output, to a GTK+ widget or a log file for example. the new error message handler the old error message handler 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. Note that on some systems, when variables are overwritten, the memory used for the previous variables and its value isn't reclaimed. You should be mindful of the fact that environment variable handling in UNIX is not thread-safe, and your program may crash if one thread calls g_setenv() while another thread is calling getenv(). (And note that many functions, such as gettext(), call getenv() internally.) This function is only safe to use at the very start of your program, before creating any other threads (or creating objects that create worker threads of their own). If you need to set up the environment for a child process, you can use g_get_environ() to get an environment array, modify that with g_environ_setenv() and g_environ_unsetenv(), and then pass that array directly to execvpe(), g_spawn_async(), or the like. Since: 2.4 the environment variable to set, must not contain '='. the value for to set the variable to. whether to change the variable if it already exists. %FALSE if the environment variable couldn't be set. Parses a command line into an argument vector, in much the same way the shell would, but without many of the expansions the shell would perform (variable expansion, globs, operators, filename expansion, etc. are not supported). The results are defined to be the same as those you would get from a UNIX98 /bin/sh, as long as the input contains none of the unsupported shell expansions. If the input does contain such expansions, they are passed through literally. Possible errors are those from the #G_SHELL_ERROR domain. Free the returned vector with g_strfreev(). command line to parse return location for number of args, or %NULL return location for array of args, or %NULL return location for error, or %NULL %TRUE on success, %FALSE if error set Quotes a string so that the shell (/bin/sh) will interpret the quoted string to mean @unquoted_string. If you pass a filename to the shell, for example, you should first quote it with this function. The return value must be freed with g_free(). The quoting style used is undefined (single or double quotes may be used). a literal string quoted string Unquotes a string as the shell (/bin/sh) would. Only handles quotes; if a string contains file globs, arithmetic operators, variables, backticks, redirections, or other special-to-the-shell features, the result will be different from the result a real shell would produce (the variables, backticks, etc. will be passed through literally instead of being expanded). This function is guaranteed to succeed if applied to the result of g_shell_quote(). If it fails, it returns %NULL and sets the error. The @quoted_string need not actually contain quoted or escaped text; g_shell_unquote() simply goes through the string and unquotes/unescapes anything that the shell would. Both single and double quotes are handled, as are escapes including escaped newlines. The return value must be freed with g_free(). Possible errors are in the #G_SHELL_ERROR domain. Shell quoting rules are a bit strange. Single quotes preserve the literal string exactly. escape sequences are not allowed; not even \' - if you want a ' in the quoted text, you have to do something like 'foo'\''bar'. Double quotes allow $, `, ", \, and newline to be escaped with backslash. Otherwise double quotes preserve things literally. shell-quoted string error return location or NULL an unquoted string A predefined #GSignalAccumulator for signals intended to be used as a hook for application code to provide a particular value. Usually only one such value is desired and multiple handlers for the same signal don't make much sense (except for the case of the default handler defined in the class structure, in which case you will usually want the signal connection to override the class handler). This accumulator will use the return value from the first signal handler that is run as the return value for the signal and not run any further handlers (ie: the first handler "wins"). Since: 2.28 standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter standard #GSignalAccumulator result A predefined #GSignalAccumulator for signals that return a boolean values. The behavior that this accumulator gives is that a return of %TRUE stops the signal emission: no further callbacks will be invoked, while a return of %FALSE allows the emission to continue. The idea here is that a %TRUE return indicates that the callback handled the signal, and no further handling is needed. Since: 2.4 standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter standard #GSignalAccumulator parameter standard #GSignalAccumulator result Adds an emission hook for a signal, which will get called for any emission of that signal, independent of the instance. This is possible only for signals which don't have #G_SIGNAL_NO_HOOKS flag set. the signal identifier, as returned by g_signal_lookup(). the detail on which to call the hook. a #GSignalEmissionHook function. user data for @hook_func. a #GDestroyNotify for @hook_data. the hook id, for later use with g_signal_remove_emission_hook(). Calls the original class closure of a signal. This function should only be called from an overridden class closure; see g_signal_override_class_closure() and g_signal_override_class_handler(). (array) the argument list of the signal emission. The first element in the array is a #GValue for the instance the signal is being emitted on. The rest are any arguments to be passed to the signal. Location for the return value. Calls the original class closure of a signal. This function should only be called from an overridden class closure; see g_signal_override_class_closure() and g_signal_override_class_handler(). Since: 2.18 the instance the signal is being emitted on. parameters to be passed to the parent class closure, followed by a location for the return value. If the return type of the signal is #G_TYPE_NONE, the return value location can be omitted. Connects a #GCallback function to a signal for a particular object. The handler will be called before the default handler of the signal. the instance to connect to. a string of the form "signal-name::detail". the #GCallback to connect. data to pass to @c_handler calls. the handler id (always greater than 0 for successful connections) Connects a #GCallback function to a signal for a particular object. The handler will be called after the default handler of the signal. the instance to connect to. a string of the form "signal-name::detail". the #GCallback to connect. data to pass to @c_handler calls. the handler id (always greater than 0 for successful connections) Connects a closure to a signal for a particular object. the instance to connect to. a string of the form "signal-name::detail". the closure to connect. whether the handler should be called before or after the default handler of the signal. the handler id (always greater than 0 for successful connections) Connects a closure to a signal for a particular object. the instance to connect to. the id of the signal. the detail. the closure to connect. whether the handler should be called before or after the default handler of the signal. the handler id (always greater than 0 for successful connections) Connects a #GCallback function to a signal for a particular object. Similar to g_signal_connect(), but allows to provide a #GClosureNotify for the data which will be called when the signal handler is disconnected and no longer used. Specify @connect_flags if you need `..._after()` or `..._swapped()` variants of this function. the instance to connect to. a string of the form "signal-name::detail". the #GCallback to connect. data to pass to @c_handler calls. a #GClosureNotify for @data. a combination of #GConnectFlags. the handler id (always greater than 0 for successful connections) This is similar to g_signal_connect_data(), but uses a closure which ensures that the @gobject stays alive during the call to @c_handler by temporarily adding a reference count to @gobject. When the @gobject is destroyed the signal handler will be automatically disconnected. Note that this is not currently threadsafe (ie: emitting a signal while @gobject is being destroyed in another thread is not safe). the instance to connect to. a string of the form "signal-name::detail". the #GCallback to connect. the object to pass as data to @c_handler. a combination of #GConnectFlags. the handler id. Connects a #GCallback function to a signal for a particular object. The instance on which the signal is emitted and @data will be swapped when calling the handler. This is useful when calling pre-existing functions to operate purely on the @data, rather than the @instance: swapping the parameters avoids the need to write a wrapper function. For example, this allows the shorter code: |[<!-- language="C" --> g_signal_connect_swapped (button, "clicked", (GCallback) gtk_widget_hide, other_widget); ]| Rather than the cumbersome: |[<!-- language="C" --> static void button_clicked_cb (GtkButton *button, GtkWidget *other_widget) { gtk_widget_hide (other_widget); } … g_signal_connect (button, "clicked", (GCallback) button_clicked_cb, other_widget); ]| the instance to connect to. a string of the form "signal-name::detail". the #GCallback to connect. data to pass to @c_handler calls. the handler ID (always greater than 0 for successful connections) Emits a signal. Note that g_signal_emit() resets the return value to the default if no handlers are connected, in contrast to g_signal_emitv(). the instance the signal is being emitted on. the signal id the detail parameters to be passed to the signal, followed by a location for the return value. If the return type of the signal is #G_TYPE_NONE, the return value location can be omitted. Emits a signal. Note that g_signal_emit_by_name() resets the return value to the default if no handlers are connected, in contrast to g_signal_emitv(). the instance the signal is being emitted on. a string of the form "signal-name::detail". parameters to be passed to the signal, followed by a location for the return value. If the return type of the signal is #G_TYPE_NONE, the return value location can be omitted. Emits a signal. Note that g_signal_emit_valist() resets the return value to the default if no handlers are connected, in contrast to g_signal_emitv(). the instance the signal is being emitted on. the signal id the detail a list of parameters to be passed to the signal, followed by a location for the return value. If the return type of the signal is #G_TYPE_NONE, the return value location can be omitted. Emits a signal. Note that g_signal_emitv() doesn't change @return_value if no handlers are connected, in contrast to g_signal_emit() and g_signal_emit_valist(). argument list for the signal emission. The first element in the array is a #GValue for the instance the signal is being emitted on. The rest are any arguments to be passed to the signal. the signal id the detail Location to store the return value of the signal emission. This must be provided if the specified signal returns a value, but may be ignored otherwise. Returns the invocation hint of the innermost signal emission of instance. the instance to query the invocation hint of the innermost signal emission. Blocks a handler of an instance so it will not be called during any signal emissions unless it is unblocked again. Thus "blocking" a signal handler means to temporarily deactive it, a signal handler has to be unblocked exactly the same amount of times it has been blocked before to become active again. The @handler_id has to be a valid signal handler id, connected to a signal of @instance. The instance to block the signal handler of. Handler id of the handler to be blocked. Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to. The @handler_id becomes invalid and may be reused. The @handler_id has to be a valid signal handler id, connected to a signal of @instance. The instance to remove the signal handler from. Handler id of the handler to be disconnected. Finds the first signal handler that matches certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. The match @mask has to be non-0 for successful matches. If no handler was found, 0 is returned. The instance owning the signal handler to be found. Mask indicating which of @signal_id, @detail, @closure, @func and/or @data the handler has to match. Signal the handler has to be connected to. Signal detail the handler has to be connected to. The closure the handler will invoke. The C closure callback of the handler (useless for non-C closures). The closure data of the handler's closure. A valid non-0 signal handler id for a successful match. Returns whether @handler_id is the id of a handler connected to @instance. The instance where a signal handler is sought. the handler id. whether @handler_id identifies a handler connected to @instance. Undoes the effect of a previous g_signal_handler_block() call. A blocked handler is skipped during signal emissions and will not be invoked, unblocking it (for exactly the amount of times it has been blocked before) reverts its "blocked" state, so the handler will be recognized by the signal system and is called upon future or currently ongoing signal emissions (since the order in which handlers are called during signal emissions is deterministic, whether the unblocked handler in question is called as part of a currently ongoing emission depends on how far that emission has proceeded yet). The @handler_id has to be a valid id of a signal handler that is connected to a signal of @instance and is currently blocked. The instance to unblock the signal handler of. Handler id of the handler to be unblocked. Blocks all handlers on an instance that match @func and @data. The instance to block handlers from. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. The number of handlers that matched. Blocks all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or %G_SIGNAL_MATCH_DATA match flags is required for successful matches. If no handlers were found, 0 is returned, the number of blocked handlers otherwise. The instance to block handlers from. Mask indicating which of @signal_id, @detail, @closure, @func and/or @data the handlers have to match. Signal the handlers have to be connected to. Signal detail the handlers have to be connected to. The closure the handlers will invoke. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. The number of handlers that matched. Destroy all signal handlers of a type instance. This function is an implementation detail of the #GObject dispose implementation, and should not be used outside of the type system. The instance whose signal handlers are destroyed Disconnects all handlers on an instance that match @data. Since: 2.32 The instance to remove handlers from the closure data of the handlers' closures The number of handlers that matched. Disconnects all handlers on an instance that match @func and @data. The instance to remove handlers from. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. The number of handlers that matched. Disconnects all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or %G_SIGNAL_MATCH_DATA match flags is required for successful matches. If no handlers were found, 0 is returned, the number of disconnected handlers otherwise. The instance to remove handlers from. Mask indicating which of @signal_id, @detail, @closure, @func and/or @data the handlers have to match. Signal the handlers have to be connected to. Signal detail the handlers have to be connected to. The closure the handlers will invoke. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. The number of handlers that matched. Unblocks all handlers on an instance that match @func and @data. The instance to unblock handlers from. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. The number of handlers that matched. Unblocks all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or %G_SIGNAL_MATCH_DATA match flags is required for successful matches. If no handlers were found, 0 is returned, the number of unblocked handlers otherwise. The match criteria should not apply to any handlers that are not currently blocked. The instance to unblock handlers from. Mask indicating which of @signal_id, @detail, @closure, @func and/or @data the handlers have to match. Signal the handlers have to be connected to. Signal detail the handlers have to be connected to. The closure the handlers will invoke. The C closure callback of the handlers (useless for non-C closures). The closure data of the handlers' closures. The number of handlers that matched. Returns whether there are any handlers connected to @instance for the given signal id and detail. If @detail is 0 then it will only match handlers that were connected without detail. If @detail is non-zero then it will match handlers connected both without detail and with the given detail. This is consistent with how a signal emitted with @detail would be delivered to those handlers. One example of when you might use this is when the arguments to the signal are difficult to compute. A class implementor may opt to not emit the signal if no one is attached anyway, thus saving the cost of building the arguments. the object whose signal handlers are sought. the signal id. the detail. whether blocked handlers should count as match. %TRUE if a handler is connected to the signal, %FALSE otherwise. Lists the signals by id that a certain instance or interface type created. Further information about the signals can be acquired through g_signal_query(). Instance or interface type. Location to store the number of signal ids for @itype. Newly allocated array of signal IDs. Given the name of the signal and the type of object it connects to, gets the signal's identifying integer. Emitting the signal by number is somewhat faster than using the name each time. Also tries the ancestors of the given type. See g_signal_new() for details on allowed signal names. the signal's name. the type that the signal operates on. the signal's identifying number, or 0 if no signal was found. Given the signal's identifier, finds its name. Two different signals may have the same name, if they have differing types. the signal's identifying number. the signal name, or %NULL if the signal number was invalid. Creates a new signal. (This is usually done in the class initializer.) A signal name consists of segments consisting of ASCII letters and digits, separated by either the '-' or '_' character. The first character of a signal name must be a letter. Names which violate these rules lead to undefined behaviour of the GSignal system. When registering a signal and looking up a signal, either separator can be used, but they cannot be mixed. If 0 is used for @class_offset subclasses cannot override the class handler in their class_init method by doing super_class->signal_handler = my_signal_handler. Instead they will have to use g_signal_override_class_handler(). If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as the marshaller for this signal. the name for the signal the type this signal pertains to. It will also pertain to types which are derived from this type. a combination of #GSignalFlags specifying detail of when the default handler is to be invoked. You should at least specify %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST. The offset of the function pointer in the class structure for this type. Used to invoke a class method generically. Pass 0 to not associate a class method slot with this signal. the accumulator for this signal; may be %NULL. user data for the @accumulator. the function to translate arrays of parameter values to signal emissions into C language callback invocations or %NULL. the type of return value, or #G_TYPE_NONE for a signal without a return value. the number of parameter types to follow. a list of types, one for each parameter. the signal id Creates a new signal. (This is usually done in the class initializer.) This is a variant of g_signal_new() that takes a C callback instead off a class offset for the signal's class handler. This function doesn't need a function pointer exposed in the class structure of an object definition, instead the function pointer is passed directly and can be overriden by derived classes with g_signal_override_class_closure() or g_signal_override_class_handler()and chained to with g_signal_chain_from_overridden() or g_signal_chain_from_overridden_handler(). See g_signal_new() for information about signal names. If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as the marshaller for this signal. Since: 2.18 the name for the signal the type this signal pertains to. It will also pertain to types which are derived from this type. a combination of #GSignalFlags specifying detail of when the default handler is to be invoked. You should at least specify %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST. a #GCallback which acts as class implementation of this signal. Used to invoke a class method generically. Pass %NULL to not associate a class method with this signal. the accumulator for this signal; may be %NULL. user data for the @accumulator. the function to translate arrays of parameter values to signal emissions into C language callback invocations or %NULL. the type of return value, or #G_TYPE_NONE for a signal without a return value. the number of parameter types to follow. a list of types, one for each parameter. the signal id Creates a new signal. (This is usually done in the class initializer.) See g_signal_new() for details on allowed signal names. If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as the marshaller for this signal. the name for the signal the type this signal pertains to. It will also pertain to types which are derived from this type. a combination of #GSignalFlags specifying detail of when the default handler is to be invoked. You should at least specify %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST. The closure to invoke on signal emission; may be %NULL. the accumulator for this signal; may be %NULL. user data for the @accumulator. the function to translate arrays of parameter values to signal emissions into C language callback invocations or %NULL. the type of return value, or #G_TYPE_NONE for a signal without a return value. the number of parameter types in @args. va_list of #GType, one for each parameter. the signal id Creates a new signal. (This is usually done in the class initializer.) See g_signal_new() for details on allowed signal names. If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as the marshaller for this signal. the name for the signal the type this signal pertains to. It will also pertain to types which are derived from this type a combination of #GSignalFlags specifying detail of when the default handler is to be invoked. You should at least specify %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST The closure to invoke on signal emission; may be %NULL the accumulator for this signal; may be %NULL user data for the @accumulator the function to translate arrays of parameter values to signal emissions into C language callback invocations or %NULL the type of return value, or #G_TYPE_NONE for a signal without a return value the length of @param_types an array of types, one for each parameter the signal id Overrides the class closure (i.e. the default handler) for the given signal for emissions on instances of @instance_type. @instance_type must be derived from the type to which the signal belongs. See g_signal_chain_from_overridden() and g_signal_chain_from_overridden_handler() for how to chain up to the parent class closure from inside the overridden one. the signal id the instance type on which to override the class closure for the signal. the closure. Overrides the class closure (i.e. the default handler) for the given signal for emissions on instances of @instance_type with callback @class_handler. @instance_type must be derived from the type to which the signal belongs. See g_signal_chain_from_overridden() and g_signal_chain_from_overridden_handler() for how to chain up to the parent class closure from inside the overridden one. Since: 2.18 the name for the signal the instance type on which to override the class handler for the signal. the handler. Internal function to parse a signal name into its @signal_id and @detail quark. a string of the form "signal-name::detail". The interface/instance type that introduced "signal-name". Location to store the signal id. Location to store the detail quark. %TRUE forces creation of a #GQuark for the detail. Whether the signal name could successfully be parsed and @signal_id_p and @detail_p contain valid return values. Queries the signal system for in-depth information about a specific signal. This function will fill in a user-provided structure to hold signal-specific information. If an invalid signal id is passed in, the @signal_id member of the #GSignalQuery is 0. All members filled into the #GSignalQuery structure should be considered constant and have to be left untouched. The signal id of the signal to query information for. A user provided structure that is filled in with constant values upon success. Deletes an emission hook. the id of the signal the id of the emission hook, as returned by g_signal_add_emission_hook() Change the #GSignalCVaMarshaller used for a given signal. This is a specialised form of the marshaller that can often be used for the common case of a single connected signal handler and avoids the overhead of #GValue. Its use is optional. Since: 2.32 the signal id the instance type on which to set the marshaller. the marshaller to set. Stops a signal's current emission. This will prevent the default method from running, if the signal was %G_SIGNAL_RUN_LAST and you connected normally (i.e. without the "after" flag). Prints a warning if used on a signal which isn't being emitted. the object whose signal handlers you wish to stop. the signal identifier, as returned by g_signal_lookup(). the detail which the signal was emitted with. Stops a signal's current emission. This is just like g_signal_stop_emission() except it will look up the signal id for you. the object whose signal handlers you wish to stop. a string of the form "signal-name::detail". Creates a new closure which invokes the function found at the offset @struct_offset in the class structure of the interface or classed type identified by @itype. the #GType identifier of an interface or classed type the offset of the member function of @itype's class structure which is to be invoked by the new closure a new #GCClosure Allocates a block of memory from the slice allocator. The block adress handed out can be expected to be aligned to at least 1 * sizeof (void*), though in general slices are 2 * sizeof (void*) bytes aligned, if a malloc() fallback implementation is used instead, the alignment may be reduced in a libc dependent fashion. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable. Since: 2.10 the number of bytes to allocate a pointer to the allocated memory block Allocates a block of memory via g_slice_alloc() and initializes the returned memory to 0. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable. Since: 2.10 the number of bytes to allocate a pointer to the allocated block Allocates a block of memory from the slice allocator and copies @block_size bytes into it from @mem_block. Since: 2.14 the number of bytes to allocate the memory to copy a pointer to the allocated memory block A convenience macro to duplicate a block of memory using the slice allocator. It calls g_slice_copy() with `sizeof (@type)` and casts the returned pointer to a pointer of the given type, avoiding a type cast in the source code. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable. Since: 2.14 the type to duplicate, typically a structure name the memory to copy into the allocated block a pointer to the allocated block, cast to a pointer to @type A convenience macro to free a block of memory that has been allocated from the slice allocator. It calls g_slice_free1() using `sizeof (type)` as the block size. Note that the exact release behaviour can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable, also see [`G_SLICE`][G_SLICE] for related debugging options. Since: 2.10 the type of the block to free, typically a structure name a pointer to the block to free Frees a block of memory. The memory must have been allocated via g_slice_alloc() or g_slice_alloc0() and the @block_size has to match the size specified upon allocation. Note that the exact release behaviour can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable, also see [`G_SLICE`][G_SLICE] for related debugging options. Since: 2.10 the size of the block a pointer to the block to free Frees a linked list of memory blocks of structure type @type. The memory blocks must be equal-sized, allocated via g_slice_alloc() or g_slice_alloc0() and linked together by a @next pointer (similar to #GSList). The name of the @next field in @type is passed as third argument. Note that the exact release behaviour can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable, also see [`G_SLICE`][G_SLICE] for related debugging options. Since: 2.10 the type of the @mem_chain blocks a pointer to the first block of the chain the field name of the next pointer in @type Frees a linked list of memory blocks of structure type @type. The memory blocks must be equal-sized, allocated via g_slice_alloc() or g_slice_alloc0() and linked together by a @next pointer (similar to #GSList). The offset of the @next field in each block is passed as third argument. Note that the exact release behaviour can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable, also see [`G_SLICE`][G_SLICE] for related debugging options. Since: 2.10 the size of the blocks a pointer to the first block of the chain the offset of the @next field in the blocks A convenience macro to allocate a block of memory from the slice allocator. It calls g_slice_alloc() with `sizeof (@type)` and casts the returned pointer to a pointer of the given type, avoiding a type cast in the source code. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable. Since: 2.10 the type to allocate, typically a structure name a pointer to the allocated block, cast to a pointer to @type A convenience macro to allocate a block of memory from the slice allocator and set the memory to 0. It calls g_slice_alloc0() with `sizeof (@type)` and casts the returned pointer to a pointer of the given type, avoiding a type cast in the source code. Note that the underlying slice allocation mechanism can be changed with the [`G_SLICE=always-malloc`][G_SLICE] environment variable. Since: 2.10 the type to allocate, typically a structure name Allocates space for one #GSList element. It is called by the g_slist_append(), g_slist_prepend(), g_slist_insert() and g_slist_insert_sorted() functions and so is rarely used on its own. a pointer to the newly-allocated #GSList element. Adds a new element on to the end of the list. The return value is the new start of the list, which may have changed, so make sure you store the new value. Note that g_slist_append() has to traverse the entire list to find the end, which is inefficient when adding multiple elements. A common idiom to avoid the inefficiency is to prepend the elements and reverse the list when all elements have been added. |[<!-- language="C" --> // Notice that these are initialized to the empty list. GSList *list = NULL, *number_list = NULL; // This is a list of strings. list = g_slist_append (list, "first"); list = g_slist_append (list, "second"); // This is a list of integers. number_list = g_slist_append (number_list, GINT_TO_POINTER (27)); number_list = g_slist_append (number_list, GINT_TO_POINTER (14)); ]| a #GSList the data for the new element the new start of the #GSList Adds the second #GSList onto the end of the first #GSList. Note that the elements of the second #GSList are not copied. They are used directly. a #GSList the #GSList to add to the end of the first #GSList the start of the new #GSList Copies a #GSList. Note that this is a "shallow" copy. If the list elements consist of pointers to data, the pointers are copied but the actual data isn't. See g_slist_copy_deep() if you need to copy the data as well. a #GSList a copy of @list Makes a full (deep) copy of a #GSList. In contrast with g_slist_copy(), this function uses @func to make a copy of each list element, in addition to copying the list container itself. @func, as a #GCopyFunc, takes two arguments, the data to be copied and a user pointer. It's safe to pass #NULL as user_data, if the copy function takes only one argument. For instance, if @list holds a list of GObjects, you can do: |[<!-- language="C" --> another_list = g_slist_copy_deep (list, (GCopyFunc) g_object_ref, NULL); ]| And, to entirely free the new list, you could do: |[<!-- language="C" --> g_slist_free_full (another_list, g_object_unref); ]| Since: 2.34 a #GSList a copy function used to copy every element in the list user data passed to the copy function @func, or #NULL a full copy of @list, use #g_slist_free_full to free it Removes the node link_ from the list and frees it. Compare this to g_slist_remove_link() which removes the node without freeing it. Removing arbitrary nodes from a singly-linked list requires time that is proportional to the length of the list (ie. O(n)). If you find yourself using g_slist_delete_link() frequently, you should consider a different data structure, such as the doubly-linked #GList. a #GSList node to delete the new head of @list Finds the element in a #GSList which contains the given data. a #GSList the element data to find the found #GSList element, or %NULL if it is not found Finds an element in a #GSList, using a supplied function to find the desired element. It iterates over the list, calling the given function which should return 0 when the desired element is found. The function takes two #gconstpointer arguments, the #GSList element's data as the first argument and the given user data. a #GSList user data passed to the function the function to call for each element. It should return 0 when the desired element is found the found #GSList element, or %NULL if it is not found Calls a function for each element of a #GSList. a #GSList the function to call with each element's data user data to pass to the function Frees all of the memory used by a #GSList. The freed elements are returned to the slice allocator. If list elements contain dynamically-allocated memory, you should either use g_slist_free_full() or free them manually first. a #GSList A macro which does the same as g_slist_free_1(). Since: 2.10 Frees one #GSList element. It is usually used after g_slist_remove_link(). a #GSList element Convenience method, which frees all the memory used by a #GSList, and calls the specified destroy function on every element's data. Since: 2.28 a pointer to a #GSList the function to be called to free each element's data Gets the position of the element containing the given data (starting from 0). a #GSList the data to find the index of the element containing the data, or -1 if the data is not found Inserts a new element into the list at the given position. a #GSList the data for the new element the position to insert the element. If this is negative, or is larger than the number of elements in the list, the new element is added on to the end of the list. the new start of the #GSList Inserts a node before @sibling containing @data. a #GSList node to insert @data before data to put in the newly-inserted node the new head of the list. Inserts a new element into the list, using the given comparison function to determine its position. a #GSList the data for the new element the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order. the new start of the #GSList Inserts a new element into the list, using the given comparison function to determine its position. Since: 2.10 a #GSList the data for the new element the function to compare elements in the list. It should return a number > 0 if the first parameter comes after the second parameter in the sort order. data to pass to comparison function the new start of the #GSList Gets the last element in a #GSList. This function iterates over the whole list. a #GSList the last element in the #GSList, or %NULL if the #GSList has no elements Gets the number of elements in a #GSList. This function iterates over the whole list to count its elements. To check whether the list is non-empty, it is faster to check @list against %NULL. a #GSList the number of elements in the #GSList A convenience macro to get the next element in a #GSList. an element in a #GSList. the next element, or %NULL if there are no more elements. Gets the element at the given position in a #GSList. a #GSList the position of the element, counting from 0 the element, or %NULL if the position is off the end of the #GSList Gets the data of the element at the given position. a #GSList the position of the element the element's data, or %NULL if the position is off the end of the #GSList Gets the position of the given element in the #GSList (starting from 0). a #GSList an element in the #GSList the position of the element in the #GSList, or -1 if the element is not found Adds a new element on to the start of the list. The return value is the new start of the list, which may have changed, so make sure you store the new value. |[<!-- language="C" --> // Notice that it is initialized to the empty list. GSList *list = NULL; list = g_slist_prepend (list, "last"); list = g_slist_prepend (list, "first"); ]| a #GSList the data for the new element the new start of the #GSList Removes an element from a #GSList. If two elements contain the same data, only the first is removed. If none of the elements contain the data, the #GSList is unchanged. a #GSList the data of the element to remove the new start of the #GSList Removes all list nodes with data equal to @data. Returns the new head of the list. Contrast with g_slist_remove() which removes only the first node matching the given data. a #GSList data to remove new head of @list Removes an element from a #GSList, without freeing the element. The removed element's next link is set to %NULL, so that it becomes a self-contained list with one element. Removing arbitrary nodes from a singly-linked list requires time that is proportional to the length of the list (ie. O(n)). If you find yourself using g_slist_remove_link() frequently, you should consider a different data structure, such as the doubly-linked #GList. a #GSList an element in the #GSList the new start of the #GSList, without the element Reverses a #GSList. a #GSList the start of the reversed #GSList Sorts a #GSList using the given comparison function. a #GSList the comparison function used to sort the #GSList. This function is passed the data from 2 elements of the #GSList and should return 0 if they are equal, a negative value if the first element comes before the second, or a positive value if the first element comes after the second. the start of the sorted #GSList Like g_slist_sort(), but the sort function accepts a user data argument. a #GSList comparison function data to pass to comparison function new head of the list A safer form of the standard sprintf() function. The output is guaranteed to not exceed @n characters (including the terminating nul character), so it is easy to ensure that a buffer overflow cannot occur. See also g_strdup_printf(). In versions of GLib prior to 1.2.3, this function may return -1 if the output was truncated, and the truncated string may not be nul-terminated. In versions prior to 1.3.12, this function returns the length of the output string. The return value of g_snprintf() conforms to the snprintf() function as standardized in ISO C99. Note that this is different from traditional snprintf(), which returns the length of the output string. The format string may contain positional parameters, as specified in the Single Unix Specification. the buffer to hold the output. the maximum number of bytes to produce (including the terminating nul character). a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output. the number of bytes which would be produced if the buffer was large enough. Adds @child_source to @source as a "polled" source; when @source is added to a #GMainContext, @child_source will be automatically added with the same priority, when @child_source is triggered, it will cause @source to dispatch (in addition to calling its own callback), and when @source is destroyed, it will destroy @child_source as well. (@source will also still be dispatched if its own prepare/check functions indicate that it is ready.) If you don't need @child_source to do anything on its own when it triggers, you can call g_source_set_dummy_callback() on it to set a callback that does nothing (except return %TRUE if appropriate). @source will hold a reference on @child_source while @child_source is attached to it. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. Since: 2.28 a #GSource a second #GSource that @source should "poll" Adds a file descriptor to the set of file descriptors polled for this source. This is usually combined with g_source_new() to add an event source. The event source's check function will typically test the @revents field in the #GPollFD struct and return %TRUE if events need to be processed. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. Using this API forces the linear scanning of event sources on each main loop iteration. Newly-written event sources should try to use g_source_add_unix_fd() instead of this API. a #GSource a #GPollFD structure holding information about a file descriptor to watch. Monitors @fd for the IO events in @events. The tag returned by this function can be used to remove or modify the monitoring of the fd using g_source_remove_unix_fd() or g_source_modify_unix_fd(). It is not necessary to remove the fd before destroying the source; it will be cleaned up automatically. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows. Since: 2.36 a #GSource the fd to monitor an event mask an opaque tag Adds a #GSource to a @context so that it will be executed within that context. Remove it by calling g_source_destroy(). a #GSource a #GMainContext (if %NULL, the default context will be used) the ID (greater than 0) for the source within the #GMainContext. Removes a source from its #GMainContext, if any, and mark it as destroyed. The source cannot be subsequently added to another context. It is safe to call this on sources which have already been removed from their context. a #GSource Checks whether a source is allowed to be called recursively. see g_source_set_can_recurse(). a #GSource whether recursion is allowed. Gets the #GMainContext with which the source is associated. You can call this on a source that has been destroyed, provided that the #GMainContext it was attached to still exists (in which case it will return that #GMainContext). In particular, you can always call this function on the source returned from g_main_current_source(). But calling this function on a source whose #GMainContext has been destroyed is an error. a #GSource the #GMainContext with which the source is associated, or %NULL if the context has not yet been added to a source. This function ignores @source and is otherwise the same as g_get_current_time(). Deprecated: 2.28: use g_source_get_time() instead a #GSource #GTimeVal structure in which to store current time. Returns the numeric ID for a particular source. The ID of a source is a positive integer which is unique within a particular main loop context. The reverse mapping from ID to source is done by g_main_context_find_source_by_id(). a #GSource the ID (greater than 0) for the source Gets a name for the source, used in debugging and profiling. The name may be #NULL if it has never been set with g_source_set_name(). Since: 2.26 a #GSource the name of the source Gets the priority of a source. a #GSource the priority of the source Gets the "ready time" of @source, as set by g_source_set_ready_time(). Any time before the current monotonic time (including 0) is an indication that the source will fire immediately. a #GSource the monotonic ready time, -1 for "never" Gets the time to be used when checking this source. The advantage of calling this function over calling g_get_monotonic_time() directly is that when checking multiple sources, GLib can cache a single value instead of having to repeatedly get the system monotonic time. The time here is the system monotonic time, if available, or some other reasonable alternative otherwise. See g_get_monotonic_time(). Since: 2.28 a #GSource the monotonic time in microseconds Returns whether @source has been destroyed. This is important when you operate upon your objects from within idle handlers, but may have freed the object before the dispatch of your idle handler. |[<!-- language="C" --> static gboolean idle_callback (gpointer data) { SomeWidget *self = data; GDK_THREADS_ENTER (); // do stuff with self self->idle_id = 0; GDK_THREADS_LEAVE (); return G_SOURCE_REMOVE; } static void some_widget_do_stuff_later (SomeWidget *self) { self->idle_id = g_idle_add (idle_callback, self); } static void some_widget_finalize (GObject *object) { SomeWidget *self = SOME_WIDGET (object); if (self->idle_id) g_source_remove (self->idle_id); G_OBJECT_CLASS (parent_class)->finalize (object); } ]| This will fail in a multi-threaded application if the widget is destroyed before the idle handler fires due to the use after free in the callback. A solution, to this particular problem, is to check to if the source has already been destroy within the callback. |[<!-- language="C" --> static gboolean idle_callback (gpointer data) { SomeWidget *self = data; GDK_THREADS_ENTER (); if (!g_source_is_destroyed (g_main_current_source ())) { // do stuff with self } GDK_THREADS_LEAVE (); return FALSE; } ]| Since: 2.12 a #GSource %TRUE if the source has been destroyed Updates the event mask to watch for the fd identified by @tag. @tag is the tag returned from g_source_add_unix_fd(). If you want to remove a fd, don't set its event mask to zero. Instead, call g_source_remove_unix_fd(). This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows. Since: 2.36 a #GSource the tag from g_source_add_unix_fd() the new event mask to watch Creates a new #GSource structure. The size is specified to allow creating structures derived from #GSource that contain additional data. The size passed in must be at least `sizeof (GSource)`. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. structure containing functions that implement the sources behavior. size of the #GSource structure to create. the newly-created #GSource. Queries the events reported for the fd corresponding to @tag on @source during the last poll. The return value of this function is only defined when the function is called from the check or dispatch functions for @source. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows. Since: 2.36 a #GSource the tag from g_source_add_unix_fd() the conditions reported on the fd Increases the reference count on a source by one. a #GSource @source Removes the source with the given id from the default main context. The id of a #GSource is given by g_source_get_id(), or will be returned by the functions g_source_attach(), g_idle_add(), g_idle_add_full(), g_timeout_add(), g_timeout_add_full(), g_child_watch_add(), g_child_watch_add_full(), g_io_add_watch(), and g_io_add_watch_full(). See also g_source_destroy(). You must use g_source_destroy() for sources added to a non-default main context. It is a programmer error to attempt to remove a non-existent source. More specifically: source IDs can be reissued after a source has been destroyed and therefore it is never valid to use this function with a source ID which may have already been removed. An example is when scheduling an idle to run in another thread with g_idle_add(): the idle may already have run and been removed by the time this function is called on its (now invalid) source ID. This source ID may have been reissued, leading to the operation being performed against the wrong source. the ID of the source to remove. For historical reasons, this function always returns %TRUE Removes a source from the default main loop context given the source functions and user data. If multiple sources exist with the same source functions and user data, only one will be destroyed. The @source_funcs passed to g_source_new() the user data for the callback %TRUE if a source was found and removed. Removes a source from the default main loop context given the user data for the callback. If multiple sources exist with the same user data, only one will be destroyed. the user_data for the callback. %TRUE if a source was found and removed. Detaches @child_source from @source and destroys it. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. Since: 2.28 a #GSource a #GSource previously passed to g_source_add_child_source(). Removes a file descriptor from the set of file descriptors polled for this source. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. a #GSource a #GPollFD structure previously passed to g_source_add_poll(). Reverses the effect of a previous call to g_source_add_unix_fd(). You only need to call this if you want to remove an fd from being watched while keeping the same source around. In the normal case you will just want to destroy the source. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. As the name suggests, this function is not available on Windows. Since: 2.36 a #GSource the tag from g_source_add_unix_fd() Sets the callback function for a source. The callback for a source is called from the source's dispatch function. The exact type of @func depends on the type of source; ie. you should not count on @func being called with @data as its first parameter. Typically, you won't use this function. Instead use functions specific to the type of source you are using. the source a callback function the data to pass to callback function a function to call when @data is no longer in use, or %NULL. Sets the callback function storing the data as a refcounted callback "object". This is used internally. Note that calling g_source_set_callback_indirect() assumes an initial reference count on @callback_data, and thus @callback_funcs->unref will eventually be called once more than @callback_funcs->ref. the source pointer to callback data "object" functions for reference counting @callback_data and getting the callback and data Sets whether a source can be called recursively. If @can_recurse is %TRUE, then while the source is being dispatched then this source will be processed normally. Otherwise, all processing of this source is blocked until the dispatch function returns. a #GSource whether recursion is allowed for this source Set the callback for a source as a #GClosure. If the source is not one of the standard GLib types, the @closure_callback and @closure_marshal fields of the #GSourceFuncs structure must have been filled in with pointers to appropriate functions. the source a #GClosure Sets a dummy callback for @source. The callback will do nothing, and if the source expects a #gboolean return value, it will return %TRUE. (If the source expects any other type of return value, it will return a 0/%NULL value; whatever g_value_init() initializes a #GValue to for that type.) If the source is not one of the standard GLib types, the @closure_callback and @closure_marshal fields of the #GSourceFuncs structure must have been filled in with pointers to appropriate functions. the source Sets the source functions (can be used to override default implementations) of an unattached source. Since: 2.12 a #GSource the new #GSourceFuncs Sets a name for the source, used in debugging and profiling. The name defaults to #NULL. The source name should describe in a human-readable way what the source does. For example, "X11 event queue" or "GTK+ repaint idle handler" or whatever it is. It is permitted to call this function multiple times, but is not recommended due to the potential performance impact. For example, one could change the name in the "check" function of a #GSourceFuncs to include details like the event type in the source name. Use caution if changing the name while another thread may be accessing it with g_source_get_name(); that function does not copy the value, and changing the value will free it while the other thread may be attempting to use it. Since: 2.26 a #GSource debug name for the source Sets the name of a source using its ID. This is a convenience utility to set source names from the return value of g_idle_add(), g_timeout_add(), etc. It is a programmer error to attempt to set the name of a non-existent source. More specifically: source IDs can be reissued after a source has been destroyed and therefore it is never valid to use this function with a source ID which may have already been removed. An example is when scheduling an idle to run in another thread with g_idle_add(): the idle may already have run and been removed by the time this function is called on its (now invalid) source ID. This source ID may have been reissued, leading to the operation being performed against the wrong source. Since: 2.26 a #GSource ID debug name for the source Sets the priority of a source. While the main loop is being run, a source will be dispatched if it is ready to be dispatched and no sources at a higher (numerically smaller) priority are ready to be dispatched. A child source always has the same priority as its parent. It is not permitted to change the priority of a source once it has been added as a child of another source. a #GSource the new priority. Sets a #GSource to be dispatched when the given monotonic time is reached (or passed). If the monotonic time is in the past (as it always will be if @ready_time is 0) then the source will be dispatched immediately. If @ready_time is -1 then the source is never woken up on the basis of the passage of time. Dispatching the source does not reset the ready time. You should do so yourself, from the source dispatch function. Note that if you have a pair of sources where the ready time of one suggests that it will be delivered first but the priority for the other suggests that it would be delivered first, and the ready time for both sources is reached during the same main context iteration then the order of dispatch is undefined. This API is only intended to be used by implementations of #GSource. Do not call this API on a #GSource that you did not create. Since: 2.36 a #GSource the monotonic time at which the source will be ready, 0 for "immediately", -1 for "never" Decreases the reference count of a source by one. If the resulting reference count is zero the source and associated memory will be destroyed. a #GSource 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. The built-in array of primes ranges from 11 to 13845163 such that each prime is approximately 1.5-2 times the previous prime. a #guint the smallest prime number from a built-in array of primes which is larger than @num See g_spawn_async_with_pipes() for a full description; this function simply calls the g_spawn_async_with_pipes() without any pipes. You should call g_spawn_close_pid() on the returned child process reference when you don't need it any more. If you are writing a GTK+ application, and the program you are spawning is a graphical application, too, then you may want to use gdk_spawn_on_screen() instead to ensure that the spawned program opens its windows on the right screen. Note that the returned @child_pid on Windows is a handle to the child process and not its identifier. Process handles and process identifiers are different concepts on Windows. child's current working directory, or %NULL to inherit parent's child's argument vector child's environment, or %NULL to inherit parent's flags from #GSpawnFlags function to run in the child just before exec() user data for @child_setup return location for child process reference, or %NULL return location for error %TRUE on success, %FALSE if error is set Executes a child program asynchronously (your program will not block waiting for the child to exit). The child program is specified by the only argument that must be provided, @argv. @argv should be a %NULL-terminated array of strings, to be passed as the argument vector for the child. The first string in @argv is of course the name of the program to execute. By default, the name of the program must be a full path. If @flags contains the %G_SPAWN_SEARCH_PATH flag, the `PATH` environment variable is used to search for the executable. If @flags contains the %G_SPAWN_SEARCH_PATH_FROM_ENVP flag, the `PATH` variable from @envp is used to search for the executable. If both the %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP flags are set, the `PATH` variable from @envp takes precedence over the environment variable. If the program name is not a full path and %G_SPAWN_SEARCH_PATH flag is not used, then the program will be run from the current directory (or @working_directory, if specified); this might be unexpected or even dangerous in some cases when the current directory is world-writable. On Windows, note that all the string or string vector arguments to this function and the other g_spawn*() functions are in UTF-8, the GLib file name encoding. Unicode characters that are not part of the system codepage passed in these arguments will be correctly available in the spawned program only if it uses wide character API to retrieve its command line. For C programs built with Microsoft's tools it is enough to make the program have a wmain() instead of main(). wmain() has a wide character argument vector as parameter. At least currently, mingw doesn't support wmain(), so if you use mingw to develop the spawned program, it will have to call the undocumented function __wgetmainargs() to get the wide character argument vector and environment. See gspawn-win32-helper.c in the GLib sources or init.c in the mingw runtime sources for a prototype for that function. Alternatively, you can retrieve the Win32 system level wide character command line passed to the spawned program using the GetCommandLineW() function. On Windows the low-level child process creation API CreateProcess() doesn't use argument vectors, but a command line. The C runtime library's spawn*() family of functions (which g_spawn_async_with_pipes() eventually calls) paste the argument vector elements together into a command line, and the C runtime startup code does a corresponding reconstruction of an argument vector from the command line, to be passed to main(). Complications arise when you have argument vector elements that contain spaces of double quotes. The spawn*() functions don't do any quoting or escaping, but on the other hand the startup code does do unquoting and unescaping in order to enable receiving arguments with embedded spaces or double quotes. To work around this asymmetry, g_spawn_async_with_pipes() will do quoting and escaping on argument vector elements that need it before calling the C runtime spawn() function. The returned @child_pid on Windows is a handle to the child process, not its identifier. Process handles and process identifiers are different concepts on Windows. @envp is a %NULL-terminated array of strings, where each string has the form `KEY=VALUE`. This will become the child's environment. If @envp is %NULL, the child inherits its parent's environment. @flags should be the bitwise OR of any flags you want to affect the function's behaviour. The %G_SPAWN_DO_NOT_REAP_CHILD means that the child will not automatically be reaped; you must use a child watch to be notified about the death of the child process. Eventually you must call g_spawn_close_pid() on the @child_pid, in order to free resources which may be associated with the child process. (On Unix, using a child watch is equivalent to calling waitpid() or handling the %SIGCHLD signal manually. On Windows, calling g_spawn_close_pid() is equivalent to calling CloseHandle() on the process handle returned in @child_pid). See g_child_watch_add(). %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that the parent's open file descriptors will be inherited by the child; otherwise all descriptors except stdin/stdout/stderr will be closed before calling exec() in the child. %G_SPAWN_SEARCH_PATH means that @argv[0] need not be an absolute path, it will be looked for in the `PATH` environment variable. %G_SPAWN_SEARCH_PATH_FROM_ENVP means need not be an absolute path, it will be looked for in the `PATH` variable from @envp. If both %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP are used, the value from @envp takes precedence over the environment. %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will be discarded, instead of going to the same location as the parent's standard output. If you use this flag, @standard_output must be %NULL. %G_SPAWN_STDERR_TO_DEV_NULL means that the child's standard error will be discarded, instead of going to the same location as the parent's standard error. If you use this flag, @standard_error must be %NULL. %G_SPAWN_CHILD_INHERITS_STDIN means that the child will inherit the parent's standard input (by default, the child's standard input is attached to /dev/null). If you use this flag, @standard_input must be %NULL. %G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of @argv is the file to execute, while the remaining elements are the actual argument vector to pass to the file. Normally g_spawn_async_with_pipes() uses @argv[0] as the file to execute, and passes all of @argv to the child. @child_setup and @user_data are a function and user data. On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform (including creating pipes, closing file descriptors, etc.) but before calling exec(). That is, @child_setup is called just before calling exec() in the child. Obviously actions taken in this function will only affect the child, not the parent. On Windows, there is no separate fork() and exec() functionality. Child processes are created and run with a single API call, CreateProcess(). There is no sensible thing @child_setup could be used for on Windows so it is ignored and not called. If non-%NULL, @child_pid will on Unix be filled with the child's process ID. You can use the process ID to send signals to the child, or to use g_child_watch_add() (or waitpid()) if you specified the %G_SPAWN_DO_NOT_REAP_CHILD flag. On Windows, @child_pid will be filled with a handle to the child process only if you specified the %G_SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child process using the Win32 API, for example wait for its termination with the WaitFor*() functions, or examine its exit code with GetExitCodeProcess(). You should close the handle with CloseHandle() or g_spawn_close_pid() when you no longer need it. If non-%NULL, the @standard_input, @standard_output, @standard_error locations will be filled with file descriptors for writing to the child's standard input or reading from its standard output or standard error. The caller of g_spawn_async_with_pipes() must close these file descriptors when they are no longer in use. If these parameters are %NULL, the corresponding pipe won't be created. If @standard_input is NULL, the child's standard input is attached to /dev/null unless %G_SPAWN_CHILD_INHERITS_STDIN is set. If @standard_error is NULL, the child's standard error goes to the same location as the parent's standard error unless %G_SPAWN_STDERR_TO_DEV_NULL is set. If @standard_output is NULL, the child's standard output goes to the same location as the parent's standard output unless %G_SPAWN_STDOUT_TO_DEV_NULL is set. @error can be %NULL to ignore errors, or non-%NULL to report errors. If an error is set, the function returns %FALSE. Errors are reported even if they occur in the child (for example if the executable in @argv[0] is not found). Typically the `message` field of returned errors should be displayed to users. Possible errors are those from the #G_SPAWN_ERROR domain. If an error occurs, @child_pid, @standard_input, @standard_output, and @standard_error will not be filled with valid values. If @child_pid is not %NULL and an error does not occur then the returned process reference must be closed using g_spawn_close_pid(). If you are writing a GTK+ application, and the program you are spawning is a graphical application, too, then you may want to use gdk_spawn_on_screen_with_pipes() instead to ensure that the spawned program opens its windows on the right screen. child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding child's argument vector, in the GLib file name encoding child's environment, or %NULL to inherit parent's, in the GLib file name encoding flags from #GSpawnFlags function to run in the child just before exec() user data for @child_setup return location for child process ID, or %NULL return location for file descriptor to write to child's stdin, or %NULL return location for file descriptor to read child's stdout, or %NULL return location for file descriptor to read child's stderr, or %NULL return location for error %TRUE on success, %FALSE if an error was set Set @error if @exit_status indicates the child exited abnormally (e.g. with a nonzero exit code, or via a fatal signal). The g_spawn_sync() and g_child_watch_add() family of APIs return an exit status for subprocesses encoded in a platform-specific way. On Unix, this is guaranteed to be in the same format waitpid() returns, and on Windows it is guaranteed to be the result of GetExitCodeProcess(). Prior to the introduction of this function in GLib 2.34, interpreting @exit_status required use of platform-specific APIs, which is problematic for software using GLib as a cross-platform layer. Additionally, many programs simply want to determine whether or not the child exited successfully, and either propagate a #GError or print a message to standard error. In that common case, this function can be used. Note that the error message in @error will contain human-readable information about the exit status. The @domain and @code of @error have special semantics in the case where the process has an "exit code", as opposed to being killed by a signal. On Unix, this happens if WIFEXITED() would be true of @exit_status. On Windows, it is always the case. The special semantics are that the actual exit code will be the code set in @error, and the domain will be %G_SPAWN_EXIT_ERROR. This allows you to differentiate between different exit codes. If the process was terminated by some means other than an exit status, the domain will be %G_SPAWN_ERROR, and the code will be %G_SPAWN_ERROR_FAILED. This function just offers convenience; you can of course also check the available platform via a macro such as %G_OS_UNIX, and use WIFEXITED() and WEXITSTATUS() on @exit_status directly. Do not attempt to scan or parse the error message string; it may be translated and/or change in future versions of GLib. Since: 2.34 An exit code as returned from g_spawn_sync() a #GError %TRUE if child exited successfully, %FALSE otherwise (and @error will be set) On some platforms, notably Windows, the #GPid type represents a resource which must be closed to prevent resource leaking. g_spawn_close_pid() is provided for this purpose. It should be used on all platforms, even though it doesn't do anything under UNIX. The process reference to close A simple version of g_spawn_async() that parses a command line with g_shell_parse_argv() and passes it to g_spawn_async(). Runs a command line in the background. Unlike g_spawn_async(), the %G_SPAWN_SEARCH_PATH flag is enabled, other flags are not. Note that %G_SPAWN_SEARCH_PATH can have security implications, so consider using g_spawn_async() directly if appropriate. Possible errors are those from g_shell_parse_argv() and g_spawn_async(). The same concerns on Windows apply as for g_spawn_command_line_sync(). a command line return location for errors %TRUE on success, %FALSE if error is set A simple version of g_spawn_sync() with little-used parameters removed, taking a command line instead of an argument vector. See g_spawn_sync() for full details. @command_line will be parsed by g_shell_parse_argv(). Unlike g_spawn_sync(), the %G_SPAWN_SEARCH_PATH flag is enabled. Note that %G_SPAWN_SEARCH_PATH can have security implications, so consider using g_spawn_sync() directly if appropriate. Possible errors are those from g_spawn_sync() and those from g_shell_parse_argv(). If @exit_status is non-%NULL, the platform-specific exit status of the child is stored there; see the documentation of g_spawn_check_exit_status() for how to use and interpret this. On Windows, please note the implications of g_shell_parse_argv() parsing @command_line. Parsing is done according to Unix shell rules, not Windows command interpreter rules. Space is a separator, and backslashes are special. Thus you cannot simply pass a @command_line containing canonical Windows paths, like "c:\\program files\\app\\app.exe", as the backslashes will be eaten, and the space will act as a separator. You need to enclose such paths with single quotes, like "'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'". a command line return location for child output return location for child errors return location for child exit status, as returned by waitpid() return location for errors %TRUE on success, %FALSE if an error was set Executes a child synchronously (waits for the child to exit before returning). All output from the child is stored in @standard_output and @standard_error, if those parameters are non-%NULL. Note that you must set the %G_SPAWN_STDOUT_TO_DEV_NULL and %G_SPAWN_STDERR_TO_DEV_NULL flags when passing %NULL for @standard_output and @standard_error. If @exit_status is non-%NULL, the platform-specific exit status of the child is stored there; see the documentation of g_spawn_check_exit_status() for how to use and interpret this. Note that it is invalid to pass %G_SPAWN_DO_NOT_REAP_CHILD in @flags. If an error occurs, no data is returned in @standard_output, @standard_error, or @exit_status. This function calls g_spawn_async_with_pipes() internally; see that function for full details on the other parameters and details on how these functions work on Windows. child's current working directory, or %NULL to inherit parent's child's argument vector child's environment, or %NULL to inherit parent's flags from #GSpawnFlags function to run in the child just before exec() user data for @child_setup return location for child output, or %NULL return location for child error messages, or %NULL return location for child exit status, as returned by waitpid(), or %NULL return location for error, or %NULL %TRUE on success, %FALSE if an error was set An implementation of the standard sprintf() function which supports positional parameters, as specified in the Single Unix Specification. Note that it is usually better to use g_snprintf(), to avoid the risk of buffer overflow. See also g_strdup_printf(). Since: 2.2 A pointer to a memory buffer to contain the resulting string. It is up to the caller to ensure that the allocated buffer is large enough to hold the formatted result a standard printf() format string, but notice [string precision pitfalls][string-precision] the arguments to insert in the output. the number of bytes printed. A wrapper for the POSIX stat() function. The stat() function returns information about a file. On Windows the stat() function in the C library checks only the FAT-style READONLY attribute and does not look at the ACL at all. Thus on Windows the protection bits in the @st_mode field are a fabrication of little use. On Windows the Microsoft C libraries have several variants of the stat struct and stat() function with names like _stat(), _stat32(), _stat32i64() and _stat64i32(). The one used here is for 32-bit code the one with 32-bit size and time fields, specifically called _stat32(). In Microsoft's compiler, by default struct stat means one with 64-bit time fields while in MinGW struct stat is the legacy one with 32-bit fields. To hopefully clear up this messs, the gstdio.h header defines a type #GStatBuf which is the appropriate struct type depending on the platform and/or compiler being used. On POSIX it is just struct stat, but note that even on POSIX platforms, stat() might be a macro. See your C library manual for more details about stat(). Since: 2.6 a pathname in the GLib file name encoding (UTF-8 on Windows) a pointer to a stat struct, which will be filled with the file information 0 if the information was successfully retrieved, -1 if an error occurred Releases all resources allocated to @mutex. You don't have to call this functions for a #GStaticMutex with an unbounded lifetime, i.e. objects declared 'static', but if you have a #GStaticMutex as a member of a structure and the structure is freed, you should also free the #GStaticMutex. Calling g_static_mutex_free() on a locked mutex may result in undefined behaviour. Deprecated: 2.32: Use g_mutex_clear() a #GStaticMutex to be freed. For some operations (like g_cond_wait()) you must have a #GMutex instead of a #GStaticMutex. This function will return the corresponding #GMutex for @mutex. Deprecated: 2.32: Just use a #GMutex a #GStaticMutex. the #GMutex corresponding to @mutex. Initializes @mutex. Alternatively you can initialize it with #G_STATIC_MUTEX_INIT. Deprecated: 2.32: Use g_mutex_init() a #GStaticMutex to be initialized. Works like g_mutex_lock(), but for a #GStaticMutex. Deprecated: 2.32: Use g_mutex_lock() a #GStaticMutex. Works like g_mutex_trylock(), but for a #GStaticMutex. Deprecated: 2.32: Use g_mutex_trylock() a #GStaticMutex. %TRUE, if the #GStaticMutex could be locked. Works like g_mutex_unlock(), but for a #GStaticMutex. Deprecated: 2.32: Use g_mutex_unlock() a #GStaticMutex. Releases all resources allocated to @private_key. You don't have to call this functions for a #GStaticPrivate with an unbounded lifetime, i.e. objects declared 'static', but if you have a #GStaticPrivate as a member of a structure and the structure is freed, you should also free the #GStaticPrivate. a #GStaticPrivate to be freed Works like g_private_get() only for a #GStaticPrivate. This function works even if g_thread_init() has not yet been called. a #GStaticPrivate the corresponding pointer Initializes @private_key. Alternatively you can initialize it with #G_STATIC_PRIVATE_INIT. a #GStaticPrivate to be initialized Sets the pointer keyed to @private_key for the current thread and the function @notify to be called with that pointer (%NULL or non-%NULL), whenever the pointer is set again or whenever the current thread ends. This function works even if g_thread_init() has not yet been called. If g_thread_init() is called later, the @data keyed to @private_key will be inherited only by the main thread, i.e. the one that called g_thread_init(). @notify is used quite differently from @destructor in g_private_new(). a #GStaticPrivate the new pointer a function to be called with the pointer whenever the current thread ends or sets this pointer again Releases all resources allocated to a #GStaticRecMutex. You don't have to call this functions for a #GStaticRecMutex with an unbounded lifetime, i.e. objects declared 'static', but if you have a #GStaticRecMutex as a member of a structure and the structure is freed, you should also free the #GStaticRecMutex. Deprecated: 2.32: Use g_rec_mutex_clear() a #GStaticRecMutex to be freed. A #GStaticRecMutex must be initialized with this function before it can be used. Alternatively you can initialize it with #G_STATIC_REC_MUTEX_INIT. Deprecated: 2.32: Use g_rec_mutex_init() a #GStaticRecMutex to be initialized. Locks @mutex. If @mutex is already locked by another thread, the current thread will block until @mutex is unlocked by the other thread. If @mutex is already locked by the calling thread, this functions increases the depth of @mutex and returns immediately. Deprecated: 2.32: Use g_rec_mutex_lock() a #GStaticRecMutex to lock. Works like calling g_static_rec_mutex_lock() for @mutex @depth times. Deprecated: 2.32: Use g_rec_mutex_lock() a #GStaticRecMutex to lock. number of times this mutex has to be unlocked to be completely unlocked. Tries to lock @mutex. If @mutex is already locked by another thread, it immediately returns %FALSE. Otherwise it locks @mutex and returns %TRUE. If @mutex is already locked by the calling thread, this functions increases the depth of @mutex and immediately returns %TRUE. Deprecated: 2.32: Use g_rec_mutex_trylock() a #GStaticRecMutex to lock. %TRUE, if @mutex could be locked. Unlocks @mutex. Another thread will be allowed to lock @mutex only when it has been unlocked as many times as it had been locked before. If @mutex is completely unlocked and another thread is blocked in a g_static_rec_mutex_lock() call for @mutex, it will be woken and can lock @mutex itself. Deprecated: 2.32: Use g_rec_mutex_unlock() a #GStaticRecMutex to unlock. Completely unlocks @mutex. If another thread is blocked in a g_static_rec_mutex_lock() call for @mutex, it will be woken and can lock @mutex itself. This function returns the number of times that @mutex has been locked by the current thread. To restore the state before the call to g_static_rec_mutex_unlock_full() you can call g_static_rec_mutex_lock_full() with the depth returned by this function. Deprecated: 2.32: Use g_rec_mutex_unlock() a #GStaticRecMutex to completely unlock. number of times @mutex has been locked by the current thread. Releases all resources allocated to @lock. You don't have to call this functions for a #GStaticRWLock with an unbounded lifetime, i.e. objects declared 'static', but if you have a #GStaticRWLock as a member of a structure, and the structure is freed, you should also free the #GStaticRWLock. Deprecated: 2.32: Use a #GRWLock instead a #GStaticRWLock to be freed. A #GStaticRWLock must be initialized with this function before it can be used. Alternatively you can initialize it with #G_STATIC_RW_LOCK_INIT. Deprecated: 2.32: Use g_rw_lock_init() instead a #GStaticRWLock to be initialized. Locks @lock for reading. There may be unlimited concurrent locks for reading of a #GStaticRWLock at the same time. If @lock is already locked for writing by another thread or if another thread is already waiting to lock @lock for writing, this function will block until @lock is unlocked by the other writing thread and no other writing threads want to lock @lock. This lock has to be unlocked by g_static_rw_lock_reader_unlock(). #GStaticRWLock is not recursive. It might seem to be possible to recursively lock for reading, but that can result in a deadlock, due to writer preference. Deprecated: 2.32: Use g_rw_lock_reader_lock() instead a #GStaticRWLock to lock for reading. Tries to lock @lock for reading. If @lock is already locked for writing by another thread or if another thread is already waiting to lock @lock for writing, immediately returns %FALSE. Otherwise locks @lock for reading and returns %TRUE. This lock has to be unlocked by g_static_rw_lock_reader_unlock(). a #GStaticRWLock to lock for reading %TRUE, if @lock could be locked for reading Deprectated: 2.32: Use g_rw_lock_reader_trylock() instead Unlocks @lock. If a thread waits to lock @lock for writing and all locks for reading have been unlocked, the waiting thread is woken up and can lock @lock for writing. Deprectated: 2.32: Use g_rw_lock_reader_unlock() instead a #GStaticRWLock to unlock after reading Locks @lock for writing. If @lock is already locked for writing or reading by other threads, this function will block until @lock is completely unlocked and then lock @lock for writing. While this functions waits to lock @lock, no other thread can lock @lock for reading. When @lock is locked for writing, no other thread can lock @lock (neither for reading nor writing). This lock has to be unlocked by g_static_rw_lock_writer_unlock(). Deprectated: 2.32: Use g_rw_lock_writer_lock() instead a #GStaticRWLock to lock for writing Tries to lock @lock for writing. If @lock is already locked (for either reading or writing) by another thread, it immediately returns %FALSE. Otherwise it locks @lock for writing and returns %TRUE. This lock has to be unlocked by g_static_rw_lock_writer_unlock(). a #GStaticRWLock to lock for writing %TRUE, if @lock could be locked for writing Deprectated: 2.32: Use g_rw_lock_writer_trylock() instead Unlocks @lock. If a thread is waiting to lock @lock for writing and all locks for reading have been unlocked, the waiting thread is woken up and can lock @lock for writing. If no thread is waiting to lock @lock for writing, and some thread or threads are waiting to lock @lock for reading, the waiting threads are woken up and can lock @lock for reading. Deprectated: 2.32: Use g_rw_lock_writer_unlock() instead a #GStaticRWLock to unlock after writing. Sets @pp to %NULL, returning the value that was there before. Conceptually, this transfers the ownership of the pointer from the referenced variable to the "caller" of the macro (ie: "steals" the reference). The return value will be properly typed, according to the type of @pp. This can be very useful when combined with g_autoptr() to prevent the return value of a function from being automatically freed. Consider the following example (which only works on GCC and clang): |[ GObject * create_object (void) { g_autoptr(GObject) obj = g_object_new (G_TYPE_OBJECT, NULL); if (early_error_case) return NULL; return g_steal_pointer (&obj); } ]| It can also be used in similar ways for 'out' parameters and is particularly useful for dealing with optional out parameters: |[ gboolean get_object (GObject **obj_out) { g_autoptr(GObject) obj = g_object_new (G_TYPE_OBJECT, NULL); if (early_error_case) return FALSE; if (obj_out) *obj_out = g_steal_pointer (&obj); return TRUE; } ]| In the above example, the object will be automatically freed in the early error case and also in the case that %NULL was given for @obj_out. Since: 2.44 a pointer to a pointer Copies a nul-terminated string into the dest buffer, include the trailing nul, and return a pointer to the trailing nul byte. This is useful for concatenating multiple strings together without having to repeatedly scan for the end. destination buffer. source string. a pointer to trailing nul byte. Compares two strings for byte-by-byte equality and returns %TRUE if they are equal. It can be passed to g_hash_table_new() as the @key_equal_func parameter, when using non-%NULL strings as keys in a #GHashTable. Note that this function is primarily meant as a hash table comparison function. For a general-purpose, %NULL-safe string comparison function, see g_strcmp0(). a key a key to compare with @v1 %TRUE if the two keys match Looks whether the string @str begins with @prefix. Since: 2.2 a nul-terminated string the nul-terminated prefix to look for %TRUE if @str begins with @prefix, %FALSE otherwise. Looks whether the string @str ends with @suffix. Since: 2.2 a nul-terminated string the nul-terminated suffix to look for %TRUE if @str end with @suffix, %FALSE otherwise. Converts a string to a hash value. This function implements the widely used "djb" hash apparently posted by Daniel Bernstein to comp.lang.c some time ago. The 32 bit unsigned hash value starts at 5381 and for each byte 'c' in the string, is updated: `hash = hash * 33 + c`. This function uses the signed value of each byte. It can be passed to g_hash_table_new() as the @hash_func parameter, when using non-%NULL strings as keys in a #GHashTable. a string key a hash value corresponding to the key Determines if a string is pure ASCII. A string is pure ASCII if it contains no bytes with the high bit set. Since: 2.40 a string %TRUE if @str is ASCII Checks if a search conducted for @search_term should match @potential_hit. This function calls g_str_tokenize_and_fold() on both @search_term and @potential_hit. ASCII alternates are never taken for @search_term but will be taken for @potential_hit according to the value of @accept_alternates. A hit occurs when each folded token in @search_term is a prefix of a folded token from @potential_hit. Depending on how you're performing the search, it will typically be faster to call g_str_tokenize_and_fold() on each string in your corpus and build an index on the returned folded tokens, then call g_str_tokenize_and_fold() on the search term and perform lookups into that index. As some examples, searching for "fred" would match the potential hit "Smith, Fred" and also "Frédéric". Searching for "Fréd" would match "Frédéric" but not "Frederic" (due to the one-directional nature of accent matching). Searching "fo" would match "Foo" and "Bar Foo Baz", but not "SFO" (because no word as "fo" as a prefix). Since: 2.40 the search term from the user the text that may be a hit %TRUE to accept ASCII alternates %TRUE if @potential_hit is a hit Transliterate @str to plain ASCII. For best results, @str should be in composed normalised form. This function performs a reasonably good set of character replacements. The particular set of replacements that is done may change by version or even by runtime environment. If the source language of @str is known, it can used to improve the accuracy of the translation by passing it as @from_locale. It should be a valid POSIX locale string (of the form "language[_territory][.codeset][@modifier]"). If @from_locale is %NULL then the current locale is used. If you want to do translation for no specific locale, and you want it to be done independently of the currently locale, specify "C" for @from_locale. a string, in UTF-8 the source locale, if known a string in plain ASCII Tokenises @string and performs folding on each token. A token is a non-empty sequence of alphanumeric characters in the source string, separated by non-alphanumeric characters. An "alphanumeric" character for this purpose is one that matches g_unichar_isalnum() or g_unichar_ismark(). Each token is then (Unicode) normalised and case-folded. If @ascii_alternates is non-%NULL and some of the returned tokens contain non-ASCII characters, ASCII alternatives will be generated. The number of ASCII alternatives that are generated and the method for doing so is unspecified, but @translit_locale (if specified) may improve the transliteration if the language of the source string is known. Since: 2.40 a string the language code (like 'de' or 'en_GB') from which @string originates a return location for ASCII alternates the folded tokens For each character in @string, if the character is not in @valid_chars, replaces the character with @substitutor. Modifies @string in place, and return @string itself, not a copy. The return value is to allow nesting such as |[<!-- language="C" --> g_ascii_strup (g_strcanon (str, "abc", '?')) ]| a nul-terminated array of bytes bytes permitted in @string replacement character for disallowed bytes @string A case-insensitive string comparison, corresponding to the standard strcasecmp() function on platforms which support it. Deprecated:2.2: See g_strncasecmp() for a discussion of why this function is deprecated and how to replace it. a string a string to compare with @s1 0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2. Removes trailing whitespace from a string. This function doesn't allocate or reallocate any memory; it modifies @string in place. Therefore, it cannot be used on statically allocated strings. The pointer to @string is returned to allow the nesting of functions. Also see g_strchug() and g_strstrip(). a string to remove the trailing whitespace from @string Removes leading whitespace from a string, by moving the rest of the characters forward. This function doesn't allocate or reallocate any memory; it modifies @string in place. Therefore, it cannot be used on statically allocated strings. The pointer to @string is returned to allow the nesting of functions. Also see g_strchomp() and g_strstrip(). a string to remove the leading whitespace from @string Compares @str1 and @str2 like strcmp(). Handles %NULL gracefully by sorting it before non-%NULL strings. Comparing two %NULL pointers returns 0. Since: 2.16 a C string or %NULL another C string or %NULL an integer less than, equal to, or greater than zero, if @str1 is <, == or > than @str2. Replaces all escaped characters with their one byte equivalent. This function does the reverse conversion of g_strescape(). a string to compress a newly-allocated copy of @source with all escaped character compressed Concatenates all of the given strings into one long string. The returned string should be freed with g_free() when no longer needed. The variable argument list must end with %NULL. If you forget the %NULL, g_strconcat() will start appending random memory junk to your string. Note that this function is usually not the right function to use to assemble a translated message from pieces, since proper translation often requires the pieces to be reordered. the first string to add, which must not be %NULL a %NULL-terminated list of strings to append to the string a newly-allocated string containing all the string arguments Converts any delimiter characters in @string to @new_delimiter. Any characters in @string which are found in @delimiters are changed to the @new_delimiter character. Modifies @string in place, and returns @string itself, not a copy. The return value is to allow nesting such as |[<!-- language="C" --> g_ascii_strup (g_strdelimit (str, "abc", '?')) ]| the string to convert a string containing the current delimiters, or %NULL to use the standard delimiters defined in #G_STR_DELIMITERS the new delimiter character @string Converts a string to lower case. Deprecated:2.2: This function is totally broken for the reasons discussed in the g_strncasecmp() docs - use g_ascii_strdown() or g_utf8_strdown() instead. the string to convert. the string Duplicates a string. If @str is %NULL it returns %NULL. The returned string should be freed with g_free() when no longer needed. the string to duplicate a newly-allocated copy of @str Similar to the standard C sprintf() function but safer, since it calculates the maximum space required and allocates memory to hold the result. The returned string should be freed with g_free() when no longer needed. a standard printf() format string, but notice [string precision pitfalls][string-precision] the parameters to insert into the format string a newly-allocated string holding the result Return a newly allocated string, which describes the contents of a #GValue. The main purpose of this function is to describe #GValue contents for debugging output, the way in which the contents are described may change between different GLib versions. #GValue which contents are to be described. Newly allocated string. Similar to the standard C vsprintf() function but safer, since it calculates the maximum space required and allocates memory to hold the result. The returned string should be freed with g_free() when no longer needed. See also g_vasprintf(), which offers the same functionality, but additionally returns the length of the allocated string. a standard printf() format string, but notice [string precision pitfalls][string-precision] the list of parameters to insert into the format string a newly-allocated string holding the result Copies %NULL-terminated array of strings. The copy is a deep copy; the new array should be freed by first freeing each string, then the array itself. g_strfreev() does this for you. If called on a %NULL value, g_strdupv() simply returns %NULL. a %NULL-terminated array of strings a new %NULL-terminated array of strings. Returns a string corresponding to the given error code, e.g. "no such process". You should use this function in preference to strerror(), because it returns a string in UTF-8 encoding, and since not all platforms support the strerror() function. the system error number. See the standard C %errno documentation a UTF-8 string describing the error code. If the error code is unknown, it returns "unknown error (<code>)". Escapes the special characters '\b', '\f', '\n', '\r', '\t', '\v', '\' and '"' in the string @source by inserting a '\' before them. Additionally all characters in the range 0x01-0x1F (everything below SPACE) and in the range 0x7F-0xFF (all non-ASCII chars) are replaced with a '\' followed by their octal representation. Characters supplied in @exceptions are not escaped. g_strcompress() does the reverse conversion. a string to escape a string of characters not to escape in @source a newly-allocated copy of @source with certain characters escaped. See above. Frees a %NULL-terminated array of strings, as well as each string it contains. If @str_array is %NULL, this function simply returns. a %NULL-terminated array of strings to free Adds a string onto the end of a #GString, expanding it if necessary. a #GString the string to append onto the end of @string @string Adds a byte onto the end of a #GString, expanding it if necessary. a #GString the byte to append onto the end of @string @string Appends @len bytes of @val to @string. Because @len is provided, @val may contain embedded nuls and need not be nul-terminated. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @val has at least @len addressable bytes. a #GString bytes to append number of bytes of @val to use @string Appends a formatted string onto the end of a #GString. This function is similar to g_string_printf() except that the text is appended to the #GString. a #GString the string format. See the printf() documentation the parameters to insert into the format string Converts a Unicode character into UTF-8, and appends it to the string. a #GString a Unicode character @string Appends @unescaped to @string, escaped any characters that are reserved in URIs using URI-style escape sequences. Since: 2.16 a #GString a string a string of reserved characters allowed to be used, or %NULL set %TRUE if the escaped string may include UTF8 characters @string Appends a formatted string onto the end of a #GString. This function is similar to g_string_append_printf() except that the arguments to the format string are passed as a va_list. Since: 2.14 a #GString the string format. See the printf() documentation the list of arguments to insert in the output Converts all uppercase ASCII letters to lowercase ASCII letters. a GString passed-in @string pointer, with all the uppercase characters converted to lowercase in place, with semantics that exactly match g_ascii_tolower(). Converts all lowercase ASCII letters to uppercase ASCII letters. a GString passed-in @string pointer, with all the lowercase characters converted to uppercase in place, with semantics that exactly match g_ascii_toupper(). Copies the bytes from a string into a #GString, destroying any previous contents. It is rather like the standard strcpy() function, except that you do not have to worry about having enough space to copy the string. the destination #GString. Its current contents are destroyed. the string to copy into @string @string Frees all strings contained within the #GStringChunk. After calling g_string_chunk_clear() it is not safe to access any of the strings which were contained within it. Since: 2.14 a #GStringChunk Frees all memory allocated by the #GStringChunk. After calling g_string_chunk_free() it is not safe to access any of the strings which were contained within it. a #GStringChunk Adds a copy of @string to the #GStringChunk. It returns a pointer to the new copy of the string in the #GStringChunk. The characters in the string can be changed, if necessary, though you should not change anything after the end of the string. Unlike g_string_chunk_insert_const(), this function does not check for duplicates. Also strings added with g_string_chunk_insert() will not be searched by g_string_chunk_insert_const() when looking for duplicates. a #GStringChunk the string to add a pointer to the copy of @string within the #GStringChunk Adds a copy of @string to the #GStringChunk, unless the same string has already been added to the #GStringChunk with g_string_chunk_insert_const(). This function is useful if you need to copy a large number of strings but do not want to waste space storing duplicates. But you must remember that there may be several pointers to the same string, and so any changes made to the strings should be done very carefully. Note that g_string_chunk_insert_const() will not return a pointer to a string added with g_string_chunk_insert(), even if they do match. a #GStringChunk the string to add a pointer to the new or existing copy of @string within the #GStringChunk Adds a copy of the first @len bytes of @string to the #GStringChunk. The copy is nul-terminated. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @string has at least @len addressable bytes. The characters in the returned string can be changed, if necessary, though you should not change anything after the end of the string. Since: 2.4 a #GStringChunk bytes to insert number of bytes of @string to insert, or -1 to insert a nul-terminated string a pointer to the copy of @string within the #GStringChunk Creates a new #GStringChunk. the default size of the blocks of memory which are allocated to store the strings. If a particular string is larger than this default size, a larger block of memory will be allocated for it. a new #GStringChunk Converts a #GString to lowercase. Deprecated:2.2: This function uses the locale-specific tolower() function, which is almost never the right thing. Use g_string_ascii_down() or g_utf8_strdown() instead. a #GString the #GString Compares two strings for equality, returning %TRUE if they are equal. For use with #GHashTable. a #GString another #GString %TRUE if the strings are the same length and contain the same bytes Removes @len bytes from a #GString, starting at position @pos. The rest of the #GString is shifted down to fill the gap. a #GString the position of the content to remove the number of bytes to remove, or -1 to remove all following bytes @string Frees the memory allocated for the #GString. If @free_segment is %TRUE it also frees the character data. If it's %FALSE, the caller gains ownership of the buffer and must free it after use with g_free(). a #GString if %TRUE, the actual character data is freed as well the character data of @string (i.e. %NULL if @free_segment is %TRUE) Transfers ownership of the contents of @string to a newly allocated #GBytes. The #GString structure itself is deallocated, and it is therefore invalid to use @string after invoking this function. Note that while #GString ensures that its buffer always has a trailing nul character (not reflected in its "len"), the returned #GBytes does not include this extra nul; i.e. it has length exactly equal to the "len" member. Since: 2.34 a #GString A newly allocated #GBytes containing contents of @string; @string itself is freed Creates a hash code for @str; for use with #GHashTable. a string to hash hash code for @str Inserts a copy of a string into a #GString, expanding it if necessary. a #GString the position to insert the copy of the string the string to insert @string Inserts a byte into a #GString, expanding it if necessary. a #GString the position to insert the byte the byte to insert @string Inserts @len bytes of @val into @string at @pos. Because @len is provided, @val may contain embedded nuls and need not be nul-terminated. If @pos is -1, bytes are inserted at the end of the string. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @val has at least @len addressable bytes. a #GString position in @string where insertion should happen, or -1 for at the end bytes to insert number of bytes of @val to insert @string Converts a Unicode character into UTF-8, and insert it into the string at the given position. a #GString the position at which to insert character, or -1 to append at the end of the string a Unicode character @string Creates a new #GString, initialized with the given string. the initial text to copy into the string, or %NULL to start with an empty string. the new #GString Creates a new #GString with @len bytes of the @init buffer. Because a length is provided, @init need not be nul-terminated, and can contain embedded nul bytes. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @init has at least @len addressable bytes. initial contents of the string length of @init to use a new #GString Overwrites part of a string, lengthening it if necessary. Since: 2.14 a #GString the position at which to start overwriting the string that will overwrite the @string starting at @pos @string Overwrites part of a string, lengthening it if necessary. This function will work with embedded nuls. Since: 2.14 a #GString the position at which to start overwriting the string that will overwrite the @string starting at @pos the number of bytes to write from @val @string Adds a string on to the start of a #GString, expanding it if necessary. a #GString the string to prepend on the start of @string @string Adds a byte onto the start of a #GString, expanding it if necessary. a #GString the byte to prepend on the start of the #GString @string Prepends @len bytes of @val to @string. Because @len is provided, @val may contain embedded nuls and need not be nul-terminated. Since this function does not stop at nul bytes, it is the caller's responsibility to ensure that @val has at least @len addressable bytes. a #GString bytes to prepend number of bytes in @val to prepend @string Converts a Unicode character into UTF-8, and prepends it to the string. a #GString a Unicode character @string Writes a formatted string into a #GString. This is similar to the standard sprintf() function, except that the #GString buffer automatically expands to contain the results. The previous contents of the #GString are destroyed. a #GString the string format. See the printf() documentation the parameters to insert into the format string Sets the length of a #GString. If the length is less than the current length, the string will be truncated. If the length is greater than the current length, the contents of the newly added area are undefined. (However, as always, string->str[string->len] will be a nul byte.) a #GString the new length @string Creates a new #GString, with enough space for @dfl_size bytes. This is useful if you are going to add a lot of text to the string and don't want it to be reallocated too often. the default size of the space allocated to hold the string the new #GString Writes a formatted string into a #GString. This is similar to the standard sprintf() function, except that the #GString buffer automatically expands to contain the results. The previous contents of the #GString are destroyed. Deprecated: This function has been renamed to g_string_printf(). a #GString the string format. See the sprintf() documentation the parameters to insert into the format string Appends a formatted string onto the end of a #GString. This function is similar to g_string_sprintf() except that the text is appended to the #GString. Deprecated: This function has been renamed to g_string_append_printf() a #GString the string format. See the sprintf() documentation the parameters to insert into the format string Cuts off the end of the GString, leaving the first @len bytes. a #GString the new size of @string @string Converts a #GString to uppercase. Deprecated:2.2: This function uses the locale-specific toupper() function, which is almost never the right thing. Use g_string_ascii_up() or g_utf8_strup() instead. a #GString @string Writes a formatted string into a #GString. This function is similar to g_string_printf() except that the arguments to the format string are passed as a va_list. Since: 2.14 a #GString the string format. See the printf() documentation the parameters to insert into the format string An auxiliary function for gettext() support (see Q_()). Since: 2.4 a string another string @msgval, unless @msgval is identical to @msgid and contains a '|' character, in which case a pointer to the substring of msgid after the first '|' character is returned. Joins a number of strings together to form one long string, with the optional @separator inserted between each of them. The returned string should be freed with g_free(). a string to insert between each of the strings, or %NULL a %NULL-terminated list of strings to join a newly-allocated string containing all of the strings joined together, with @separator between them Joins a number of strings together to form one long string, with the optional @separator inserted between each of them. The returned string should be freed with g_free(). a string to insert between each of the strings, or %NULL a %NULL-terminated array of strings to join a newly-allocated string containing all of the strings joined together, with @separator between them Portability wrapper that calls strlcat() on systems which have it, and emulates it otherwise. Appends nul-terminated @src string to @dest, guaranteeing nul-termination for @dest. The total size of @dest won't exceed @dest_size. At most @dest_size - 1 characters will be copied. Unlike strncat(), @dest_size is the full size of dest, not the space left over. This function does not allocate memory. It always nul-terminates (unless @dest_size == 0 or there were no nul characters in the @dest_size characters of dest to start with). Caveat: this is supposedly a more secure alternative to strcat() or strncat(), but for real security g_strconcat() is harder to mess up. destination buffer, already containing one nul-terminated string source buffer length of @dest buffer in bytes (not length of existing string inside @dest) size of attempted result, which is MIN (dest_size, strlen (original dest)) + strlen (src), so if retval >= dest_size, truncation occurred. Portability wrapper that calls strlcpy() on systems which have it, and emulates strlcpy() otherwise. Copies @src to @dest; @dest is guaranteed to be nul-terminated; @src must be nul-terminated; @dest_size is the buffer size, not the number of bytes to copy. At most @dest_size - 1 characters will be copied. Always nul-terminates (unless @dest_size is 0). This function does not allocate memory. Unlike strncpy(), this function doesn't pad @dest (so it's often faster). It returns the size of the attempted result, strlen (src), so if @retval >= @dest_size, truncation occurred. Caveat: strlcpy() is supposedly more secure than strcpy() or strncpy(), but if you really want to avoid screwups, g_strdup() is an even better idea. destination buffer source buffer length of @dest in bytes length of @src A case-insensitive string comparison, corresponding to the standard strncasecmp() function on platforms which support it. It is similar to g_strcasecmp() except it only compares the first @n characters of the strings. Deprecated:2.2: The problem with g_strncasecmp() is that it does the comparison by calling toupper()/tolower(). These functions are locale-specific and operate on single bytes. However, it is impossible to handle things correctly from an internationalization standpoint by operating on bytes, since characters may be multibyte. Thus g_strncasecmp() is broken if your string is guaranteed to be ASCII, since it is locale-sensitive, and it's broken if your string is localized, since it doesn't work on many encodings at all, including UTF-8, EUC-JP, etc. There are therefore two replacement techniques: g_ascii_strncasecmp(), which only works on ASCII and is not locale-sensitive, and g_utf8_casefold() followed by strcmp() on the resulting strings, which is good for case-insensitive sorting of UTF-8. a string a string to compare with @s1 the maximum number of characters to compare 0 if the strings match, a negative value if @s1 < @s2, or a positive value if @s1 > @s2. Duplicates the first @n bytes of a string, returning a newly-allocated buffer @n + 1 bytes long which will always be nul-terminated. If @str is less than @n bytes long the buffer is padded with nuls. If @str is %NULL it returns %NULL. The returned value should be freed when no longer needed. To copy a number of characters from a UTF-8 encoded string, use g_utf8_strncpy() instead. the string to duplicate the maximum number of bytes to copy from @str a newly-allocated buffer containing the first @n bytes of @str, nul-terminated Creates a new string @length bytes long filled with @fill_char. The returned string should be freed when no longer needed. the length of the new string the byte to fill the string with a newly-allocated string filled the @fill_char Reverses all of the bytes in a string. For example, `g_strreverse ("abcdef")` will result in "fedcba". Note that g_strreverse() doesn't work on UTF-8 strings containing multibyte characters. For that purpose, use g_utf8_strreverse(). the string to reverse the same pointer passed in as @string Searches the string @haystack for the last occurrence of the string @needle. a nul-terminated string the nul-terminated string to search for a pointer to the found occurrence, or %NULL if not found. Searches the string @haystack for the last occurrence of the string @needle, limiting the length of the search to @haystack_len. a nul-terminated string the maximum length of @haystack the nul-terminated string to search for a pointer to the found occurrence, or %NULL if not found. Returns a string describing the given signal, e.g. "Segmentation fault". You should use this function in preference to strsignal(), because it returns a string in UTF-8 encoding, and since not all platforms support the strsignal() function. the signal number. See the `signal` documentation a UTF-8 string describing the signal. If the signal is unknown, it returns "unknown signal (<signum>)". Splits a string into a maximum of @max_tokens pieces, using the given @delimiter. If @max_tokens is reached, the remainder of @string is appended to the last token. As an example, the result of g_strsplit (":a:bc::d:", ":", -1) is a %NULL-terminated vector containing the six strings "", "a", "bc", "", "d" and "". As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent a empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling g_strsplit(). a string to split a string which specifies the places at which to split the string. The delimiter is not included in any of the resulting strings, unless @max_tokens is reached. the maximum number of pieces to split @string into. If this is less than 1, the string is split completely. a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it. Splits @string into a number of tokens not containing any of the characters in @delimiter. A token is the (possibly empty) longest string that does not contain any of the characters in @delimiters. If @max_tokens is reached, the remainder is appended to the last token. For example the result of g_strsplit_set ("abc:def/ghi", ":/", -1) is a %NULL-terminated vector containing the three strings "abc", "def", and "ghi". The result of g_strsplit_set (":def/ghi:", ":/", -1) is a %NULL-terminated vector containing the four strings "", "def", "ghi", and "". As a special case, the result of splitting the empty string "" is an empty vector, not a vector containing a single string. The reason for this special case is that being able to represent a empty vector is typically more useful than consistent handling of empty elements. If you do need to represent empty elements, you'll need to check for the empty string before calling g_strsplit_set(). Note that this function works on bytes not characters, so it can't be used to delimit UTF-8 strings for anything but ASCII characters. Since: 2.4 The string to be tokenized A nul-terminated string containing bytes that are used to split the string. The maximum number of tokens to split @string into. If this is less than 1, the string is split completely a newly-allocated %NULL-terminated array of strings. Use g_strfreev() to free it. Searches the string @haystack for the first occurrence of the string @needle, limiting the length of the search to @haystack_len. a string the maximum length of @haystack. Note that -1 is a valid length, if @haystack is nul-terminated, meaning it will search through the whole string. the string to search for a pointer to the found occurrence, or %NULL if not found. Removes leading and trailing whitespace from a string. See g_strchomp() and g_strchug(). a string to remove the leading and trailing whitespace from @string Converts a string to a #gdouble value. It calls the standard strtod() function to handle the conversion, but if the string is not completely converted it attempts the conversion again with g_ascii_strtod(), and returns the best match. This function should seldom be used. The normal situation when reading numbers not for human consumption is to use g_ascii_strtod(). Only when you know that you must expect both locale formatted and C formatted numbers should you use this. Make sure that you don't pass strings such as comma separated lists of values, since the commas may be interpreted as a decimal point in some locales, causing unexpected results. the string to convert to a numeric value. if non-%NULL, it returns the character after the last character used in the conversion. the #gdouble value. Converts a string to upper case. Deprecated:2.2: This function is totally broken for the reasons discussed in the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead. the string to convert the string Checks if @strv contains @str. @strv must not be %NULL. Since: 2.44 a %NULL-terminated array of strings a string %TRUE if @str is an element of @strv, according to g_str_equal(). Returns the length of the given %NULL-terminated string array @str_array. Since: 2.6 a %NULL-terminated array of strings length of @str_array. Hook up a new test case at @testpath, similar to g_test_add_func(). A fixture data structure with setup and teardown functions may be provided, similar to g_test_create_case(). g_test_add() is implemented as a macro, so that the fsetup(), ftest() and fteardown() callbacks can expect a @Fixture pointer as their first argument in a type safe manner. They otherwise have type #GTestFixtureFunc. Since: 2.16 The test path for a new test case. The type of a fixture data structure. Data argument for the test functions. The function to set up the fixture data. The actual test function. The function to tear down the fixture data. Create a new test case, similar to g_test_create_case(). However the test is assumed to use no fixture, and test suites are automatically created on the fly and added to the root fixture, based on the slash-separated portions of @testpath. The @test_data argument will be passed as first argument to @test_func. If @testpath includes the component "subprocess" anywhere in it, the test will be skipped by default, and only run if explicitly required via the `-p` command-line option or g_test_trap_subprocess(). Since: 2.16 /-separated test case path name for the test. Test data argument for the test function. The test function to invoke for this test. Create a new test case, as with g_test_add_data_func(), but freeing @test_data after the test run is complete. Since: 2.34 /-separated test case path name for the test. Test data argument for the test function. The test function to invoke for this test. #GDestroyNotify for @test_data. Create a new test case, similar to g_test_create_case(). However the test is assumed to use no fixture, and test suites are automatically created on the fly and added to the root fixture, based on the slash-separated portions of @testpath. If @testpath includes the component "subprocess" anywhere in it, the test will be skipped by default, and only run if explicitly required via the `-p` command-line option or g_test_trap_subprocess(). Since: 2.16 /-separated test case path name for the test. The test function to invoke for this test. Asserts that all messages previously indicated via g_test_expect_message() have been seen and suppressed. If messages at %G_LOG_LEVEL_DEBUG are emitted, but not explicitly expected via g_test_expect_message() then they will be ignored. Since: 2.34 This function adds a message to test reports that associates a bug URI with a test case. Bug URIs are constructed from a base URI set with g_test_bug_base() and @bug_uri_snippet. Since: 2.16 Bug specific bug tracker URI portion. Specify the base URI for bug reports. The base URI is used to construct bug report messages for g_test_message() when g_test_bug() is called. Calling this function outside of a test case sets the default base URI for all test cases. Calling it from within a test case changes the base URI for the scope of the test case only. Bug URIs are constructed by appending a bug specific URI portion to @uri_pattern, or by replacing the special string '\%s' within @uri_pattern if that is present. Since: 2.16 the base pattern for bug URIs Creates the pathname to a data file that is required for a test. This function is conceptually similar to g_build_filename() except that the first argument has been replaced with a #GTestFileType argument. The data file should either have been distributed with the module containing the test (%G_TEST_DIST) or built as part of the build system of that module (%G_TEST_BUILT). In order for this function to work in srcdir != builddir situations, the G_TEST_SRCDIR and G_TEST_BUILDDIR environment variables need to have been defined. As of 2.38, this is done by the glib.mk included in GLib. Please ensure that your copy is up to date before using this function. In case neither variable is set, this function will fall back to using the dirname portion of argv[0], possibly removing ".libs". This allows for casual running of tests directly from the commandline in the srcdir == builddir case and should also support running of installed tests, assuming the data files have been installed in the same relative path as the test binary. Since: 2.38 the type of file (built vs. distributed) the first segment of the pathname %NULL-terminated additional path segments the path of the file, to be freed using g_free() Create a new #GTestCase, named @test_name, this API is fairly low level, calling g_test_add() or g_test_add_func() is preferable. When this test is executed, a fixture structure of size @data_size will be automatically allocated and filled with zeros. Then @data_setup is called to initialize the fixture. After fixture setup, the actual test function @data_test is called. Once the test run completes, the fixture structure is torn down by calling @data_teardown and after that the memory is automatically released by the test framework. Splitting up a test run into fixture setup, test function and fixture teardown is most useful if the same fixture is used for multiple tests. In this cases, g_test_create_case() will be called with the same fixture, but varying @test_name and @data_test arguments. Since: 2.16 the name for the test case the size of the fixture data structure test data argument for the test functions the function to set up the fixture data the actual test function the function to teardown the fixture data a newly allocated #GTestCase. Create a new test suite with the name @suite_name. Since: 2.16 a name for the suite A newly allocated #GTestSuite instance. Indicates that a message with the given @log_domain and @log_level, with text matching @pattern, is expected to be logged. When this message is logged, it will not be printed, and the test case will not abort. Use g_test_assert_expected_messages() to assert that all previously-expected messages have been seen and suppressed. You can call this multiple times in a row, if multiple messages are expected as a result of a single call. (The messages must appear in the same order as the calls to g_test_expect_message().) For example: |[<!-- language="C" --> // g_main_context_push_thread_default() should fail if the // context is already owned by another thread. g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "assertion*acquired_context*failed"); g_main_context_push_thread_default (bad_context); g_test_assert_expected_messages (); ]| Note that you cannot use this to test g_error() messages, since g_error() intentionally never returns even if the program doesn't abort; use g_test_trap_subprocess() in this case. If messages at %G_LOG_LEVEL_DEBUG are emitted, but not explicitly expected via g_test_expect_message() then they will be ignored. Since: 2.34 the log domain of the message the log level of the message a glob-style [pattern][glib-Glob-style-pattern-matching] 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. Do not use this function if the failure of a test could cause other tests to malfunction. Calling this function will not stop the test from running, you need to return from the test function yourself. So you can produce additional diagnostic messages or even continue running the test. If not called from inside a test, this function does nothing. Since: 2.30 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. This can be useful to return early from a test if continuing after a failed assertion might be harmful. The return value of this function is only meaningful if it is called from inside a test function. Since: 2.38 %TRUE if the test has failed Gets the pathname of the directory containing test files of the type specified by @file_type. This is approximately the same as calling g_test_build_filename("."), but you don't need to free the return value. Since: 2.38 the type of file (built vs. distributed) the path of the directory, owned by GLib Gets the pathname to a data file that is required for a test. This is the same as g_test_build_filename() with two differences. The first difference is that must only use this function from within a testcase function. The second difference is that you need not free the return value -- it will be automatically freed when the testcase finishes running. It is safe to use this function from a thread inside of a testcase but you must ensure that all such uses occur before the main testcase function returns (ie: it is best to ensure that all threads have been joined). Since: 2.38 the type of file (built vs. distributed) the first segment of the pathname %NULL-terminated additional path segments the path, automatically freed at the end of the testcase Get the toplevel test suite for the test path API. Since: 2.16 the toplevel #GTestSuite Indicates that a test failed because of some incomplete functionality. This function can be called multiple times from the same test. Calling this function will not stop the test from running, you need to return from the test function yourself. So you can produce additional diagnostic messages or even continue running the test. If not called from inside a test, this function does nothing. Since: 2.38 explanation Initialize the GLib testing framework, e.g. by seeding the test random number generator, the name for g_get_prgname() and parsing test related command line args. So far, the following arguments are understood: - `-l`: List test cases available in a test executable. - `--seed=SEED`: Provide a random seed to reproduce test runs using random numbers. - `--verbose`: Run tests verbosely. - `-q`, `--quiet`: Run tests quietly. - `-p PATH`: Execute all tests matching the given path. This can also be used to force a test to run that would otherwise be skipped (ie, a test whose name contains "/subprocess"). - `-m {perf|slow|thorough|quick|undefined|no-undefined}`: Execute tests according to these test modes: `perf`: Performance tests, may take long and report results. `slow`, `thorough`: Slow and thorough tests, may take quite long and maximize coverage. `quick`: Quick tests, should run really quickly and give good coverage. `undefined`: Tests for undefined behaviour, may provoke programming errors under g_test_trap_subprocess() or g_test_expect_messages() to check that appropriate assertions or warnings are given `no-undefined`: Avoid tests for undefined behaviour - `--debug-log`: Debug test logging output. Since: 2.16 Address of the @argc parameter of the main() function. Changed if any arguments were handled. Address of the @argv parameter of main(). Any parameters understood by g_test_init() stripped before return. %NULL-terminated list of special options. Currently the only defined option is `"no_g_set_prgname"`, which will cause g_test_init() to not call g_set_prgname(). Returns %TRUE if g_test_init() has been called. Since: 2.36 %TRUE if g_test_init() has been called. Internal function for gtester to free test log messages, no ABI guarantees provided. Internal function for gtester to decode test log messages, no ABI guarantees provided. Internal function for gtester to retrieve test log messages, no ABI guarantees provided. Internal function for gtester to decode test log messages, no ABI guarantees provided. Internal function for gtester to free test log messages, no ABI guarantees provided. Installs a non-error fatal log handler which can be used to decide whether log messages which are counted as fatal abort the program. The use case here is that you are running a test case that depends on particular libraries or circumstances and cannot prevent certain known critical or warning messages. So you install a handler that compares the domain and message to precisely not abort in such a case. Note that the handler is reset at the beginning of any test case, so you have to set it inside each test function which needs the special behavior. This handler has no effect on g_error messages. Since: 2.22 the log handler function. data passed to the log handler. Report the result of a performance or measurement test. The test should generally strive to maximize the reported quantities (larger values are better than smaller ones), this and @maximized_quantity can determine sorting order for test result reports. Since: 2.16 the reported value the format string of the report message arguments to pass to the printf() function Add a message to the test report. Since: 2.16 the format string printf-like arguments to @format Report the result of a performance or measurement test. The test should generally strive to minimize the reported quantities (smaller values are better than larger ones), this and @minimized_quantity can determine sorting order for test result reports. Since: 2.16 the reported value the format string of the report message arguments to pass to the printf() function Returns %TRUE if tests are run in performance mode. %TRUE if in performance mode This function enqueus a callback @destroy_func to be executed during the next test case teardown phase. This is most useful to auto destruct allocted test resources at the end of a test run. Resources are released in reverse queue order, that means enqueueing callback A before callback B will cause B() to be called before A() during teardown. Since: 2.16 Destroy callback for teardown phase. Destroy callback data. Enqueue a pointer to be released with g_free() during the next teardown phase. This is equivalent to calling g_test_queue_destroy() with a destroy callback of g_free(). Since: 2.16 the pointer to be stored. Enqueue an object to be released with g_object_unref() during the next teardown phase. This is equivalent to calling g_test_queue_destroy() with a destroy callback of g_object_unref(). Since: 2.16 the object to unref Returns %TRUE if tests are run in quick mode. Exactly one of g_test_quick() and g_test_slow() is active in any run; there is no "medium speed". %TRUE if in quick mode Returns %TRUE if tests are run in quiet mode. The default is neither g_test_verbose() nor g_test_quiet(). %TRUE if in quiet mode Get a reproducible random bit (0 or 1), see g_test_rand_int() for details on test case random numbers. Since: 2.16 Get a reproducible random floating point number, see g_test_rand_int() for details on test case random numbers. Since: 2.16 a random number from the seeded random number generator. Get a reproducible random floating pointer number out of a specified range, see g_test_rand_int() for details on test case random numbers. Since: 2.16 the minimum value returned by this function the minimum value not returned by this function a number with @range_start <= number < @range_end. Get a reproducible random integer number. The random numbers generated by the g_test_rand_*() family of functions change with every new test program start, unless the --seed option is given when starting test programs. For individual test cases however, the random number generator is reseeded, to avoid dependencies between tests and to make --seed effective for all test cases. Since: 2.16 a random number from the seeded random number generator. Get a reproducible random integer number out of a specified range, see g_test_rand_int() for details on test case random numbers. Since: 2.16 the minimum value returned by this function the smallest value not to be returned by this function a number with @begin <= number < @end. 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`) as parsed by g_test_init(). g_test_run_suite() or g_test_run() may only be called once in a program. In general, the tests and sub-suites within each suite are run in the order in which they are defined. However, note that prior to GLib 2.36, there was a bug in the `g_test_add_*` functions which caused them to create multiple suites with the same name, meaning that if you created tests "/foo/simple", "/bar/simple", and "/foo/using-bar" in that order, they would get run in that order (since g_test_run() would run the first "/foo" suite, then the "/bar" suite, then the second "/foo" suite). As of 2.36, this bug is fixed, and adding the tests in that order would result in a running order of "/foo/simple", "/foo/using-bar", "/bar/simple". If this new ordering is sub-optimal (because it puts more-complicated tests before simpler ones, making it harder to figure out exactly what has failed), you can fix it by changing the test paths to group tests by suite in a way that will result in the desired running order. Eg, "/simple/foo", "/simple/bar", "/complex/foo-using-bar". However, you should never make the actual result of a test depend on the order that tests are run in. If you need to ensure that some particular code runs before or after a given test case, use g_test_add(), which lets you specify setup and teardown functions. If all tests are skipped, this function will return 0 if producing TAP output, or 77 (treated as "skip test" by Automake) otherwise. Since: 2.16 0 on success, 1 on failure (assuming it returns at all), 0 or 77 if all tests were skipped with g_test_skip() Execute the tests within @suite and all nested #GTestSuites. The test suites to be executed are filtered according to test path arguments (`-p testpath`) as parsed by g_test_init(). See the g_test_run() documentation for more information on the order that tests are run in. g_test_run_suite() or g_test_run() may only be called once in a program. Since: 2.16 a #GTestSuite 0 on success Changes the behaviour of g_assert_cmpstr(), g_assert_cmpint(), g_assert_cmpuint(), g_assert_cmphex(), g_assert_cmpfloat(), g_assert_true(), g_assert_false(), g_assert_null(), g_assert_no_error(), g_assert_error(), 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.) Note that the g_assert_not_reached() and g_assert() are not affected by this. This function can only be called after g_test_init(). Since: 2.38 Indicates that a test was skipped. Calling this function will not stop the test from running, you need to return from the test function yourself. So you can produce additional diagnostic messages or even continue running the test. If not called from inside a test, this function does nothing. Since: 2.38 explanation Returns %TRUE if tests are run in slow mode. Exactly one of g_test_quick() and g_test_slow() is active in any run; there is no "medium speed". the opposite of g_test_quick() Returns %TRUE (after g_test_init() has been called) if the test program is running under g_test_trap_subprocess(). Since: 2.38 %TRUE if the test program is running under g_test_trap_subprocess(). Adds @test_case to @suite. Since: 2.16 a #GTestSuite a #GTestCase Adds @nestedsuite to @suite. Since: 2.16 a #GTestSuite another #GTestSuite Returns %TRUE if tests are run in thorough mode, equivalent to g_test_slow(). the same thing as g_test_slow() Get the time since the last start of the timer with g_test_timer_start(). Since: 2.16 the time since the last start of the timer, as a double Report the last result of g_test_timer_elapsed(). Since: 2.16 the last result of g_test_timer_elapsed(), as a double 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. Since: 2.16 Assert that the last test subprocess failed. See g_test_trap_subprocess(). This is sometimes used to test situations that are formally considered to be undefined behaviour, like inputs that fail a g_return_if_fail() check. In these situations you should skip the entire test, including the call to g_test_trap_subprocess(), unless g_test_undefined() returns %TRUE to indicate that undefined behaviour may be tested. Since: 2.16 Assert that the last test subprocess passed. See g_test_trap_subprocess(). Since: 2.16 Assert that the stderr output of the last test subprocess matches @serrpattern. See g_test_trap_subprocess(). This is sometimes used to test situations that are formally considered to be undefined behaviour, like code that hits a g_assert() or g_error(). In these situations you should skip the entire test, including the call to g_test_trap_subprocess(), unless g_test_undefined() returns %TRUE to indicate that undefined behaviour may be tested. Since: 2.16 a glob-style [pattern][glib-Glob-style-pattern-matching] Assert that the stderr output of the last test subprocess does not match @serrpattern. See g_test_trap_subprocess(). Since: 2.16 a glob-style [pattern][glib-Glob-style-pattern-matching] Assert that the stdout output of the last test subprocess matches @soutpattern. See g_test_trap_subprocess(). Since: 2.16 a glob-style [pattern][glib-Glob-style-pattern-matching] Assert that the stdout output of the last test subprocess does not match @soutpattern. See g_test_trap_subprocess(). Since: 2.16 a glob-style [pattern][glib-Glob-style-pattern-matching] Fork the current test program to execute a test case that might not return or that might abort. If @usec_timeout is non-0, the forked test case is aborted and considered failing if its run time exceeds it. The forking behavior can be configured with the #GTestTrapFlags flags. In the following example, the test code forks, the forked child process produces some sample output and exits successfully. The forking parent process then asserts successful child program termination and validates child program outputs. |[<!-- language="C" --> static void test_fork_patterns (void) { if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR)) { g_print ("some stdout text: somagic17\n"); g_printerr ("some stderr text: semagic43\n"); exit (0); // successful test run } g_test_trap_assert_passed (); g_test_trap_assert_stdout ("*somagic17*"); g_test_trap_assert_stderr ("*semagic43*"); } ]| Since: 2.16 Deprecated: This function is implemented only on Unix platforms, and is not always reliable due to problems inherent in fork-without-exec. Use g_test_trap_subprocess() instead. Timeout for the forked test in micro seconds. Flags to modify forking behaviour. %TRUE for the forked child and %FALSE for the executing parent process. Check the result of the last g_test_trap_subprocess() call. Since: 2.16 %TRUE if the last test subprocess terminated successfully. Check the result of the last g_test_trap_subprocess() call. Since: 2.16 %TRUE if the last test subprocess got killed due to a timeout. Respawns the test program to run only @test_path in a subprocess. This can be used for a test case that might not return, or that might abort. If @test_path is %NULL then the same test is re-run in a subprocess. You can use g_test_subprocess() to determine whether the test is in a subprocess or not. @test_path can also be the name of the parent test, followed by "`/subprocess/`" and then a name for the specific subtest (or just ending with "`/subprocess`" if the test only has one child test); tests with names of this form will automatically be skipped in the parent process. If @usec_timeout is non-0, the test subprocess is aborted and considered failing if its run time exceeds it. The subprocess behavior can be configured with the #GTestSubprocessFlags flags. You can use methods such as g_test_trap_assert_passed(), g_test_trap_assert_failed(), and g_test_trap_assert_stderr() to check the results of the subprocess. (But note that g_test_trap_assert_stdout() and g_test_trap_assert_stderr() cannot be used if @test_flags specifies that the child should inherit the parent stdout/stderr.) If your `main ()` needs to behave differently in the subprocess, you can call g_test_subprocess() (after calling g_test_init()) to see whether you are in a subprocess. The following example tests that calling `my_object_new(1000000)` will abort with an error message. |[<!-- language="C" --> static void test_create_large_object_subprocess (void) { if (g_test_subprocess ()) { my_object_new (1000000); return; } // Reruns this same test in a subprocess g_test_trap_subprocess (NULL, 0, 0); g_test_trap_assert_failed (); g_test_trap_assert_stderr ("*ERROR*too large*"); } int main (int argc, char **argv) { g_test_init (&argc, &argv, NULL); g_test_add_func ("/myobject/create_large_object", test_create_large_object); return g_test_run (); } ]| Since: 2.38 Test to run in a subprocess Timeout for the subprocess test in micro seconds. Flags to modify subprocess behaviour. Returns %TRUE if tests may provoke assertions and other formally-undefined behaviour, to verify that appropriate warnings are given. It might, in some cases, be useful to turn this off if running tests under valgrind. %TRUE if tests may provoke programming errors Returns %TRUE if tests are run in verbose mode. The default is neither g_test_verbose() nor g_test_quiet(). %TRUE if in verbose mode This function creates a new thread. The new thread executes the function @func with the argument @data. If the thread was created successfully, it is returned. @error can be %NULL to ignore errors, or non-%NULL to report errors. The error is set, if and only if the function returns %NULL. This function returns a reference to the created thread only if @joinable is %TRUE. In that case, you must free this reference by calling g_thread_unref() or g_thread_join(). If @joinable is %FALSE then you should probably not touch the return value. Deprecated:2.32: Use g_thread_new() instead a function to execute in the new thread an argument to supply to the new thread should this thread be joinable? return location for error, or %NULL the new #GThread on success This function creates a new thread. Deprecated:2.32: The @bound and @priority arguments are now ignored. Use g_thread_new(). a function to execute in the new thread. an argument to supply to the new thread. a stack size for the new thread. should this thread be joinable? ignored ignored return location for error. the new #GThread on success. Terminates the current thread. If another thread is waiting for us using g_thread_join() then the waiting thread will be woken up and get @retval as the return value of g_thread_join(). Calling g_thread_exit() with a parameter @retval is equivalent to returning @retval from the function @func, as given to g_thread_new(). You must only call g_thread_exit() from a thread that you created yourself with g_thread_new() or related APIs. You must not call this function from a thread created with another threading library or or from within a #GThreadPool. the return value of this thread Call @thread_func on all #GThreads that have been created with g_thread_create(). Note that threads may decide to exit while @thread_func is running, so without intimate knowledge about the lifetime of foreign threads, @thread_func shouldn't access the GThread* pointer passed in as first argument. However, @thread_func will not be called for threads which are known to have exited already. Due to thread lifetime checks, this function has an execution complexity which is quadratic in the number of existing threads. Since: 2.10 Deprecated:2.32: There aren't many things you can do with a #GThread, except comparing it with one that was returned from g_thread_create(). There are better ways to find out if your thread is still alive. function to call for all #GThread structures second argument to @thread_func Indicates if g_thread_init() has been called. Since: 2.20 %TRUE if threads have been initialized. If you use GLib from more than one thread, you must initialize the thread system by calling g_thread_init(). Since version 2.24, calling g_thread_init() multiple times is allowed, but nothing happens except for the first call. Since version 2.32, GLib does not support custom thread implementations anymore and the @vtable parameter is ignored and you should pass %NULL. <note><para>g_thread_init() must not be called directly or indirectly in a callback from GLib. Also no mutexes may be currently locked while calling g_thread_init().</para></note> <note><para>To use g_thread_init() in your program, you have to link with the libraries that the command <command>pkg-config --libs gthread-2.0</command> outputs. This is not the case for all the other thread-related functions of GLib. Those can be used without having to link with the thread libraries.</para></note> Deprecated:2.32: This function is no longer necessary. The GLib threading system is automatically initialized at the start of your program. a function table of type #GThreadFunctions, that provides the entry points to the thread system to be used. Since 2.32, this parameter is ignored and should always be %NULL Waits until @thread finishes, i.e. the function @func, as given to g_thread_new(), returns or g_thread_exit() is called. If @thread has already terminated, then g_thread_join() returns immediately. Any thread can wait for any other thread by calling g_thread_join(), not just its 'creator'. Calling g_thread_join() from multiple threads for the same @thread leads to undefined behaviour. The value returned by @func or given to g_thread_exit() is returned by this function. g_thread_join() consumes the reference to the passed-in @thread. This will usually cause the #GThread struct and associated resources to be freed. Use g_thread_ref() to obtain an extra reference if you want to keep the GThread alive beyond the g_thread_join() call. a #GThread the return value of the thread This function creates a new thread. The new thread starts by invoking @func with the argument data. The thread will run until @func returns or until g_thread_exit() is called from the new thread. The return value of @func becomes the return value of the thread, which can be obtained with g_thread_join(). The @name can be useful for discriminating threads in a debugger. It is not used for other purposes and does not have to be unique. Some systems restrict the length of @name to 16 bytes. If the thread can not be created the program aborts. See g_thread_try_new() if you want to attempt to deal with failures. To free the struct returned by this function, use g_thread_unref(). Note that g_thread_join() implicitly unrefs the #GThread as well. Since: 2.32 an (optional) name for the new thread a function to execute in the new thread an argument to supply to the new thread the new #GThread Frees all resources allocated for @pool. If @immediate is %TRUE, no new task is processed for @pool. Otherwise @pool is not freed before the last task is processed. Note however, that no thread of this pool is interrupted while processing a task. Instead at least all still running threads can finish their tasks before the @pool is freed. If @wait_ is %TRUE, the functions does not return before all tasks to be processed (dependent on @immediate, whether all or only the currently running) are ready. Otherwise the function returns immediately. After calling this function @pool must not be used anymore. a #GThreadPool should @pool shut down immediately? should the function wait for all tasks to be finished? This function will return the maximum @interval that a thread will wait in the thread pool for new tasks before being stopped. If this function returns 0, threads waiting in the thread pool for new work are not stopped. Since: 2.10 the maximum @interval (milliseconds) to wait for new tasks in the thread pool before stopping the thread Returns the maximal number of threads for @pool. a #GThreadPool the maximal number of threads Returns the maximal allowed number of unused threads. the maximal number of unused threads Returns the number of threads currently running in @pool. a #GThreadPool the number of threads currently running Returns the number of currently unused threads. the number of currently unused threads Moves the item to the front of the queue of unprocessed items, so that it will be processed next. Since: 2.46 a #GThreadPool an unprocessed item in the pool %TRUE if the item was found and moved This function creates a new thread pool. Whenever you call g_thread_pool_push(), either a new thread is created or an unused one is reused. At most @max_threads threads are running concurrently for this thread pool. @max_threads = -1 allows unlimited threads to be created for this thread pool. The newly created or reused thread now executes the function @func with the two arguments. The first one is the parameter to g_thread_pool_push() and the second one is @user_data. The parameter @exclusive determines whether the thread pool owns all threads exclusive or shares them with other thread pools. If @exclusive is %TRUE, @max_threads threads are started immediately and they will run exclusively for this thread pool until it is destroyed by g_thread_pool_free(). If @exclusive is %FALSE, threads are created when needed and shared between all non-exclusive thread pools. This implies that @max_threads may not be -1 for exclusive thread pools. Besides, exclusive thread pools are not affected by g_thread_pool_set_max_idle_time() since their threads are never considered idle and returned to the global pool. @error can be %NULL to ignore errors, or non-%NULL to report errors. An error can only occur when @exclusive is set to %TRUE and not all @max_threads threads could be created. See #GThreadError for possible errors that may occur. Note, even in case of error a valid #GThreadPool is returned. a function to execute in the threads of the new thread pool user data that is handed over to @func every time it is called the maximal number of threads to execute concurrently in the new thread pool, -1 means no limit should this thread pool be exclusive? return location for error, or %NULL the new #GThreadPool Inserts @data into the list of tasks to be executed by @pool. When the number of currently running threads is lower than the maximal allowed number of threads, a new thread is started (or reused) with the properties given to g_thread_pool_new(). Otherwise, @data stays in the queue until a thread in this pool finishes its previous task and processes @data. @error can be %NULL to ignore errors, or non-%NULL to report errors. An error can only occur when a new thread couldn't be created. In that case @data is simply appended to the queue of work to do. Before version 2.32, this function did not return a success status. a #GThreadPool a new task for @pool return location for error, or %NULL %TRUE on success, %FALSE if an error occurred 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. By setting @interval to 0, idle threads will not be stopped. The default value is 15000 (15 seconds). Since: 2.10 the maximum @interval (in milliseconds) a thread can be idle Sets the maximal allowed number of threads for @pool. A value of -1 means that the maximal number of threads is unlimited. If @pool is an exclusive thread pool, setting the maximal number of threads to -1 is not allowed. Setting @max_threads to 0 means stopping all work for @pool. It is effectively frozen until @max_threads is set to a non-zero value again. A thread is never terminated while calling @func, as supplied by g_thread_pool_new(). Instead the maximal number of threads only has effect for the allocation of new threads in g_thread_pool_push(). A new thread is allocated, whenever the number of currently running threads in @pool is smaller than the maximal number. @error can be %NULL to ignore errors, or non-%NULL to report errors. An error can only occur when a new thread couldn't be created. Before version 2.32, this function did not return a success status. a #GThreadPool a new maximal number of threads for @pool, or -1 for unlimited return location for error, or %NULL %TRUE on success, %FALSE if an error occurred 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. The default value is 2. maximal number of unused threads Sets the function used to sort the list of tasks. This allows the tasks to be processed by a priority determined by @func, and not just in the order in which they were added to the pool. Note, if the maximum number of threads is more than 1, the order that threads are executed cannot be guaranteed 100%. Threads are scheduled by the operating system and are executed at random. It cannot be assumed that threads are executed in the order they are created. Since: 2.10 a #GThreadPool the #GCompareDataFunc used to sort the list of tasks. This function is passed two tasks. It should return 0 if the order in which they are handled does not matter, a negative value if the first task should be processed before the second or a positive value if the second task should be processed first. user data passed to @func 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(). Returns the number of tasks still unprocessed in @pool. a #GThreadPool the number of unprocessed tasks Increase the reference count on @thread. Since: 2.32 a #GThread a new reference to @thread This function returns the #GThread corresponding to the current thread. Note that this function does not increase the reference count of the returned struct. This function will return a #GThread even for threads that were not created by GLib (i.e. those created by other threading APIs). This may be useful for thread identification purposes (i.e. comparisons) but you must not use GLib functions (such as g_thread_join()) on these threads. the #GThread representing the current thread This function does nothing. Deprecated:2.32: Thread priorities no longer have any effect. a #GThread. ignored This macro returns %TRUE if the thread system is initialized, and %FALSE if it is not. For language bindings, g_thread_get_initialized() provides the same functionality as a function. %TRUE, if the thread system is initialized This function is the same as g_thread_new() except that it allows for the possibility of failure. If a thread can not be created (due to resource limits), @error is set and %NULL is returned. Since: 2.32 an (optional) name for the new thread a function to execute in the new thread an argument to supply to the new thread return location for error, or %NULL the new #GThread, or %NULL if an error occurred Decrease the reference count on @thread, possibly freeing all resources associated with it. Note that each thread holds a reference to its #GThread while it is running, so it is safe to drop your own reference to it if you don't need it anymore. Since: 2.32 a #GThread Causes the calling thread to voluntarily relinquish the CPU, so that other threads can run. This function is often used as a method to make busy wait less evil. Adds the given number of microseconds to @time_. @microseconds can also be negative to decrease the value of @time_. a #GTimeVal number of microseconds to add to @time Converts a string containing an ISO 8601 encoded date and time to a #GTimeVal and puts it into @time_. @iso_date must include year, month, day, hours, minutes, and seconds. It can optionally include fractions of a second and a time zone indicator. (In the absence of any time zone indication, the timestamp is assumed to be in local time.) Since: 2.12 an ISO 8601 encoded date string a #GTimeVal %TRUE if the conversion was successful. Converts @time_ into an RFC 3339 encoded string, relative to the Coordinated Universal Time (UTC). This is one of the many formats allowed by ISO 8601. ISO 8601 allows a large number of date/time formats, with or without punctuation and optional elements. The format returned by this function is a complete date and time, with optional punctuation included, the UTC time zone represented as "Z", and the @tv_usec part included if and only if it is nonzero, i.e. either "YYYY-MM-DDTHH:MM:SSZ" or "YYYY-MM-DDTHH:MM:SS.fffffZ". This corresponds to the Internet date/time format defined by [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt), and to either of the two most-precise formats defined by the W3C Note [Date and Time Formats](http://www.w3.org/TR/NOTE-datetime-19980827). Both of these documents are profiles of ISO 8601. Use g_date_time_format() or g_strdup_printf() if a different variation of ISO 8601 format is required. Since: 2.12 a #GTimeVal a newly allocated string containing an ISO 8601 date Finds an interval within @tz that corresponds to the given @time_, possibly adjusting @time_ if required to fit into an interval. The meaning of @time_ depends on @type. This function is similar to g_time_zone_find_interval(), with the difference that it always succeeds (by making the adjustments described below). In any of the cases where g_time_zone_find_interval() succeeds then this function returns the same value, without modifying @time_. This function may, however, modify @time_ in order to deal with non-existent times. If the non-existent local @time_ of 02:30 were requested on March 14th 2010 in Toronto then this function would adjust @time_ to be 03:00 and return the interval containing the adjusted time. Since: 2.26 a #GTimeZone the #GTimeType of @time_ a pointer to a number of seconds since January 1, 1970 the interval containing @time_, never -1 Finds an the interval within @tz that corresponds to the given @time_. The meaning of @time_ depends on @type. If @type is %G_TIME_TYPE_UNIVERSAL then this function will always succeed (since universal time is monotonic and continuous). Otherwise @time_ is treated as local time. The distinction between %G_TIME_TYPE_STANDARD and %G_TIME_TYPE_DAYLIGHT is ignored except in the case that the given @time_ is ambiguous. In Toronto, for example, 01:30 on November 7th 2010 occurred twice (once inside of daylight savings time and the next, an hour later, outside of daylight savings time). In this case, the different value of @type would result in a different interval being returned. It is still possible for this function to fail. In Toronto, for example, 02:00 on March 14th 2010 does not exist (due to the leap forward to begin daylight savings time). -1 is returned in that case. Since: 2.26 a #GTimeZone the #GTimeType of @time_ a number of seconds since January 1, 1970 the interval containing @time_, or -1 in case of failure Determines the time zone abbreviation to be used during a particular @interval of time in the time zone @tz. For example, in Toronto this is currently "EST" during the winter months and "EDT" during the summer months when daylight savings time is in effect. Since: 2.26 a #GTimeZone an interval within the timezone the time zone abbreviation, which belongs to @tz Determines the offset to UTC in effect during a particular @interval of time in the time zone @tz. The offset is the number of seconds that you add to UTC time to arrive at local time for @tz (ie: negative numbers for time zones west of GMT, positive numbers for east). Since: 2.26 a #GTimeZone an interval within the timezone the number of seconds that should be added to UTC to get the local time in @tz Determines if daylight savings time is in effect during a particular @interval of time in the time zone @tz. Since: 2.26 a #GTimeZone an interval within the timezone %TRUE if daylight savings time is in effect Creates a #GTimeZone corresponding to @identifier. @identifier can either be an RFC3339/ISO 8601 time offset or something that would pass as a valid value for the `TZ` environment variable (including %NULL). In Windows, @identifier can also be the unlocalized name of a time zone for standard time, for example "Pacific Standard Time". Valid RFC3339 time offsets are `"Z"` (for UTC) or `"±hh:mm"`. ISO 8601 additionally specifies `"±hhmm"` and `"±hh"`. Offsets are time values to be added to Coordinated Universal Time (UTC) to get the local time. In UNIX, the `TZ` environment variable typically corresponds to the name of a file in the zoneinfo database, or string in "std offset [dst [offset],start[/time],end[/time]]" (POSIX) format. There are no spaces in the specification. The name of standard and daylight savings time zone must be three or more alphabetic characters. Offsets are time values to be added to local time to get Coordinated Universal Time (UTC) and should be `"[±]hh[[:]mm[:ss]]"`. Dates are either `"Jn"` (Julian day with n between 1 and 365, leap years not counted), `"n"` (zero-based Julian day with n between 0 and 365) or `"Mm.w.d"` (day d (0 <= d <= 6) of week w (1 <= w <= 5) of month m (1 <= m <= 12), day 0 is a Sunday). Times are in local wall clock time, the default is 02:00:00. In Windows, the "tzn[+|–]hh[:mm[:ss]][dzn]" format is used, but also accepts POSIX format. The Windows format uses US rules for all time zones; daylight savings time is 60 minutes behind the standard time with date and time of change taken from Pacific Standard Time. Offsets are time values to be added to the local time to get Coordinated Universal Time (UTC). g_time_zone_new_local() calls this function with the value of the `TZ` environment variable. This function itself is independent of the value of `TZ`, but if @identifier is %NULL then `/etc/localtime` will be consulted to discover the correct time zone on UNIX and the registry will be consulted or GetTimeZoneInformation() will be used to get the local time zone on Windows. If intervals are not available, only time zone rules from `TZ` environment variable or other means, then they will be computed from year 1900 to 2037. If the maximum year for the rules is available and it is greater than 2037, then it will followed instead. See [RFC3339 §5.6](http://tools.ietf.org/html/rfc3339#section-5.6) for a precise definition of valid RFC3339 time offsets (the `time-offset` expansion) and ISO 8601 for the full list of valid time offsets. See [The GNU C Library manual](http://www.gnu.org/s/libc/manual/html_node/TZ-Variable.html) for an explanation of the possible values of the `TZ` environment variable. See [Microsoft Time Zone Index Values](http://msdn.microsoft.com/en-us/library/ms912391%28v=winembedded.11%29.aspx) for the list of time zones on Windows. You should release the return value by calling g_time_zone_unref() when you are done with it. Since: 2.26 a timezone identifier the requested timezone Creates a #GTimeZone corresponding to local time. The local time zone may change between invocations to this function; for example, if the system administrator changes it. This is equivalent to calling g_time_zone_new() with the value of the `TZ` environment variable (including the possibility of %NULL). You should release the return value by calling g_time_zone_unref() when you are done with it. Since: 2.26 the local timezone Creates a #GTimeZone corresponding to UTC. This is equivalent to calling g_time_zone_new() with a value like "Z", "UTC", "+00", etc. You should release the return value by calling g_time_zone_unref() when you are done with it. Since: 2.26 the universal timezone Increases the reference count on @tz. Since: 2.26 a #GTimeZone a new reference to @tz. Decreases the reference count on @tz. Since: 2.26 a #GTimeZone Sets a function to be called at regular intervals, with the default priority, #G_PRIORITY_DEFAULT. 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 first call to the function will be at the end of the first @interval. Note that timeout functions may be delayed, due to the processing of other event sources. Thus they should not be relied on for precise timing. After each call to the timeout function, the time of the next timeout is recalculated based on the current time and the given interval (it does not try to 'catch up' time lost in delays). If you want to have a timer in the "seconds" range and do not care about the exact time of the first call of the timer, use the g_timeout_add_seconds() function; this function allows for more optimizations and more efficient system power usage. This internally creates a main loop source using g_timeout_source_new() and attaches it to the global #GMainContext using g_source_attach(), so the callback will be invoked in whichever thread is running that main context. You can do these steps manually if you need greater control or to use a custom main context. The interval given is in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). the time between calls to the function, in milliseconds (1/1000ths of a second) function to call data to pass to @function the ID (greater than 0) of the event source. 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. Note that timeout functions may be delayed, due to the processing of other event sources. Thus they should not be relied on for precise timing. After each call to the timeout function, the time of the next timeout is recalculated based on the current time and the given interval (it does not try to 'catch up' time lost in delays). This internally creates a main loop source using g_timeout_source_new() and attaches it to the global #GMainContext using g_source_attach(), so the callback will be invoked in whichever thread is running that main context. You can do these steps manually if you need greater control or to use a custom main context. The interval given in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). the priority of the timeout source. Typically this will be in the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH. the time between calls to the function, in milliseconds (1/1000ths of a second) function to call data to pass to @function function to call when the timeout is removed, or %NULL the ID (greater than 0) of the event source. Sets a function to be called at regular intervals with the default priority, #G_PRIORITY_DEFAULT. 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. This internally creates a main loop source using g_timeout_source_new_seconds() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. Also see g_timeout_add_seconds_full(). Note that the first call of the timer may not be precise for timeouts of one second. If you need finer precision and have such a timeout, you may want to use g_timeout_add() instead. The interval given is in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). Since: 2.14 the time between calls to the function, in seconds function to call data to pass to @function the ID (greater than 0) of the event source. Sets a function to be called at regular intervals, with @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. Unlike g_timeout_add(), this function operates at whole second granularity. The initial starting point of the timer is determined by the implementation and the implementation is expected to group multiple timers together so that they fire all at the same time. To allow this grouping, the @interval to the first timer is rounded and can deviate up to one second from the specified interval. Subsequent timer iterations will generally run at the specified interval. Note that timeout functions may be delayed, due to the processing of other event sources. Thus they should not be relied on for precise timing. After each call to the timeout function, the time of the next timeout is recalculated based on the current time and the given @interval If you want timing more precise than whole seconds, use g_timeout_add() instead. The grouping of timers to fire at the same time results in a more power and CPU efficient behavior so if your timer is in multiples of seconds and you don't require the first timer exactly one second from now, the use of g_timeout_add_seconds() is preferred over g_timeout_add(). This internally creates a main loop source using g_timeout_source_new_seconds() and attaches it to the main loop context using g_source_attach(). You can do these steps manually if you need greater control. The interval given is in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). Since: 2.14 the priority of the timeout source. Typically this will be in the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH. the time between calls to the function, in seconds function to call data to pass to @function function to call when the timeout is removed, or %NULL the ID (greater than 0) of the event source. Creates a new timeout source. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. The interval given is in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). the timeout interval in milliseconds. the newly-created timeout source Creates a new timeout source. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. The scheduling granularity/accuracy of this timeout source will be in seconds. The interval given in terms of monotonic time, not wall clock time. See g_get_monotonic_time(). Since: 2.14 the timeout interval in seconds the newly-created timeout source Resumes a timer that has previously been stopped with g_timer_stop(). g_timer_stop() must be called before using this function. Since: 2.4 a #GTimer. Destroys a timer, freeing associated resources. a #GTimer to destroy. If @timer has been started but not stopped, obtains the time since the timer was started. If @timer has been stopped, obtains the elapsed time between the time it was started and the time it was stopped. The return value is the number of seconds elapsed, including any fractional part. The @microseconds out parameter is essentially useless. a #GTimer. return location for the fractional part of seconds elapsed, in microseconds (that is, the total number of microseconds elapsed, modulo 1000000), or %NULL seconds elapsed as a floating point value, including any fractional part. Creates a new timer, and starts timing (i.e. g_timer_start() is implicitly called for you). a new #GTimer. This function is useless; it's fine to call g_timer_start() on an already-started timer to reset the start time, so g_timer_reset() serves no purpose. a #GTimer. Marks a start time, so that future calls to g_timer_elapsed() will report the time since g_timer_start() was called. g_timer_new() automatically marks the start time, so no need to call g_timer_start() immediately after creating the timer. a #GTimer. Marks an end time, so calls to g_timer_elapsed() will return the difference between this end time and the start time. a #GTimer. Returns the height of a #GTrashStack. Note that execution of this function is of O(N) complexity where N denotes the number of items on the stack. a #GTrashStack the height of the stack Returns the element at the top of a #GTrashStack which may be %NULL. a #GTrashStack the element at the top of the stack Pops a piece of memory off a #GTrashStack. a #GTrashStack the element at the top of the stack Pushes a piece of memory onto a #GTrashStack. a #GTrashStack the piece of memory to push on the stack Removes all keys and values from the #GTree and decreases its reference count by one. If keys and/or values are dynamically allocated, you should either free them first or create the #GTree using g_tree_new_full(). In the latter case the destroy functions you supplied will be called on all keys and values before destroying the #GTree. a #GTree Calls the given function for each of the key/value pairs in the #GTree. The function is passed the key and value of each pair, and the given @data parameter. The tree is traversed in sorted order. The tree may not be modified while iterating over it (you can't add/remove items). To remove all items matching a predicate, you need to add each item to a list in your #GTraverseFunc as you walk over the tree, then walk the list and remove each item. a #GTree the function to call for each node visited. If this function returns %TRUE, the traversal is stopped. user data to pass to the function Gets the height of a #GTree. If the #GTree contains no nodes, the height is 0. If the #GTree contains only one root node the height is 1. If the root node has children the height is 2, etc. a #GTree the height of @tree Inserts a key/value pair into a #GTree. If the given key already exists in the #GTree its corresponding value is set to the new value. If you supplied a @value_destroy_func when creating the #GTree, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GTree, the passed key is freed using that function. The tree is automatically 'balanced' as new key/value pairs are added, so that the distance from the root to every leaf is as small as possible. a #GTree the key to insert the value corresponding to the key Gets the value corresponding to the given key. Since a #GTree is automatically balanced as key/value pairs are added, key lookup is O(log n) (where n is the number of key/value pairs in the tree). a #GTree the key to look up the value corresponding to the key, or %NULL if the key was not found Looks up a key in the #GTree, returning the original key and the associated value. This is useful if you need to free the memory allocated for the original key, for example before calling g_tree_remove(). a #GTree the key to look up returns the original key returns the value associated with the key %TRUE if the key was found in the #GTree Creates a new #GTree. the function used to order the nodes in the #GTree. It should return values similar to the standard strcmp() function - 0 if the two arguments are equal, a negative value if the first argument comes before the second, or a positive value if the first argument comes after the second. a newly allocated #GTree Creates a new #GTree like g_tree_new() and allows to specify functions to free the memory allocated for the key and value that get called when removing the entry from the #GTree. qsort()-style comparison function data to pass to comparison function a function to free the memory allocated for the key used when removing the entry from the #GTree or %NULL if you don't want to supply such a function a function to free the memory allocated for the value used when removing the entry from the #GTree or %NULL if you don't want to supply such a function a newly allocated #GTree Creates a new #GTree with a comparison function that accepts user data. See g_tree_new() for more details. qsort()-style comparison function data to pass to comparison function a newly allocated #GTree Gets the number of nodes in a #GTree. a #GTree the number of nodes in @tree Increments the reference count of @tree by one. It is safe to call this function from any thread. Since: 2.22 a #GTree the passed in #GTree Removes a key/value pair from a #GTree. If the #GTree was created using g_tree_new_full(), the key and value are freed using the supplied destroy functions, otherwise you have to make sure that any dynamically allocated values are freed yourself. If the key does not exist in the #GTree, the function does nothing. a #GTree the key to remove %TRUE if the key was found (prior to 2.8, this function returned nothing) Inserts a new key and value into a #GTree similar to g_tree_insert(). The difference is that if the key already exists in the #GTree, it gets replaced by the new key. If you supplied a @value_destroy_func when creating the #GTree, the old value is freed using that function. If you supplied a @key_destroy_func when creating the #GTree, the old key is freed using that function. The tree is automatically 'balanced' as new key/value pairs are added, so that the distance from the root to every leaf is as small as possible. a #GTree the key to insert the value corresponding to the key Searches a #GTree using @search_func. The @search_func is called with a pointer to the key of a key/value pair in the tree, and the passed in @user_data. If @search_func returns 0 for a key/value pair, then the corresponding value is returned as the result of g_tree_search(). If @search_func returns -1, searching will proceed among the key/value pairs that have a smaller key; if @search_func returns 1, searching will proceed among the key/value pairs that have a larger key. a #GTree a function used to search the #GTree the data passed as the second argument to @search_func the value corresponding to the found key, or %NULL if the key was not found Removes a key and its associated value from a #GTree without calling the key and value destroy functions. If the key does not exist in the #GTree, the function does nothing. a #GTree the key to remove %TRUE if the key was found (prior to 2.8, this function returned nothing) Calls the given function for each node in the #GTree. Deprecated:2.2: The order of a balanced tree is somewhat arbitrary. If you just want to visit all nodes in sorted order, use g_tree_foreach() instead. If you really need to visit nodes in a different order, consider using an [n-ary tree][glib-N-ary-Trees]. a #GTree the function to call for each node visited. If this function returns %TRUE, the traversal is stopped. the order in which nodes are visited, one of %G_IN_ORDER, %G_PRE_ORDER and %G_POST_ORDER user data to pass to the function Decrements the reference count of @tree by one. If the reference count drops to 0, all keys and values will be destroyed (if destroy functions were specified) and all memory allocated by @tree will be released. It is safe to call this function from any thread. Since: 2.22 a #GTree Attempts to allocate @n_bytes, and returns %NULL on failure. Contrast with g_malloc(), which aborts the program on failure. number of bytes to allocate. the allocated memory, or %NULL. Attempts to allocate @n_bytes, initialized to 0's, and returns %NULL on failure. Contrast with g_malloc0(), which aborts the program on failure. Since: 2.8 number of bytes to allocate the allocated memory, or %NULL This function is similar to g_try_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. Since: 2.24 the number of blocks to allocate the size of each block in bytes the allocated memory, or %NULL This function is similar to g_try_malloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. Since: 2.24 the number of blocks to allocate the size of each block in bytes the allocated memory, or %NULL. Attempts to allocate @n_structs elements of type @struct_type, and returns %NULL on failure. Contrast with g_new(), which aborts the program on failure. The returned pointer is cast to a pointer to the given type. The function returns %NULL when @n_structs is 0 of if an overflow occurs. Since: 2.8 the type of the elements to allocate the number of elements to allocate a pointer to the allocated memory, cast to a pointer to @struct_type Attempts to allocate @n_structs elements of type @struct_type, initialized to 0's, and returns %NULL on failure. Contrast with g_new0(), which aborts the program on failure. The returned pointer is cast to a pointer to the given type. The function returns %NULL when @n_structs is 0 of if an overflow occurs. Since: 2.8 the type of the elements to allocate the number of elements to allocate a pointer to the allocated memory, cast to a pointer to @struct_type Attempts to realloc @mem to a new size, @n_bytes, and returns %NULL on failure. Contrast with g_realloc(), which aborts the program on failure. If @mem is %NULL, behaves the same as g_try_malloc(). previously-allocated memory, or %NULL. number of bytes to allocate. the allocated memory, or %NULL. This function is similar to g_try_realloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication. Since: 2.24 previously-allocated memory, or %NULL. the number of blocks to allocate the size of each block in bytes the allocated memory, or %NULL. Attempts to reallocate the memory pointed to by @mem, so that it now has space for @n_structs elements of type @struct_type, and returns %NULL on failure. Contrast with g_renew(), which aborts the program on failure. It returns the new address of the memory, which may have been moved. The function returns %NULL if an overflow occurs. Since: 2.8 the type of the elements to allocate the currently allocated memory the number of elements to allocate a pointer to the new allocated memory, cast to a pointer to @struct_type Frees the records which were returned by g_relation_select(). This should always be called after g_relation_select() when you are finished with the records. The records are not removed from the #GRelation. Deprecated: 2.26: Rarely used API the tuple data to free. Gets a field from the records returned by g_relation_select(). It returns the given field of the record at the given index. The returned value should not be changed. Deprecated: 2.26: Rarely used API the tuple data, returned by g_relation_select(). the index of the record. the field to return. the field of the record. Adds a #GTypeClassCacheFunc to be called before the reference count of a class goes from one to zero. This can be used to prevent premature class destruction. All installed #GTypeClassCacheFunc functions will be chained until one of them returns %TRUE. The functions have to check the class id passed in to figure whether they actually want to cache the class of this type, since all classes are routed through the same #GTypeClassCacheFunc chain. data to be passed to @cache_func a #GTypeClassCacheFunc Registers a private class structure for a classed type; when the class is allocated, the private structures for the class and all of its parent types are allocated sequentially in the same memory block as the public structures, and are zero-filled. This function should be called in the type's get_type() function after the type is registered. The private structure can be retrieved using the G_TYPE_CLASS_GET_PRIVATE() macro. Since: 2.24 GType of an classed type size of private structure Adds a function to be called after an interface vtable is initialized for any class (i.e. after the @interface_init member of #GInterfaceInfo has been called). This function is useful when you want to check an invariant that depends on the interfaces of a class. For instance, the implementation of #GObject uses this facility to check that an object implements all of the properties that are defined on its interfaces. Since: 2.4 data to pass to @check_func function to be called after each interface is initialized Adds the dynamic @interface_type to @instantiable_type. The information contained in the #GTypePlugin structure pointed to by @plugin is used to manage the relationship. #GType value of an instantiable type #GType value of an interface type #GTypePlugin structure to retrieve the #GInterfaceInfo from Adds the static @interface_type to @instantiable_type. The information contained in the #GInterfaceInfo structure pointed to by @info is used to manage the relationship. #GType value of an instantiable type #GType value of an interface type #GInterfaceInfo structure for this (@instance_type, @interface_type) combination Private helper function to aid implementation of the G_TYPE_CHECK_INSTANCE() macro. a valid #GTypeInstance structure %TRUE if @instance is valid, %FALSE otherwise Return a newly allocated and 0-terminated array of type IDs, listing the child types of @type. the parent type location to store the length of the returned array, or %NULL Newly allocated and 0-terminated array of child types, free with g_free() Registers a private structure for an instantiatable type. When an object is allocated, the private structures for the type and all of its parent types are allocated sequentially in the same memory block as the public structures, and are zero-filled. Note that the accumulated size of the private structures of a type and all its parent types cannot exceed 64 KiB. This function should be called in the type's class_init() function. The private structure can be retrieved using the G_TYPE_INSTANCE_GET_PRIVATE() macro. The following example shows attaching a private structure MyObjectPrivate to an object MyObject defined in the standard GObject fashion in the type's class_init() function. Note the use of a structure member "priv" to avoid the overhead of repeatedly calling MY_OBJECT_GET_PRIVATE(). |[<!-- language="C" --> typedef struct _MyObject MyObject; typedef struct _MyObjectPrivate MyObjectPrivate; struct _MyObject { GObject parent; MyObjectPrivate *priv; }; struct _MyObjectPrivate { int some_field; }; static void my_object_class_init (MyObjectClass *klass) { g_type_class_add_private (klass, sizeof (MyObjectPrivate)); } static void my_object_init (MyObject *my_object) { my_object->priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object, MY_TYPE_OBJECT, MyObjectPrivate); // my_object->priv->some_field will be automatically initialised to 0 } static int my_object_get_some_field (MyObject *my_object) { MyObjectPrivate *priv; g_return_val_if_fail (MY_IS_OBJECT (my_object), 0); priv = my_object->priv; return priv->some_field; } ]| Since: 2.4 class structure for an instantiatable type size of private structure Gets the offset of the private data for instances of @g_class. This is how many bytes you should add to the instance pointer of a class in order to get the private data for the type represented by @g_class. You can only call this function after you have registered a private data area for @g_class using g_type_class_add_private(). Since: 2.38 a #GTypeClass the offset, in bytes This function is essentially the same as g_type_class_ref(), except that the classes reference count isn't incremented. As a consequence, this function may return %NULL if the class of the type passed in does not currently exist (hasn't been referenced before). type ID of a classed type the #GTypeClass structure for the given type ID or %NULL if the class does not currently exist This is a convenience function often needed in class initializers. It returns the class structure of the immediate parent type of the class passed in. Since derived classes hold a reference count on their parent classes as long as they are instantiated, the returned class will always exist. This function is essentially equivalent to: g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class))) the #GTypeClass structure to retrieve the parent class for the parent class of @g_class A more efficient version of g_type_class_peek() which works only for static types. Since: 2.4 type ID of a classed type the #GTypeClass structure for the given type ID or %NULL if the class does not currently exist or is dynamically loaded Increments the reference count of the class structure belonging to @type. This function will demand-create the class if it doesn't exist already. type ID of a classed type the #GTypeClass structure for the given type ID Decrements the reference count of the class structure being passed in. Once the last reference count of a class has been released, classes may be finalized by the type system, so further dereferencing of a class pointer after g_type_class_unref() are invalid. a #GTypeClass structure to unref A variant of g_type_class_unref() for use in #GTypeClassCacheFunc implementations. It unreferences a class without consulting the chain of #GTypeClassCacheFuncs, avoiding the recursion which would occur otherwise. a #GTypeClass structure to unref Creates and initializes an instance of @type if @type is valid and can be instantiated. The type system only performs basic allocation and structure setups for instances: actual instance creation should happen through functions supplied by the type's fundamental type implementation. So use of g_type_create_instance() is reserved for implementators of fundamental types only. E.g. instances of the #GObject hierarchy should be created via g_object_new() and never directly through g_type_create_instance() which doesn't handle things like singleton objects or object construction. The extended members of the returned instance are guaranteed to be filled with zeros. Note: Do not use this function, unless you're implementing a fundamental type. Also language bindings should not use this function, but g_object_new() instead. an instantiatable type to create an instance for an allocated and initialized instance, subject to further treatment by the fundamental type implementation If the interface type @g_type is currently in use, returns its default interface vtable. Since: 2.4 an interface type the default vtable for the interface, or %NULL if the type is not currently in use Increments the reference count for the interface type @g_type, and returns the default interface vtable for the type. If the type is not currently in use, then the default vtable for the type will be created and initalized by calling the base interface init and default vtable init functions for the type (the @base_init and @class_init members of #GTypeInfo). Calling g_type_default_interface_ref() is useful when you want to make sure that signals and properties for an interface have been installed. Since: 2.4 an interface type the default vtable for the interface; call g_type_default_interface_unref() when you are done using the interface. Decrements the reference count for the type corresponding to the interface default vtable @g_iface. If the type is dynamic, then when no one is using the interface and all references have been released, the finalize function for the interface's default vtable (the @class_finalize member of #GTypeInfo) will be called. Since: 2.4 the default vtable structure for a interface, as returned by g_type_default_interface_ref() Returns the length of the ancestry of the passed in type. This includes the type itself, so that e.g. a fundamental type has depth 1. a #GType the depth of @type Ensures that the indicated @type has been registered with the type system, and its _class_init() method has been run. In theory, simply calling the type's _get_type() method (or using the corresponding macro) is supposed take care of this. However, _get_type() methods are often marked %G_GNUC_CONST for performance reasons, even though this is technically incorrect (since %G_GNUC_CONST requires that the function not have side effects, which _get_type() methods do on the first call). As a result, if you write a bare call to a _get_type() macro, it may get optimized out by the compiler. Using g_type_ensure() guarantees that the type's _get_type() method is called. Since: 2.34 a #GType Frees an instance of a type, returning it to the instance pool for the type, if there is one. Like g_type_create_instance(), this function is reserved for implementors of fundamental types. an instance of a type Lookup the type ID from a given type name, returning 0 if no type has been registered under this name (this is the preferred method to find out by name whether a specific type has been registered yet). type name to lookup corresponding type ID or 0 Internal function, used to extract the fundamental type ID portion. Use G_TYPE_FUNDAMENTAL() instead. valid type ID fundamental type ID Returns the next free fundamental type id which can be used to register a new fundamental type with g_type_register_fundamental(). The returned type ID represents the highest currently registered fundamental type identifier. the next available fundamental type ID to be registered, or 0 if the type system ran out of fundamental type IDs Returns the number of instances allocated of the particular type; this is only available if GLib is built with debugging support and the instance_count debug flag is set (by setting the GOBJECT_DEBUG variable to include instance-count). Since: 2.44 a #GType the number of instances allocated of the given type; if instance counts are not available, returns 0. Returns the #GTypePlugin structure for @type. #GType to retrieve the plugin for the corresponding plugin if @type is a dynamic type, %NULL otherwise Obtains data which has previously been attached to @type with g_type_set_qdata(). Note that this does not take subtyping into account; data attached to one type with g_type_set_qdata() cannot be retrieved from a subtype using g_type_get_qdata(). a #GType a #GQuark id to identify the data the data, or %NULL if no data was found Returns an opaque serial number that represents the state of the set of registered types. Any time a type is registered this serial changes, which means you can cache information based on type lookups (such as g_type_from_name()) and know if the cache is still valid at a later time by comparing the current serial with the one at the type lookup. Since: 2.36 An unsigned int, representing the state of type registrations This function used to initialise the type system. Since GLib 2.36, the type system is initialised automatically and this function does nothing. Deprecated: 2.36: the type system is now initialised automatically This function used to initialise the type system with debugging flags. Since GLib 2.36, the type system is initialised automatically and this function does nothing. If you need to enable debugging features, use the GOBJECT_DEBUG environment variable. Deprecated: 2.36: the type system is now initialised automatically bitwise combination of #GTypeDebugFlags values for debugging purposes Adds @prerequisite_type to the list of prerequisites of @interface_type. This means that any type implementing @interface_type must also implement @prerequisite_type. Prerequisites can be thought of as an alternative to interface derivation (which GType doesn't support). An interface can have at most one instantiatable prerequisite type. #GType value of an interface type #GType value of an interface or instantiatable type Returns the #GTypePlugin structure for the dynamic interface @interface_type which has been added to @instance_type, or %NULL if @interface_type has not been added to @instance_type or does not have a #GTypePlugin structure. See g_type_add_interface_dynamic(). #GType of an instantiatable type #GType of an interface type the #GTypePlugin for the dynamic interface @interface_type of @instance_type Returns the #GTypeInterface structure of an interface to which the passed in class conforms. a #GTypeClass structure an interface ID which this class conforms to the #GTypeInterface structure of @iface_type if implemented by @instance_class, %NULL otherwise Returns the corresponding #GTypeInterface structure of the parent type of the instance type to which @g_iface belongs. This is useful when deriving the implementation of an interface from the parent type and then possibly overriding some methods. a #GTypeInterface structure the corresponding #GTypeInterface structure of the parent type of the instance type to which @g_iface belongs, or %NULL if the parent type doesn't conform to the interface Returns the prerequisites of an interfaces type. Since: 2.2 an interface type location to return the number of prerequisites, or %NULL a newly-allocated zero-terminated array of #GType containing the prerequisites of @interface_type Return a newly allocated and 0-terminated array of type IDs, listing the interface types that @type conforms to. the type to list interface types for location to store the length of the returned array, or %NULL Newly allocated and 0-terminated array of interface types, free with g_free() If @is_a_type is a derivable type, check whether @type is a descendant of @is_a_type. If @is_a_type is an interface, check whether @type conforms to it. type to check anchestry for possible anchestor of @type or interface that @type could conform to %TRUE if @type is a @is_a_type Registers an additional interface for a type, whose interface lives in the given type plugin. If the interface was already registered for the type in this plugin, nothing will be done. As long as any instances of the type exist, the type plugin will not be unloaded. a #GTypeModule type to which to add the interface. interface type to add type information structure Looks up or registers an enumeration that is implemented with a particular type plugin. If a type with name @type_name was previously registered, the #GType identifier for the type is returned, otherwise the type is newly registered, and the resulting #GType identifier returned. As long as any instances of the type exist, the type plugin will not be unloaded. Since: 2.6 a #GTypeModule name for the type an array of #GEnumValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. the new or existing type ID Looks up or registers a flags type that is implemented with a particular type plugin. If a type with name @type_name was previously registered, the #GType identifier for the type is returned, otherwise the type is newly registered, and the resulting #GType identifier returned. As long as any instances of the type exist, the type plugin will not be unloaded. Since: 2.6 a #GTypeModule name for the type an array of #GFlagsValue structs for the possible flags values. The array is terminated by a struct with all members being 0. the new or existing type ID Looks up or registers a type that is implemented with a particular type plugin. If a type with name @type_name was previously registered, the #GType identifier for the type is returned, otherwise the type is newly registered, and the resulting #GType identifier returned. When reregistering a type (typically because a module is unloaded then reloaded, and reinitialized), @module and @parent_type must be the same as they were previously. As long as any instances of the type exist, the type plugin will not be unloaded. a #GTypeModule the type for the parent class name for the type type information structure flags field providing details about the type the new or existing type ID Sets the name for a #GTypeModule a #GTypeModule. a human-readable name to use in error messages. Decreases the use count of a #GTypeModule by one. If the result is zero, the module will be unloaded. (However, the #GTypeModule will not be freed, and types associated with the #GTypeModule are not unregistered. Once a #GTypeModule is initialized, it must exist forever.) a #GTypeModule Increases the use count of a #GTypeModule by one. If the use count was zero before, the plugin will be loaded. If loading the plugin fails, the use count is reset to its prior value. a #GTypeModule %FALSE if the plugin needed to be loaded and loading the plugin failed. Get the unique name that is assigned to a type ID. Note that this function (like all other GType API) cannot cope with invalid type IDs. %G_TYPE_INVALID may be passed to this function, as may be any other validly registered type ID, but randomized type IDs should not be passed in and will most likely lead to a crash. type to return name for static type name or %NULL Given a @leaf_type and a @root_type which is contained in its anchestry, return the type that @root_type is the immediate parent of. In other words, this function determines the type that is derived directly from @root_type which is also a base class of @leaf_type. Given a root type and a leaf type, this function can be used to determine the types and order in which the leaf type is descended from the root type. descendant of @root_type and the type to be returned immediate parent of the returned type immediate child of @root_type and anchestor of @leaf_type Return the direct parent type of the passed in type. If the passed in type has no parent, i.e. is a fundamental type, 0 is returned. the derived type the parent type Calls the @complete_interface_info function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself. the #GTypePlugin the #GType of an instantiable type to which the interface is added the #GType of the interface whose info is completed the #GInterfaceInfo to fill in Calls the @complete_type_info function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself. a #GTypePlugin the #GType whose info is completed the #GTypeInfo struct to fill in the #GTypeValueTable to fill in Calls the @unuse_plugin function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself. a #GTypePlugin Calls the @use_plugin function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself. a #GTypePlugin Get the corresponding quark of the type IDs name. type to return quark of type name for the type names quark or 0 Queries the type system for information about a specific type. This function will fill in a user-provided structure to hold type-specific information. If an invalid #GType is passed in, the @type member of the #GTypeQuery is 0. All members filled into the #GTypeQuery structure should be considered constant and have to be left untouched. #GType of a static, classed type a user provided structure that is filled in with constant values upon success Registers @type_name as the name of a new dynamic type derived from @parent_type. The type system uses the information contained in the #GTypePlugin structure pointed to by @plugin to manage the type and its instances (if not abstract). The value of @flags determines the nature (e.g. abstract or not) of the type. type from which this type will be derived 0-terminated string used as the name of the new type #GTypePlugin structure to retrieve the #GTypeInfo from bitwise combination of #GTypeFlags values the new type identifier or #G_TYPE_INVALID if registration failed Registers @type_id as the predefined identifier and @type_name as the name of a fundamental type. If @type_id is already registered, or a type named @type_name is already registered, the behaviour is undefined. The type system uses the information contained in the #GTypeInfo structure pointed to by @info and the #GTypeFundamentalInfo structure pointed to by @finfo to manage the type and its instances. The value of @flags determines additional characteristics of the fundamental type. a predefined type identifier 0-terminated string used as the name of the new type #GTypeInfo structure for this type #GTypeFundamentalInfo structure for this type bitwise combination of #GTypeFlags values the predefined type identifier Registers @type_name as the name of a new static type derived from @parent_type. The type system uses the information contained in the #GTypeInfo structure pointed to by @info to manage the type and its instances (if not abstract). The value of @flags determines the nature (e.g. abstract or not) of the type. type from which this type will be derived 0-terminated string used as the name of the new type #GTypeInfo structure for this type bitwise combination of #GTypeFlags values the new type identifier Registers @type_name as the name of a new static type derived from @parent_type. The value of @flags determines the nature (e.g. abstract or not) of the type. It works by filling a #GTypeInfo struct and calling g_type_register_static(). Since: 2.12 type from which this type will be derived 0-terminated string used as the name of the new type size of the class structure (see #GTypeInfo) location of the class initialization function (see #GTypeInfo) size of the instance structure (see #GTypeInfo) location of the instance initialization function (see #GTypeInfo) bitwise combination of #GTypeFlags values the new type identifier Removes a previously installed #GTypeClassCacheFunc. The cache maintained by @cache_func has to be empty when calling g_type_remove_class_cache_func() to avoid leaks. data that was given when adding @cache_func a #GTypeClassCacheFunc Removes an interface check function added with g_type_add_interface_check(). Since: 2.4 callback data passed to g_type_add_interface_check() callback function passed to g_type_add_interface_check() Attaches arbitrary data to a type. a #GType a #GQuark id to identify the data the data Returns the location of the #GTypeValueTable associated with @type. Note that this function should only be used from source code that implements or has internal knowledge of the implementation of @type. a #GType location of the #GTypeValueTable associated with @type or %NULL if there is no #GTypeValueTable associated with @type Convert a string from UCS-4 to UTF-16. A 0 character will be added to the result after the converted text. a UCS-4 encoded string the maximum length (number of characters) of @str to use. If @len < 0, then the string is nul-terminated. location to store number of bytes read, or %NULL. If an error occurs then the index of the invalid input is stored here. location to store number of #gunichar2 written, or %NULL. The value stored here does not include the trailing 0. location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError other than %G_CONVERT_ERROR_NO_CONVERSION may occur. a pointer to a newly allocated UTF-16 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. Convert a string from a 32-bit fixed width representation as UCS-4. to UTF-8. The result will be terminated with a 0 byte. a UCS-4 encoded string the maximum length (number of characters) of @str to use. If @len < 0, then the string is nul-terminated. location to store number of characters read, or %NULL. location to store number of bytes written or %NULL. The value here stored does not include the trailing 0 byte. location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError other than %G_CONVERT_ERROR_NO_CONVERSION may occur. a pointer to a newly allocated UTF-8 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. In that case, @items_read will be set to the position of the first invalid input character. 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. a Unicode character the break type of @c Determines the canonical combining class of a Unicode character. Since: 2.14 a Unicode character the combining class of the character Performs a single composition step of the Unicode canonical composition algorithm. This function includes algorithmic Hangul Jamo composition, but it is not exactly the inverse of g_unichar_decompose(). No composition can have either of @a or @b equal to zero. To be precise, this function composes if and only if there exists a Primary Composite P which is canonically equivalent to the sequence <@a,@b>. See the Unicode Standard for the definition of Primary Composite. If @a and @b do not compose a new character, @ch is set to zero. See [UAX#15](http://unicode.org/reports/tr15/) for details. Since: 2.30 a Unicode character a Unicode character return location for the composed character %TRUE if the characters could be composed Performs a single decomposition step of the Unicode canonical decomposition algorithm. This function does not include compatibility decompositions. It does, however, include algorithmic Hangul Jamo decomposition, as well as 'singleton' decompositions which replace a character by a single other character. In the case of singletons *@b will be set to zero. If @ch is not decomposable, *@a is set to @ch and *@b is set to zero. Note that the way Unicode decomposition pairs are defined, it is guaranteed that @b would not decompose further, but @a may itself decompose. To get the full canonical decomposition for @ch, one would need to recursively call this function on @a. Or use g_unichar_fully_decompose(). See [UAX#15](http://unicode.org/reports/tr15/) for details. Since: 2.30 a Unicode character return location for the first component of @ch return location for the second component of @ch %TRUE if the character could be decomposed Determines the numeric value of a character as a decimal digit. a Unicode character If @c is a decimal digit (according to g_unichar_isdigit()), its numeric value. Otherwise, -1. Computes the canonical or compatibility decomposition of a Unicode character. For compatibility decomposition, pass %TRUE for @compat; for canonical decomposition pass %FALSE for @compat. The decomposed sequence is placed in @result. Only up to @result_len characters are written into @result. The length of the full decomposition (irrespective of @result_len) is returned by the function. For canonical decomposition, currently all decompositions are of length at most 4, but this may change in the future (very unlikely though). At any rate, Unicode does guarantee that a buffer of length 18 is always enough for both compatibility and canonical decompositions, so that is the size recommended. This is provided as %G_UNICHAR_MAX_DECOMPOSITION_LENGTH. See [UAX#15](http://unicode.org/reports/tr15/) for details. Since: 2.30 a Unicode character. whether perform canonical or compatibility decomposition location to store decomposed result, or %NULL length of @result the length of the full decomposition. In Unicode, some characters are "mirrored". This means that their images are mirrored horizontally in text that is laid out from right to left. For instance, "(" would become its mirror image, ")", in right-to-left text. If @ch has the Unicode mirrored property and there is another unicode character that typically has a glyph that is the mirror image of @ch's glyph and @mirrored_ch is set, it puts that character in the address pointed to by @mirrored_ch. Otherwise the original character is put. Since: 2.4 a Unicode character location to store the mirrored character %TRUE if @ch has a mirrored character, %FALSE otherwise 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. This function is equivalent to pango_script_for_unichar() and the two are interchangeable. Since: 2.14 a Unicode character the #GUnicodeScript for the character. Determines whether a character is alphanumeric. Given some UTF-8 text, obtain a character value with g_utf8_get_char(). a Unicode character %TRUE if @c is an alphanumeric character Determines whether a character is alphabetic (i.e. a letter). Given some UTF-8 text, obtain a character value with g_utf8_get_char(). a Unicode character %TRUE if @c is an alphabetic character Determines whether a character is a control character. Given some UTF-8 text, obtain a character value with g_utf8_get_char(). a Unicode character %TRUE if @c is a control character Determines if a given character is assigned in the Unicode standard. a Unicode character %TRUE if the character has an assigned value 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(). a Unicode character %TRUE if @c is a digit 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(). a Unicode character %TRUE if @c is printable unless it's a space Determines whether a character is a lowercase letter. Given some UTF-8 text, obtain a character value with g_utf8_get_char(). a Unicode character %TRUE if @c is a lowercase letter 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(). Note: in most cases where isalpha characters are allowed, ismark characters should be allowed to as they are essential for writing most European languages as well as many non-Latin scripts. Since: 2.14 a Unicode character %TRUE if @c is a mark character 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(). a Unicode character %TRUE if @c is printable Determines whether a character is punctuation or a symbol. Given some UTF-8 text, obtain a character value with g_utf8_get_char(). a Unicode character %TRUE if @c is a punctuation or symbol character 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(). (Note: don't use this to do word breaking; you have to use Pango or equivalent to get word breaking right, the algorithm is fairly complex.) a Unicode character %TRUE if @c is a space character 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. a Unicode character %TRUE if the character is titlecase Determines if a character is uppercase. a Unicode character %TRUE if @c is an uppercase character Determines if a character is typically rendered in a double-width cell. a Unicode character %TRUE if the character is wide 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](http://www.unicode.org/reports/tr11/) for details. If a character passes the g_unichar_iswide() test then it will also pass this test, but not the other way around. Note that some characters may pass both this test and g_unichar_iszerowidth(). Since: 2.12 a Unicode character %TRUE if the character is wide in legacy East Asian locales Determines if a character is a hexidecimal digit. a Unicode character. %TRUE if the 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. A typical use of this function is with one of g_unichar_iswide() or g_unichar_iswide_cjk() to determine the number of cells a string occupies when displayed on a grid display (terminals). However, note that not all terminals support zero-width rendering of zero-width marks. Since: 2.14 a Unicode character %TRUE if the character has zero width Converts a single character to UTF-8. a Unicode character code output buffer, must have at least 6 bytes of space. If %NULL, the length will be computed and returned and nothing will be written to @outbuf. number of bytes written Converts a character to lower case. a Unicode character. the result of converting @c to lower case. If @c is not an upperlower or titlecase character, or has no lowercase equivalent @c is returned unchanged. Converts a character to the titlecase. a Unicode character the result of converting @c to titlecase. If @c is not an uppercase or lowercase character, @c is returned unchanged. Converts a character to uppercase. a Unicode character the result of converting @c to uppercase. If @c is not an lowercase or titlecase character, or has no upper case equivalent @c is returned unchanged. Classifies a Unicode character by type. a Unicode character the type of the character. 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. a Unicode character %TRUE if @ch is a valid Unicode character Determines the numeric value of a character as a hexidecimal digit. a Unicode character If @c is a hex digit (according to g_unichar_isxdigit()), its numeric value. Otherwise, -1. Computes the canonical decomposition of a Unicode character. Deprecated: 2.30: Use the more flexible g_unichar_fully_decompose() instead. a Unicode character. location to store the length of the return value. a newly allocated string of Unicode characters. @result_len is set to the resulting length of the string. Computes the canonical ordering of a string in-place. This rearranges decomposed characters in the string according to their combining classes. See the Unicode manual for more information. a UCS-4 encoded string. the maximum length of @string to use. 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). See [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html) for details. Since: 2.30 a Unicode script the Unicode script for @iso15924, or of %G_UNICODE_SCRIPT_INVALID_CODE if @iso15924 is zero and %G_UNICODE_SCRIPT_UNKNOWN if @iso15924 is unknown. 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). See [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html) for details. Since: 2.30 a Unicode script the ISO 15924 code for @script, encoded as an integer, of zero if @script is %G_UNICODE_SCRIPT_INVALID_CODE or ISO 15924 code 'Zzzz' (script code for UNKNOWN) if @script is not understood. Sets a function to be called when the IO condition, as specified by @condition becomes true for @fd. @function will be called when the specified IO condition becomes %TRUE. The function is expected to clear whatever event caused the IO condition to become true and return %TRUE in order to be notified when it happens again. If @function returns %FALSE then the watch will be cancelled. The return value of this function can be passed to g_source_remove() to cancel the watch at any time that it exists. The source will never close the fd -- you must do it yourself. Since: 2.36 a file descriptor IO conditions to watch for on @fd a #GPollFDFunc data to pass to @function the ID (greater than 0) of the event source Sets a function to be called when the IO condition, as specified by @condition becomes true for @fd. This is the same as g_unix_fd_add(), except that it allows you to specify a non-default priority and a provide a #GDestroyNotify for @user_data. Since: 2.36 the priority of the source a file descriptor IO conditions to watch for on @fd a #GUnixFDSourceFunc data to pass to @function function to call when the idle is removed, or %NULL the ID (greater than 0) of the event source Creates a #GSource to watch for a particular IO condition on a file descriptor. The source will never close the fd -- you must do it yourself. Since: 2.36 a file descriptor IO conditions to watch for on @fd the newly created #GSource Similar to the UNIX pipe() call, but on modern systems like Linux uses the pipe2() system call, which atomically creates a pipe with the configured flags. The only supported flag currently is %FD_CLOEXEC. If for example you want to configure %O_NONBLOCK, that must still be done separately with fcntl(). This function does not take %O_CLOEXEC, it takes %FD_CLOEXEC as if for fcntl(); these are different on Linux/glibc. Since: 2.30 Array of two integers Bitfield of file descriptor flags, as for fcntl() a #GError %TRUE on success, %FALSE if not (and errno will be set). 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. Since: 2.30 A file descriptor If %TRUE, set the descriptor to be non-blocking a #GError %TRUE if successful A convenience function for g_unix_signal_source_new(), which attaches to the default #GMainContext. You can remove the watch using g_source_remove(). Since: 2.30 Signal number Callback Data for @handler An ID (greater than 0) for the event source A convenience function for g_unix_signal_source_new(), which attaches to the default #GMainContext. You can remove the watch using g_source_remove(). Since: 2.30 the priority of the signal source. Typically this will be in the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH. Signal number Callback Data for @handler #GDestroyNotify for @handler An ID (greater than 0) for the event source 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. Note that unlike the UNIX default, all sources which have created a watch will be dispatched, regardless of which underlying thread invoked g_unix_signal_source_new(). For example, an effective use of this function is to handle `SIGTERM` cleanly; flushing any outstanding files, and then calling g_main_loop_quit (). It is not safe to do any of this a regular UNIX signal handler; your handler may be invoked while malloc() or another library function is running, causing reentrancy if you attempt to use it from the handler. None of the GLib/GObject API is safe against this kind of reentrancy. The interaction of this source when combined with native UNIX functions like sigprocmask() is not defined. The source will not initially be associated with any #GMainContext and must be added to one with g_source_attach() before it will be executed. Since: 2.30 A signal number A newly created #GSource 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. See your C library manual for more details about unlink(). Note that on Windows, it is in general not possible to delete files that are open to some process, or mapped into memory. Since: 2.6 a pathname in the GLib file name encoding (UTF-8 on Windows) 0 if the name was successfully deleted, -1 if an error occurred Removes an environment variable from the environment. Note that on some systems, when variables are overwritten, the memory used for the previous variables and its value isn't reclaimed. You should be mindful of the fact that environment variable handling in UNIX is not thread-safe, and your program may crash if one thread calls g_unsetenv() while another thread is calling getenv(). (And note that many functions, such as gettext(), call getenv() internally.) This function is only safe to use at the very start of your program, before creating any other threads (or creating objects that create worker threads of their own). If you need to set up the environment for a child process, you can use g_get_environ() to get an environment array, modify that with g_environ_setenv() and g_environ_unsetenv(), and then pass that array directly to execvpe(), g_spawn_async(), or the like. Since: 2.4 the environment variable to remove, must not contain '=' Escapes a string for use in a URI. Normally all characters that are not "unreserved" (i.e. ASCII alphanumerical characters plus dash, dot, underscore and tilde) are escaped. But if you specify characters in @reserved_chars_allowed they are not escaped. This is useful for the "reserved" characters in the URI specification, since those are allowed unescaped in some portions of a URI. Since: 2.16 the unescaped input string. a string of reserved characters that are allowed to be used, or %NULL. %TRUE if the result can include UTF-8 characters. an escaped version of @unescaped. The returned string should be freed when no longer needed. 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. Since: 2.6 an URI list a newly allocated %NULL-terminated list of strings holding the individual URIs. The array should be freed with g_strfreev(). Gets the scheme portion of a URI string. RFC 3986 decodes the scheme as: |[ URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] ]| Common schemes include "file", "http", "svn+ssh", etc. Since: 2.16 a valid URI. The "Scheme" component of the URI, or %NULL on error. The returned string should be freed when no longer needed. Unescapes a segment of an escaped string. If any of the characters in @illegal_characters or the character zero appears as an escaped character in @escaped_string then that is an error and %NULL will be returned. This is useful it you want to avoid for instance having a slash being expanded in an escaped path element, which might confuse pathname handling. Since: 2.16 A string, may be %NULL Pointer to end of @escaped_string, may be %NULL An optional string of illegal characters not to be allowed, may be %NULL an unescaped version of @escaped_string or %NULL on error. The returned string should be freed when no longer needed. As a special case if %NULL is given for @escaped_string, this function will return %NULL. Unescapes a whole escaped string. If any of the characters in @illegal_characters or the character zero appears as an escaped character in @escaped_string then that is an error and %NULL will be returned. This is useful it you want to avoid for instance having a slash being expanded in an escaped path element, which might confuse pathname handling. Since: 2.16 an escaped string to be unescaped. a string of illegal characters not to be allowed, or %NULL. an unescaped version of @escaped_string. The returned string should be freed when no longer needed. Pauses the current thread for the given number of microseconds. There are 1 million microseconds per second (represented by the #G_USEC_PER_SEC macro). g_usleep() may have limited precision, depending on hardware and operating system; don't rely on the exact length of the sleep. number of microseconds to pause Convert a string from UTF-16 to UCS-4. The result will be nul-terminated. a UTF-16 encoded string the maximum length (number of #gunichar2) of @str to use. If @len < 0, then the string is nul-terminated. location to store number of words read, or %NULL. If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. location to store number of characters written, or %NULL. The value stored here does not include the trailing 0 character. location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError other than %G_CONVERT_ERROR_NO_CONVERSION may occur. a pointer to a newly allocated UCS-4 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. Convert a string from UTF-16 to UTF-8. The result will be terminated with a 0 byte. Note that the input is expected to be already in native endianness, an initial byte-order-mark character is not handled specially. g_convert() can be used to convert a byte buffer of UTF-16 data of ambiguous endianess. Further note that this function does not validate the result string; it may e.g. include embedded NUL characters. The only validation done by this function is to ensure that the input can be correctly interpreted as UTF-16, i.e. it doesn't contain things unpaired surrogates. a UTF-16 encoded string the maximum length (number of #gunichar2) of @str to use. If @len < 0, then the string is nul-terminated. location to store number of words read, or %NULL. If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. location to store number of bytes written, or %NULL. The value stored here does not include the trailing 0 byte. location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError other than %G_CONVERT_ERROR_NO_CONVERSION may occur. a pointer to a newly allocated UTF-8 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. Converts a string into a form that is independent of case. The result will not correspond to any particular case, but can be compared for equality or ordered with the results of calling g_utf8_casefold() on other strings. Note that calling g_utf8_casefold() followed by g_utf8_collate() is only an approximation to the correct linguistic case insensitive ordering, though it is a fairly good one. Getting this exactly right would require a more sophisticated collation function that takes case sensitivity into account. GLib does not currently provide such a function. a UTF-8 encoded string length of @str, in bytes, or -1 if @str is nul-terminated. a newly allocated string, that is a case independent form of @str. Compares two strings for ordering using the linguistically correct rules for the [current locale][setlocale]. When sorting a large number of strings, it will be significantly faster to obtain collation keys with g_utf8_collate_key() and compare the keys with strcmp() when sorting instead of sorting the original strings. a UTF-8 encoded string a UTF-8 encoded string < 0 if @str1 compares before @str2, 0 if they compare equal, > 0 if @str1 compares after @str2. Converts a string into a collation key that can be compared with other collation keys produced by the same function using strcmp(). The results of comparing the collation keys of two strings with strcmp() will always be the same as comparing the two original keys with g_utf8_collate(). Note that this function depends on the [current locale][setlocale]. a UTF-8 encoded string. length of @str, in bytes, or -1 if @str is nul-terminated. a newly allocated string. This string should be freed with g_free() when you are done with it. Converts a string into a collation key that can be compared with other collation keys produced by the same function using strcmp(). In order to sort filenames correctly, this function treats the dot '.' as a special case. Most dictionary orderings seem to consider it insignificant, thus producing the ordering "event.c" "eventgenerator.c" "event.h" instead of "event.c" "event.h" "eventgenerator.c". Also, we would like to treat numbers intelligently so that "file1" "file10" "file5" is sorted as "file1" "file5" "file10". Note that this function depends on the [current locale][setlocale]. Since: 2.8 a UTF-8 encoded string. length of @str, in bytes, or -1 if @str is nul-terminated. a newly allocated string. This string should be freed with g_free() when you are done with it. Finds the start of the next UTF-8 character in the string after @p. @p does not have to be at the beginning of a UTF-8 character. No check is made to see if the character found is actually valid other than it starts with an appropriate byte. a pointer to a position within a UTF-8 encoded string a pointer to the byte following the end of the string, or %NULL to indicate that the string is nul-terminated a pointer to the found character or %NULL Given a position @p with a UTF-8 encoded string @str, find the start of the previous UTF-8 character starting before @p. Returns %NULL if no UTF-8 characters are present in @str before @p. @p does not have to be at the beginning of a UTF-8 character. No check is made to see if the character found is actually valid other than it starts with an appropriate byte. pointer to the beginning of a UTF-8 encoded string pointer to some position within @str a pointer to the found character or %NULL. Converts a sequence of bytes encoded as UTF-8 to a Unicode character. If @p does not point to a valid UTF-8 encoded character, results are undefined. If you are not sure that the bytes are complete valid Unicode characters, you should use g_utf8_get_char_validated() instead. a pointer to Unicode character encoded as UTF-8 the resulting character Convert a sequence of bytes encoded as UTF-8 to a Unicode character. This function checks for incomplete characters, for invalid characters such as characters that are out of the range of Unicode, and for overlong encodings of valid characters. a pointer to Unicode character encoded as UTF-8 the maximum number of bytes to read, or -1, for no maximum or if @p is nul-terminated the resulting character. If @p points to a partial sequence at the end of a string that could begin a valid character (or if @max_len is zero), returns (gunichar)-2; otherwise, if @p does not point to a valid UTF-8 encoded Unicode character, returns (gunichar)-1. Skips to the next character in a UTF-8 string. The string must be valid; this macro is as fast as possible, and has no error-checking. You would use this macro to iterate over a string character by character. The macro returns the start of the next UTF-8 character. Before using this macro, use g_utf8_validate() to validate strings that may contain invalid UTF-8. Pointer to the start of a valid UTF-8 character Converts a string into canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character. The string has to be valid UTF-8, otherwise %NULL is returned. You should generally call g_utf8_normalize() before comparing two Unicode strings. The normalization mode %G_NORMALIZE_DEFAULT only standardizes differences that do not affect the text content, such as the above-mentioned accent representation. %G_NORMALIZE_ALL also standardizes the "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to the standard forms (in this case DIGIT THREE). Formatting information may be lost but for most text operations such characters should be considered the same. %G_NORMALIZE_DEFAULT_COMPOSE and %G_NORMALIZE_ALL_COMPOSE are like %G_NORMALIZE_DEFAULT and %G_NORMALIZE_ALL, but returned a result with composed forms rather than a maximally decomposed form. This is often useful if you intend to convert the string to a legacy encoding or pass it to a system with less capable Unicode handling. a UTF-8 encoded string. length of @str, in bytes, or -1 if @str is nul-terminated. the type of normalization to perform. a newly allocated string, that is the normalized form of @str, or %NULL if @str is not valid UTF-8. Converts from an integer character offset to a pointer to a position within the string. Since 2.10, this function allows to pass a negative @offset to step backwards. It is usually worth stepping backwards from the end instead of forwards if @offset is in the last fourth of the string, since moving forward is about 3 times faster than moving backward. Note that this function doesn't abort when reaching the end of @str. Therefore you should be sure that @offset is within string boundaries before calling that function. Call g_utf8_strlen() when unsure. This limitation exists as this function is called frequently during text rendering and therefore has to be as fast as possible. a UTF-8 encoded string a character offset within @str the resulting pointer Converts from a pointer to position within a string to a integer character offset. Since 2.10, this function allows @pos to be before @str, and returns a negative offset in this case. a UTF-8 encoded string a pointer to a position within @str the resulting character offset Finds the previous UTF-8 character in the string before @p. @p does not have to be at the beginning of a UTF-8 character. No check is made to see if the character found is actually valid other than it starts with an appropriate byte. If @p might be the first character of the string, you must use g_utf8_find_prev_char() instead. a pointer to a position within a UTF-8 encoded string a pointer to the found character Finds the leftmost occurrence of the given Unicode character in a UTF-8 encoded string, while limiting the search to @len bytes. If @len is -1, allow unbounded search. a nul-terminated UTF-8 encoded string the maximum length of @p a Unicode character %NULL if the string does not contain the character, otherwise, a pointer to the start of the leftmost occurrence of the character in the string. Converts all Unicode characters in the string that have a case to lowercase. The exact manner that this is done depends on the current locale, and may result in the number of characters in the string changing. a UTF-8 encoded string length of @str, in bytes, or -1 if @str is nul-terminated. a newly allocated string, with all characters converted to lowercase. Computes the length of the string in characters, not including the terminating nul character. If the @max'th byte falls in the middle of a character, the last (partial) character is not counted. pointer to the start of a UTF-8 encoded string the maximum number of bytes to examine. If @max is less than 0, then the string is assumed to be nul-terminated. If @max is 0, @p will not be examined and may be %NULL. If @max is greater than 0, up to @max bytes are examined the length of the string in characters Like the standard C strncpy() function, but copies a given number of characters instead of a given number of bytes. The @src string must be valid UTF-8 encoded text. (Use g_utf8_validate() on all text before trying to use UTF-8 utility functions with it.) buffer to fill with characters from @src UTF-8 encoded string character count @dest Find the rightmost occurrence of the given Unicode character in a UTF-8 encoded string, while limiting the search to @len bytes. If @len is -1, allow unbounded search. a nul-terminated UTF-8 encoded string the maximum length of @p a Unicode character %NULL if the string does not contain the character, otherwise, a pointer to the start of the rightmost occurrence of the character in the string. Reverses a UTF-8 string. @str must be valid UTF-8 encoded text. (Use g_utf8_validate() on all text before trying to use UTF-8 utility functions with it.) This function is intended for programmatic uses of reversed strings. It pays no attention to decomposed characters, combining marks, byte order marks, directional indicators (LRM, LRO, etc) and similar characters which might need special handling when reversing a string for display purposes. Note that unlike g_strreverse(), this function returns newly-allocated memory, which should be freed with g_free() when no longer needed. Since: 2.2 a UTF-8 encoded string the maximum length of @str to use, in bytes. If @len < 0, then the string is nul-terminated. a newly-allocated string which is the reverse of @str Converts all Unicode characters in the string that have a case to uppercase. The exact manner that this is done depends on the current locale, and may result in the number of characters in the string increasing. (For instance, the German ess-zet will be changed to SS.) a UTF-8 encoded string length of @str, in bytes, or -1 if @str is nul-terminated. a newly allocated string, with all characters converted to uppercase. Copies a substring out of a UTF-8 encoded string. The substring will contain @end_pos - @start_pos characters. Since: 2.30 a UTF-8 encoded string a character offset within @str another character offset within @str a newly allocated copy of the requested substring. Free with g_free() when no longer needed. Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4. A trailing 0 character will be added to the string after the converted text. a UTF-8 encoded string the maximum length of @str to use, in bytes. If @len < 0, then the string is nul-terminated. location to store number of bytes read, or %NULL. If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. location to store number of characters written or %NULL. The value here stored does not include the trailing 0 character. location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError other than %G_CONVERT_ERROR_NO_CONVERSION may occur. a pointer to a newly allocated UCS-4 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4, assuming valid UTF-8 input. This function is roughly twice as fast as g_utf8_to_ucs4() but does no error checking on the input. A trailing 0 character will be added to the string after the converted text. a UTF-8 encoded string the maximum length of @str to use, in bytes. If @len < 0, then the string is nul-terminated. location to store the number of characters in the result, or %NULL. a pointer to a newly allocated UCS-4 string. This value must be freed with g_free(). Convert a string from UTF-8 to UTF-16. A 0 character will be added to the result after the converted text. a UTF-8 encoded string the maximum length (number of bytes) of @str to use. If @len < 0, then the string is nul-terminated. location to store number of bytes read, or %NULL. If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be returned in case @str contains a trailing partial character. If an error occurs then the index of the invalid input is stored here. location to store number of #gunichar2 written, or %NULL. The value stored here does not include the trailing 0. location to store the error occurring, or %NULL to ignore errors. Any of the errors in #GConvertError other than %G_CONVERT_ERROR_NO_CONVERSION may occur. a pointer to a newly allocated UTF-16 string. This value must be freed with g_free(). If an error occurs, %NULL will be returned and @error set. Validates UTF-8 encoded text. @str is the text to validate; if @str is nul-terminated, then @max_len can be -1, otherwise @max_len should be the number of bytes to validate. If @end is non-%NULL, then the end of the valid range will be stored there (i.e. the start of the first invalid character if some bytes were invalid, or the end of the text being validated otherwise). Note that g_utf8_validate() returns %FALSE if @max_len is positive and any of the @max_len bytes are nul. a pointer to character data max bytes to validate, or -1 to go until NUL return location for end of valid data %TRUE if the text was valid UTF-8 A wrapper for the POSIX utime() function. The utime() function sets the access and modification timestamps of a file. See your C library manual for more details about how utime() works on your system. Since: 2.18 a pathname in the GLib file name encoding (UTF-8 on Windows) a pointer to a struct utimbuf. 0 if the operation was successful, -1 if an error occurred Insert a copy of @value as last element of @value_array. If @value is %NULL, an uninitialized value is appended. Deprecated: 2.32: Use #GArray and g_array_append_val() instead. #GValueArray to add an element to #GValue to copy into #GValueArray, or %NULL the #GValueArray passed in as @value_array Construct an exact copy of a #GValueArray by duplicating all its contents. Deprecated: 2.32: Use #GArray and g_array_ref() instead. #GValueArray to copy Newly allocated copy of #GValueArray Free a #GValueArray including its contents. Deprecated: 2.32: Use #GArray and g_array_unref() instead. #GValueArray to free Return a pointer to the value at @index_ containd in @value_array. Deprecated: 2.32: Use g_array_index() instead. #GValueArray to get a value from index of the value of interest pointer to a value at @index_ in @value_array Insert a copy of @value at specified position into @value_array. If @value is %NULL, an uninitialized value is inserted. Deprecated: 2.32: Use #GArray and g_array_insert_val() instead. #GValueArray to add an element to insertion position, must be <= value_array->n_values #GValue to copy into #GValueArray, or %NULL the #GValueArray passed in as @value_array Allocate and initialize a new #GValueArray, optionally preserve space for @n_prealloced elements. New arrays always contain 0 elements, regardless of the value of @n_prealloced. Deprecated: 2.32: Use #GArray and g_array_sized_new() instead. number of values to preallocate space for a newly allocated #GValueArray with 0 values Insert a copy of @value as first element of @value_array. If @value is %NULL, an uninitialized value is prepended. Deprecated: 2.32: Use #GArray and g_array_prepend_val() instead. #GValueArray to add an element to #GValue to copy into #GValueArray, or %NULL the #GValueArray passed in as @value_array Remove the value at position @index_ from @value_array. Deprecated: 2.32: Use #GArray and g_array_remove_index() instead. #GValueArray to remove an element from position of value to remove, which must be less than @value_array->n_values the #GValueArray passed in as @value_array Sort @value_array using @compare_func to compare the elements according to the semantics of #GCompareFunc. The current implementation uses the same sorting algorithm as standard C qsort() function. Deprecated: 2.32: Use #GArray and g_array_sort(). #GValueArray to sort function to compare elements the #GValueArray passed in as @value_array Sort @value_array using @compare_func to compare the elements according to the semantics of #GCompareDataFunc. The current implementation uses the same sorting algorithm as standard C qsort() function. Deprecated: 2.32: Use #GArray and g_array_sort_with_data(). #GValueArray to sort function to compare elements extra data argument provided for @compare_func the #GValueArray passed in as @value_array Copies the value of @src_value into @dest_value. An initialized #GValue structure. An initialized #GValue structure of the same type as @src_value. Get the contents of a %G_TYPE_BOXED derived #GValue. Upon getting, the boxed value is duplicated and needs to be later freed with g_boxed_free(), e.g. like: g_boxed_free (G_VALUE_TYPE (@value), return_value); a valid #GValue of %G_TYPE_BOXED derived type boxed contents of @value Get the contents of a %G_TYPE_OBJECT derived #GValue, increasing its reference count. If the contents of the #GValue are %NULL, then %NULL will be returned. a valid #GValue whose type is derived from %G_TYPE_OBJECT object content of @value, should be unreferenced when no longer needed. Get the contents of a %G_TYPE_PARAM #GValue, increasing its reference count. a valid #GValue whose type is derived from %G_TYPE_PARAM #GParamSpec content of @value, should be unreferenced when no longer needed. Get a copy the contents of a %G_TYPE_STRING #GValue. a valid #GValue of type %G_TYPE_STRING a newly allocated copy of the string content of @value Get the contents of a variant #GValue, increasing its refcount. Since: 2.26 a valid #GValue of type %G_TYPE_VARIANT variant contents of @value, should be unrefed using g_variant_unref() when no longer needed Determines if @value will fit inside the size of a pointer value. This is an internal function introduced mainly for C marshallers. An initialized #GValue structure. %TRUE if @value will fit inside a pointer value. Get the contents of a %G_TYPE_BOOLEAN #GValue. a valid #GValue of type %G_TYPE_BOOLEAN boolean contents of @value Get the contents of a %G_TYPE_BOXED derived #GValue. a valid #GValue of %G_TYPE_BOXED derived type boxed contents of @value Do not use this function; it is broken on platforms where the %char type is unsigned, such as ARM and PowerPC. See g_value_get_schar(). Get the contents of a %G_TYPE_CHAR #GValue. Deprecated: 2.32: This function's return type is broken, see g_value_get_schar() a valid #GValue of type %G_TYPE_CHAR character contents of @value Get the contents of a %G_TYPE_DOUBLE #GValue. a valid #GValue of type %G_TYPE_DOUBLE double contents of @value Get the contents of a %G_TYPE_ENUM #GValue. a valid #GValue whose type is derived from %G_TYPE_ENUM enum contents of @value Get the contents of a %G_TYPE_FLAGS #GValue. a valid #GValue whose type is derived from %G_TYPE_FLAGS flags contents of @value Get the contents of a %G_TYPE_FLOAT #GValue. a valid #GValue of type %G_TYPE_FLOAT float contents of @value Get the contents of a %G_TYPE_GTYPE #GValue. Since: 2.12 a valid #GValue of type %G_TYPE_GTYPE the #GType stored in @value Get the contents of a %G_TYPE_INT #GValue. a valid #GValue of type %G_TYPE_INT integer contents of @value Get the contents of a %G_TYPE_INT64 #GValue. a valid #GValue of type %G_TYPE_INT64 64bit integer contents of @value Get the contents of a %G_TYPE_LONG #GValue. a valid #GValue of type %G_TYPE_LONG long integer contents of @value Get the contents of a %G_TYPE_OBJECT derived #GValue. a valid #GValue of %G_TYPE_OBJECT derived type object contents of @value Get the contents of a %G_TYPE_PARAM #GValue. a valid #GValue whose type is derived from %G_TYPE_PARAM #GParamSpec content of @value Get the contents of a pointer #GValue. a valid #GValue of %G_TYPE_POINTER pointer contents of @value Get the contents of a %G_TYPE_CHAR #GValue. Since: 2.32 a valid #GValue of type %G_TYPE_CHAR signed 8 bit integer contents of @value Get the contents of a %G_TYPE_STRING #GValue. a valid #GValue of type %G_TYPE_STRING string content of @value Get the contents of a %G_TYPE_UCHAR #GValue. a valid #GValue of type %G_TYPE_UCHAR unsigned character contents of @value Get the contents of a %G_TYPE_UINT #GValue. a valid #GValue of type %G_TYPE_UINT unsigned integer contents of @value Get the contents of a %G_TYPE_UINT64 #GValue. a valid #GValue of type %G_TYPE_UINT64 unsigned 64bit integer contents of @value Get the contents of a %G_TYPE_ULONG #GValue. a valid #GValue of type %G_TYPE_ULONG unsigned long integer contents of @value Get the contents of a variant #GValue. Since: 2.26 a valid #GValue of type %G_TYPE_VARIANT variant contents of @value Initializes @value with the default value of @type. A zero-filled (uninitialized) #GValue structure. Type the #GValue should hold values of. the #GValue structure that has been passed in Initializes and sets @value from an instantiatable type via the value_table's collect_value() function. Note: The @value will be initialised with the exact type of @instance. If you wish to set the @value's type to a different GType (such as a parent class GType), you need to manually call g_value_init() and g_value_set_instance(). Since: 2.42 An uninitialized #GValue structure. the instance Returns the value contents as pointer. This function asserts that g_value_fits_pointer() returned %TRUE for the passed in value. This is an internal function introduced mainly for C marshallers. An initialized #GValue structure the value contents as pointer Registers a value transformation function for use in g_value_transform(). A previously registered transformation function for @src_type and @dest_type will be replaced. Source type. Target type. a function which transforms values of type @src_type into value of type @dest_type Clears the current value in @value and resets it to the default value (as if the value had just been initialized). An initialized #GValue structure. the #GValue structure that has been passed in Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean. a valid #GValue of type %G_TYPE_BOOLEAN boolean value to be set Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed. a valid #GValue of %G_TYPE_BOXED derived type boxed value to be set This is an internal function introduced mainly for C marshallers. Deprecated: 2.4: Use g_value_take_boxed() instead. a valid #GValue of %G_TYPE_BOXED derived type duplicated unowned boxed value to be set Set the contents of a %G_TYPE_CHAR #GValue to @v_char. Deprecated: 2.32: This function's input type is broken, see g_value_set_schar() a valid #GValue of type %G_TYPE_CHAR character value to be set Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double. a valid #GValue of type %G_TYPE_DOUBLE double value to be set Set the contents of a %G_TYPE_ENUM #GValue to @v_enum. a valid #GValue whose type is derived from %G_TYPE_ENUM enum value to be set Set the contents of a %G_TYPE_FLAGS #GValue to @v_flags. a valid #GValue whose type is derived from %G_TYPE_FLAGS flags value to be set Set the contents of a %G_TYPE_FLOAT #GValue to @v_float. a valid #GValue of type %G_TYPE_FLOAT float value to be set Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype. Since: 2.12 a valid #GValue of type %G_TYPE_GTYPE #GType to be set Sets @value from an instantiatable type via the value_table's collect_value() function. An initialized #GValue structure. the instance Set the contents of a %G_TYPE_INT #GValue to @v_int. a valid #GValue of type %G_TYPE_INT integer value to be set Set the contents of a %G_TYPE_INT64 #GValue to @v_int64. a valid #GValue of type %G_TYPE_INT64 64bit integer value to be set Set the contents of a %G_TYPE_LONG #GValue to @v_long. a valid #GValue of type %G_TYPE_LONG long integer value to be set Set the contents of a %G_TYPE_OBJECT derived #GValue to @v_object. g_value_set_object() increases the reference count of @v_object (the #GValue holds a reference to @v_object). If you do not wish to increase the reference count of the object (i.e. you wish to pass your current reference to the #GValue because you no longer need it), use g_value_take_object() instead. It is important that your #GValue holds a reference to @v_object (either its own, or one it has taken) to ensure that the object won't be destroyed while the #GValue still exists). a valid #GValue of %G_TYPE_OBJECT derived type object value to be set This is an internal function introduced mainly for C marshallers. Deprecated: 2.4: Use g_value_take_object() instead. a valid #GValue of %G_TYPE_OBJECT derived type object value to be set Set the contents of a %G_TYPE_PARAM #GValue to @param. a valid #GValue of type %G_TYPE_PARAM the #GParamSpec to be set This is an internal function introduced mainly for C marshallers. Deprecated: 2.4: Use g_value_take_param() instead. a valid #GValue of type %G_TYPE_PARAM the #GParamSpec to be set Set the contents of a pointer #GValue to @v_pointer. a valid #GValue of %G_TYPE_POINTER pointer value to be set Set the contents of a %G_TYPE_CHAR #GValue to @v_char. Since: 2.32 a valid #GValue of type %G_TYPE_CHAR signed 8 bit integer to be set Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed. The boxed value is assumed to be static, and is thus not duplicated when setting the #GValue. a valid #GValue of %G_TYPE_BOXED derived type static boxed value to be set Set the contents of a %G_TYPE_STRING #GValue to @v_string. The string is assumed to be static, and is thus not duplicated when setting the #GValue. a valid #GValue of type %G_TYPE_STRING static string to be set Set the contents of a %G_TYPE_STRING #GValue to @v_string. a valid #GValue of type %G_TYPE_STRING caller-owned string to be duplicated for the #GValue This is an internal function introduced mainly for C marshallers. Deprecated: 2.4: Use g_value_take_string() instead. a valid #GValue of type %G_TYPE_STRING duplicated unowned string to be set Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar. a valid #GValue of type %G_TYPE_UCHAR unsigned character value to be set Set the contents of a %G_TYPE_UINT #GValue to @v_uint. a valid #GValue of type %G_TYPE_UINT unsigned integer value to be set Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64. a valid #GValue of type %G_TYPE_UINT64 unsigned 64bit integer value to be set Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong. a valid #GValue of type %G_TYPE_ULONG unsigned long integer value to be set Set the contents of a variant #GValue to @variant. If the variant is floating, it is consumed. Since: 2.26 a valid #GValue of type %G_TYPE_VARIANT a #GVariant, or %NULL Sets the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed and takes over the ownership of the callers reference to @v_boxed; the caller doesn't have to unref it any more. Since: 2.4 a valid #GValue of %G_TYPE_BOXED derived type duplicated unowned boxed value to be set Sets the contents of a %G_TYPE_OBJECT derived #GValue to @v_object and takes over the ownership of the callers reference to @v_object; the caller doesn't have to unref it any more (i.e. the reference count of the object is not increased). If you want the #GValue to hold its own reference to @v_object, use g_value_set_object() instead. Since: 2.4 a valid #GValue of %G_TYPE_OBJECT derived type object value to be set Sets the contents of a %G_TYPE_PARAM #GValue to @param and takes over the ownership of the callers reference to @param; the caller doesn't have to unref it any more. Since: 2.4 a valid #GValue of type %G_TYPE_PARAM the #GParamSpec to be set Sets the contents of a %G_TYPE_STRING #GValue to @v_string. Since: 2.4 a valid #GValue of type %G_TYPE_STRING string to take ownership of Set the contents of a variant #GValue to @variant, and takes over the ownership of the caller's reference to @variant; the caller doesn't have to unref it any more (i.e. the reference count of the variant is not increased). If @variant was floating then its floating reference is converted to a hard reference. If you want the #GValue to hold its own reference to @variant, use g_value_set_variant() instead. This is an internal function introduced mainly for C marshallers. Since: 2.26 a valid #GValue of type %G_TYPE_VARIANT a #GVariant, or %NULL Tries to cast the contents of @src_value into a type appropriate to store in @dest_value, e.g. to transform a %G_TYPE_INT value into a %G_TYPE_FLOAT value. Performing transformations between value types might incur precision lossage. Especially transformations into strings might reveal seemingly arbitrary results and shouldn't be relied upon for production code (such as rcfile value or object property serialization). Source value. Target value. Whether a transformation rule was found and could be applied. Upon failing transformations, @dest_value is left untouched. Returns whether a #GValue of type @src_type can be copied into a #GValue of type @dest_type. source type to be copied. destination type for copying. %TRUE if g_value_copy() is possible with @src_type and @dest_type. Check whether g_value_transform() is able to transform values of type @src_type into values of type @dest_type. Note that for the types to be transformable, they must be compatible and a transform function must be registered. Source type. Target type. %TRUE if the transformation is possible, %FALSE otherwise. Clears the current value in @value and "unsets" the type, this releases all resources associated with this GValue. An unset value is the same as an uninitialized (zero-filled) #GValue structure. An initialized #GValue structure. Adds to a #GVariantBuilder. This call is a convenience wrapper that is exactly equivalent to calling g_variant_new() followed by g_variant_builder_add_value(). Note that the arguments must be of the correct width for their types specified in @format_string. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. This function might be used as follows: |[<!-- language="C" --> GVariant * make_pointless_dictionary (void) { GVariantBuilder builder; int i; g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); for (i = 0; i < 16; i++) { gchar buf[3]; sprintf (buf, "%d", i); g_variant_builder_add (&builder, "{is}", i, buf); } return g_variant_builder_end (&builder); } ]| Since: 2.24 a #GVariantBuilder a #GVariant varargs format string arguments, as per @format_string Adds to a #GVariantBuilder. This call is a convenience wrapper that is exactly equivalent to calling g_variant_new_parsed() followed by g_variant_builder_add_value(). Note that the arguments must be of the correct width for their types specified in @format_string. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. This function might be used as follows: |[<!-- language="C" --> GVariant * make_pointless_dictionary (void) { GVariantBuilder builder; int i; g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); g_variant_builder_add_parsed (&builder, "{'width', <%i>}", 600); g_variant_builder_add_parsed (&builder, "{'title', <%s>}", "foo"); g_variant_builder_add_parsed (&builder, "{'transparency', <0.5>}"); return g_variant_builder_end (&builder); } ]| Since: 2.26 a #GVariantBuilder a text format #GVariant arguments as per @format Adds @value to @builder. It is an error to call this function in any way that would create an inconsistent value to be constructed. Some examples of this are putting different types of items into an array, putting the wrong types or number of items in a tuple, putting more than one value into a variant, etc. If @value is a floating reference (see g_variant_ref_sink()), the @builder instance takes ownership of @value. Since: 2.24 a #GVariantBuilder a #GVariant Releases all memory associated with a #GVariantBuilder without freeing the #GVariantBuilder structure itself. It typically only makes sense to do this on a stack-allocated #GVariantBuilder if you want to abort building the value part-way through. This function need not be called if you call g_variant_builder_end() and it also doesn't need to be called on builders allocated with g_variant_builder_new (see g_variant_builder_unref() for that). This function leaves the #GVariantBuilder structure set to all-zeros. It is valid to call this function on either an initialised #GVariantBuilder or one that is set to all-zeros but it is not valid to call this function on uninitialised memory. Since: 2.24 a #GVariantBuilder Closes the subcontainer inside the given @builder that was opened by the most recent call to g_variant_builder_open(). It is an error to call this function in any way that would create an inconsistent value to be constructed (ie: too few values added to the subcontainer). Since: 2.24 a #GVariantBuilder Ends the builder process and returns the constructed value. It is not permissible to use @builder in any way after this call except for reference counting operations (in the case of a heap-allocated #GVariantBuilder) or by reinitialising it with g_variant_builder_init() (in the case of stack-allocated). It is an error to call this function in any way that would create an inconsistent value to be constructed (ie: insufficient number of items added to a container with a specific number of children required). It is also an error to call this function if the builder was created with an indefinite array or maybe type and no children have been added; in this case it is impossible to infer the type of the empty array. Since: 2.24 a #GVariantBuilder a new, floating, #GVariant Initialises a #GVariantBuilder structure. @type must be non-%NULL. It specifies the type of container to construct. It can be an indefinite type such as %G_VARIANT_TYPE_ARRAY or a definite type such as "as" or "(ii)". Maybe, array, tuple, dictionary entry and variant-typed values may be constructed. After the builder is initialised, values are added using g_variant_builder_add_value() or g_variant_builder_add(). After all the child values are added, g_variant_builder_end() frees the memory associated with the builder and returns the #GVariant that was created. This function completely ignores the previous contents of @builder. On one hand this means that it is valid to pass in completely uninitialised memory. On the other hand, this means that if you are initialising over top of an existing #GVariantBuilder you need to first call g_variant_builder_clear() in order to avoid leaking memory. You must not call g_variant_builder_ref() or g_variant_builder_unref() on a #GVariantBuilder that was initialised with this function. If you ever pass a reference to a #GVariantBuilder outside of the control of your own code then you should assume that the person receiving that reference may try to use reference counting; you should use g_variant_builder_new() instead of this function. Since: 2.24 a #GVariantBuilder a container type Allocates and initialises a new #GVariantBuilder. You should call g_variant_builder_unref() on the return value when it is no longer needed. The memory will not be automatically freed by any other call. In most cases it is easier to place a #GVariantBuilder directly on the stack of the calling function and initialise it with g_variant_builder_init(). Since: 2.24 a container type a #GVariantBuilder Opens a subcontainer inside the given @builder. When done adding items to the subcontainer, g_variant_builder_close() must be called. It is an error to call this function in any way that would cause an inconsistent value to be constructed (ie: adding too many values or a value of an incorrect type). Since: 2.24 a #GVariantBuilder a #GVariantType Increases the reference count on @builder. Don't call this on stack-allocated #GVariantBuilder instances or bad things will happen. Since: 2.24 a #GVariantBuilder allocated by g_variant_builder_new() a new reference to @builder Decreases the reference count on @builder. In the event that there are no more references, releases all memory associated with the #GVariantBuilder. Don't call this on stack-allocated #GVariantBuilder instances or bad things will happen. Since: 2.24 a #GVariantBuilder allocated by g_variant_builder_new() Performs a byteswapping operation on the contents of @value. The result is that all multi-byte numeric data contained in @value is byteswapped. That includes 16, 32, and 64bit signed and unsigned integers as well as file handles and double precision floating point values. This function is an identity mapping on any value that does not contain multi-byte numeric data. That include strings, booleans, bytes and containers containing only these things (recursively). The returned value is always in normal form and is marked as trusted. Since: 2.24 a #GVariant the byteswapped form of @value Checks if calling g_variant_get() with @format_string on @value would be valid from a type-compatibility standpoint. @format_string is assumed to be a valid format string (from a syntactic standpoint). If @copy_only is %TRUE then this function additionally checks that it would be safe to call g_variant_unref() on @value immediately after the call to g_variant_get() without invalidating the result. This is only possible if deep copies are made (ie: there are no pointers to the data inside of the soon-to-be-freed #GVariant instance). If this check fails then a g_critical() is printed and %FALSE is returned. This function is meant to be used by functions that wish to provide varargs accessors to #GVariant values of uncertain values (eg: g_variant_lookup() or g_menu_model_get_item_attribute()). Since: 2.34 a #GVariant a valid #GVariant format string %TRUE to ensure the format string makes deep copies %TRUE if @format_string is safe to use Classifies @value according to its top-level type. Since: 2.24 a #GVariant the #GVariantClass of @value Compares @one and @two. The types of @one and @two are #gconstpointer only to allow use of this function with #GTree, #GPtrArray, etc. They must each be a #GVariant. Comparison is only defined for basic types (ie: booleans, numbers, strings). For booleans, %FALSE is less than %TRUE. Numbers are ordered in the usual way. Strings are in ASCII lexographical order. It is a programmer error to attempt to compare container values or two values that have types that are not exactly equal. For example, you cannot compare a 32-bit signed integer with a 32-bit unsigned integer. Also note that this function is not particularly well-behaved when it comes to comparison of doubles; in particular, the handling of incomparable values (ie: NaN) is undefined. If you only require an equality comparison, g_variant_equal() is more general. Since: 2.26 a basic-typed #GVariant instance a #GVariant instance of the same type negative value if a < b; zero if a = b; positive value if a > b. Releases all memory associated with a #GVariantDict without freeing the #GVariantDict structure itself. It typically only makes sense to do this on a stack-allocated #GVariantDict if you want to abort building the value part-way through. This function need not be called if you call g_variant_dict_end() and it also doesn't need to be called on dicts allocated with g_variant_dict_new (see g_variant_dict_unref() for that). It is valid to call this function on either an initialised #GVariantDict or one that was previously cleared by an earlier call to g_variant_dict_clear() but it is not valid to call this function on uninitialised memory. Since: 2.40 a #GVariantDict Checks if @key exists in @dict. Since: 2.40 a #GVariantDict the key to lookup in the dictionary %TRUE if @key is in @dict Returns the current value of @dict as a #GVariant of type %G_VARIANT_TYPE_VARDICT, clearing it in the process. It is not permissible to use @dict in any way after this call except for reference counting operations (in the case of a heap-allocated #GVariantDict) or by reinitialising it with g_variant_dict_init() (in the case of stack-allocated). Since: 2.40 a #GVariantDict a new, floating, #GVariant Initialises a #GVariantDict structure. If @from_asv is given, it is used to initialise the dictionary. This function completely ignores the previous contents of @dict. On one hand this means that it is valid to pass in completely uninitialised memory. On the other hand, this means that if you are initialising over top of an existing #GVariantDict you need to first call g_variant_dict_clear() in order to avoid leaking memory. You must not call g_variant_dict_ref() or g_variant_dict_unref() on a #GVariantDict that was initialised with this function. If you ever pass a reference to a #GVariantDict outside of the control of your own code then you should assume that the person receiving that reference may try to use reference counting; you should use g_variant_dict_new() instead of this function. Since: 2.40 a #GVariantDict the initial value for @dict Inserts a value into a #GVariantDict. This call is a convenience wrapper that is exactly equivalent to calling g_variant_new() followed by g_variant_dict_insert_value(). Since: 2.40 a #GVariantDict the key to insert a value for a #GVariant varargs format string arguments, as per @format_string Inserts (or replaces) a key in a #GVariantDict. @value is consumed if it is floating. Since: 2.40 a #GVariantDict the key to insert a value for the value to insert Looks up a value in a #GVariantDict. This function is a wrapper around g_variant_dict_lookup_value() and g_variant_get(). In the case that %NULL would have been returned, this function returns %FALSE. Otherwise, it unpacks the returned value and returns %TRUE. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers]. Since: 2.40 a #GVariantDict the key to lookup in the dictionary a GVariant format string the arguments to unpack the value into %TRUE if a value was unpacked Looks up a value in a #GVariantDict. If @key is not found in @dictionary, %NULL is returned. The @expected_type string specifies what type of value is expected. If the value associated with @key has a different type then %NULL is returned. If the key is found and the value has the correct type, it is returned. If @expected_type was specified then any non-%NULL return value will have this type. Since: 2.40 a #GVariantDict the key to lookup in the dictionary a #GVariantType, or %NULL the value of the dictionary key, or %NULL Allocates and initialises a new #GVariantDict. You should call g_variant_dict_unref() on the return value when it is no longer needed. The memory will not be automatically freed by any other call. In some cases it may be easier to place a #GVariantDict directly on the stack of the calling function and initialise it with g_variant_dict_init(). This is particularly useful when you are using #GVariantDict to construct a #GVariant. Since: 2.40 the #GVariant with which to initialise the dictionary a #GVariantDict Increases the reference count on @dict. Don't call this on stack-allocated #GVariantDict instances or bad things will happen. Since: 2.40 a heap-allocated #GVariantDict a new reference to @dict Removes a key and its associated value from a #GVariantDict. Since: 2.40 a #GVariantDict the key to remove %TRUE if the key was found and removed Decreases the reference count on @dict. In the event that there are no more references, releases all memory associated with the #GVariantDict. Don't call this on stack-allocated #GVariantDict instances or bad things will happen. Since: 2.40 a heap-allocated #GVariantDict Similar to g_variant_get_bytestring() except that instead of returning a constant string, the string is duplicated. The return value must be freed using g_free(). Since: 2.26 an array-of-bytes #GVariant instance a pointer to a #gsize, to store the length (not including the nul terminator) a newly allocated string Gets the contents of an array of array of bytes #GVariant. This call makes a deep copy; the return result should be released with g_strfreev(). If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. Since: 2.26 an array of array of bytes #GVariant ('aay') the length of the result, or %NULL an array of strings Gets the contents of an array of object paths #GVariant. This call makes a deep copy; the return result should be released with g_strfreev(). If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. Since: 2.30 an array of object paths #GVariant the length of the result, or %NULL an array of strings Similar to g_variant_get_string() except that instead of returning a constant string, the string is duplicated. The string will always be UTF-8 encoded. The return value must be freed using g_free(). Since: 2.24 a string #GVariant instance a pointer to a #gsize, to store the length a newly allocated string, UTF-8 encoded Gets the contents of an array of strings #GVariant. This call makes a deep copy; the return result should be released with g_strfreev(). If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. Since: 2.24 an array of strings #GVariant the length of the result, or %NULL an array of strings Checks if @one and @two have the same type and value. The types of @one and @two are #gconstpointer only to allow use of this function with #GHashTable. They must each be a #GVariant. Since: 2.24 a #GVariant instance a #GVariant instance %TRUE if @one and @two are equal Deconstructs a #GVariant instance. Think of this function as an analogue to scanf(). The arguments that are expected by this function are entirely determined by @format_string. @format_string also restricts the permissible types of @value. It is an error to give a value with an incompatible type. See the section on [GVariant format strings][gvariant-format-strings]. Please note that the syntax of the format string is very likely to be extended in the future. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers]. Since: 2.24 a #GVariant instance a #GVariant format string arguments, as per @format_string Returns the boolean value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_BOOLEAN. Since: 2.24 a boolean #GVariant instance %TRUE or %FALSE Returns the byte value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_BYTE. Since: 2.24 a byte #GVariant instance a #guchar Returns the string value of a #GVariant instance with an array-of-bytes type. The string has no particular encoding. If the array does not end with a nul terminator character, the empty string is returned. For this reason, you can always trust that a non-%NULL nul-terminated string will be returned by this function. If the array contains a nul terminator character somewhere other than the last byte then the returned string is the string, up to the first such nul character. It is an error to call this function with a @value that is not an array of bytes. The return value remains valid as long as @value exists. Since: 2.26 an array-of-bytes #GVariant instance the constant string Gets the contents of an array of array of bytes #GVariant. This call makes a shallow copy; the return result should be released with g_free(), but the individual strings must not be modified. If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. Since: 2.26 an array of array of bytes #GVariant ('aay') the length of the result, or %NULL an array of constant strings Reads a child item out of a container #GVariant instance and deconstructs it according to @format_string. This call is essentially a combination of g_variant_get_child_value() and g_variant_get(). @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers]. Since: 2.24 a container #GVariant the index of the child to deconstruct a #GVariant format string arguments, as per @format_string Reads a child item out of a container #GVariant instance. This includes variants, maybes, arrays, tuples and dictionary entries. It is an error to call this function on any other type of #GVariant. It is an error if @index_ is greater than the number of child items in the container. See g_variant_n_children(). The returned value is never floating. You should free it with g_variant_unref() when you're done with it. This function is O(1). Since: 2.24 a container #GVariant the index of the child to fetch the child at the specified index Returns a pointer to the serialised form of a #GVariant instance. The returned data may not be in fully-normalised form if read from an untrusted source. The returned data must not be freed; it remains valid for as long as @value exists. If @value is a fixed-sized value that was deserialised from a corrupted serialised container then %NULL may be returned. In this case, the proper thing to do is typically to use the appropriate number of nul bytes in place of @value. If @value is not fixed-sized then %NULL is never returned. In the case that @value is already in serialised form, this function is O(1). If the value is not already in serialised form, serialisation occurs implicitly and is approximately O(n) in the size of the result. To deserialise the data returned by this function, in addition to the serialised data, you must know the type of the #GVariant, and (if the machine might be different) the endianness of the machine that stored it. As a result, file formats or network messages that incorporate serialised #GVariants must include this information either implicitly (for instance "the file always contains a %G_VARIANT_TYPE_VARIANT and it is always in little-endian order") or explicitly (by storing the type and/or endianness in addition to the serialised data). Since: 2.24 a #GVariant instance the serialised form of @value, or %NULL Returns a pointer to the serialised form of a #GVariant instance. The semantics of this function are exactly the same as g_variant_get_data(), except that the returned #GBytes holds a reference to the variant data. Since: 2.36 a #GVariant A new #GBytes representing the variant data Returns the double precision floating point value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_DOUBLE. Since: 2.24 a double #GVariant instance a #gdouble Provides access to the serialised data for an array of fixed-sized items. @value must be an array with fixed-sized elements. Numeric types are fixed-size, as are tuples containing only other fixed-sized types. @element_size must be the size of a single element in the array, as given by the section on [serialized data memory][gvariant-serialised-data-memory]. In particular, arrays of these fixed-sized types can be interpreted as an array of the given C type, with @element_size set to the size the appropriate type: - %G_VARIANT_TYPE_INT16 (etc.): #gint16 (etc.) - %G_VARIANT_TYPE_BOOLEAN: #guchar (not #gboolean!) - %G_VARIANT_TYPE_BYTE: #guchar - %G_VARIANT_TYPE_HANDLE: #guint32 - %G_VARIANT_TYPE_DOUBLE: #gdouble For example, if calling this function for an array of 32-bit integers, you might say sizeof(gint32). This value isn't used except for the purpose of a double-check that the form of the serialised data matches the caller's expectation. @n_elements, which must be non-%NULL is set equal to the number of items in the array. Since: 2.24 a #GVariant array with fixed-sized elements a pointer to the location to store the number of items the size of each element a pointer to the fixed array Returns the 32-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_HANDLE. By convention, handles are indexes into an array of file descriptors that are sent alongside a D-Bus message. If you're not interacting with D-Bus, you probably don't need them. Since: 2.24 a handle #GVariant instance a #gint32 Returns the 16-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_INT16. Since: 2.24 a int16 #GVariant instance a #gint16 Returns the 32-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_INT32. Since: 2.24 a int32 #GVariant instance a #gint32 Returns the 64-bit signed integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_INT64. Since: 2.24 a int64 #GVariant instance a #gint64 Given a maybe-typed #GVariant instance, extract its value. If the value is Nothing, then this function returns %NULL. Since: 2.24 a maybe-typed value the contents of @value, or %NULL Gets a #GVariant instance that has the same value as @value and is trusted to be in normal form. If @value is already trusted to be in normal form then a new reference to @value is returned. If @value is not already trusted, then it is scanned to check if it is in normal form. If it is found to be in normal form then it is marked as trusted and a new reference to it is returned. If @value is found not to be in normal form then a new trusted #GVariant is created with the same value as @value. It makes sense to call this function if you've received #GVariant data from untrusted sources and you want to ensure your serialised output is definitely in normal form. Since: 2.24 a #GVariant a trusted #GVariant Gets the contents of an array of object paths #GVariant. This call makes a shallow copy; the return result should be released with g_free(), but the individual strings must not be modified. If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. Since: 2.30 an array of object paths #GVariant the length of the result, or %NULL an array of constant strings Determines the number of bytes that would be required to store @value with g_variant_store(). If @value has a fixed-sized type then this function always returned that fixed size. In the case that @value is already in serialised form or the size has already been calculated (ie: this function has been called before) then this function is O(1). Otherwise, the size is calculated, an operation which is approximately O(n) in the number of values involved. Since: 2.24 a #GVariant instance the serialised size of @value Returns the string value of a #GVariant instance with a string type. This includes the types %G_VARIANT_TYPE_STRING, %G_VARIANT_TYPE_OBJECT_PATH and %G_VARIANT_TYPE_SIGNATURE. The string will always be UTF-8 encoded. If @length is non-%NULL then the length of the string (in bytes) is returned there. For trusted values, this information is already known. For untrusted values, a strlen() will be performed. It is an error to call this function with a @value of any type other than those three. The return value remains valid as long as @value exists. Since: 2.24 a string #GVariant instance a pointer to a #gsize, to store the length the constant string, UTF-8 encoded Gets the contents of an array of strings #GVariant. This call makes a shallow copy; the return result should be released with g_free(), but the individual strings must not be modified. If @length is non-%NULL then the number of elements in the result is stored there. In any case, the resulting array will be %NULL-terminated. For an empty array, @length will be set to 0 and a pointer to a %NULL pointer will be returned. Since: 2.24 an array of strings #GVariant the length of the result, or %NULL an array of constant strings Determines the type of @value. The return value is valid for the lifetime of @value and must not be freed. Since: 2.24 a #GVariant a #GVariantType Returns the type string of @value. Unlike the result of calling g_variant_type_peek_string(), this string is nul-terminated. This string belongs to #GVariant and must not be freed. Since: 2.24 a #GVariant the type string for the type of @value Returns the 16-bit unsigned integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_UINT16. Since: 2.24 a uint16 #GVariant instance a #guint16 Returns the 32-bit unsigned integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_UINT32. Since: 2.24 a uint32 #GVariant instance a #guint32 Returns the 64-bit unsigned integer value of @value. It is an error to call this function with a @value of any type other than %G_VARIANT_TYPE_UINT64. Since: 2.24 a uint64 #GVariant instance a #guint64 This function is intended to be used by libraries based on #GVariant that want to provide g_variant_get()-like functionality to their users. The API is more general than g_variant_get() to allow a wider range of possible uses. @format_string must still point to a valid format string, but it only need to be nul-terminated if @endptr is %NULL. If @endptr is non-%NULL then it is updated to point to the first character past the end of the format string. @app is a pointer to a #va_list. The arguments, according to @format_string, are collected from this #va_list and the list is left pointing to the argument following the last. These two generalisations allow mixing of multiple calls to g_variant_new_va() and g_variant_get_va() within a single actual varargs call by the user. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers]. Since: 2.24 a #GVariant a string that is prefixed with a format string location to store the end pointer, or %NULL a pointer to a #va_list Unboxes @value. The result is the #GVariant instance that was contained in @value. Since: 2.24 a variant #GVariant instance the item contained in the variant Generates a hash value for a #GVariant instance. The output of this function is guaranteed to be the same for a given value only per-process. It may change between different processor architectures or even different versions of GLib. Do not use this function as a basis for building protocols or file formats. The type of @value is #gconstpointer only to allow use of this function with #GHashTable. @value must be a #GVariant. Since: 2.24 a basic #GVariant value as a #gconstpointer a hash value corresponding to @value Checks if @value is a container. Since: 2.24 a #GVariant instance %TRUE if @value is a container Checks whether @value has a floating reference count. This function should only ever be used to assert that a given variant is or is not floating, or for debug purposes. To acquire a reference to a variant that might be floating, always use g_variant_ref_sink() or g_variant_take_ref(). See g_variant_ref_sink() for more information about floating reference counts. Since: 2.26 a #GVariant whether @value is floating Checks if @value is in normal form. The main reason to do this is to detect if a given chunk of serialised data is in normal form: load the data into a #GVariant using g_variant_new_from_data() and then use this function to check. If @value is found to be in normal form then it will be marked as being trusted. If the value was already marked as being trusted then this function will immediately return %TRUE. Since: 2.24 a #GVariant instance %TRUE if @value is in normal form 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(). A valid object path starts with '/' followed by zero or more sequences of characters separated by '/' characters. Each sequence must contain only the characters "[A-Z][a-z][0-9]_". No sequence (including the one following the final '/' character) may be empty. Since: 2.24 a normal C nul-terminated string %TRUE if @string is a D-Bus object path Checks if a value has a type matching the provided type. Since: 2.24 a #GVariant instance a #GVariantType %TRUE if the type of @value matches @type 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(). D-Bus type signatures consist of zero or more definite #GVariantType strings in sequence. Since: 2.24 a normal C nul-terminated string %TRUE if @string is a D-Bus type signature Creates a new heap-allocated #GVariantIter to iterate over the container that was being iterated over by @iter. Iteration begins on the new iterator from the current position of the old iterator but the two copies are independent past that point. Use g_variant_iter_free() to free the return value when you no longer need it. A reference is taken to the container that @iter is iterating over and will be releated only when g_variant_iter_free() is called. Since: 2.24 a #GVariantIter a new heap-allocated #GVariantIter Frees a heap-allocated #GVariantIter. Only call this function on iterators that were returned by g_variant_iter_new() or g_variant_iter_copy(). Since: 2.24 a heap-allocated #GVariantIter Initialises (without allocating) a #GVariantIter. @iter may be completely uninitialised prior to this call; its old value is ignored. The iterator remains valid for as long as @value exists, and need not be freed in any way. Since: 2.24 a pointer to a #GVariantIter a container #GVariant the number of items in @value Gets the next item in the container and unpacks it into the variable argument list according to @format_string, returning %TRUE. If no more items remain then %FALSE is returned. On the first call to this function, the pointers appearing on the variable argument list are assumed to point at uninitialised memory. On the second and later calls, it is assumed that the same pointers will be given and that they will point to the memory as set by the previous call to this function. This allows the previous values to be freed, as appropriate. This function is intended to be used with a while loop as demonstrated in the following example. This function can only be used when iterating over an array. It is only valid to call this function with a string constant for the format string and the same string constant must be used each time. Mixing calls to this function and g_variant_iter_next() or g_variant_iter_next_value() on the same iterator causes undefined behavior. If you break out of a such a while loop using g_variant_iter_loop() then you must free or unreference all the unpacked values as you would with g_variant_get(). Failure to do so will cause a memory leak. Here is an example for memory management with g_variant_iter_loop(): |[<!-- language="C" --> // Iterates a dictionary of type 'a{sv}' void iterate_dictionary (GVariant *dictionary) { GVariantIter iter; GVariant *value; gchar *key; g_variant_iter_init (&iter, dictionary); while (g_variant_iter_loop (&iter, "{sv}", &key, &value)) { g_print ("Item '%s' has type '%s'\n", key, g_variant_get_type_string (value)); // no need to free 'key' and 'value' here // unless breaking out of this loop } } ]| For most cases you should use g_variant_iter_next(). This function is really only useful when unpacking into #GVariant or #GVariantIter in order to allow you to skip the call to g_variant_unref() or g_variant_iter_free(). For example, if you are only looping over simple integer and string types, g_variant_iter_next() is definitely preferred. For string types, use the '&' prefix to avoid allocating any memory at all (and thereby avoiding the need to free anything as well). @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed. See the section on [GVariant format strings][gvariant-format-strings-pointers]. Since: 2.24 a #GVariantIter a GVariant format string the arguments to unpack the value into %TRUE if a value was unpacked, or %FALSE if there was no value Queries the number of child items in the container that we are iterating over. This is the total number of items -- not the number of items remaining. This function might be useful for preallocation of arrays. Since: 2.24 a #GVariantIter the number of children in the container Creates a heap-allocated #GVariantIter for iterating over the items in @value. Use g_variant_iter_free() to free the return value when you no longer need it. A reference is taken to @value and will be released only when g_variant_iter_free() is called. Since: 2.24 a container #GVariant a new heap-allocated #GVariantIter Gets the next item in the container and unpacks it into the variable argument list according to @format_string, returning %TRUE. If no more items remain then %FALSE is returned. All of the pointers given on the variable arguments list of this function are assumed to point at uninitialised memory. It is the responsibility of the caller to free all of the values returned by the unpacking process. Here is an example for memory management with g_variant_iter_next(): |[<!-- language="C" --> // Iterates a dictionary of type 'a{sv}' void iterate_dictionary (GVariant *dictionary) { GVariantIter iter; GVariant *value; gchar *key; g_variant_iter_init (&iter, dictionary); while (g_variant_iter_next (&iter, "{sv}", &key, &value)) { g_print ("Item '%s' has type '%s'\n", key, g_variant_get_type_string (value)); // must free data for ourselves g_variant_unref (value); g_free (key); } } ]| For a solution that is likely to be more convenient to C programmers when dealing with loops, see g_variant_iter_loop(). @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed. See the section on [GVariant format strings][gvariant-format-strings-pointers]. Since: 2.24 a #GVariantIter a GVariant format string the arguments to unpack the value into %TRUE if a value was unpacked, or %FALSE if there as no value Gets the next item in the container. If no more items remain then %NULL is returned. Use g_variant_unref() to drop your reference on the return value when you no longer need it. Here is an example for iterating with g_variant_iter_next_value(): |[<!-- language="C" --> // recursively iterate a container void iterate_container_recursive (GVariant *container) { GVariantIter iter; GVariant *child; g_variant_iter_init (&iter, container); while ((child = g_variant_iter_next_value (&iter))) { g_print ("type '%s'\n", g_variant_get_type_string (child)); if (g_variant_is_container (child)) iterate_container_recursive (child); g_variant_unref (child); } } ]| Since: 2.24 a #GVariantIter a #GVariant, or %NULL Looks up a value in a dictionary #GVariant. This function is a wrapper around g_variant_lookup_value() and g_variant_get(). In the case that %NULL would have been returned, this function returns %FALSE. Otherwise, it unpacks the returned value and returns %TRUE. @format_string determines the C types that are used for unpacking the values and also determines if the values are copied or borrowed, see the section on [GVariant format strings][gvariant-format-strings-pointers]. This function is currently implemented with a linear scan. If you plan to do many lookups then #GVariantDict may be more efficient. Since: 2.28 a dictionary #GVariant the key to lookup in the dictionary a GVariant format string the arguments to unpack the value into %TRUE if a value was unpacked Looks up a value in a dictionary #GVariant. This function works with dictionaries of the type a{s*} (and equally well with type a{o*}, but we only further discuss the string case for sake of clarity). In the event that @dictionary has the type a{sv}, the @expected_type string specifies what type of value is expected to be inside of the variant. If the value inside the variant has a different type then %NULL is returned. In the event that @dictionary has a value type other than v then @expected_type must directly match the key type and it is used to unpack the value directly or an error occurs. In either case, if @key is not found in @dictionary, %NULL is returned. If the key is found and the value has the correct type, it is returned. If @expected_type was specified then any non-%NULL return value will have this type. This function is currently implemented with a linear scan. If you plan to do many lookups then #GVariantDict may be more efficient. Since: 2.28 a dictionary #GVariant the key to lookup in the dictionary a #GVariantType, or %NULL the value of the dictionary key, or %NULL Determines the number of children in a container #GVariant instance. This includes variants, maybes, arrays, tuples and dictionary entries. It is an error to call this function on any other type of #GVariant. For variants, the return value is always 1. For values with maybe types, it is always zero or one. For arrays, it is the length of the array. For tuples it is the number of tuple items (which depends only on the type). For dictionary entries, it is always 2 This function is O(1). Since: 2.24 a container #GVariant the number of children in the container Creates a new #GVariant instance. Think of this function as an analogue to g_strdup_printf(). The type of the created instance and the arguments that are expected by this function are determined by @format_string. See the section on [GVariant format strings][gvariant-format-strings]. Please note that the syntax of the format string is very likely to be extended in the future. The first character of the format string must not be '*' '?' '@' or 'r'; in essence, a new #GVariant must always be constructed by this function (and not merely passed through it unmodified). Note that the arguments must be of the correct width for their types specified in @format_string. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. |[<!-- language="C" --> MyFlags some_flags = FLAG_ONE | FLAG_TWO; const gchar *some_strings[] = { "a", "b", "c", NULL }; GVariant *new_variant; new_variant = g_variant_new ("(t^as)", /<!-- -->* This cast is required. *<!-- -->/ (guint64) some_flags, some_strings); ]| Since: 2.24 a #GVariant format string arguments, as per @format_string a new floating #GVariant instance Creates a new #GVariant array from @children. @child_type must be non-%NULL if @n_children is zero. Otherwise, the child type is determined by inspecting the first element of the @children array. If @child_type is non-%NULL then it must be a definite type. The items of the array are taken from the @children array. No entry in the @children array may be %NULL. All items in the array must have the same type, which must be the same as @child_type, if given. If the @children are floating references (see g_variant_ref_sink()), the new instance takes ownership of them as if via g_variant_ref_sink(). Since: 2.24 the element type of the new array an array of #GVariant pointers, the children the length of @children a floating reference to a new #GVariant array Creates a new boolean #GVariant instance -- either %TRUE or %FALSE. Since: 2.24 a #gboolean value a floating reference to a new boolean #GVariant instance Creates a new byte #GVariant instance. Since: 2.24 a #guint8 value a floating reference to a new byte #GVariant instance Creates an array-of-bytes #GVariant with the contents of @string. This function is just like g_variant_new_string() except that the string need not be valid UTF-8. The nul terminator character at the end of the string is stored in the array. Since: 2.26 a normal nul-terminated string in no particular encoding a floating reference to a new bytestring #GVariant instance Constructs an array of bytestring #GVariant from the given array of strings. If @length is -1 then @strv is %NULL-terminated. Since: 2.26 an array of strings the length of @strv, or -1 a new floating #GVariant instance Creates a new dictionary entry #GVariant. @key and @value must be non-%NULL. @key must be a value of a basic type (ie: not a container). If the @key or @value are floating references (see g_variant_ref_sink()), the new instance takes ownership of them as if via g_variant_ref_sink(). Since: 2.24 a basic #GVariant, the key a #GVariant, the value a floating reference to a new dictionary entry #GVariant Creates a new double #GVariant instance. Since: 2.24 a #gdouble floating point value a floating reference to a new double #GVariant instance Provides access to the serialised data for an array of fixed-sized items. @value must be an array with fixed-sized elements. Numeric types are fixed-size as are tuples containing only other fixed-sized types. @element_size must be the size of a single element in the array. For example, if calling this function for an array of 32-bit integers, you might say sizeof(gint32). This value isn't used except for the purpose of a double-check that the form of the serialised data matches the caller's expectation. @n_elements, which must be non-%NULL is set equal to the number of items in the array. Since: 2.32 the #GVariantType of each element a pointer to the fixed array of contiguous elements the number of elements the size of each element a floating reference to a new array #GVariant instance Constructs a new serialised-mode #GVariant instance. This is the inner interface for creation of new serialised values that gets called from various functions in gvariant.c. A reference is taken on @bytes. Since: 2.36 a #GVariantType a #GBytes if the contents of @bytes are trusted a new #GVariant with a floating reference Creates a new #GVariant instance from serialised data. @type is the type of #GVariant instance that will be constructed. The interpretation of @data depends on knowing the type. @data is not modified by this function and must remain valid with an unchanging value until such a time as @notify is called with @user_data. If the contents of @data change before that time then the result is undefined. If @data is trusted to be serialised data in normal form then @trusted should be %TRUE. This applies to serialised data created within this process or read from a trusted location on the disk (such as a file installed in /usr/lib alongside your application). You should set trusted to %FALSE if @data is read from the network, a file in the user's home directory, etc. If @data was not stored in this machine's native endianness, any multi-byte numeric values in the returned variant will also be in non-native endianness. g_variant_byteswap() can be used to recover the original values. @notify will be called with @user_data when @data is no longer needed. The exact time of this call is unspecified and might even be before this function returns. Since: 2.24 a definite #GVariantType the serialised data the size of @data %TRUE if @data is definitely in normal form function to call when @data is no longer needed data for @notify a new floating #GVariant of type @type Creates a new handle #GVariant instance. By convention, handles are indexes into an array of file descriptors that are sent alongside a D-Bus message. If you're not interacting with D-Bus, you probably don't need them. Since: 2.24 a #gint32 value a floating reference to a new handle #GVariant instance Creates a new int16 #GVariant instance. Since: 2.24 a #gint16 value a floating reference to a new int16 #GVariant instance Creates a new int32 #GVariant instance. Since: 2.24 a #gint32 value a floating reference to a new int32 #GVariant instance Creates a new int64 #GVariant instance. Since: 2.24 a #gint64 value a floating reference to a new int64 #GVariant instance Depending on if @child is %NULL, either wraps @child inside of a maybe container or creates a Nothing instance for the given @type. At least one of @child_type and @child must be non-%NULL. If @child_type is non-%NULL then it must be a definite type. If they are both non-%NULL then @child_type must be the type of @child. If @child is a floating reference (see g_variant_ref_sink()), the new instance takes ownership of @child. Since: 2.24 the #GVariantType of the child, or %NULL the child value, or %NULL a floating reference to a new #GVariant maybe instance Creates a D-Bus object path #GVariant with the contents of @string. @string must be a valid D-Bus object path. Use g_variant_is_object_path() if you're not sure. Since: 2.24 a normal C nul-terminated string a floating reference to a new object path #GVariant instance Constructs an array of object paths #GVariant from the given array of strings. Each string must be a valid #GVariant object path; see g_variant_is_object_path(). If @length is -1 then @strv is %NULL-terminated. Since: 2.30 an array of strings the length of @strv, or -1 a new floating #GVariant instance Parses @format and returns the result. @format must be a text format #GVariant with one extension: at any point that a value may appear in the text, a '%' character followed by a GVariant format string (as per g_variant_new()) may appear. In that case, the same arguments are collected from the argument list as g_variant_new() would have collected. Note that the arguments must be of the correct width for their types specified in @format. This can be achieved by casting them. See the [GVariant varargs documentation][gvariant-varargs]. Consider this simple example: |[<!-- language="C" --> g_variant_new_parsed ("[('one', 1), ('two', %i), (%s, 3)]", 2, "three"); ]| In the example, the variable argument parameters are collected and filled in as if they were part of the original string to produce the result of |[<!-- language="C" --> [('one', 1), ('two', 2), ('three', 3)] ]| This function is intended only to be used with @format as a string literal. Any parse error is fatal to the calling process. If you want to parse data from untrusted sources, use g_variant_parse(). You may not use this function to return, unmodified, a single #GVariant pointer from the argument list. ie: @format may not solely be anything along the lines of "%*", "%?", "\%r", or anything starting with "%@". a text format #GVariant arguments as per @format a new floating #GVariant instance Parses @format and returns the result. This is the version of g_variant_new_parsed() intended to be used from libraries. The return value will be floating if it was a newly created GVariant instance. In the case that @format simply specified the collection of a #GVariant pointer (eg: @format was "%*") then the collected #GVariant pointer will be returned unmodified, without adding any additional references. Note that the arguments in @app must be of the correct width for their types specified in @format when collected into the #va_list. See the [GVariant varargs documentation][gvariant-varargs]. In order to behave correctly in all cases it is necessary for the calling function to g_variant_ref_sink() the return result before returning control to the user that originally provided the pointer. At this point, the caller will have their own full reference to the result. This can also be done by adding the result to a container, or by passing it to another g_variant_new() call. a text format #GVariant a pointer to a #va_list a new, usually floating, #GVariant Creates a string-type GVariant using printf formatting. This is similar to calling g_strdup_printf() and then g_variant_new_string() but it saves a temporary variable and an unnecessary copy. Since: 2.38 a printf-style format string arguments for @format_string a floating reference to a new string #GVariant instance Creates a D-Bus type signature #GVariant with the contents of @string. @string must be a valid D-Bus type signature. Use g_variant_is_signature() if you're not sure. Since: 2.24 a normal C nul-terminated string a floating reference to a new signature #GVariant instance Creates a string #GVariant with the contents of @string. @string must be valid UTF-8. Since: 2.24 a normal UTF-8 nul-terminated string a floating reference to a new string #GVariant instance Constructs an array of strings #GVariant from the given array of strings. If @length is -1 then @strv is %NULL-terminated. Since: 2.24 an array of strings the length of @strv, or -1 a new floating #GVariant instance Creates a string #GVariant with the contents of @string. @string must be valid UTF-8. This function consumes @string. g_free() will be called on @string when it is no longer required. You must not modify or access @string in any other way after passing it to this function. It is even possible that @string is immediately freed. Since: 2.38 a normal UTF-8 nul-terminated string a floating reference to a new string #GVariant instance Creates a new tuple #GVariant out of the items in @children. The type is determined from the types of @children. No entry in the @children array may be %NULL. If @n_children is 0 then the unit tuple is constructed. If the @children are floating references (see g_variant_ref_sink()), the new instance takes ownership of them as if via g_variant_ref_sink(). Since: 2.24 the items to make the tuple out of the length of @children a floating reference to a new #GVariant tuple Creates a new uint16 #GVariant instance. Since: 2.24 a #guint16 value a floating reference to a new uint16 #GVariant instance Creates a new uint32 #GVariant instance. Since: 2.24 a #guint32 value a floating reference to a new uint32 #GVariant instance Creates a new uint64 #GVariant instance. Since: 2.24 a #guint64 value a floating reference to a new uint64 #GVariant instance This function is intended to be used by libraries based on #GVariant that want to provide g_variant_new()-like functionality to their users. The API is more general than g_variant_new() to allow a wider range of possible uses. @format_string must still point to a valid format string, but it only needs to be nul-terminated if @endptr is %NULL. If @endptr is non-%NULL then it is updated to point to the first character past the end of the format string. @app is a pointer to a #va_list. The arguments, according to @format_string, are collected from this #va_list and the list is left pointing to the argument following the last. Note that the arguments in @app must be of the correct width for their types specified in @format_string when collected into the #va_list. See the [GVariant varargs documentation][gvariant-varargs. These two generalisations allow mixing of multiple calls to g_variant_new_va() and g_variant_get_va() within a single actual varargs call by the user. The return value will be floating if it was a newly created GVariant instance (for example, if the format string was "(ii)"). In the case that the format_string was '*', '?', 'r', or a format starting with '@' then the collected #GVariant pointer will be returned unmodified, without adding any additional references. In order to behave correctly in all cases it is necessary for the calling function to g_variant_ref_sink() the return result before returning control to the user that originally provided the pointer. At this point, the caller will have their own full reference to the result. This can also be done by adding the result to a container, or by passing it to another g_variant_new() call. Since: 2.24 a string that is prefixed with a format string location to store the end pointer, or %NULL a pointer to a #va_list a new, usually floating, #GVariant Boxes @value. The result is a #GVariant instance representing a variant containing the original value. If @child is a floating reference (see g_variant_ref_sink()), the new instance takes ownership of @child. Since: 2.24 a #GVariant instance a floating reference to a new variant #GVariant instance Parses a #GVariant from a text representation. A single #GVariant is parsed from the content of @text. The format is described [here][gvariant-text]. The memory at @limit will never be accessed and the parser behaves as if the character at @limit is the nul terminator. This has the effect of bounding @text. If @endptr is non-%NULL then @text is permitted to contain data following the value that this function parses and @endptr will be updated to point to the first character past the end of the text parsed by this function. If @endptr is %NULL and there is extra data then an error is returned. If @type is non-%NULL then the value will be parsed to have that type. This may result in additional parse errors (in the case that the parsed value doesn't fit the type) but may also result in fewer errors (in the case that the type would have been ambiguous, such as with empty arrays). In the event that the parsing is successful, the resulting #GVariant is returned. It is never floating, and must be freed with g_variant_unref(). In case of any error, %NULL will be returned. If @error is non-%NULL then it will be set to reflect the error that occurred. Officially, the language understood by the parser is "any string produced by g_variant_print()". a #GVariantType, or %NULL a string containing a GVariant in text form a pointer to the end of @text, or %NULL a location to store the end pointer, or %NULL a pointer to a %NULL #GError pointer, or %NULL a non-floating reference to a #GVariant, or %NULL Pretty-prints a message showing the context of a #GVariant parse error within the string for which parsing was attempted. The resulting string is suitable for output to the console or other monospace media where newlines are treated in the usual way. The message will typically look something like one of the following: |[ unterminated string constant: (1, 2, 3, 'abc ^^^^ ]| or |[ unable to find a common type: [1, 2, 3, 'str'] ^ ^^^^^ ]| The format of the message may change in a future version. @error must have come from a failed attempt to g_variant_parse() and @source_str must be exactly the same string that caused the error. If @source_str was not nul-terminated when you passed it to g_variant_parse() then you must add nul termination before using this function. Since: 2.40 a #GError from the #GVariantParseError domain the string that was given to the parser the printed message Same as g_variant_error_quark(). Deprecated: Use g_variant_parse_error_quark() instead. Pretty-prints @value in the format understood by g_variant_parse(). The format is described [here][gvariant-text]. If @type_annotate is %TRUE, then type information is included in the output. Since: 2.24 a #GVariant %TRUE if type information should be included in the output a newly-allocated string holding the result. Behaves as g_variant_print(), but operates on a #GString. If @string is non-%NULL then it is appended to and returned. Else, a new empty #GString is allocated and it is returned. Since: 2.24 a #GVariant a #GString, or %NULL %TRUE if type information should be included in the output a #GString containing the string Increases the reference count of @value. Since: 2.24 a #GVariant the same @value #GVariant uses a floating reference count system. All functions with names starting with `g_variant_new_` return floating references. Calling g_variant_ref_sink() on a #GVariant with a floating reference will convert the floating reference into a full reference. Calling g_variant_ref_sink() on a non-floating #GVariant results in an additional normal reference being added. In other words, if the @value is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference. If the @value is not floating, then this call adds a new normal reference increasing the reference count by one. All calls that result in a #GVariant instance being inserted into a container will call g_variant_ref_sink() on the instance. This means that if the value was just created (and has only its floating reference) then the container will assume sole ownership of the value at that point and the caller will not need to unreference it. This makes certain common styles of programming much easier while still maintaining normal refcounting semantics in situations where values are not floating. Since: 2.24 a #GVariant the same @value Stores the serialised form of @value at @data. @data should be large enough. See g_variant_get_size(). The stored data is in machine native byte order but may not be in fully-normalised form if read from an untrusted source. See g_variant_get_normal_form() for a solution. As with g_variant_get_data(), to be able to deserialise the serialised variant successfully, its type and (if the destination machine might be different) its endianness must also be available. This function is approximately O(n) in the size of @data. Since: 2.24 the #GVariant to store the location to store the serialised data at If @value is floating, sink it. Otherwise, do nothing. Typically you want to use g_variant_ref_sink() in order to automatically do the correct thing with respect to floating or non-floating references, but there is one specific scenario where this function is helpful. The situation where this function is helpful is when creating an API that allows the user to provide a callback function that returns a #GVariant. We certainly want to allow the user the flexibility to return a non-floating reference from this callback (for the case where the value that is being returned already exists). At the same time, the style of the #GVariant API makes it likely that for newly-created #GVariant instances, the user can be saved some typing if they are allowed to return a #GVariant with a floating reference. Using this function on the return value of the user's callback allows the user to do whichever is more convenient for them. The caller will alway receives exactly one full reference to the value: either the one that was returned in the first place, or a floating reference that has been converted to a full reference. This function has an odd interaction when combined with g_variant_ref_sink() running at the same time in another thread on the same #GVariant instance. If g_variant_ref_sink() runs first then the result will be that the floating reference is converted to a hard reference. If g_variant_take_ref() runs first then the result will be that the floating reference is converted to a hard reference and an additional reference on top of that one is added. It is best to avoid this situation. a #GVariant the same @value Makes a copy of a #GVariantType. It is appropriate to call g_variant_type_free() on the return value. @type may not be %NULL. Since 2.24 a #GVariantType a new #GVariantType Returns a newly-allocated copy of the type string corresponding to @type. The returned string is nul-terminated. It is appropriate to call g_free() on the return value. Since 2.24 a #GVariantType the corresponding type string Determines the element type of an array or maybe type. This function may only be used with array or maybe types. Since 2.24 an array or maybe #GVariantType the element type of @type Compares @type1 and @type2 for equality. Only returns %TRUE if the types are exactly equal. Even if one type is an indefinite type and the other is a subtype of it, %FALSE will be returned if they are not exactly equal. If you want to check for subtypes, use g_variant_type_is_subtype_of(). The argument types of @type1 and @type2 are only #gconstpointer to allow use with #GHashTable without function pointer casting. For both arguments, a valid #GVariantType must be provided. Since 2.24 a #GVariantType a #GVariantType %TRUE if @type1 and @type2 are exactly equal Determines the first item type of a tuple or dictionary entry type. This function may only be used with tuple or dictionary entry types, but must not be used with the generic tuple type %G_VARIANT_TYPE_TUPLE. In the case of a dictionary entry type, this returns the type of the key. %NULL is returned in case of @type being %G_VARIANT_TYPE_UNIT. This call, together with g_variant_type_next() provides an iterator interface over tuple and dictionary entry types. Since 2.24 a tuple or dictionary entry #GVariantType the first item type of @type, or %NULL Frees a #GVariantType that was allocated with g_variant_type_copy(), g_variant_type_new() or one of the container type constructor functions. In the case that @type is %NULL, this function does nothing. Since 2.24 a #GVariantType, or %NULL Returns the length of the type string corresponding to the given @type. This function must be used to determine the valid extent of the memory region returned by g_variant_type_peek_string(). Since 2.24 a #GVariantType the length of the corresponding type string Hashes @type. The argument type of @type is only #gconstpointer to allow use with #GHashTable without function pointer casting. A valid #GVariantType must be provided. Since 2.24 a #GVariantType the hash value Determines if the given @type is an array type. This is true if the type string for @type starts with an 'a'. This function returns %TRUE for any indefinite type for which every definite subtype is an array type -- %G_VARIANT_TYPE_ARRAY, for example. Since 2.24 a #GVariantType %TRUE if @type is an array type Determines if the given @type is a basic type. Basic types are booleans, bytes, integers, doubles, strings, object paths and signatures. Only a basic type may be used as the key of a dictionary entry. This function returns %FALSE for all indefinite types except %G_VARIANT_TYPE_BASIC. Since 2.24 a #GVariantType %TRUE if @type is a basic type Determines if the given @type is a container type. Container types are any array, maybe, tuple, or dictionary entry types plus the variant type. This function returns %TRUE for any indefinite type for which every definite subtype is a container -- %G_VARIANT_TYPE_ARRAY, for example. Since 2.24 a #GVariantType %TRUE if @type is a container type Determines if the given @type is definite (ie: not indefinite). A type is definite if its type string does not contain any indefinite type characters ('*', '?', or 'r'). A #GVariant instance may not have an indefinite type, so calling this function on the result of g_variant_get_type() will always result in %TRUE being returned. Calling this function on an indefinite type like %G_VARIANT_TYPE_ARRAY, however, will result in %FALSE being returned. Since 2.24 a #GVariantType %TRUE if @type is definite Determines if the given @type is a dictionary entry type. This is true if the type string for @type starts with a '{'. This function returns %TRUE for any indefinite type for which every definite subtype is a dictionary entry type -- %G_VARIANT_TYPE_DICT_ENTRY, for example. Since 2.24 a #GVariantType %TRUE if @type is a dictionary entry type Determines if the given @type is a maybe type. This is true if the type string for @type starts with an 'm'. This function returns %TRUE for any indefinite type for which every definite subtype is a maybe type -- %G_VARIANT_TYPE_MAYBE, for example. Since 2.24 a #GVariantType %TRUE if @type is a maybe type Checks if @type is a subtype of @supertype. This function returns %TRUE if @type is a subtype of @supertype. All types are considered to be subtypes of themselves. Aside from that, only indefinite types can have subtypes. Since 2.24 a #GVariantType a #GVariantType %TRUE if @type is a subtype of @supertype Determines if the given @type is a tuple type. This is true if the type string for @type starts with a '(' or if @type is %G_VARIANT_TYPE_TUPLE. This function returns %TRUE for any indefinite type for which every definite subtype is a tuple type -- %G_VARIANT_TYPE_TUPLE, for example. Since 2.24 a #GVariantType %TRUE if @type is a tuple type Determines if the given @type is the variant type. Since 2.24 a #GVariantType %TRUE if @type is the variant type Determines the key type of a dictionary entry type. This function may only be used with a dictionary entry type. Other than the additional restriction, this call is equivalent to g_variant_type_first(). Since 2.24 a dictionary entry #GVariantType the key type of the dictionary entry Determines the number of items contained in a tuple or dictionary entry type. This function may only be used with tuple or dictionary entry types, but must not be used with the generic tuple type %G_VARIANT_TYPE_TUPLE. In the case of a dictionary entry type, this function will always return 2. Since 2.24 a tuple or dictionary entry #GVariantType the number of items in @type Creates a new #GVariantType corresponding to the type string given by @type_string. It is appropriate to call g_variant_type_free() on the return value. It is a programmer error to call this function with an invalid type string. Use g_variant_type_string_is_valid() if you are unsure. Since: 2.24 a valid GVariant type string a new #GVariantType Constructs the type corresponding to an array of elements of the type @type. It is appropriate to call g_variant_type_free() on the return value. Since 2.24 a #GVariantType a new array #GVariantType Constructs the type corresponding to a dictionary entry with a key of type @key and a value of type @value. It is appropriate to call g_variant_type_free() on the return value. Since 2.24 a basic #GVariantType a #GVariantType a new dictionary entry #GVariantType Constructs the type corresponding to a maybe instance containing type @type or Nothing. It is appropriate to call g_variant_type_free() on the return value. Since 2.24 a #GVariantType a new maybe #GVariantType Constructs a new tuple type, from @items. @length is the number of items in @items, or -1 to indicate that @items is %NULL-terminated. It is appropriate to call g_variant_type_free() on the return value. Since 2.24 an array of #GVariantTypes, one for each item the length of @items, or -1 a new tuple #GVariantType Determines the next item type of a tuple or dictionary entry type. @type must be the result of a previous call to g_variant_type_first() or g_variant_type_next(). If called on the key type of a dictionary entry then this call returns the value type. If called on the value type of a dictionary entry then this call returns %NULL. For tuples, %NULL is returned when @type is the last item in a tuple. Since 2.24 a #GVariantType from a previous call the next #GVariantType after @type, or %NULL Returns the type string corresponding to the given @type. The result is not nul-terminated; in order to determine its length you must call g_variant_type_get_string_length(). To get a nul-terminated string, see g_variant_type_dup_string(). Since 2.24 a #GVariantType the corresponding type string (not nul-terminated) 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. Since 2.24 a pointer to any string %TRUE if @type_string is exactly one valid type string Scan for a single complete and valid GVariant type string in @string. The memory pointed to by @limit (or bytes beyond it) is never accessed. If a valid type string is found, @endptr is updated to point to the first character past the end of the string that was found and %TRUE is returned. If there is no valid type string starting at @string, or if the type string does not end before @limit then %FALSE is returned. For the simple case of checking if a string is a valid type string, see g_variant_type_string_is_valid(). Since: 2.24 a pointer to any string the end of @string, or %NULL location to store the end pointer, or %NULL %TRUE if a valid type string was found Determines the value type of a dictionary entry type. This function may only be used with a dictionary entry type. Since 2.24 a dictionary entry #GVariantType the value type of the dictionary entry Decreases the reference count of @value. When its reference count drops to 0, the memory used by the variant is freed. Since: 2.24 a #GVariant An implementation of the GNU vasprintf() function which supports positional parameters, as specified in the Single Unix Specification. This function is similar to g_vsprintf(), except that it allocates a string to hold the output, instead of putting the output in a buffer you allocate in advance. Since: 2.4 the return location for the newly-allocated string. a standard printf() format string, but notice [string precision pitfalls][string-precision] the list of arguments to insert in the output. the number of bytes printed. An implementation of the standard fprintf() function which supports positional parameters, as specified in the Single Unix Specification. Since: 2.2 the stream to write to. a standard printf() format string, but notice [string precision pitfalls][string-precision] the list of arguments to insert in the output. the number of bytes printed. An implementation of the standard vprintf() function which supports positional parameters, as specified in the Single Unix Specification. Since: 2.2 a standard printf() format string, but notice [string precision pitfalls][string-precision] the list of arguments to insert in the output. the number of bytes printed. A safer form of the standard vsprintf() function. The output is guaranteed to not exceed @n characters (including the terminating nul character), so it is easy to ensure that a buffer overflow cannot occur. See also g_strdup_vprintf(). In versions of GLib prior to 1.2.3, this function may return -1 if the output was truncated, and the truncated string may not be nul-terminated. In versions prior to 1.3.12, this function returns the length of the output string. The return value of g_vsnprintf() conforms to the vsnprintf() function as standardized in ISO C99. Note that this is different from traditional vsnprintf(), which returns the length of the output string. The format string may contain positional parameters, as specified in the Single Unix Specification. the buffer to hold the output. the maximum number of bytes to produce (including the terminating nul character). a standard printf() format string, but notice string precision pitfalls][string-precision] the list of arguments to insert in the output. the number of bytes which would be produced if the buffer was large enough. An implementation of the standard vsprintf() function which supports positional parameters, as specified in the Single Unix Specification. Since: 2.2 the buffer to hold the output. a standard printf() format string, but notice [string precision pitfalls][string-precision] the list of arguments to insert in the output. the number of bytes printed. Acknowledges receipt of a wakeup signal on @wakeup. You must call this after @wakeup polls as ready. If not, it will continue to poll as ready until you do so. If you call this function and @wakeup is not signaled, nothing happens. Since: 2.30 a #GWakeup Frees @wakeup. You must not currently be polling on the #GPollFD returned by g_wakeup_get_pollfd(), or the result is undefined. a #GWakeup Prepares a @poll_fd such that polling on it will succeed when g_wakeup_signal() has been called on @wakeup. @poll_fd is valid until @wakeup is freed. Since: 2.30 a #GWakeup a #GPollFD Creates a new #GWakeup. You should use g_wakeup_free() to free it when you are done. Since: 2.30 a new #GWakeup Signals @wakeup. Any future (or present) polling on the #GPollFD returned by g_wakeup_get_pollfd() will immediately succeed until such a time as g_wakeup_acknowledge() is called. This function is safe to call from a UNIX signal handler. Since: 2.30 a #GWakeup Logs a warning if the expression is not true. Since: 2.16 the expression to check Logs a critical warning. Since: 2.16 A convenience function/macro to log a warning message. You can make warnings fatal at runtime by setting the `G_DEBUG` environment variable (see [Running GLib Applications](glib-running.html)). If g_log_default_handler() is used as the log handler function, a newline character will automatically be appended to @..., and need not be entered manually. format string, followed by parameters to insert into the format string (as with printf()) Frees resources associated with a non-statically-allocated #GWeakRef. After this call, the #GWeakRef is left in an undefined state. You should only call this on a #GWeakRef that previously had g_weak_ref_init() called on it. Since: 2.32 location of a weak reference, which may be empty If @weak_ref is not empty, atomically acquire a strong reference to the object it points to, and return that reference. This function is needed because of the potential race between taking the pointer value and g_object_ref() on it, if the object was losing its last reference at the same time in a different thread. The caller should release the resulting reference in the usual way, by using g_object_unref(). Since: 2.32 location of a weak reference to a #GObject the object pointed to by @weak_ref, or %NULL if it was empty Initialise a non-statically-allocated #GWeakRef. This function also calls g_weak_ref_set() with @object on the freshly-initialised weak reference. This function should always be matched with a call to g_weak_ref_clear(). It is not necessary to use this function for a #GWeakRef in static storage because it will already be properly initialised. Just use g_weak_ref_set() directly. Since: 2.32 uninitialized or empty location for a weak reference a #GObject or %NULL Change the object to which @weak_ref points, or set it to %NULL. You must own a strong reference on @object while calling this function. Since: 2.32 location for a weak reference a #GObject or %NULL Returns whether the version of the Windows operating system the code is running on is at least the specified major, minor and service pack versions. See MSDN documentation for the Operating System Version. Software that needs even more detailed version and feature information should use the Win32 API VerifyVersionInfo() directly. Successive calls of this function can be used for enabling or disabling features at run-time for a range of Windows versions, as per the VerifyVersionInfo() API documentation. Since: 2.44 major version of Windows minor version of Windows Windows Service Pack Level, 0 if none Type of Windows OS %TRUE if the Windows Version is the same or greater than the specified major, minor and service pack versions, and whether the running Windows is a workstation or server edition of Windows, if specifically specified. Translate a Win32 error code (as returned by GetLastError() or WSAGetLastError()) into the corresponding message. The message is either language neutral, or in the thread's language, or the user's language, the system's language, or US English (see docs for FormatMessage()). The returned string is in UTF-8. It should be deallocated with g_free(). error code. newly-allocated error message Gets the command line arguments, on Windows, in the GLib filename encoding (ie: UTF-8). Normally, on Windows, the command line arguments are passed to main() in the system codepage encoding. This prevents passing filenames as arguments if the filenames contain characters that fall outside of this codepage. If such filenames are passed, then substitutions will occur (such as replacing some characters with '?'). GLib's policy of using UTF-8 as a filename encoding on Windows was designed to localise the pain of dealing with filenames outside of the system codepage to one area: dealing with commandline arguments in main(). As such, most GLib programs should ignore the value of argv passed to their main() function and call g_win32_get_command_line() instead. This will get the "full Unicode" commandline arguments using GetCommandLineW() and convert it to the GLib filename encoding (which is UTF-8 on Windows). The strings returned by this function are suitable for use with functions such as g_open() and g_file_new_for_commandline_arg() but are not suitable for use with g_option_context_parse(), which assumes that its input will be in the system codepage. The return value is suitable for use with g_option_context_parse_strv(), however, which is a better match anyway because it won't leak memory. Unlike argv, the returned value is a normal strv and can (and should) be freed with g_strfreev() when no longer needed. Since: 2.40 the commandline arguments in the GLib filename encoding (ie: UTF-8) Try to determine the installation directory for a software package. This function is deprecated. Use g_win32_get_package_installation_directory_of_module() instead. The use of @package is deprecated. You should always pass %NULL. A warning is printed if non-NULL is passed as @package. The original intended use of @package was for a short identifier of the package, typically the same identifier as used for `GETTEXT_PACKAGE` in software configured using GNU autotools. The function first looks in the Windows Registry for the value `#InstallationDirectory` in the key `#HKLM\Software\@package`, and if that value exists and is a string, returns that. It is strongly recommended that packagers of GLib-using libraries for Windows do not store installation paths in the Registry to be used by this function as that interfers with having several parallel installations of the library. Enabling multiple installations of different versions of some GLib-using library, or GLib itself, is desirable for various reasons. For this reason it is recommeded to always pass %NULL as @package to this function, to avoid the temptation to use the Registry. In version 2.20 of GLib the @package parameter will be ignored and this function won't look in the Registry at all. If @package is %NULL, or the above value isn't found in the Registry, but @dll_name is non-%NULL, it should name a DLL loaded into the current process. Typically that would be the name of the DLL calling this function, looking for its installation directory. The function then asks Windows what directory that DLL was loaded from. If that directory's last component is "bin" or "lib", the parent directory is returned, otherwise the directory itself. If that DLL isn't loaded, the function proceeds as if @dll_name was %NULL. If both @package and @dll_name are %NULL, the directory from where the main executable of the process was loaded is used instead in the same way as above. Deprecated: 2.18: Pass the HMODULE of a DLL or EXE to g_win32_get_package_installation_directory_of_module() instead. You should pass %NULL for this. The name of a DLL that a package provides in UTF-8, or %NULL. a string containing the installation directory for @package. The string is in the GLib file name encoding, i.e. UTF-8. The return value should be freed with g_free() when not needed any longer. If the function fails %NULL is returned. This function tries to determine the installation directory of a software package based on the location of a DLL of the software package. @hmodule should be the handle of a loaded DLL or %NULL. The function looks up the directory that DLL was loaded from. If @hmodule is NULL, the directory the main executable of the current process is looked up. If that directory's last component is "bin" or "lib", its parent directory is returned, otherwise the directory itself. It thus makes sense to pass only the handle to a "public" DLL of a software package to this function, as such DLLs typically are known to be installed in a "bin" or occasionally "lib" subfolder of the installation folder. DLLs that are of the dynamically loaded module or plugin variety are often located in more private locations deeper down in the tree, from which it is impossible for GLib to deduce the root of the package installation. The typical use case for this function is to have a DllMain() that saves the handle for the DLL. Then when code in the DLL needs to construct names of files in the installation tree it calls this function passing the DLL handle. Since: 2.16 The Win32 handle for a DLL loaded into the current process, or %NULL a string containing the guessed installation directory for the software package @hmodule is from. The string is in the GLib file name encoding, i.e. UTF-8. The return value should be freed with g_free() when not needed any longer. If the function fails %NULL is returned. This function is deprecated. Use g_win32_get_package_installation_directory_of_module() and g_build_filename() instead. Deprecated: 2.18: Pass the HMODULE of a DLL or EXE to g_win32_get_package_installation_directory_of_module() instead, and then construct a subdirectory pathname with g_build_filename(). You should pass %NULL for this. The name of a DLL that a package provides, in UTF-8, or %NULL. A subdirectory of the package installation directory, also in UTF-8 a string containing the complete path to @subdir inside the installation directory of @package. The returned string is in the GLib file name encoding, i.e. UTF-8. The return value should be freed with g_free() when no longer needed. If something goes wrong, %NULL is returned. This function is deprecated. Use g_win32_check_windows_version() instead. Deprecated: 2.44: Be aware that for Windows 8.1 and Windows Server 2012 R2 and later, this will return 62 unless the application is manifested for Windows 8.1/Windows Server 2012 R2, for example. MSDN stated that GetVersion(), which is used here, is subject to further change or removal after Windows 8.1. The version information. The setlocale() function in the Microsoft C library uses locale names of the form "English_United States.1252" etc. We want the UNIXish standard form "en_US", "zh_TW" etc. This function gets the current thread locale from Windows - without any encoding info - and returns it as a string of the above form for use in forming file names etc. The returned string should be deallocated with g_free(). newly-allocated locale name. Converts a filename from UTF-8 to the system codepage. On NT-based Windows, on NTFS file systems, file names are in Unicode. It is quite possible that Unicode file names contain characters not representable in the system codepage. (For instance, Greek or Cyrillic characters on Western European or US Windows installations, or various less common CJK characters on CJK Windows installations.) In such a case, and if the filename refers to an existing file, and the file system stores alternate short (8.3) names for directory entries, the short form of the filename is returned. Note that the "short" name might in fact be longer than the Unicode name if the Unicode name has very short pathname components containing non-ASCII characters. If no system codepage name for the file is possible, %NULL is returned. The return value is dynamically allocated and should be freed with g_free() when no longer needed. Since: 2.8 a UTF-8 encoded filename. The converted filename, or %NULL on conversion failure and lack of short names. A standard boolean type. Variables of this type should only contain the value %TRUE or %FALSE. Corresponds to the standard C char type. A C representable type name for #G_TYPE_STRING. An untyped pointer to constant data. The data pointed to should not be changed. This is typically used in function prototypes to indicate that the data pointed to will not be altered by the function. Corresponds to the standard C double type. Values of this type can range from -#G_MAXDOUBLE to #G_MAXDOUBLE. Corresponds to the standard C float type. Values of this type can range from -#G_MAXFLOAT to #G_MAXFLOAT. Corresponds to the standard C int type. Values of this type can range from #G_MININT to #G_MAXINT. A signed integer guaranteed to be 16 bits on all platforms. Values of this type can range from #G_MININT16 (= -32,768) to #G_MAXINT16 (= 32,767). To print or scan values of this type, use %G_GINT16_MODIFIER and/or %G_GINT16_FORMAT. A signed integer guaranteed to be 32 bits on all platforms. Values of this type can range from #G_MININT32 (= -2,147,483,648) to #G_MAXINT32 (= 2,147,483,647). To print or scan values of this type, use %G_GINT32_MODIFIER and/or %G_GINT32_FORMAT. A signed integer guaranteed to be 64 bits on all platforms. Values of this type can range from #G_MININT64 (= -9,223,372,036,854,775,808) to #G_MAXINT64 (= 9,223,372,036,854,775,807). To print or scan values of this type, use %G_GINT64_MODIFIER and/or %G_GINT64_FORMAT. A signed integer guaranteed to be 8 bits on all platforms. Values of this type can range from #G_MININT8 (= -128) to #G_MAXINT8 (= 127). Corresponds to the C99 type intptr_t, a signed integer type that can hold any pointer. To print or scan values of this type, use %G_GINTPTR_MODIFIER and/or %G_GINTPTR_FORMAT. Since: 2.18 Do not call this function; it is used to share private API between glib, gobject, and gio. Do not use this argument The binary age of the GLib library. Defines how far back backwards compatibility reaches. An integer variable exported from the library linked against at application run time. Checks that the GLib library in use is compatible with the given version. Generally you would pass in the constants #GLIB_MAJOR_VERSION, #GLIB_MINOR_VERSION, #GLIB_MICRO_VERSION as the three arguments to this function; that produces a check that the library in use is compatible with the version of GLib the application or module was compiled against. Compatibility is defined by two things: first the version of the running library is newer than the version @required_major.required_minor.@required_micro. Second the running library must be binary compatible with the version @required_major.required_minor.@required_micro (same major version.) Since: 2.6 the required major version the required minor version the required micro version %NULL if the GLib library is compatible with the given version, or a string describing the version mismatch. The returned string is owned by GLib and must not be modified or freed. Returns the translated string from the glib translations. This is an internal function and should only be used by the internals of glib (such as libgio). The string to be translated the transation of @str to the current locale The interface age of the GLib library. Defines how far back the API has last been extended. An integer variable exported from the library linked against at application run time. The major version of the GLib library. An integer variable exported from the library linked against at application run time. A #GMemVTable containing profiling variants of the memory allocation functions. Use them together with g_mem_profile() in order to get information about the memory allocation pattern of your program. The micro version number of the GLib library. An integer variable exported from the library linked against at application run time. The minor version number of the GLib library. An integer variable exported from the library linked against at application run time. This function is a variant of glib_gettext() which supports a disambiguating message context. See g_dpgettext() for full details. This is an internal function and should only be used by the internals of glib (such as libgio). a combined message context and message id, separated by a \004 character the offset of the message id in @msgctxid the translation of @str to the current locale Corresponds to the standard C long type. Values of this type can range from #G_MINLONG to #G_MAXLONG. A signed integer type that is used for file offsets, corresponding to the C99 type off64_t. Values of this type can range from #G_MINOFFSET to #G_MAXOFFSET. To print or scan values of this type, use %G_GOFFSET_MODIFIER and/or %G_GOFFSET_FORMAT. Since: 2.14 An untyped pointer. #gpointer looks better and is easier to use than void*. Corresponds to the standard C short type. Values of this type can range from #G_MINSHORT to #G_MAXSHORT. An unsigned integer type of the result of the sizeof operator, corresponding to the size_t type defined in C99. This type is wide enough to hold the numeric value of a pointer, so it is usually 32 bit wide on a 32-bit platform and 64 bit wide on a 64-bit platform. Values of this type can range from 0 to #G_MAXSIZE. To print or scan values of this type, use %G_GSIZE_MODIFIER and/or %G_GSIZE_FORMAT. A signed variant of #gsize, corresponding to the ssize_t defined on most platforms. Values of this type can range from #G_MINSSIZE to #G_MAXSSIZE. To print or scan values of this type, use %G_GSSIZE_MODIFIER and/or %G_GSSIZE_FORMAT. Corresponds to the standard C unsigned char type. Corresponds to the standard C unsigned int type. Values of this type can range from 0 to #G_MAXUINT. An unsigned integer guaranteed to be 16 bits on all platforms. Values of this type can range from 0 to #G_MAXUINT16 (= 65,535). To print or scan values of this type, use %G_GINT16_MODIFIER and/or %G_GUINT16_FORMAT. An unsigned integer guaranteed to be 32 bits on all platforms. Values of this type can range from 0 to #G_MAXUINT32 (= 4,294,967,295). To print or scan values of this type, use %G_GINT32_MODIFIER and/or %G_GUINT32_FORMAT. An unsigned integer guaranteed to be 64-bits on all platforms. Values of this type can range from 0 to #G_MAXUINT64 (= 18,446,744,073,709,551,615). To print or scan values of this type, use %G_GINT64_MODIFIER and/or %G_GUINT64_FORMAT. An unsigned integer guaranteed to be 8 bits on all platforms. Values of this type can range from 0 to #G_MAXUINT8 (= 255). Corresponds to the C99 type uintptr_t, an unsigned integer type that can hold any pointer. To print or scan values of this type, use %G_GINTPTR_MODIFIER and/or %G_GUINTPTR_FORMAT. Since: 2.18 Corresponds to the standard C unsigned long type. Values of this type can range from 0 to #G_MAXULONG. A type which can hold any UTF-32 or UCS-4 character code, also known as a Unicode code point. If you want to produce the UTF-8 representation of a #gunichar, use g_ucs4_to_utf8(). See also g_utf8_to_ucs4() for the reverse process. To print/scan values of this type as integer, use %G_GINT32_MODIFIER and/or %G_GUINT32_FORMAT. The notation to express a Unicode code point in running text is as a hexadecimal number with four to six digits and uppercase letters, prefixed by the string "U+". Leading zeros are omitted, unless the code point would have fewer than four hexadecimal digits. For example, "U+0041 LATIN CAPITAL LETTER A". To print a code point in the U+-notation, use the format string "U+\%04"G_GINT32_FORMAT"X". To scan, use the format string "U+\%06"G_GINT32_FORMAT"X". |[ gunichar c; sscanf ("U+0041", "U+%06"G_GINT32_FORMAT"X", &c) g_print ("Read U+%04"G_GINT32_FORMAT"X", c); ]| A type which can hold any UTF-16 code point<footnote id="utf16_surrogate_pairs">UTF-16 also has so called <firstterm>surrogate pairs</firstterm> to encode characters beyond the BMP as pairs of 16bit numbers. Surrogate pairs cannot be stored in a single gunichar2 field, but all GLib functions accepting gunichar2 arrays will correctly interpret surrogate pairs.</footnote>. To print/scan values of this type to/from text you need to convert to/from UTF-8, using g_utf16_to_utf8()/g_utf8_to_utf16(). To print/scan values of this type as integer, use %G_GINT16_MODIFIER and/or %G_GUINT16_FORMAT. Corresponds to the standard C unsigned short type. Values of this type can range from 0 to #G_MAXUSHORT.