Animate Bindings Reactivity (slint-ui#10387)

* Add test case for reactive Animate bindings

See issue slint-ui#348

* Add C++ test case for animate bindings reactivity

* Fix animted property bindings for C++ and Rust

* Fix animate bindings reactivity in interpreter

* Use optional start time instead of current_tick

This avoids re-evaluating the PropertyAnimation during the mark_dirty
function and re-evaluates it on the first call to evaluate.

* Remove set_animated_binding

This has been replaced by set_animated_binding_for_transition

* Rename set_animated_binding_for_transation to set_animated_binding

* Revert Animation::Transition to a single CodeBlock

The `state` variable is referenced by both expressions, so using a
single CodeBlock is easier.
In the generated code, use tuple destructuring to convert the Instant to
an Option<Instant>.

* Fix set_animated_binding unit tests

Author: LeonMatthes

api/cpp/include/slint_properties.h

@@ -23,41 +23,37 @@ using cbindgen_private::StateInfo;
 inline void slint_property_set_animated_binding_helper(
         const cbindgen_private::PropertyHandleOpaque *handle, void (*binding)(void *, int *),
         void *user_data, void (*drop_user_data)(void *),
-        const cbindgen_private::PropertyAnimation *animation_data,
-        cbindgen_private::PropertyAnimation (*transition_data)(void *, uint64_t *))
+        cbindgen_private::PropertyAnimation (*transition_data)(void *, uint64_t **))
 {
-    cbindgen_private::slint_property_set_animated_binding_int(
-            handle, binding, user_data, drop_user_data, animation_data, transition_data);
+    cbindgen_private::slint_property_set_animated_binding_int(handle, binding, user_data,
+                                                              drop_user_data, transition_data);
 }
 
 inline void slint_property_set_animated_binding_helper(
         const cbindgen_private::PropertyHandleOpaque *handle, void (*binding)(void *, float *),
         void *user_data, void (*drop_user_data)(void *),
-        const cbindgen_private::PropertyAnimation *animation_data,
-        cbindgen_private::PropertyAnimation (*transition_data)(void *, uint64_t *))
+        cbindgen_private::PropertyAnimation (*transition_data)(void *, uint64_t **))
 {
-    cbindgen_private::slint_property_set_animated_binding_float(
-            handle, binding, user_data, drop_user_data, animation_data, transition_data);
+    cbindgen_private::slint_property_set_animated_binding_float(handle, binding, user_data,
+                                                                drop_user_data, transition_data);
 }
 
 inline void slint_property_set_animated_binding_helper(
         const cbindgen_private::PropertyHandleOpaque *handle, void (*binding)(void *, Color *),
         void *user_data, void (*drop_user_data)(void *),
-        const cbindgen_private::PropertyAnimation *animation_data,
-        cbindgen_private::PropertyAnimation (*transition_data)(void *, uint64_t *))
+        cbindgen_private::PropertyAnimation (*transition_data)(void *, uint64_t **))
 {
-    cbindgen_private::slint_property_set_animated_binding_color(
-            handle, binding, user_data, drop_user_data, animation_data, transition_data);
+    cbindgen_private::slint_property_set_animated_binding_color(handle, binding, user_data,
+                                                                drop_user_data, transition_data);
 }
 
 inline void slint_property_set_animated_binding_helper(
         const cbindgen_private::PropertyHandleOpaque *handle, void (*binding)(void *, Brush *),
         void *user_data, void (*drop_user_data)(void *),
-        const cbindgen_private::PropertyAnimation *animation_data,
-        cbindgen_private::PropertyAnimation (*transition_data)(void *, uint64_t *))
+        cbindgen_private::PropertyAnimation (*transition_data)(void *, uint64_t **))
 {
-    cbindgen_private::slint_property_set_animated_binding_brush(
-            handle, binding, user_data, drop_user_data, animation_data, transition_data);
+    cbindgen_private::slint_property_set_animated_binding_brush(handle, binding, user_data,
+                                                                drop_user_data, transition_data);
 }
 
 template<typename T>
@@ -106,21 +102,9 @@ struct Property
 
     inline void set_animated_value(const T &value,
                                    const cbindgen_private::PropertyAnimation &animation_data) const;
-    template<typename F>
-    inline void
-    set_animated_binding(F binding, const cbindgen_private::PropertyAnimation &animation_data) const
-    {
-        private_api::slint_property_set_animated_binding_helper(
-                &inner,
-                [](void *user_data, T *value) {
-                    *reinterpret_cast<T *>(value) = (*reinterpret_cast<F *>(user_data))();
-                },
-                new F(binding), [](void *user_data) { delete reinterpret_cast<F *>(user_data); },
-                &animation_data, nullptr);
-    }
 
     template<typename F, typename Trans>
-    inline void set_animated_binding_for_transition(F binding, Trans animation) const
+    inline void set_animated_binding(F binding, Trans animation) const
     {
         struct UserData
         {
@@ -134,8 +118,8 @@ struct Property
                             reinterpret_cast<UserData *>(user_data)->binding();
                 },
                 new UserData { binding, animation },
-                [](void *user_data) { delete reinterpret_cast<UserData *>(user_data); }, nullptr,
-                [](void *user_data, uint64_t *instant) {
+                [](void *user_data) { delete reinterpret_cast<UserData *>(user_data); },
+                [](void *user_data, uint64_t **instant) {
                     return reinterpret_cast<UserData *>(user_data)->animation(instant);
                 });
     }

api/rs/slint/private_unstable_api.rs

@@ -67,33 +67,18 @@ pub fn set_property_binding<
 pub fn set_animated_property_binding<
     T: Clone + i_slint_core::properties::InterpolatedPropertyValue + 'static,
     StrongRef: StrongItemTreeRef + 'static,
->(
-    property: Pin<&Property<T>>,
-    component_strong: &StrongRef,
-    binding: fn(StrongRef) -> T,
-    animation_data: PropertyAnimation,
-) {
-    let weak = component_strong.to_weak();
-    property.set_animated_binding(
-        move || binding(<StrongRef as StrongItemTreeRef>::from_weak(&weak).unwrap()),
-        animation_data,
-    )
-}
-
-pub fn set_animated_property_binding_for_transition<
-    T: Clone + i_slint_core::properties::InterpolatedPropertyValue + 'static,
-    StrongRef: StrongItemTreeRef + 'static,
 >(
     property: Pin<&Property<T>>,
     component_strong: &StrongRef,
     binding: fn(StrongRef) -> T,
     compute_animation_details: fn(
         StrongRef,
-    ) -> (PropertyAnimation, i_slint_core::animations::Instant),
+    )
+        -> (PropertyAnimation, Option<i_slint_core::animations::Instant>),
 ) {
     let weak_1 = component_strong.to_weak();
     let weak_2 = weak_1.clone();
-    property.set_animated_binding_for_transition(
+    property.set_animated_binding(
         move || binding(<StrongRef as StrongItemTreeRef>::from_weak(&weak_1).unwrap()),
         move || {
             compute_animation_details(<StrongRef as StrongItemTreeRef>::from_weak(&weak_2).unwrap())
@@ -186,7 +171,7 @@ pub mod re_exports {
     pub use i_slint_core::accessibility::{
         AccessibilityAction, AccessibleStringProperty, SupportedAccessibilityAction,
     };
-    pub use i_slint_core::animations::{EasingCurve, animation_tick};
+    pub use i_slint_core::animations::{EasingCurve, animation_tick, current_tick};
     pub use i_slint_core::api::{LogicalPosition, StyledText};
     pub use i_slint_core::callbacks::Callback;
     pub use i_slint_core::date_time::*;

internal/compiler/generator/cpp.rs

@@ -669,19 +669,26 @@ fn handle_property_init(
                 match &binding_expression.animation {
                     Some(llr::Animation::Static(anim)) => {
                         let anim = compile_expression(anim, ctx);
-                        format!("{prop_access}.set_animated_binding({binding_code}, {anim});")
+                        // Note: The start_time defaults to the current tick, so doesn't need to be
+                        // udpated here.
+                        format!("{prop_access}.set_animated_binding({binding_code},
+                                [this](uint64_t **start_time) -> slint::cbindgen_private::PropertyAnimation {{
+                                    [[maybe_unused]] auto self = this;
+                                    auto anim = {anim};
+                                    *start_time = nullptr;
+                                    return anim;
+                                }});",
+                                )
                     }
-                    Some(llr::Animation::Transition (
-                        anim
-                    )) => {
-                        let anim = compile_expression(anim, ctx);
+                    Some(llr::Animation::Transition(animation)) => {
+                        let animation = compile_expression(animation, ctx);
                         format!(
-                            "{prop_access}.set_animated_binding_for_transition({binding_code},
-                            [this](uint64_t *start_time) -> slint::cbindgen_private::PropertyAnimation {{
+                            "{prop_access}.set_animated_binding({binding_code},
+                            [this](uint64_t **start_time) -> slint::cbindgen_private::PropertyAnimation {{
                                 [[maybe_unused]] auto self = this;
-                                auto [anim, time] = {anim};
-                                *start_time = time;
-                                return anim;
+                                auto [animation, change_time] = {animation};
+                                **start_time = change_time;
+                                return animation;
                             }});",
                         )
                     }

internal/compiler/generator/rust.rs

@@ -633,16 +633,21 @@ fn handle_property_init(
                         let anim = compile_expression(anim, ctx);
                         quote! { {
                             #init_self_pin_ref
-                            slint::private_unstable_api::set_animated_property_binding(#rust_property, &self_rc, #binding_tokens, #anim);
+                            slint::private_unstable_api::set_animated_property_binding(
+                                #rust_property, &self_rc, #binding_tokens, move |self_rc| {
+                                    #init_self_pin_ref
+                                    (#anim, None)
+                                });
                         } }
                     }
-                    Some(llr::Animation::Transition(anim)) => {
-                        let anim = compile_expression(anim, ctx);
+                    Some(llr::Animation::Transition(animation)) => {
+                        let animation = compile_expression(animation, ctx);
                         quote! {
-                            slint::private_unstable_api::set_animated_property_binding_for_transition(
+                            slint::private_unstable_api::set_animated_property_binding(
                                 #rust_property, &self_rc, #binding_tokens, move |self_rc| {
                                     #init_self_pin_ref
-                                    #anim
+                                    let (animation, change_time) = #animation;
+                                    (animation, Some(change_time))
                                 }
                             );
                         }

internal/compiler/llr/optim_passes/count_property_use.rs

@@ -159,7 +159,7 @@ fn visit_binding_expression(binding: &BindingExpression, ctx: &EvaluationContext
     binding.expression.borrow().visit_property_references(ctx, &mut visit_property);
     match &binding.animation {
         Some(Animation::Static(e) | Animation::Transition(e)) => {
-            e.visit_property_references(ctx, &mut visit_property)
+            e.visit_property_references(ctx, &mut visit_property);
         }
         None => (),
     }

internal/compiler/llr/optim_passes/remove_unused.rs

@@ -501,9 +501,8 @@ mod visitor {
     ) {
         visit_expression(expression.get_mut(), scope, state, visitor);
         match animation {
-            Some(Animation::Static(anim)) => visit_expression(anim, scope, state, visitor),
-            Some(Animation::Transition(anim)) => {
-                visit_expression(anim, scope, state, visitor);
+            Some(Animation::Static(anim) | Animation::Transition(anim)) => {
+                visit_expression(anim, scope, state, visitor)
             }
             None => (),
         }

internal/core/properties/ffi.rs

@@ -261,10 +261,10 @@ unsafe fn c_set_animated_binding<T: InterpolatedPropertyValue + Clone>(
     binding: extern "C" fn(*mut c_void, *mut T),
     user_data: *mut c_void,
     drop_user_data: Option<extern "C" fn(*mut c_void)>,
-    animation_data: Option<&PropertyAnimation>,
-    transition_data: Option<
-        extern "C" fn(user_data: *mut c_void, start_instant: &mut u64) -> PropertyAnimation,
-    >,
+    transition_data: extern "C" fn(
+        user_data: *mut c_void,
+        start_instant: &mut *mut u64,
+    ) -> PropertyAnimation,
 ) {
     unsafe {
         let binding = core::mem::transmute::<
@@ -286,27 +286,31 @@ unsafe fn c_set_animated_binding<T: InterpolatedPropertyValue + Clone>(
         let animation_data = RefCell::new(properties_animations::PropertyValueAnimationData::new(
             T::default(),
             T::default(),
-            animation_data.cloned().unwrap_or_default(),
+            PropertyAnimation::default(),
         ));
-        if let Some(transition_data) = transition_data {
-            handle.0.set_binding(properties_animations::AnimatedBindingCallable::<T, _> {
-                original_binding,
-                state: Cell::new(properties_animations::AnimatedBindingState::NotAnimating),
-                animation_data,
-                compute_animation_details: move || -> properties_animations::AnimationDetail {
-                    let mut start_instant = 0;
-                    let anim = transition_data(user_data, &mut start_instant);
-                    Some((anim, crate::animations::Instant(start_instant)))
-                },
-            });
-        } else {
-            handle.0.set_binding(properties_animations::AnimatedBindingCallable::<T, _> {
-                original_binding,
-                state: Cell::new(properties_animations::AnimatedBindingState::NotAnimating),
-                animation_data,
-                compute_animation_details: || -> properties_animations::AnimationDetail { None },
-            });
-        }
+
+        handle.0.set_binding(properties_animations::AnimatedBindingCallable::<T, _> {
+            original_binding,
+            state: Cell::new(properties_animations::AnimatedBindingState::NotAnimating),
+            animation_data,
+            compute_animation_details: move || -> properties_animations::AnimationDetail {
+                // The transition_data function receives a *mut *mut u64 pointer for the
+                // timestamp.
+                // If the function sets the pointer to nullptr, it doesn't provide a start_time.
+                // Otherwise, we assume it has written a value to the start_instant.
+                // This basically models a `&mut Option<u64>`, which is then converted to an
+                // `Option<Instant>`
+                let mut start_instant = 0u64;
+                let mut start_instant_ref = &mut start_instant as *mut u64;
+                let anim = transition_data(user_data, &mut start_instant_ref);
+                let start_instant = if start_instant_ref.is_null() {
+                    None
+                } else {
+                    Some(crate::animations::Instant(start_instant))
+                };
+                (anim, start_instant)
+            },
+        });
         handle.0.mark_dirty();
     }
 }
@@ -318,20 +322,13 @@ pub unsafe extern "C" fn slint_property_set_animated_binding_int(
     binding: extern "C" fn(*mut c_void, *mut core::ffi::c_int),
     user_data: *mut c_void,
     drop_user_data: Option<extern "C" fn(*mut c_void)>,
-    animation_data: Option<&PropertyAnimation>,
-    transition_data: Option<
-        extern "C" fn(user_data: *mut c_void, start_instant: &mut u64) -> PropertyAnimation,
-    >,
+    transition_data: extern "C" fn(
+        user_data: *mut c_void,
+        start_instant: &mut *mut u64,
+    ) -> PropertyAnimation,
 ) {
     unsafe {
-        c_set_animated_binding(
-            handle,
-            binding,
-            user_data,
-            drop_user_data,
-            animation_data,
-            transition_data,
-        );
+        c_set_animated_binding(handle, binding, user_data, drop_user_data, transition_data);
     }
 }
 
@@ -342,20 +339,13 @@ pub unsafe extern "C" fn slint_property_set_animated_binding_float(
     binding: extern "C" fn(*mut c_void, *mut f32),
     user_data: *mut c_void,
     drop_user_data: Option<extern "C" fn(*mut c_void)>,
-    animation_data: Option<&PropertyAnimation>,
-    transition_data: Option<
-        extern "C" fn(user_data: *mut c_void, start_instant: &mut u64) -> PropertyAnimation,
-    >,
+    transition_data: extern "C" fn(
+        user_data: *mut c_void,
+        start_instant: &mut *mut u64,
+    ) -> PropertyAnimation,
 ) {
     unsafe {
-        c_set_animated_binding(
-            handle,
-            binding,
-            user_data,
-            drop_user_data,
-            animation_data,
-            transition_data,
-        );
+        c_set_animated_binding(handle, binding, user_data, drop_user_data, transition_data);
     }
 }
 
@@ -366,20 +356,13 @@ pub unsafe extern "C" fn slint_property_set_animated_binding_color(
     binding: extern "C" fn(*mut c_void, *mut Color),
     user_data: *mut c_void,
     drop_user_data: Option<extern "C" fn(*mut c_void)>,
-    animation_data: Option<&PropertyAnimation>,
-    transition_data: Option<
-        extern "C" fn(user_data: *mut c_void, start_instant: &mut u64) -> PropertyAnimation,
-    >,
+    transition_data: extern "C" fn(
+        user_data: *mut c_void,
+        start_instant: &mut *mut u64,
+    ) -> PropertyAnimation,
 ) {
     unsafe {
-        c_set_animated_binding(
-            handle,
-            binding,
-            user_data,
-            drop_user_data,
-            animation_data,
-            transition_data,
-        );
+        c_set_animated_binding(handle, binding, user_data, drop_user_data, transition_data);
     }
 }
 
@@ -390,20 +373,13 @@ pub unsafe extern "C" fn slint_property_set_animated_binding_brush(
     binding: extern "C" fn(*mut c_void, *mut Brush),
     user_data: *mut c_void,
     drop_user_data: Option<extern "C" fn(*mut c_void)>,
-    animation_data: Option<&PropertyAnimation>,
-    transition_data: Option<
-        extern "C" fn(user_data: *mut c_void, start_instant: &mut u64) -> PropertyAnimation,
-    >,
+    transition_data: extern "C" fn(
+        user_data: *mut c_void,
+        start_instant: &mut *mut u64,
+    ) -> PropertyAnimation,
 ) {
     unsafe {
-        c_set_animated_binding(
-            handle,
-            binding,
-            user_data,
-            drop_user_data,
-            animation_data,
-            transition_data,
-        );
+        c_set_animated_binding(handle, binding, user_data, drop_user_data, transition_data);
     }
 }