glib

func Access ¶

func Access(filename string, mode int) (return__ int)

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

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().

func AsciiDigitValue ¶

func AsciiDigitValue(c byte) (return__ int)

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.

func AsciiDtostr ¶

func AsciiDtostr(buffer string, buf_len int, d float64) (return__ string)

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.

func AsciiFormatd ¶

func AsciiFormatd(buffer string, buf_len int, format string, d float64) (return__ 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'.

If you just want to want to serialize the value into a string, use g_ascii_dtostr().

func AsciiStrcasecmp ¶

func AsciiStrcasecmp(s1 string, s2 string) (return__ int)

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.

func AsciiStrdown ¶

func AsciiStrdown(str string, len_ int64) (return__ string)

Converts all upper case ASCII letters to lower case ASCII letters.

func AsciiStrncasecmp ¶

func AsciiStrncasecmp(s1 string, s2 string, n int64) (return__ int)

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.

func AsciiStrtod ¶

func AsciiStrtod(nptr string, endptr []string) (return__ float64)

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.

func AsciiStrtoll ¶

func AsciiStrtoll(nptr string, endptr []string, base uint) (return__ int64)

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).

func AsciiStrtoull ¶

func AsciiStrtoull(nptr string, endptr []string, base uint) (return__ uint64)

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).

func AsciiStrup ¶

func AsciiStrup(str string, len_ int64) (return__ string)

Converts all lower case ASCII letters to upper case ASCII letters.

func AsciiTolower ¶

func AsciiTolower(c byte) (return__ byte)

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.

func AsciiToupper ¶

func AsciiToupper(c byte) (return__ byte)

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.

func AsciiXdigitValue ¶

func AsciiXdigitValue(c byte) (return__ int)

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.

func AssertionMessage ¶

func AssertionMessage(domain string, file string, line int, func_ string, message string)

func AssertionMessageCmpstr ¶

func AssertionMessageCmpstr(domain string, file string, line int, func_ string, expr string, arg1 string, cmp string, arg2 string)

func AssertionMessageError ¶

func AssertionMessageError(domain string, file string, line int, func_ string, expr string, error_ *C.GError, error_domain C.GQuark, error_code int)

func AssertionMessageExpr ¶

func AssertionMessageExpr(domain string, file string, line int, func_ string, expr string)

func Base64Decode ¶

func Base64Decode(text string) (out_len int64, return__ []byte)

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.

func Base64Encode ¶

func Base64Encode(data []byte, len_ int64) (return__ string)

Encode a sequence of binary data into its Base-64 stringified representation.

func BitLock ¶

func BitLock(address *C.gint, lock_bit int)

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.

func BitNthLsf ¶

func BitNthLsf(mask uint64, nth_bit int) (return__ int)

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

func BitNthMsf ¶

func BitNthMsf(mask uint64, nth_bit int) (return__ int)

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

func BitStorage ¶

func BitStorage(number uint64) (return__ uint)

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

func BitTrylock ¶

func BitTrylock(address *C.gint, lock_bit int) (return__ bool)

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.

func BitUnlock ¶

func BitUnlock(address *C.gint, lock_bit int)

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.

func BookmarkFileErrorQuark ¶

func BookmarkFileErrorQuark() (return__ C.GQuark)

func BuildFilenamev ¶

func BuildFilenamev(args []string) (return__ string)

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.

func BuildPathv ¶

func BuildPathv(separator string, args []string) (return__ string)

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.

func ByteArrayFree ¶

func ByteArrayFree(array *C.GByteArray, free_segment bool) (return__ *C.guint8)

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.

func ByteArrayFreeToBytes ¶

func ByteArrayFreeToBytes(array *C.GByteArray) (return__ *C.GBytes)

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.

func ByteArrayNew ¶

func ByteArrayNew() (return__ *C.GByteArray)

Creates a new #GByteArray with a reference count of 1.

func ByteArrayNewTake ¶

func ByteArrayNewTake(data []byte, len_ int64) (return__ *C.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().

func ByteArrayUnref ¶

func ByteArrayUnref(array *C.GByteArray)

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.

func Chdir ¶

func Chdir(path string) (return__ int)

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().

func CheckVersion ¶

func CheckVersion(required_major uint, required_minor uint, required_micro uint) (return__ string)

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.)

func ChecksumTypeGetLength ¶

func ChecksumTypeGetLength(checksum_type C.GChecksumType) (return__ int64)

Gets the length in bytes of digests of type @checksum_type

func ChildWatchAdd ¶

func ChildWatchAdd(pid C.GPid, function C.GChildWatchFunc, data unsafe.Pointer) (return__ uint)

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.

func ChildWatchAddFull ¶

func ChildWatchAddFull(priority int, pid C.GPid, function C.GChildWatchFunc, data unsafe.Pointer, notify C.GDestroyNotify) (return__ uint)

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.

func ChildWatchSourceNew ¶

func ChildWatchSourceNew(pid C.GPid) (return__ *C.GSource)

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).

func ClearError ¶

func ClearError() (__err__ error)

If @err is %NULL, does nothing. If @err is non-%NULL, calls g_error_free() on *@err and sets *@err to %NULL.

func Close ¶

func Close(fd int) (return__ bool, __err__ error)

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.

func ComputeChecksumForBytes ¶

func ComputeChecksumForBytes(checksum_type C.GChecksumType, data *C.GBytes) (return__ string)

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.

func ComputeChecksumForData ¶

func ComputeChecksumForData(checksum_type C.GChecksumType, data []byte, length int64) (return__ string)

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.

func ComputeChecksumForString ¶

func ComputeChecksumForString(checksum_type C.GChecksumType, str string, length int64) (return__ string)

Computes the checksum of a string.

The hexadecimal string returned will be in lower case.

func ComputeHmacForData ¶

func ComputeHmacForData(digest_type C.GChecksumType, key []byte, key_len int64, data *C.guchar, length int64) (return__ string)

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.

func ComputeHmacForString ¶

func ComputeHmacForString(digest_type C.GChecksumType, key []byte, key_len int64, str string, length int64) (return__ string)

Computes the HMAC for a string.

The hexadecimal string returned will be in lower case.

func Convert ¶

func Convert(str string, len_ int64, to_codeset string, from_codeset string) (bytes_read int64, bytes_written int64, return__ string, __err__ error)

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.

func ConvertErrorQuark ¶

func ConvertErrorQuark() (return__ C.GQuark)

func ConvertWithFallback ¶

func ConvertWithFallback(str string, len_ int64, to_codeset string, from_codeset string, fallback string, bytes_read *C.gsize, bytes_written *C.gsize) (return__ string, __err__ error)

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.)

func ConvertWithIconv ¶

func ConvertWithIconv(str string, len_ int64, converter C.GIConv, bytes_read *C.gsize, bytes_written *C.gsize) (return__ string, __err__ error)

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.)

func DatalistClear ¶

func DatalistClear(datalist **C.GData)

Frees all the data elements of the datalist. The data elements' destroy functions are called if they have been set.

func DatalistForeach ¶

func DatalistForeach(datalist **C.GData, func_ C.GDataForeachFunc, user_data unsafe.Pointer)

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.

func DatalistGetData ¶

func DatalistGetData(datalist **C.GData, key string) (return__ unsafe.Pointer)

Gets a data element, using its string identifier. This is slower than g_datalist_id_get_data() because it compares strings.

func DatalistGetFlags ¶

func DatalistGetFlags(datalist **C.GData) (return__ uint)

Gets flags values packed in together with the datalist. See g_datalist_set_flags().

func DatalistIdDupData ¶

func DatalistIdDupData(datalist **C.GData, key_id C.GQuark, dup_func C.GDuplicateFunc, user_data unsafe.Pointer) (return__ unsafe.Pointer)

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.

func DatalistIdGetData ¶

func DatalistIdGetData(datalist **C.GData, key_id C.GQuark) (return__ unsafe.Pointer)

Retrieves the data element corresponding to @key_id.

func DatalistIdRemoveNoNotify ¶

func DatalistIdRemoveNoNotify(datalist **C.GData, key_id C.GQuark) (return__ unsafe.Pointer)

Removes an element, without calling its destroy notification function.

func DatalistIdReplaceData ¶

func DatalistIdReplaceData(datalist **C.GData, key_id C.GQuark, oldval unsafe.Pointer, newval unsafe.Pointer, destroy C.GDestroyNotify, old_destroy *C.GDestroyNotify) (return__ bool)

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.

func DatalistIdSetDataFull ¶

func DatalistIdSetDataFull(datalist **C.GData, key_id C.GQuark, data unsafe.Pointer, destroy_func C.GDestroyNotify)

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.

func DatalistInit ¶

func DatalistInit(datalist **C.GData)

Resets the datalist to %NULL. It does not free any memory or call any destroy functions.

func DatalistSetFlags ¶

func DatalistSetFlags(datalist **C.GData, flags uint)

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.)

func DatalistUnsetFlags ¶

func DatalistUnsetFlags(datalist **C.GData, flags uint)

Turns off flag values for a data list. See g_datalist_unset_flags()

func DatasetDestroy ¶

func DatasetDestroy(dataset_location unsafe.Pointer)

Destroys the dataset, freeing all memory allocated, and calling any destroy functions set for data elements.

func DatasetForeach ¶

func DatasetForeach(dataset_location unsafe.Pointer, func_ C.GDataForeachFunc, user_data unsafe.Pointer)

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.

func DatasetIdGetData ¶

func DatasetIdGetData(dataset_location unsafe.Pointer, key_id C.GQuark) (return__ unsafe.Pointer)

Gets the data element corresponding to a #GQuark.

func DatasetIdRemoveNoNotify ¶

func DatasetIdRemoveNoNotify(dataset_location unsafe.Pointer, key_id C.GQuark) (return__ unsafe.Pointer)

Removes an element, without calling its destroy notification function.

func DatasetIdSetDataFull ¶

func DatasetIdSetDataFull(dataset_location unsafe.Pointer, key_id C.GQuark, data unsafe.Pointer, destroy_func C.GDestroyNotify)

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.

func DateGetDaysInMonth ¶

func DateGetDaysInMonth(month C.GDateMonth, year C.GDateYear) (return__ uint8)

Returns the number of days in a month, taking leap years into account.

func DateGetMondayWeeksInYear ¶

func DateGetMondayWeeksInYear(year C.GDateYear) (return__ uint8)

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.)

func DateGetSundayWeeksInYear ¶

func DateGetSundayWeeksInYear(year C.GDateYear) (return__ uint8)

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.)

func DateIsLeapYear ¶

func DateIsLeapYear(year C.GDateYear) (return__ bool)

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.

func DateStrftime ¶

func DateStrftime(s string, slen int64, format string, date *C.GDate) (return__ int64)

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.

func DateTimeCompare ¶

func DateTimeCompare(dt1 unsafe.Pointer, dt2 unsafe.Pointer) (return__ int)

A comparison function for #GDateTimes that is suitable as a #GCompareFunc. Both #GDateTimes must be non-%NULL.

func DateTimeEqual ¶

func DateTimeEqual(dt1 unsafe.Pointer, dt2 unsafe.Pointer) (return__ bool)

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.

func DateTimeHash ¶

func DateTimeHash(datetime unsafe.Pointer) (return__ uint)

Hashes @datetime into a #guint, suitable for use within #GHashTable.

func DateValidDay ¶

func DateValidDay(day C.GDateDay) (return__ bool)

Returns %TRUE if the day of the month is valid (a day is valid if it's between 1 and 31 inclusive).

func DateValidDmy ¶

func DateValidDmy(day C.GDateDay, month C.GDateMonth, year C.GDateYear) (return__ bool)

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).

func DateValidJulian ¶

func DateValidJulian(julian_date uint32) (return__ bool)

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

func DateValidMonth ¶

func DateValidMonth(month C.GDateMonth) (return__ bool)

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

func DateValidWeekday ¶

func DateValidWeekday(weekday C.GDateWeekday) (return__ bool)

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

func DateValidYear ¶

func DateValidYear(year C.GDateYear) (return__ bool)

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.

func Dcgettext ¶

func Dcgettext(domain string, msgid string, category int) (return__ string)

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

func Dgettext ¶

func Dgettext(domain string, msgid string) (return__ string)

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

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.

func DirMakeTmp ¶

func DirMakeTmp(tmpl string) (return__ string, __err__ error)

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.

func DirectEqual ¶

func DirectEqual(v1 unsafe.Pointer, v2 unsafe.Pointer) (return__ bool)

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)`.

func DirectHash ¶

func DirectHash(v unsafe.Pointer) (return__ uint)

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)`.

func Dngettext ¶

func Dngettext(domain string, msgid string, msgid_plural string, n uint64) (return__ string)

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

See g_dgettext() for details of how this differs from dngettext() proper.

func DoubleEqual ¶

func DoubleEqual(v1 unsafe.Pointer, v2 unsafe.Pointer) (return__ bool)

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.

func DoubleHash ¶

func DoubleHash(v unsafe.Pointer) (return__ uint)

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.

func Dpgettext ¶

func Dpgettext(domain string, msgctxtid string, msgidoffset int64) (return__ string)

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

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.

func Dpgettext2 ¶

func Dpgettext2(domain string, context string, msgid string) (return__ 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.

func EnvironGetenv ¶

func EnvironGetenv(envp []string, variable string) (return__ string)

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

func EnvironSetenv ¶

func EnvironSetenv(envp []string, variable string, value string, overwrite bool) (return__ **C.gchar)

Sets the environment variable @variable in the provided list @envp to @value.

func EnvironUnsetenv ¶

func EnvironUnsetenv(envp []string, variable string) (return__ **C.gchar)

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

func FileErrorFromErrno ¶

func FileErrorFromErrno(err_no int) (return__ C.GFileError)

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.

func FileErrorQuark ¶

func FileErrorQuark() (return__ C.GQuark)

func FileGetContents ¶

func FileGetContents(filename string) (contents []byte, length int64, return__ bool, __err__ error)

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.

func FileOpenTmp ¶

func FileOpenTmp(tmpl string) (name_used string, return__ int, __err__ error)

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.

func FileReadLink ¶

func FileReadLink(filename string) (return__ string, __err__ error)

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.

func FileSetContents ¶

func FileSetContents(filename string, contents []byte, length int64) (return__ bool, __err__ error)

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.

func FileTest ¶

func FileTest(filename string, test C.GFileTest) (return__ bool)

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.

func FilenameDisplayBasename ¶

func FilenameDisplayBasename(filename string) (return__ string)

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.

func FilenameDisplayName ¶

func FilenameDisplayName(filename string) (return__ string)

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.

func FilenameFromUri ¶

func FilenameFromUri(uri string) (hostname string, return__ string, __err__ error)

Converts an escaped ASCII-encoded URI to a local filename in the encoding used for filenames.

func FilenameFromUtf8 ¶

func FilenameFromUtf8(utf8string string, len_ int64) (bytes_read int64, bytes_written int64, return__ []byte, __err__ 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].

func FilenameToUri ¶

func FilenameToUri(filename string, hostname string) (return__ string, __err__ error)

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

func FilenameToUtf8 ¶

func FilenameToUtf8(opsysstring string, len_ int64, bytes_read *C.gsize, bytes_written *C.gsize) (return__ string, __err__ 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].

func FindProgramInPath ¶

func FindProgramInPath(program string) (return__ string)

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.

func FormatSize ¶

func FormatSize(size uint64) (return__ string)

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

The 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.

func FormatSizeFull ¶

func FormatSizeFull(size uint64, flags C.GFormatSizeFlags) (return__ string)

Formats a size.

This function is similar to g_format_size() but allows for flags that modify the output. See #GFormatSizeFlags.

func Free ¶

func Free(mem unsafe.Pointer)

Frees the memory pointed to by @mem. If @mem is %NULL it simply returns.

func GetApplicationName ¶

func GetApplicationName() (return__ string)

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).

func GetCharset ¶

func GetCharset(charset **C.char) (return__ bool)

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.

func GetCodeset ¶

func GetCodeset() (return__ string)

Gets the character set for the current locale.

func GetCurrentDir ¶

func GetCurrentDir() (return__ string)

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.

func GetCurrentTime ¶

func GetCurrentTime(result *C.GTimeVal)

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

You may find g_get_real_time() to be more convenient.

func GetEnviron ¶

func GetEnviron() (return__ **C.gchar)

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.

func GetFilenameCharsets ¶

func GetFilenameCharsets(charsets ***C.gchar) (return__ bool)

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 "&commat;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.

func GetHomeDir ¶

func GetHomeDir() (return__ string)

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.

func GetHostName ¶

func GetHostName() (return__ string)

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.

func GetLanguageNames ¶

func GetLanguageNames() (return__ **C.gchar)

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.

func GetLocaleVariants ¶

func GetLocaleVariants(locale string) (return__ **C.gchar)

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().

func GetMonotonicTime ¶

func GetMonotonicTime() (return__ int64)

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.

func GetNumProcessors ¶

func GetNumProcessors() (return__ uint)

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.

func GetPrgname ¶

func GetPrgname() (return__ string)

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].

func GetRealName ¶

func GetRealName() (return__ string)

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.

func GetRealTime ¶

func GetRealTime() (return__ int64)

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.

func GetSystemConfigDirs ¶

func GetSystemConfigDirs() (return__ **C.gchar)

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.

func GetSystemDataDirs ¶

func GetSystemDataDirs() (return__ **C.gchar)

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.

func GetTmpDir ¶

func GetTmpDir() (return__ string)

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.

func GetUserCacheDir ¶

func GetUserCacheDir() (return__ string)

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.

func GetUserConfigDir ¶

func GetUserConfigDir() (return__ string)

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.

func GetUserDataDir ¶

func GetUserDataDir() (return__ string)

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.

func GetUserName ¶

func GetUserName() (return__ string)

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.

func GetUserRuntimeDir ¶

func GetUserRuntimeDir() (return__ string)

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.

func GetUserSpecialDir ¶

func GetUserSpecialDir(directory C.GUserDirectory) (return__ string)

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.

func Getenv ¶

func Getenv(variable string) (return__ string)

Returns the value of an environment variable.

The name and value are in the GLib file name encoding. On UNIX, this means the actual bytes which might or might not be in some consistent character set and encoding. On Windows, it is in UTF-8. On Windows, in case the environment variable's value contains references to other environment variables, they are expanded.

func HashTableAdd ¶

func HashTableAdd(hash_table *C.GHashTable, key unsafe.Pointer) (return__ bool)

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.

func HashTableContains ¶

func HashTableContains(hash_table *C.GHashTable, key unsafe.Pointer) (return__ bool)

Checks if @key is in @hash_table.

func HashTableDestroy ¶

func HashTableDestroy(hash_table *C.GHashTable)

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.

func HashTableInsert ¶

func HashTableInsert(hash_table *C.GHashTable, key unsafe.Pointer, value unsafe.Pointer) (return__ bool)

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.

func HashTableLookupExtended ¶

func HashTableLookupExtended(hash_table *C.GHashTable, lookup_key unsafe.Pointer, orig_key *C.gpointer, value *C.gpointer) (return__ bool)

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.

func HashTableRemove ¶

func HashTableRemove(hash_table *C.GHashTable, key unsafe.Pointer) (return__ bool)

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.

func HashTableRemoveAll ¶

func HashTableRemoveAll(hash_table *C.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.

func HashTableReplace ¶

func HashTableReplace(hash_table *C.GHashTable, key unsafe.Pointer, value unsafe.Pointer) (return__ bool)

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.

func HashTableSize ¶

func HashTableSize(hash_table *C.GHashTable) (return__ uint)

Returns the number of elements contained in the #GHashTable.

func HashTableSteal ¶

func HashTableSteal(hash_table *C.GHashTable, key unsafe.Pointer) (return__ bool)

Removes a key and its associated value from a #GHashTable without calling the key and value destroy functions.

func HashTableStealAll ¶

func HashTableStealAll(hash_table *C.GHashTable)

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

func HashTableUnref ¶

func HashTableUnref(hash_table *C.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.

func HookDestroy ¶

func HookDestroy(hook_list *C.GHookList, hook_id uint64) (return__ bool)

Destroys a #GHook, given its ID.

func HookDestroyLink ¶

func HookDestroyLink(hook_list *C.GHookList, hook *C.GHook)

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

func HookFree ¶

func HookFree(hook_list *C.GHookList, hook *C.GHook)

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

func HookInsertBefore ¶

func HookInsertBefore(hook_list *C.GHookList, sibling *C.GHook, hook *C.GHook)

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

func HookPrepend ¶

func HookPrepend(hook_list *C.GHookList, hook *C.GHook)

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

func HookUnref ¶

func HookUnref(hook_list *C.GHookList, hook *C.GHook)

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.

func HostnameIsAsciiEncoded ¶

func HostnameIsAsciiEncoded(hostname string) (return__ bool)

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.

func HostnameIsIpAddress ¶

func HostnameIsIpAddress(hostname string) (return__ bool)

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

func HostnameIsNonAscii ¶

func HostnameIsNonAscii(hostname string) (return__ bool)

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.

func HostnameToAscii ¶

func HostnameToAscii(hostname string) (return__ string)

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

func HostnameToUnicode ¶

func HostnameToUnicode(hostname string) (return__ string)

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.

func Iconv ¶

func Iconv(converter C.GIConv, inbuf []string, inbytes_left *C.gsize, outbuf []string, outbytes_left *C.gsize) (return__ int64)

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.

func IdleAdd ¶

func IdleAdd(function C.GSourceFunc, data unsafe.Pointer) (return__ uint)

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 main loop context using g_source_attach(). You can do these steps manually if you need greater control.

func IdleAddFull ¶

func IdleAddFull(priority int, function C.GSourceFunc, data unsafe.Pointer, notify C.GDestroyNotify) (return__ uint)

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 main loop context using g_source_attach(). You can do these steps manually if you need greater control.

func IdleRemoveByData ¶

func IdleRemoveByData(data unsafe.Pointer) (return__ bool)

Removes the idle function with the given data.

func IdleSourceNew ¶

func IdleSourceNew() (return__ *C.GSource)

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.

func Int64Equal ¶

func Int64Equal(v1 unsafe.Pointer, v2 unsafe.Pointer) (return__ bool)

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.

func Int64Hash ¶

func Int64Hash(v unsafe.Pointer) (return__ uint)

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.

func IntEqual ¶

func IntEqual(v1 unsafe.Pointer, v2 unsafe.Pointer) (return__ bool)

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.

func IntHash ¶

func IntHash(v unsafe.Pointer) (return__ uint)

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.

func InternStaticString ¶

func InternStaticString(string_ string) (return__ string)

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

func InternString ¶

func InternString(string_ string) (return__ string)

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

func IoAddWatch ¶

func IoAddWatch(channel *C.GIOChannel, condition C.GIOCondition, func_ C.GIOFunc, user_data unsafe.Pointer) (return__ uint)

Adds the #GIOChannel into the default main loop context with the default priority.

func IoAddWatchFull ¶

func IoAddWatchFull(channel *C.GIOChannel, priority int, condition C.GIOCondition, func_ C.GIOFunc, user_data unsafe.Pointer, notify C.GDestroyNotify) (return__ uint)

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.

func IoChannelErrorFromErrno ¶

func IoChannelErrorFromErrno(en int) (return__ C.GIOChannelError)

Converts an `errno` error number to a #GIOChannelError.

func IoChannelErrorQuark ¶

func IoChannelErrorQuark() (return__ C.GQuark)

func IoCreateWatch ¶

func IoCreateWatch(channel *C.GIOChannel, condition C.GIOCondition) (return__ *C.GSource)

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.

func KeyFileErrorQuark ¶

func KeyFileErrorQuark() (return__ C.GQuark)

func Listenv ¶

func Listenv() (return__ **C.gchar)

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.

func LocaleFromUtf8 ¶

func LocaleFromUtf8(utf8string string, len_ int64, bytes_read *C.gsize, bytes_written *C.gsize) (return__ string, __err__ error)

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.

func LocaleToUtf8 ¶

func LocaleToUtf8(opsysstring string, len_ int64, bytes_read *C.gsize, bytes_written *C.gsize) (return__ string, __err__ error)

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.

func LogDefaultHandler ¶

func LogDefaultHandler(log_domain string, log_level C.GLogLevelFlags, message string, unused_data unsafe.Pointer)

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.

func LogRemoveHandler ¶

func LogRemoveHandler(log_domain string, handler_id uint)

Removes the log handler.

func LogSetAlwaysFatal ¶

func LogSetAlwaysFatal(fatal_mask C.GLogLevelFlags) (return__ C.GLogLevelFlags)

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)).

func LogSetDefaultHandler ¶

func LogSetDefaultHandler(log_func C.GLogFunc, user_data unsafe.Pointer) (return__ C.GLogFunc)

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.

func LogSetFatalMask ¶

func LogSetFatalMask(log_domain string, fatal_mask C.GLogLevelFlags) (return__ C.GLogLevelFlags)

Sets the log levels which are fatal in the given domain. %G_LOG_LEVEL_ERROR is always fatal.

func LogSetHandler ¶

func LogSetHandler(log_domain string, log_levels C.GLogLevelFlags, log_func C.GLogFunc, user_data unsafe.Pointer) (return__ uint)

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);

]|

func MainContextDefault ¶

func MainContextDefault() (return__ *C.GMainContext)

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().

func MainContextGetThreadDefault ¶

func MainContextGetThreadDefault() (return__ *C.GMainContext)

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.

func MainContextRefThreadDefault ¶

func MainContextRefThreadDefault() (return__ *C.GMainContext)

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.

func MainCurrentSource ¶

func MainCurrentSource() (return__ *C.GSource)

Returns the currently firing source for this thread.

func MainDepth ¶

func MainDepth() (return__ int)

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.

func Malloc ¶

func Malloc(n_bytes int64) (return__ unsafe.Pointer)

Allocates @n_bytes bytes of memory. If @n_bytes is 0 it returns %NULL.

func Malloc0 ¶

func Malloc0(n_bytes int64) (return__ unsafe.Pointer)

Allocates @n_bytes bytes of memory, initialized to 0's. If @n_bytes is 0 it returns %NULL.

func Malloc0N ¶

func Malloc0N(n_blocks int64, n_block_bytes int64) (return__ unsafe.Pointer)

This function is similar to g_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication.

func MallocN ¶

func MallocN(n_blocks int64, n_block_bytes int64) (return__ unsafe.Pointer)

This function is similar to g_malloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication.

func MarkupErrorQuark ¶

func MarkupErrorQuark() (return__ C.GQuark)

func MarkupEscapeText ¶

func MarkupEscapeText(text string, length int64) (return__ string)

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

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.

func MemIsSystemMalloc ¶

func MemIsSystemMalloc() (return__ bool)

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().

func MemProfile ¶

func MemProfile()

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().

func MemSetVtable ¶

func MemSetVtable(vtable *C.GMemVTable)

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.

func Memdup ¶

func Memdup(mem unsafe.Pointer, byte_size uint) (return__ unsafe.Pointer)

Allocates @byte_size bytes of memory, and copies @byte_size bytes into it from @mem. If @mem is %NULL it returns %NULL.

func MkdirWithParents ¶

func MkdirWithParents(pathname string, mode int) (return__ int)

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

func Mkdtemp ¶

func Mkdtemp(tmpl string) (return__ string)

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.

func MkdtempFull ¶

func MkdtempFull(tmpl string, mode int) (return__ string)

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.

func Mkstemp ¶

func Mkstemp(tmpl string) (return__ int)

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.

func MkstempFull ¶

func MkstempFull(tmpl string, flags int, mode int) (return__ int)

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.

func NullifyPointer ¶

func NullifyPointer(nullify_location *C.gpointer)

Set the pointer at the specified location to %NULL.

func OnErrorQuery ¶

func OnErrorQuery(prg_name string)

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

|[<!-- 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.

func OnErrorStackTrace ¶

func OnErrorStackTrace(prg_name string)

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.

func OptionErrorQuark ¶

func OptionErrorQuark() (return__ C.GQuark)

func ParseDebugString ¶

func ParseDebugString(string_ string, keys *C.GDebugKey, nkeys uint) (return__ uint)

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.

func PathGetBasename ¶

func PathGetBasename(file_name string) (return__ string)

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 ".".

func PathGetDirname ¶

func PathGetDirname(file_name string) (return__ string)

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.

func PathIsAbsolute ¶

func PathIsAbsolute(file_name string) (return__ bool)

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.

func PathSkipRoot ¶

func PathSkipRoot(file_name string) (return__ string)

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

func PatternMatch ¶

func PatternMatch(pspec *C.GPatternSpec, string_length uint, string_ string, string_reversed string) (return__ bool)

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.

func PatternMatchSimple ¶

func PatternMatchSimple(pattern string, string_ string) (return__ bool)

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.

func PatternMatchString ¶

func PatternMatchString(pspec *C.GPatternSpec, string_ string) (return__ bool)

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.

func Poll ¶

func Poll(fds *C.GPollFD, nfds uint, timeout int) (return__ int)

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

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().

func PropagateError ¶

func PropagateError(dest **C.GError, src *C.GError)

If @dest is %NULL, free @src; otherwise, moves @src into *@dest. The error variable @dest points to must be %NULL.

func QsortWithData ¶

func QsortWithData(pbase unsafe.Pointer, total_elems int, size int64, compare_func C.GCompareDataFunc, user_data unsafe.Pointer)

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.

func QuarkFromStaticString ¶

func QuarkFromStaticString(string_ string) (return__ C.GQuark)

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).

func QuarkFromString ¶

func QuarkFromString(string_ string) (return__ C.GQuark)

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.

func QuarkToString ¶

func QuarkToString(quark C.GQuark) (return__ string)

Gets the string associated with the given #GQuark.

func QuarkTryString ¶

func QuarkTryString(string_ string) (return__ C.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().

func RandomDouble ¶

func RandomDouble() (return__ float64)

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

func RandomDoubleRange ¶

func RandomDoubleRange(begin float64, end float64) (return__ float64)

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

func RandomInt ¶

func RandomInt() (return__ uint32)

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

func RandomIntRange ¶

func RandomIntRange(begin int32, end int32) (return__ int32)

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

func RandomSetSeed ¶

func RandomSetSeed(seed uint32)

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

func Realloc ¶

func Realloc(mem unsafe.Pointer, n_bytes int64) (return__ unsafe.Pointer)

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.

func ReallocN ¶

func ReallocN(mem unsafe.Pointer, n_blocks int64, n_block_bytes int64) (return__ unsafe.Pointer)

This function is similar to g_realloc(), allocating (@n_blocks * @n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication.

func RegexCheckReplacement ¶

func RegexCheckReplacement(replacement string) (has_references bool, return__ bool, __err__ error)

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.

func RegexErrorQuark ¶

func RegexErrorQuark() (return__ C.GQuark)

func RegexEscapeNul ¶

func RegexEscapeNul(string_ string, length int) (return__ 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.

func RegexEscapeString ¶