Struct sixtyfps_corelib::Property
source · [−]#[repr(C)]pub struct Property<T> { /* private fields */ }
Expand description
A Property that allow binding that track changes
Property van have be assigned value, or bindings.
When a binding is assigned, it is lazily evaluated on demand
when calling get()
.
When accessing another property from a binding evaluation,
a dependency will be registered, such that when the property
change, the binding will automatically be updated
Implementations
Get the value of the property
This may evaluate the binding if there is a binding and it is dirty
If the function is called directly or indirectly from a binding evaluation of another Property, a dependency will be registered.
Panics if this property is get while evaluating its own binding or cloning the value.
Same as get() but without registering a dependency
This allow to optimize bindings that know that they might not need to re_evaluate themselves when the property change or that have registered the dependency in another way.
Example
use std::rc::Rc;
use sixtyfps_corelib::Property;
let prop1 = Rc::pin(Property::new(100));
let prop2 = Rc::pin(Property::<i32>::default());
prop2.as_ref().set_binding({
let prop1 = prop1.clone(); // in order to move it into the closure.
move || { prop1.as_ref().get_untracked() + 30 }
});
assert_eq!(prop2.as_ref().get(), 130);
prop1.set(200);
// changing prop1 do not affect the prop2 binding because no dependency was registered
assert_eq!(prop2.as_ref().get(), 130);
Change the value of this property
If other properties have binding depending of this property, these properties will be marked as dirty.
Set a binding to this property.
Bindings are evaluated lazily from calling get, and the return value of the binding is the new value.
If other properties have bindings depending of this property, these properties will be marked as dirty.
Closures of type Fn()->T
implements Binding
Example
use std::rc::Rc;
use sixtyfps_corelib::Property;
let prop1 = Rc::pin(Property::new(100));
let prop2 = Rc::pin(Property::<i32>::default());
prop2.as_ref().set_binding({
let prop1 = prop1.clone(); // in order to move it into the closure.
move || { prop1.as_ref().get() + 30 }
});
assert_eq!(prop2.as_ref().get(), 130);
prop1.set(200);
// A change in prop1 forced the binding on prop2 to re_evaluate
assert_eq!(prop2.as_ref().get(), 230);
Any of the properties accessed during the last evaluation of the closure called from the last call to evaluate is potentially dirty.
Internal function to mark the property as dirty and notify dependencies, regardless of whether the property value has actually changed or not.
Mark that this property will never be modified again and that no tracking should be done
Change the value of this property, by animating (interpolating) from the current property’s value to the specified parameter value. The animation is done according to the parameters described by the PropertyAnimation object.
If other properties have binding depending of this property, these properties will be marked as dirty.
pub fn set_animated_binding(
&self,
binding: impl Binding<T> + 'static,
animation_data: PropertyAnimation
)
pub fn set_animated_binding(
&self,
binding: impl Binding<T> + 'static,
animation_data: PropertyAnimation
)
Set a binding to this property.
pub fn set_animated_binding_for_transition(
&self,
binding: impl Binding<T> + 'static,
compute_animation_details: impl Fn() -> (PropertyAnimation, Instant) + 'static
)
pub fn set_animated_binding_for_transition(
&self,
binding: impl Binding<T> + 'static,
compute_animation_details: impl Fn() -> (PropertyAnimation, Instant) + 'static
)
Set a binding to this property, providing a callback for the transition animation