Package-level declarations

Contains the public fields of a GArray.

GBookmarkFile lets you parse, edit or create files containing bookmarks.

Error codes returned by bookmark file parsing.

Contains the public fields of a GByteArray.

A simple refcounted data type representing an immutable sequence of zero or more bytes from an unspecified origin.

Specifies the type of the @value_destroy_func and @key_destroy_func functions passed to g_cache_new(). The functions are passed a pointer to the #GCache key or #GCache value and should free any memory and other resources associated with it.

GLib provides a generic API for computing checksums (or ‘digests’) for a sequence of arbitrary bytes, using various hashing algorithms like MD5, SHA-1 and SHA-256. Checksums are commonly used in various environments and specifications.

The hashing algorithm to be used by #GChecksum when performing the digest of some data.

Prototype of a #GChildWatchSource callback, called when a child process has exited.

Specifies the type of function passed to func@GLib.clear_handle_id The implementation is expected to free the resource identified by @handle_id; for instance, if @handle_id is a struct@GLib.Source ID, func@GLib.Source.remove can be used.

Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.

Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.

GCompletion provides support for automatic completion of a string using any group of target strings. It is typically used for file name completion as is common in many UNIX shells.

Specifies the type of the function passed to g_completion_set_compare(). This is used when you use strings as #GCompletion items.

The #GCond struct is an opaque data structure that represents a condition. Threads can block on a #GCond if they find a certain condition to be false. If other threads change the state of this condition they signal the #GCond, and that causes the waiting threads to be woken up.

Error codes returned by character set conversion routines.

Specifies the type of function passed to g_dataset_foreach(). It is called with each #GQuark id and associated data element, together with the @user_data parameter supplied to g_dataset_foreach().

GDate is a struct for calendrical calculations.

This enumeration isn't used in the API, but may be useful if you need to mark a number as a day, month, or year.

Enumeration representing a month; values are %G_DATE_JANUARY, %G_DATE_FEBRUARY, etc. %G_DATE_BAD_MONTH is the invalid value.

GDateTime is a structure that combines a Gregorian date and time into a single structure.

Enumeration representing a day of the week; %G_DATE_MONDAY, %G_DATE_TUESDAY, etc. %G_DATE_BAD_WEEKDAY is an invalid weekday.

Associates a string with a bit flag. Used in g_parse_debug_string().

Specifies the type of function which is called when a data element is destroyed. It is passed the pointer to the data element and should free any memory and resources allocated for it.

An opaque structure representing an opened directory.

Specifies the type of a function used to test two values for equality. The function should return true if both values are equal and false otherwise.

Specifies the type of a function used to test two values for equality. The function should return true if both values are equal and false otherwise.

The GError structure contains information about an error that has occurred.

Specifies the type of function which is called when an extended error instance is freed. It is passed the error pointer about to be freed, and should free the error's private data fields.

Specifies the type of function which is called when an extended error instance is copied. It is passed the pointer to the destination error and source error, and should copy only the fields of the private data from @src_error to @dest_error.

Specifies the type of function which is called just after an extended error instance is created and its fields filled. It should only initialize the fields in the private data, which can be received with the generated *_get_private() function.

The possible errors, used in the @v_error field of #GTokenValue, when the token is a %G_TOKEN_ERROR.

Values corresponding to @errno codes returned from file operations on UNIX. Unlike @errno codes, GFileError values are available on all systems, even Windows. The exact meaning of each code depends on what sort of file operation you were performing; the UNIX documentation gives more details. The following error code descriptions come from the GNU C Library manual, and are under the copyright of that manual.

Flags to pass to g_file_set_contents_full() to affect its safety and performance.

A test to perform on a file using g_file_test().

Flags to modify the format of the string returned by g_format_size_full().

Declares a type of function which takes an arbitrary data pointer argument and has no return value. It is not currently used in GLib or GTK.

Specifies the type of functions passed to g_list_foreach() and g_slist_foreach().

Specifies the type of the hash function which is passed to g_hash_table_new() when a #GHashTable is created.

The #GHashTable struct is an opaque data structure to represent a glib-Hash-Tables. It should only be accessed via the following functions.

A GHashTableIter structure represents an iterator that can be used to iterate over the elements of a #GHashTable. GHashTableIter structures are typically allocated on the stack and then initialized with g_hash_table_iter_init().

Specifies the type of the function passed to g_hash_table_foreach(). It is called with each key/value pair, together with the @user_data parameter which is passed to g_hash_table_foreach().

The #GHook struct represents a single hook function in a #GHookList.

Defines the type of a hook function that can be invoked by g_hook_list_invoke_check().

Defines the type of function used by g_hook_list_marshal_check().

Defines the type of function used to compare #GHook elements in g_hook_insert_sorted().

Defines the type of function to be called when a hook in a list of hooks gets finalized.

Defines the type of the function passed to g_hook_find().

Flags used internally in the #GHook implementation.

Defines the type of a hook function that can be invoked by g_hook_list_invoke().

The #GHookList struct represents a list of hook functions.

Defines the type of function used by g_hook_list_marshal().

Specifies the type of the function passed to func@GLib.HashTable.find, func@GLib.HashTable.foreach_remove, and func@GLib.HashTable.foreach_steal.

The GIOChannel data type aims to provide a portable method for using file descriptors, pipes, and sockets, and integrating them into the main event loop (see struct@GLib.MainContext). Currently, full support is available on UNIX platforms; support for Windows is only partially complete.

Error codes returned by #GIOChannel operations.

#GIOError is only used by the deprecated functions g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().

Specifies properties of a #GIOChannel. Some of the flags can only be read with g_io_channel_get_flags(), but not changed with g_io_channel_set_flags().

Specifies the type of function passed to g_io_add_watch() or g_io_add_watch_full(), which is called when the requested condition on a #GIOChannel is satisfied.

A table of functions used to handle different types of #GIOChannel in a generic way.

Statuses returned by most of the #GIOFuncs functions.

GKeyFile parses .ini-like config files.

Error codes returned by key file parsing.

Flags which influence the parsing.

The #GList struct is used for each element in a doubly-linked list.

Structure representing a single field in a structured log entry. See g_log_structured() for details.

Specifies the prototype of log handler functions.

Flags specifying the level of log messages.

Writer function for log entries. A log entry is a collection of one or more #GLogFields, using the standard [field names from journal

Return values from #GLogWriterFuncs to indicate whether the given log entry was successfully handled by the writer, or whether there was an error in handling it (and hence a fallback writer should be used).

The GMainContext struct is an opaque data type representing a set of sources to be handled in a main loop.

Flags to pass to ctor@GLib.MainContext.new_with_flags which affect the behaviour of a struct@GLib.MainContext.

The GMainLoop struct is an opaque data type representing the main event loop of a GLib or GTK application.

The #GMappedFile represents a file mapping created with g_mapped_file_new(). It has only private members and should not be accessed directly.

A mixed enumerated type and flags field. You must specify one type (string, strdup, boolean, tristate). Additionally, you may optionally bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL.

Error codes returned by markup parsing.

A parse context is used to parse a stream of bytes that you expect to contain marked-up text.

Flags that affect the behaviour of the parser.

Any of the fields in #GMarkupParser can be null, in which case they will be ignored. Except for the @error function, any of these callbacks can set an error; in particular the %G_MARKUP_ERROR_UNKNOWN_ELEMENT, %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and %G_MARKUP_ERROR_INVALID_CONTENT errors are intended to be set from these callbacks. If you set an error from a callback, g_markup_parse_context_parse() will report that error back to its caller.

A GMatchInfo is an opaque struct used to return information about matches.

A set of functions used to perform memory allocation. The same #GMemVTable must be used for all allocations in the same program; a call to g_mem_set_vtable(), if it exists, should be prior to any use of GLib.

The #GNode struct represents one node in a glib-N-ary-Trees.

Specifies the type of function passed to g_node_children_foreach(). The function is called with each child node, together with the user data passed to g_node_children_foreach().

Specifies the type of function passed to g_node_traverse(). The function is called with each of the nodes visited, together with the user data passed to g_node_traverse(). If the function returns true, then the traversal is stopped.

Defines how a Unicode string is transformed in a canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character. Unicode strings should generally be normalized before comparing them.

Error codes returned by functions converting a string to a number.

A #GOnce struct controls a one-time initialization function. Any one-time initialization function must have its own unique #GOnce struct.

The possible statuses of a one-time initialization function controlled by a #GOnce struct.

The #GOptionArg enum values determine which type of extra argument the options expect to find. If an option expects an extra argument, it can be specified in several ways; with a short option: -x arg, with a long option: --name arg or combined in a single argument: --name=arg.

A GOptionEntry struct defines a single option. To have an effect, they must be added to a #GOptionGroup with g_option_context_add_main_entries() or g_option_group_add_entries().

Error codes returned by option parsing.

Flags which modify individual options.

A GOptionGroup struct defines the options in a single group. The struct has only private fields and should not be directly accessed.

GPathBuf is a helper type that allows you to easily build paths from individual elements, using the platform specific conventions for path separators.

A GPatternSpec struct is the ‘compiled’ form of a glob-style pattern.

Represents a file descriptor, which events to poll for, and which events occurred.

Specifies the type of function passed to g_main_context_set_poll_func(). The semantics of the function should match those of the poll() system call.

Specifies the type of the print handler functions. These are called with the complete formatted string to output.

The #GPrivate struct is an opaque data structure to represent a thread-local data key. It is approximately equivalent to the pthread_setspecific()/pthread_getspecific() APIs on POSIX and to TlsSetValue()/TlsGetValue() on Windows.

Contains the public fields of a pointer array.

Contains the public fields of a glib-Double-ended-Queues.

The GRand struct is an opaque data structure. It should only be accessed through the g_rand_* functions.

The GRecMutex struct is an opaque data structure to represent a recursive mutex. It is similar to a #GMutex with the difference that it is possible to lock a GRecMutex multiple times in the same thread without deadlock. When doing so, care has to be taken to unlock the recursive mutex as often as it has been locked.

A GRegex is the "compiled" form of a regular expression pattern.

Flags specifying compile-time options.

Error codes returned by regular expressions functions.

Specifies the type of the function passed to g_regex_replace_eval(). It is called for each occurrence of the pattern in the string passed to g_regex_replace_eval(), and it should append the replacement to

Flags specifying match-time options.

The GRWLock struct is an opaque data structure to represent a reader-writer lock. It is similar to a #GMutex in that it allows multiple threads to coordinate access to a shared resource.

GScanner provides a general-purpose lexical scanner.

Specifies the #GScanner parser configuration. Most settings can be changed during the parsing phase and will affect the lexical parsing of the next unpeeked token.

Specifies the type of the message handler function.

An enumeration specifying the base position for a g_io_channel_seek_position() operation.

A #GSequenceIterCompareFunc is a function used to compare iterators. It must return zero if the iterators compare equal, a negative value if @a comes before @b, and a positive value if @b comes before @a.

Error codes returned by shell functions.

The #GSList struct is used for each element in the singly-linked list.

The GSource struct is an opaque data type representing an event source.

The GSourceCallbackFuncs struct contains functions for managing callback objects.

Dispose function for @source. See method@GLib.Source.set_dispose_function for details.

This is just a placeholder for #GClosureMarshal, which cannot be used here for dependency reasons.

Specifies the type of function passed to func@GLib.timeout_add, func@GLib.timeout_add_full, func@GLib.idle_add, and func@GLib.idle_add_full.

The GSourceFuncs struct contains a table of functions used to handle event sources in a generic manner.

Checks if the source is ready to be dispatched.

Finalizes the source.

Checks the source for readiness.

A source function that is only called once before being removed from the main context automatically.

Specifies the type of the setup function passed to g_spawn_async(), g_spawn_sync() and g_spawn_async_with_pipes(), which can, in very limited ways, be used to affect the child's execution.

Error codes returned by spawning processes.

Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes().

A GString is an object that handles the memory management of a C string.

GStrvBuilder is a helper object to build a null-terminated string arrays.

The type used for test case functions that take an extra pointer argument.

The type of file to return the filename for, when used with g_test_build_filename().

The type used for functions that operate on test fixtures. This is used for the fixture setup and teardown functions as well as for the testcases themselves.

The type used for test case functions.

Specifies the prototype of fatal log handler functions.

Flags to pass to g_test_trap_subprocess() to control input and output.

Test traps are guards around forked tests. These flags determine what traps to set.

The #GThread struct represents a running thread. This struct is returned by g_thread_new() or g_thread_try_new(). You can obtain the #GThread struct representing the current thread by calling g_thread_self().

Possible errors of thread related functions.

The GThreadPool struct represents a thread pool.

Disambiguates a given time in two ways.

Represents a precise time, with seconds and microseconds.

A GTimeZone represents a time zone, at no particular point in time.

The possible types of token returned from each g_scanner_get_next_token() call.

A GTrashStack is an efficient way to keep a stack of unused allocated memory chunks. Each memory chunk is required to be large enough to hold a gpointer. This allows the stack to be maintained without any space overhead, since the stack pointers can be stored inside the memory chunks.

Specifies which nodes are visited during several of the tree functions, including g_node_traverse() and g_node_find().

Specifies the type of function passed to g_tree_traverse(). It is passed the key and value of each node, together with the @user_data parameter passed to g_tree_traverse(). If the function returns true, the traversal is stopped.

Specifies the type of function passed to g_tree_foreach_node(). It is passed each node, together with the @user_data parameter passed to g_tree_foreach_node(). If the function returns true, the traversal is stopped.

Specifies the type of traversal performed by g_tree_traverse(), g_node_traverse() and g_node_find().

The GTree struct is an opaque data structure representing a glib-Balanced-Binary-Trees. It should be accessed only by using the following functions.

The #GTuples struct is used to return records (or tuples) from the #GRelation by g_relation_select(). It only contains one public member - the number of records that matched. To access the matched records, you must use g_tuples_index().

These are the possible line break classifications.

The #GUnicodeScript enumeration identifies different writing systems. The values correspond to the names as defined in the Unicode standard. The enumeration has been added in GLib 2.14, and is interchangeable with #PangoScript.

These are the possible character classifications from the Unicode specification. See Unicode Character Database.

The type of functions to be called when a UNIX fd watch source triggers.

A Unix pipe. The advantage of this type over int[2] is that it can be closed automatically when it goes out of scope, using g_auto(GUnixPipe), on compilers that support that feature.

Mnemonic constants for the ends of a Unix pipe.

The GUri type and related functions can be used to parse URIs into their components, and build valid URIs from individual components.

Error codes returned by #GUri methods.

Flags that describe a URI.

Flags describing what parts of the URI to hide in g_uri_to_string_partial(). Note that %G_URI_HIDE_PASSWORD and %G_URI_HIDE_AUTH_PARAMS will only work if the #GUri was parsed with the corresponding flags.

Flags modifying the way parameters are handled by g_uri_parse_params() and #GUriParamsIter.

Many URI schemes include one or more attribute/value pairs as part of the URI value. For example scheme://server/path?query=string&is=there has two attributes – query=string and is=there – in its query part.

These are logical ids for special directories which are defined depending on the platform used. You should use g_get_user_special_dir() to retrieve the full path associated to the logical id.

GVariant is a variant datatype; it can contain one or more values along with information about the type of the values.

A utility type for constructing container-type #GVariant instances.

The range of possible top-level types of #GVariant instances.

#GVariantDict is a mutable interface to #GVariant dictionaries.

Error codes returned by parsing text-format GVariants.

A type in the type@GLib.Variant type system.

Declares a type of function which takes no arguments and has no return value. It is used to specify the type function passed to g_atexit().