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

function Wp.Core.prototype.clone(): {
    // javascript wrapper for 'wp_core_clone'
}

Clones a core with the same context as self

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_g_main_context

function Wp.Core.prototype.get_g_main_context(): {
    // javascript wrapper for 'wp_core_get_g_main_context'
}

Wp.Core.prototype.get_properties

function Wp.Core.prototype.get_properties(): {
    // javascript wrapper for 'wp_core_get_properties'
}

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

function Wp.Core.prototype.get_remote_cookie(): {
    // javascript wrapper for 'wp_core_get_remote_cookie'
}

Wp.Core.prototype.get_remote_host_name

function Wp.Core.prototype.get_remote_host_name(): {
    // javascript wrapper for 'wp_core_get_remote_host_name'
}

Wp.Core.prototype.get_remote_name

function Wp.Core.prototype.get_remote_name(): {
    // javascript wrapper for 'wp_core_get_remote_name'
}

Wp.Core.prototype.get_remote_properties

function Wp.Core.prototype.get_remote_properties(): {
    // javascript wrapper for 'wp_core_get_remote_properties'
}

Wp.Core.prototype.get_remote_user_name

function Wp.Core.prototype.get_remote_user_name(): {
    // javascript wrapper for 'wp_core_get_remote_user_name'
}

Wp.Core.prototype.get_remote_version

function Wp.Core.prototype.get_remote_version(): {
    // javascript wrapper for 'wp_core_get_remote_version'
}

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.

Wp.Core.prototype.update_properties

function Wp.Core.prototype.update_properties(updates: Wp.Properties): {
    // javascript wrapper for 'wp_core_update_properties'
}

Updates the properties of self on the connection, making them appear on the client object that represents this connection.

If self is not connected yet, these properties are stored and passed to pw_context_connect when connecting.

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

g-main-context

“g-main-context” GLib.MainContext

Flags : Read / Write / Construct Only

properties

“properties” Wp.Properties

Flags : Read / Write / Construct Only

pw-context

“pw-context” Object

Flags : Read / Write / Construct Only

pw-core

“pw-core” Object

Flags : Read