Implement workflow-level Play button business-logic

app/gui/src/controller/graph/executed.rs

@@ -365,6 +365,13 @@ impl Handle {
         self.execution_ctx.set_execution_environment(execution_environment).await?;
         Ok(())
     }
+
+    /// Trigger a clean execution of the current graph with the "live" execution environment. That
+    /// means old computations and caches will be discarded.
+    pub async fn trigger_clean_live_execution(&self) -> FallibleResult {
+        self.execution_ctx.trigger_clean_live_execution().await?;
+        Ok(())
+    }
 }
 
 

app/gui/src/model/execution_context.rs

@@ -511,6 +511,11 @@ pub trait API: Debug {
         &'a self,
         execution_environment: ExecutionEnvironment,
     ) -> BoxFuture<'a, FallibleResult>;
+
+    /// Trigger a clean execution of the current graph with the "live" execution environment. That
+    /// means old computations and caches will be discarded.
+    #[allow(clippy::needless_lifetimes)] // Note: Needless lifetimes
+    fn trigger_clean_live_execution<'a>(&'a self) -> BoxFuture<'a, FallibleResult>;
 }
 
 // Note: Needless lifetimes

app/gui/src/model/execution_context/plain.rs

@@ -287,6 +287,10 @@ impl model::execution_context::API for ExecutionContext {
         self.execution_environment.set(environment);
         futures::future::ready(Ok(())).boxed_local()
     }
+
+    fn trigger_clean_live_execution(&self) -> LocalBoxFuture<FallibleResult> {
+        futures::future::ready(Ok(())).boxed_local()
+    }
 }
 
 

app/gui/src/model/execution_context/synchronized.rs

@@ -329,6 +329,21 @@ impl model::execution_context::API for ExecutionContext {
         }
         .boxed_local()
     }
+
+    fn trigger_clean_live_execution(&self) -> BoxFuture<FallibleResult> {
+        async move {
+            self.language_server
+                .client
+                .recompute(
+                    &self.id,
+                    &language_server::InvalidatedExpressions::All,
+                    &Some(ExecutionEnvironment::Live),
+                )
+                .await?;
+            Ok(())
+        }
+        .boxed_local()
+    }
 }
 
 impl Drop for ExecutionContext {

app/gui/src/model/project.rs

@@ -179,6 +179,8 @@ pub enum Notification {
     ConnectionLost(BackendConnection),
     /// Indicates that the project VCS status has changed.
     VcsStatusChanged(VcsStatus),
+    /// Indicates that the project has finished execution.
+    ExecutionFinished,
 }
 
 /// Denotes one of backend connections used by a project.

app/gui/src/model/project/synchronized.rs

@@ -544,6 +544,7 @@ impl Project {
                 Event::Notification(Notification::ExecutionStatus(_)) => {}
                 Event::Notification(Notification::ExecutionComplete { context_id }) => {
                     execution_update_handler(context_id, ExecutionUpdate::Completed);
+                    publisher.notify(model::project::Notification::ExecutionFinished);
                 }
                 Event::Notification(Notification::ExpressionValuesComputed(_)) => {
                     // the notification is superseded by `ExpressionUpdates`.

app/gui/src/presenter/project.rs

@@ -225,6 +225,11 @@ impl Model {
         self.view.graph().model.breadcrumbs.set_project_changed(changed);
     }
 
+    fn execution_finished(&self) {
+        self.view.graph().frp.set_read_only(false);
+        self.view.graph().frp.execution_finished.emit(());
+    }
+
     fn execution_context_interrupt(&self) {
         let controller = self.graph_controller.clone_ref();
         executor::global::spawn(async move {
@@ -306,6 +311,15 @@ impl Model {
             error!("Invalid execution environment: {execution_environment:?}");
         }
     }
+
+    fn trigger_clean_live_execution(&self) {
+        let graph_controller = self.graph_controller.clone_ref();
+        executor::global::spawn(async move {
+            if let Err(err) = graph_controller.trigger_clean_live_execution().await {
+                error!("Error starting clean live execution: {err}");
+            }
+        });
+    }
 }
 
 
@@ -405,6 +419,7 @@ impl Project {
 
             view.set_read_only <+ view.toggle_read_only.map(f_!(model.toggle_read_only()));
             eval graph_view.execution_environment((env) model.execution_environment_changed(env));
+            eval_ graph_view.execution_environment_play_button_pressed( model.trigger_clean_live_execution());
         }
 
         let graph_controller = self.model.graph_controller.clone_ref();
@@ -461,6 +476,9 @@ impl Project {
                 Notification::VcsStatusChanged(VcsStatus::Clean) => {
                     model.set_project_changed(false);
                 }
+                Notification::ExecutionFinished => {
+                    model.execution_finished();
+                }
             };
             std::future::ready(())
         });

app/gui/view/execution-environment-selector/src/lib.rs

@@ -87,11 +87,12 @@ ensogl::define_endpoints_2! {
     Input {
         set_available_execution_environments      (ExecutionEnvironments),
         set_execution_environment                 (ExecutionEnvironment),
+        reset_play_button_state (),
     }
     Output {
         selected_execution_environment (ExecutionEnvironment),
         play_press(),
-        size                    (Vector2),
+        size(Vector2),
     }
 }
 
@@ -268,6 +269,7 @@ impl component::Frp<Model> for Frp {
                 model.set_play_button_visibility(play_button_visibility);
             });
             play_button.reset <+ selected_entry.constant(());
+            play_button.reset <+ input.reset_play_button_state;
 
             // == Outputs ==
 

app/gui/view/graph-editor/src/execution_environment.rs

@@ -49,7 +49,10 @@ pub fn init_frp(frp: &Frp, model: &GraphEditorModelWithNetwork) {
             <- any(selector.selected_execution_environment,external_update);
         out.execution_environment <+ execution_environment_update;
         out.execution_environment_play_button_pressed <+ selector.play_press;
+        frp.set_read_only <+ selector.play_press.constant(true);
 
+        // === Play Button ===
+        selector.reset_play_button_state <+ frp.execution_finished;
 
         // === Layout ===
 

app/gui/view/graph-editor/src/lib.rs

@@ -593,6 +593,7 @@ ensogl::define_endpoints_2! {
         /// Set the execution environmenta available to the graph.
         set_available_execution_environments          (Rc<Vec<execution_environment_selector::ExecutionEnvironment>>),
         set_execution_environment                     (ExecutionEnvironment),
+        execution_finished(),
 
 
         // === Debug ===