Struct DelegateExpressionFfi 

pub struct DelegateExpressionFfi { /* private fields */ }

Foreign function interface for composition animations based on calling closures.

Functions are overloaded by name, argument count and argument types. A call first looks for an overload whose parameter types are exactly the argument types, in registration order; then for one reachable by widening single-precision vector arguments to the double-precision vector types; then for one reachable by converting between the two vector families in either direction.

Names are compared exactly, or ignoring ASCII case for a registry created with DelegateExpressionFfi::new_ignoring_case.

Implementations

impl DelegateExpressionFfi

pub fn new() -> Self

Creates an empty registry whose function names are case-sensitive.

pub fn new_ignoring_case() -> Self

Creates an empty registry whose function names are compared ignoring ASCII case (lerp calls the function registered as Lerp), as the functions of WinUI composition expressions are.

pub fn add0<R, F>(&mut self, name: &str, cb: F)

where R: Into<ExpressionVariant>, F: Fn() -> R + Send + Sync + 'static,

Registers a function without parameters.

pub fn add1<T1, R, F>(&mut self, name: &str, cb: F)

where T1: ExpressionVariantValue, R: Into<ExpressionVariant>, F: Fn(T1) -> R + Send + Sync + 'static,

Registers a function with one parameter.

pub fn add2<T1, T2, R, F>(&mut self, name: &str, cb: F)

where T1: ExpressionVariantValue, T2: ExpressionVariantValue, R: Into<ExpressionVariant>, F: Fn(T1, T2) -> R + Send + Sync + 'static,

Registers a function with two parameters.

pub fn add3<T1, T2, T3, R, F>(&mut self, name: &str, cb: F)

where T1: ExpressionVariantValue, T2: ExpressionVariantValue, T3: ExpressionVariantValue, R: Into<ExpressionVariant>, F: Fn(T1, T2, T3) -> R + Send + Sync + 'static,

Registers a function with three parameters.

pub fn add4<T1, T2, T3, T4, R, F>(&mut self, name: &str, cb: F)

where T1: ExpressionVariantValue, T2: ExpressionVariantValue, T3: ExpressionVariantValue, T4: ExpressionVariantValue, R: Into<ExpressionVariant>, F: Fn(T1, T2, T3, T4) -> R + Send + Sync + 'static,

Registers a function with four parameters.

pub fn add5<T1, T2, T3, T4, T5, R, F>(&mut self, name: &str, cb: F)

where T1: ExpressionVariantValue, T2: ExpressionVariantValue, T3: ExpressionVariantValue, T4: ExpressionVariantValue, T5: ExpressionVariantValue, R: Into<ExpressionVariant>, F: Fn(T1, T2, T3, T4, T5) -> R + Send + Sync + 'static,

Registers a function with five parameters.

pub fn add6<T1, T2, T3, T4, T5, T6, R, F>(&mut self, name: &str, cb: F)

where T1: ExpressionVariantValue, T2: ExpressionVariantValue, T3: ExpressionVariantValue, T4: ExpressionVariantValue, T5: ExpressionVariantValue, T6: ExpressionVariantValue, R: Into<ExpressionVariant>, F: Fn(T1, T2, T3, T4, T5, T6) -> R + Send + Sync + 'static,

Registers a function with six parameters.

The reference implementation reads the sixth parameter from the fifth argument; here each parameter reads its own argument, so Matrix3x2(m11, m12, m21, m22, m31, m32) builds the matrix WinUI builds.

pub fn add16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R, F>( &mut self, name: &str, cb: F, )

where T1: ExpressionVariantValue, T2: ExpressionVariantValue, T3: ExpressionVariantValue, T4: ExpressionVariantValue, T5: ExpressionVariantValue, T6: ExpressionVariantValue, T7: ExpressionVariantValue, T8: ExpressionVariantValue, T9: ExpressionVariantValue, T10: ExpressionVariantValue, T11: ExpressionVariantValue, T12: ExpressionVariantValue, T13: ExpressionVariantValue, T14: ExpressionVariantValue, T15: ExpressionVariantValue, T16: ExpressionVariantValue, R: Into<ExpressionVariant>, F: Fn(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R + Send + Sync + 'static,

Registers a function with sixteen parameters.

The reference implementation reads the sixth to sixteenth parameters from the fifth argument; here each parameter reads its own argument, as Matrix4x4(m11, ..., m44) of WinUI needs.

Trait Implementations

impl Default for DelegateExpressionFfi

fn default() -> Self

Returns the “default value” for a type.

impl IExpressionForeignFunctionInterface for DelegateExpressionFfi

fn call( &self, name: &str, arguments: &[ExpressionVariant], ) -> Option<ExpressionVariant>

Calls the function with the given name and arguments. Returns None when there is no function with that name accepting the arguments.