Struct Signal

pub struct Signal { /* private fields */ }

Expand description

Untyped Godot signal.

Signals are composed of a pointer to an Object and the name of the signal on this object.

In Rust, you might want to work with type-safe signals, available under the TypedSignal struct.

§Godot docs

Signal (stable)

Implementations§

§

impl Signal

pub fn from_object_signal<T, S>(object: &Gd<T>, signal_name: S) -> Signal
where T: GodotClass, S: AsArg<StringName>,

Create a signal for the signal object::signal_name.

Godot equivalent: Signal(Object object, StringName signal)

pub fn invalid() -> Signal

Creates an invalid/empty signal that cannot be called.

Godot equivalent: Signal()

pub fn connect(&self, callable: &Callable) -> Error

Connect signal to a callable.

To provide flags, see connect_flags().

pub fn connect_flags(&self, callable: &Callable, flags: ConnectFlags) -> Error

Connect signal to a callable, customizing with flags.

Optional flags can be also added to configure the connection’s behavior (see ConnectFlags constants). You can provide additional arguments to the connected callable by using Callable::bind.

A signal can only be connected once to the same Callable. If the signal is already connected, returns Error::ERR_INVALID_PARAMETER and pushes an error message, unless the signal is connected with ConnectFlags::REFERENCE_COUNTED. To prevent this, check for existing connections with is_connected().

pub fn disconnect(&self, callable: &Callable)

Disconnects this signal from the specified Callable.

If the connection does not exist, generates an error. Use is_connected() to make sure that the connection exists.

pub fn emit(&self, varargs: &[Variant])

Emits this signal.

All Callables connected to this signal will be triggered.

pub fn connections(&self) -> Array<Dictionary>

Returns an Array of connections for this signal.

Each connection is represented as a Dictionary that contains three entries:

signal is a reference to this Signal;
callable is a reference to the connected Callable;
flags is a combination of ConnectFlags.

Godot equivalent: get_connections

pub fn name(&self) -> StringName

Returns the name of the signal.

pub fn object(&self) -> Option<Gd<Object>>

Returns the object to which this signal belongs.

Returns None when this signal doesn’t have any object, or the object is dead. You can differentiate these two situations using object_id().

Godot equivalent: get_object

pub fn object_id(&self) -> Option<InstanceId>

Returns the ID of this signal’s object, see also Gd::instance_id.

Returns None when this signal doesn’t have any object.

If the pointed-to object is dead, the ID will still be returned. Use object() to check for liveness.

Godot equivalent: get_object_id

pub fn is_connected(&self, callable: &Callable) -> bool

Returns true if the specified Callable is connected to this signal.

pub fn is_null(&self) -> bool

Returns true if the signal’s name does not exist in its object, or the object is not valid.

§

impl Signal

pub fn to_fallible_future<R>(&self) -> FallibleSignalFuture<R> ⓘ
where R: InParamTuple + IntoDynamicSend,

Creates a fallible future for this signal.

The future will resolve the next time the signal is emitted. See FallibleSignalFuture for details.

Since the Signal type does not contain information on the signal argument types, the future output type has to be inferred from the call to this function.

pub fn to_future<R>(&self) -> SignalFuture<R> ⓘ
where R: InParamTuple + IntoDynamicSend,

Creates a future for this signal.

The future will resolve the next time the signal is emitted, but might panic if the signal object is freed. See SignalFuture for details.

Since the Signal type does not contain information on the signal argument types, the future output type has to be inferred from the call to this function.