@gtkx/ffi 0.1.45 → 0.1.47

package/dist/generated/glib/main-context.js

@@ -1,11 +1,22 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Source } from "./source.js";
+/**
+ * The `GMainContext` struct is an opaque data
+ * type representing a set of sources to be handled in a main loop.
+ */
 export class MainContext {
     ptr;
+    /**
+     * Creates a new [struct@GLib.MainContext] structure.
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
+    /**
+     * Creates a new [struct@GLib.MainContext] structure.
+     * @param flags - a bitwise-OR combination of flags that can only be set at creation
+     */
     static contextNewWithFlags(flags) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_new_with_flags", [
             {
@@ -18,6 +29,14 @@ export class MainContext {
     createPtr(_args) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_new", [], { type: "boxed", borrowed: true, innerType: "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
+     * [func@GLib.MainContext.get_thread_default].
+     */
     static _default() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_default", [], {
             type: "boxed",
@@ -27,6 +46,20 @@ export class MainContext {
         });
         return getObject(ptr, MainContext);
     }
+    /**
+     * Gets the thread-default main context for this thread.
+     *
+     * Asynchronous operations that want to be able to be run in contexts other than
+     * the default one should call this method or
+     * [func@GLib.MainContext.ref_thread_default] to get a
+     * [struct@GLib.MainContext] to add their [struct@GLib.Source]s 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
+     * [func@GLib.MainContext.ref_thread_default] instead.
+     */
     static getThreadDefault() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_get_thread_default", [], {
             type: "boxed",
@@ -36,6 +69,18 @@ export class MainContext {
         });
         return getObject(ptr, MainContext);
     }
+    /**
+     * Gets a reference to the thread-default [struct@GLib.MainContext] for this
+     * thread
+     *
+     * This is the same as [func@GLib.MainContext.get_thread_default], but it also
+     * adds a reference to the returned main context with [method@GLib.MainContext.ref].
+     * In addition, unlike
+     * [func@GLib.MainContext.get_thread_default], if the thread-default context
+     * is the global-default context, this will return that
+     * [struct@GLib.MainContext] (with a ref added to it) rather than returning
+     * `NULL`.
+     */
     static refThreadDefault() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_ref_thread_default", [], {
             type: "boxed",
@@ -45,6 +90,23 @@ export class MainContext {
         });
         return getObject(ptr, MainContext);
     }
+    /**
+     * Tries to become the owner of the specified context.
+     *
+     * If some other thread is the owner of the context,
+     * returns false immediately. Ownership is properly
+     * recursive: the owner can require ownership again
+     * and will release ownership when [method@GLib.MainContext.release]
+     * is called as many times as [method@GLib.MainContext.acquire].
+     *
+     * You must be the owner of a context before you
+     * can call [method@GLib.MainContext.prepare], [method@GLib.MainContext.query],
+     * [method@GLib.MainContext.check], [method@GLib.MainContext.dispatch],
+     * [method@GLib.MainContext.release].
+     *
+     * Since 2.76 `context` can be `NULL` to use the global-default
+     * main context.
+     */
     acquire() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_acquire", [
             {
@@ -53,6 +115,15 @@ export class MainContext {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Adds a file descriptor to the set of file descriptors polled for
+     * this context.
+     *
+     * This will very seldom be used directly. Instead
+     * a typical event source will use `g_source_add_unix_fd()` instead.
+     * @param fd - a [struct@GLib.PollFD] structure holding information about a file
+     * @param priority - the priority for this file descriptor which should be
+     */
     addPoll(fd, priority) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_add_poll", [
             {
@@ -74,6 +145,23 @@ export class MainContext {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Passes the results of polling back to the main loop.
+     *
+     * You should be
+     * careful to pass `fds` and its length `n_fds` as received from
+     * [method@GLib.MainContext.query], as this functions relies on assumptions
+     * on how `fds` is filled.
+     *
+     * You must have successfully acquired the context with
+     * [method@GLib.MainContext.acquire] before you may call this function.
+     *
+     * Since 2.76 `context` can be `NULL` to use the global-default
+     * main context.
+     * @param maxPriority - the maximum numerical priority of sources to check
+     * @param fds - array of [struct@GLib.PollFD]s that was passed to
+     * @param nFds - return value of [method@GLib.MainContext.query]
+     */
     check(maxPriority, fds, nFds) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_check", [
             {
@@ -101,6 +189,15 @@ export class MainContext {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Dispatches all pending sources.
+     *
+     * You must have successfully acquired the context with
+     * [method@GLib.MainContext.acquire] before you may call this function.
+     *
+     * Since 2.76 `context` can be `NULL` to use the global-default
+     * main context.
+     */
     dispatch() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_dispatch", [
             {
@@ -109,6 +206,14 @@ export class MainContext {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finds a source with the given source functions and user data.
+     *
+     * If multiple sources exist with the same source function and user data,
+     * the first one found will be returned.
+     * @param funcs - the `source_funcs` passed to [ctor@GLib.Source.new]
+     * @param userData - the user data from the callback
+     */
     findSourceByFuncsUserData(funcs, userData) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_find_source_by_funcs_user_data", [
             {
@@ -134,6 +239,21 @@ export class MainContext {
             return null;
         return getObject(ptr, Source);
     }
+    /**
+     * Finds a [struct@GLib.Source] given a pair of context and ID.
+     *
+     * It is a programmer error to attempt to look up a non-existent source.
+     *
+     * More specifically: source IDs can be reissued after a source has been
+     * destroyed and therefore it is never valid to use this function with a
+     * source ID which may have already been removed.  An example is when
+     * scheduling an idle to run in another thread with [func@GLib.idle_add]: the
+     * idle may already have run and been removed by the time this function
+     * is called on its (now invalid) source ID.  This source ID may have
+     * been reissued, leading to the operation being performed against the
+     * wrong source.
+     * @param sourceId - the source ID, as returned by [method@GLib.Source.get_id]
+     */
     findSourceById(sourceId) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_find_source_by_id", [
             {
@@ -152,6 +272,13 @@ export class MainContext {
         });
         return getObject(ptr, Source);
     }
+    /**
+     * Finds a source with the given user data for the callback.
+     *
+     * If multiple sources exist with the same user data, the first
+     * one found will be returned.
+     * @param userData - the user_data for the callback
+     */
     findSourceByUserData(userData) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_find_source_by_user_data", [
             {
@@ -173,6 +300,22 @@ export class MainContext {
             return null;
         return getObject(ptr, Source);
     }
+    /**
+     * Invokes a function in such a way that `context` is owned during the
+     * invocation of @function.
+     *
+     * This function is the same as [method@GLib.MainContext.invoke] except that it
+     * lets you specify the priority in case `function` ends up being
+     * scheduled as an idle and also lets you give a [callback@GLib.DestroyNotify]
+     * for @data.
+     *
+     * The `notify` function should not assume that it is called from any particular
+     * thread or with any particular context acquired.
+     * @param priority - the priority at which to run @function
+     * @param _function - function to call
+     * @param data - data to pass to @function
+     * @param notify - a function to call when `data` is no longer in use
+     */
     invokeFull(priority, _function, data, notify) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_invoke_full", [
             {
@@ -199,6 +342,14 @@ export class MainContext {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Determines whether this thread holds the (recursive)
+     * ownership of this [struct@GLib.MainContext].
+     *
+     * This is useful to
+     * know before waiting on another thread that may be
+     * blocking to get ownership of @context.
+     */
     isOwner() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_is_owner", [
             {
@@ -207,6 +358,22 @@ export class MainContext {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Runs a single iteration for the given main loop.
+     *
+     * This involves
+     * checking to see if any event sources are ready to be processed,
+     * then if no events sources are ready and `may_block` is true, waiting
+     * for a source to become ready, then dispatching the highest priority
+     * events sources that are ready. Otherwise, if `may_block` is false,
+     * this function does not wait for sources to become ready, and only the highest
+     * priority sources which are already ready (if any) will be dispatched.
+     *
+     * Note that even when `may_block` is true, it is still possible for
+     * [method@GLib.MainContext.iteration] to return false, since the wait may
+     * be interrupted for other reasons than an event source becoming ready.
+     * @param mayBlock - whether the call may block
+     */
     iteration(mayBlock) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_iteration", [
             {
@@ -219,6 +386,9 @@ export class MainContext {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if any sources have pending events for the given context.
+     */
     pending() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_pending", [
             {
@@ -227,6 +397,10 @@ export class MainContext {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Pops `context` off the thread-default context stack (verifying that
+     * it was on the top of the stack).
+     */
     popThreadDefault() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_pop_thread_default", [
             {
@@ -235,6 +409,16 @@ export class MainContext {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Prepares to poll sources within a main loop.
+     *
+     * The resulting information
+     * for polling is determined by calling [method@GLib.MainContext.query].
+     *
+     * You must have successfully acquired the context with
+     * [method@GLib.MainContext.acquire] before you may call this function.
+     * @param priority - location to store priority of highest priority
+     */
     prepare(priority) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_prepare", [
             {
@@ -251,6 +435,47 @@ export class MainContext {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Acquires `context` and sets it as the thread-default context for the
+     * current thread. This will cause certain asynchronous operations
+     * (such as most Gio-based I/O) which are
+     * started in this thread to run under `context` and deliver their
+     * results to its main loop, rather than running under the global
+     * default main context in the main thread. Note that calling this function
+     * changes the context returned by [func@GLib.MainContext.get_thread_default],
+     * not the one returned by [func@GLib.MainContext.default], so it does not
+     * affect the context used by functions like [func@GLib.idle_add].
+     *
+     * Normally you would call this function shortly after creating a new
+     * thread, passing it a [struct@GLib.MainContext] which will be run by a
+     * [struct@GLib.MainLoop] in that thread, to set a new default context for all
+     * async operations in that thread. In this case you may not need to
+     * ever call [method@GLib.MainContext.pop_thread_default], assuming you want
+     * the new [struct@GLib.MainContext] to be the default for the whole lifecycle
+     * of the thread.
+     *
+     * If you don’t have control over how the new thread was created (e.g.
+     * in the new thread isn’t newly created, or if the thread life
+     * cycle is managed by a #GThreadPool), it is always suggested to wrap
+     * the logic that needs to use the new [struct@GLib.MainContext] inside a
+     * [method@GLib.MainContext.push_thread_default] /
+     * [method@GLib.MainContext.pop_thread_default] pair, otherwise threads that
+     * are re-used will end up never explicitly releasing the
+     * [struct@GLib.MainContext] reference they hold.
+     *
+     * In some cases you may want to schedule a single operation in a
+     * non-default context, or temporarily use a non-default context in
+     * the main thread. In that case, you can wrap the call to the
+     * asynchronous operation inside a
+     * [method@GLib.MainContext.push_thread_default] /
+     * [method@GLib.MainContext.pop_thread_default] pair, but it is up to you to
+     * ensure that no other asynchronous operations accidentally get
+     * started while the non-default context is active.
+     *
+     * Beware that libraries that predate this function may not correctly
+     * handle being used from a thread with a thread-default context. For example,
+     * see `g_file_supports_thread_contexts()`.
+     */
     pushThreadDefault() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_push_thread_default", [
             {
@@ -259,6 +484,45 @@ export class MainContext {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Push `main_context` as the new thread-default main context for the current
+     * thread, using [method@GLib.MainContext.push_thread_default], and return a
+     * new [alias@GLib.MainContextPusher]. Pop with g_main_context_pusher_free().
+     * Using [method@GLib.MainContext.pop_thread_default] on `main_context` while a
+     * [alias@GLib.MainContextPusher] exists for it can lead to undefined behaviour.
+     *
+     * Using two [alias@GLib.MainContextPusher]s in the same scope is not allowed,
+     * as it leads to an undefined pop order.
+     *
+     * This is intended to be used with g_autoptr().  Note that g_autoptr()
+     * is only available when using GCC or clang, so the following example
+     * will only work with those compilers:
+     * |[
+     * typedef struct
+     * {
+     * ...
+     * GMainContext *context;
+     * ...
+     * } MyObject;
+     *
+     * static void
+     * my_object_do_stuff (MyObject *self)
+     * {
+     * g_autoptr(GMainContextPusher) pusher = g_main_context_pusher_new (self->context);
+     *
+     * // Code with main context as the thread default here
+     *
+     * if (cond)
+     * // No need to pop
+     * return;
+     *
+     * // Optionally early pop
+     * g_clear_pointer (&pusher, g_main_context_pusher_free);
+     *
+     * // Code with main context no longer the thread default here
+     * }
+     * ]|
+     */
     pusherNew() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_pusher_new", [
             {
@@ -267,6 +531,20 @@ export class MainContext {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Determines information necessary to poll this main loop.
+     *
+     * You should
+     * be careful to pass the resulting `fds` array and its length `n_fds` as-is when calling [method@GLib.MainContext.check], as this function relies
+     * on assumptions made when the array is filled.
+     *
+     * You must have successfully acquired the context with
+     * [method@GLib.MainContext.acquire] before you may call this function.
+     * @param maxPriority - maximum priority source to check
+     * @param timeout_ - location to store timeout to be used in polling
+     * @param fds - location to
+     * @param nFds - length of @fds
+     */
     query(maxPriority, timeout_, fds, nFds) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_query", [
             {
@@ -304,6 +582,9 @@ export class MainContext {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Increases the reference count on a [struct@GLib.MainContext] object by one.
+     */
     ref() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_ref", [
             {
@@ -318,6 +599,17 @@ export class MainContext {
         });
         return getObject(ptr, MainContext);
     }
+    /**
+     * Releases ownership of a context previously acquired by this thread
+     * with [method@GLib.MainContext.acquire].
+     *
+     * If the context was acquired multiple
+     * times, the ownership will be released only when [method@GLib.MainContext.release]
+     * is called as many times as it was acquired.
+     *
+     * You must have successfully acquired the context with
+     * [method@GLib.MainContext.acquire] before you may call this function.
+     */
     release() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_release", [
             {
@@ -326,6 +618,11 @@ export class MainContext {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes file descriptor from the set of file descriptors to be
+     * polled for a particular context.
+     * @param fd - a [struct@GLib.PollFD] descriptor previously added with
+     */
     removePoll(fd) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_remove_poll", [
             {
@@ -343,6 +640,11 @@ export class MainContext {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Decreases the reference count on a [struct@GLib.MainContext] object by one.
+     * If
+     * the result is zero, free the context and free all associated memory.
+     */
     unref() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_unref", [
             {
@@ -351,6 +653,17 @@ export class MainContext {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Tries to become the owner of the specified context, and waits on `cond` if
+     * another thread is the owner.
+     *
+     * This is the same as [method@GLib.MainContext.acquire], but if another thread
+     * is the owner, atomically drop `mutex` and wait on `cond` until
+     * that owner releases ownership or until `cond` is signaled, then
+     * try again (once) to become the owner.
+     * @param cond - a condition variable
+     * @param mutex - a mutex, currently held
+     */
     wait(cond, mutex) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_wait", [
             {
@@ -367,6 +680,39 @@ export class MainContext {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Wake up `context` if it’s currently blocking in
+     * [method@GLib.MainContext.iteration], causing it to stop blocking.
+     *
+     * The `context` could be blocking waiting for a source to become ready.
+     * Otherwise, if `context` is not currently blocking, this function causes the
+     * next invocation of [method@GLib.MainContext.iteration] to return without
+     * blocking.
+     *
+     * This API is useful for low-level control over [struct@GLib.MainContext]; for
+     * example, integrating it with main loop implementations such as
+     * [struct@GLib.MainLoop].
+     *
+     * Another related use for this function is when implementing a main
+     * loop with a termination condition, computed from multiple threads:
+     *
+     * ```c
+     * #define NUM_TASKS 10
+     * static gint tasks_remaining = NUM_TASKS;  // (atomic)
+     * ...
+     *
+     * while (g_atomic_int_get (&tasks_remaining) != 0)
+     * g_main_context_iteration (NULL, TRUE);
+     * ```
+     *
+     * Then in a thread:
+     * ```c
+     * perform_work ();
+     *
+     * if (g_atomic_int_dec_and_test (&tasks_remaining))
+     * g_main_context_wakeup (NULL);
+     * ```
+     */
     wakeup() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_context_wakeup", [
             {

package/dist/generated/glib/main-loop.d.ts

@@ -1,13 +1,51 @@
 import { MainContext } from "./main-context.js";
+/**
+ * The `GMainLoop` struct is an opaque data type
+ * representing the main event loop of a GLib or GTK application.
+ */
 export declare class MainLoop {
     ptr: unknown;
+    /**
+     * Creates a new [struct@GLib.MainLoop] structure.
+     * @param context - a main context  (if `NULL`, the global-default
+     * @param isRunning - set to true to indicate that the loop is running. This
+     */
     constructor(isRunning: boolean, context?: MainContext | null);
     constructor(_args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns the [struct@GLib.MainContext] of @loop.
+     */
     getContext(): MainContext;
+    /**
+     * Checks to see if the main loop is currently being run via
+     * [method@GLib.MainLoop.run].
+     */
     isRunning(): boolean;
+    /**
+     * Stops a [struct@GLib.MainLoop] from running. Any calls to
+     * [method@GLib.MainLoop.run] for the loop will return.
+     *
+     * Note that sources that have already been dispatched when
+     * [method@GLib.MainLoop.quit] is called will still be executed.
+     */
     quit(): void;
+    /**
+     * Increases the reference count on a [struct@GLib.MainLoop] object by one.
+     */
     ref(): MainLoop;
+    /**
+     * Runs a main loop until [method@GLib.MainLoop.quit] is called on the loop.
+     *
+     * If this is called from the thread of the loop’s [struct@GLib.MainContext],
+     * it will process events from the loop, otherwise it will
+     * simply wait.
+     */
     run(): void;
+    /**
+     * Decreases the reference count on a [struct@GLib.MainLoop] object by one.
+     *
+     * If the result is zero, the loop and all associated memory are freed.
+     */
     unref(): void;
 }

package/dist/generated/glib/main-loop.js

@@ -1,6 +1,10 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { MainContext } from "./main-context.js";
+/**
+ * The `GMainLoop` struct is an opaque data type
+ * representing the main event loop of a GLib or GTK application.
+ */
 export class MainLoop {
     ptr;
     constructor(...args) {
@@ -26,6 +30,9 @@ export class MainLoop {
             },
         ], { type: "boxed", borrowed: true, innerType: "GMainLoop" });
     }
+    /**
+     * Returns the [struct@GLib.MainContext] of @loop.
+     */
     getContext() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_loop_get_context", [
             {
@@ -40,6 +47,10 @@ export class MainLoop {
         });
         return getObject(ptr, MainContext);
     }
+    /**
+     * Checks to see if the main loop is currently being run via
+     * [method@GLib.MainLoop.run].
+     */
     isRunning() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_loop_is_running", [
             {
@@ -48,6 +59,13 @@ export class MainLoop {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Stops a [struct@GLib.MainLoop] from running. Any calls to
+     * [method@GLib.MainLoop.run] for the loop will return.
+     *
+     * Note that sources that have already been dispatched when
+     * [method@GLib.MainLoop.quit] is called will still be executed.
+     */
     quit() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_loop_quit", [
             {
@@ -56,6 +74,9 @@ export class MainLoop {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Increases the reference count on a [struct@GLib.MainLoop] object by one.
+     */
     ref() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_loop_ref", [
             {
@@ -70,6 +91,13 @@ export class MainLoop {
         });
         return getObject(ptr, MainLoop);
     }
+    /**
+     * Runs a main loop until [method@GLib.MainLoop.quit] is called on the loop.
+     *
+     * If this is called from the thread of the loop’s [struct@GLib.MainContext],
+     * it will process events from the loop, otherwise it will
+     * simply wait.
+     */
     run() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_loop_run", [
             {
@@ -78,6 +106,11 @@ export class MainLoop {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Decreases the reference count on a [struct@GLib.MainLoop] object by one.
+     *
+     * If the result is zero, the loop and all associated memory are freed.
+     */
     unref() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_main_loop_unref", [
             {