WpCore

WpCore

GObject
    ╰──WpCore

Wp.Core.prototype.new

function Wp.Core.prototype.new(context: GLib.MainContext, properties: Wp.Properties): {
    // javascript wrapper for 'wp_core_new'
}

Wp.Core.prototype.connect

function Wp.Core.prototype.connect(): {
    // javascript wrapper for 'wp_core_connect'
}

Connects this core to the PipeWire server. When connection succeeds, the connected signal is emitted

Wp.Core.prototype.disconnect

function Wp.Core.prototype.disconnect(): {
    // javascript wrapper for 'wp_core_disconnect'
}

Disconnects this core from the PipeWire server. This also effectively destroys all Wp.Proxy objects that were created through the registry, destroys the pw_core and finally emits the disconnected signal.

Wp.Core.prototype.get_context

function Wp.Core.prototype.get_context(): {
    // javascript wrapper for 'wp_core_get_context'
}

Wp.Core.prototype.get_pw_context

function Wp.Core.prototype.get_pw_context(): {
    // javascript wrapper for 'wp_core_get_pw_context'
}

Wp.Core.prototype.get_pw_core

function Wp.Core.prototype.get_pw_core(): {
    // javascript wrapper for 'wp_core_get_pw_core'
}

Wp.Core.prototype.idle_add

function Wp.Core.prototype.idle_add(function: GLib.SourceFunc, data: Object): {
    // javascript wrapper for 'wp_core_idle_add'
}

Adds an idle callback to be called in the same GLib.MainContext as the one used by this core. This is essentially the same as GLib.prototype.idle_add_full, but it adds the created GLib.Source on the GLib.MainContext used by this core instead of the default context.

Wp.Core.prototype.idle_add_closure

function Wp.Core.prototype.idle_add_closure(closure: GObject.Closure): {
    // javascript wrapper for 'wp_core_idle_add_closure'
}

Adds an idle callback to be called in the same GLib.MainContext as the one used by this core.

This is the same as Wp.Core.prototype.idle_add, but it allows you to specify a GObject.Closure instead of a C callback.

Wp.Core.prototype.install_object_manager

function Wp.Core.prototype.install_object_manager(om: Wp.ObjectManager): {
    // javascript wrapper for 'wp_core_install_object_manager'
}

Installs the object manager on this core, activating its internal management engine. This will immediately emit signals about objects added on om if objects that the om is interested in were in existence already.

Wp.Core.prototype.is_connected

function Wp.Core.prototype.is_connected(): {
    // javascript wrapper for 'wp_core_is_connected'
}

Wp.Core.prototype.sync

function Wp.Core.prototype.sync(cancellable: Gio.Cancellable, callback: Gio.AsyncReadyCallback, user_data: Object): {
    // javascript wrapper for 'wp_core_sync'
}

Asks the PipeWire server to call the callback via an event.

Since methods are handled in-order and events are delivered in-order, this can be used as a barrier to ensure all previous methods and the resulting events have been handled.

In both success and error cases, callback is always called. Use Wp.Core.prototype.sync_finish from within the callback to determine whether the operation completed successfully or if an error occurred.

Wp.Core.prototype.sync_finish

function Wp.Core.prototype.sync_finish(res: Gio.AsyncResult): {
    // javascript wrapper for 'wp_core_sync_finish'
}

This function is meant to be called from within the callback of Wp.Core.prototype.sync in order to determine the success or failure of the operation.

Wp.Core.prototype.timeout_add

function Wp.Core.prototype.timeout_add(timeout_ms: Number, function: GLib.SourceFunc, data: Object): {
    // javascript wrapper for 'wp_core_timeout_add'
}

Adds a timeout callback to be called at regular intervals in the same GLib.MainContext as the one used by this core. The function is called repeatedly until it returns FALSE, at which point the timeout is automatically destroyed and the function will not be called again. The first call to the function will be at the end of the first interval. This is essentially the same as GLib.prototype.timeout_add_full, but it adds the created GLib.Source on the GLib.MainContext used by this core instead of the default context.

Wp.Core.prototype.timeout_add_closure

function Wp.Core.prototype.timeout_add_closure(timeout_ms: Number, closure: GObject.Closure): {
    // javascript wrapper for 'wp_core_timeout_add_closure'
}

Adds a timeout callback to be called at regular intervals in the same GLib.MainContext as the one used by this core.

This is the same as Wp.Core.prototype.timeout_add, but it allows you to specify a GObject.Closure instead of a C callback.

connected

function connected_callback(self: Wp.Core, user_data: Object): {
    // javascript callback for the 'connected' signal
}

Emitted when the core is successfully connected to the PipeWire server

Flags: Run Last

disconnected

function disconnected_callback(self: Wp.Core, user_data: Object): {
    // javascript callback for the 'disconnected' signal
}

Emitted when the core is disconnected from the PipeWire server

Flags: Run Last

context

“context” GLib.MainContext

Flags : Read / Write / Construct Only

properties

“properties” Wp.Properties

Flags : Read / Write / Construct Only

pw-context

“pw-context” Object

Flags : Read

pw-core

“pw-core” Object

Flags : Read