Add a shortcut for interrupting the program

app/gui/controller/engine-protocol/src/language_server.rs

@@ -151,6 +151,14 @@ trait API {
     fn modify_visualisation
     (&self, visualisation_id: Uuid, visualisation_config: VisualisationConfiguration) -> ();
 
+    /// Interrupt the program execution.
+    #[MethodInput=InterruptInput, rpc_name="executionContext/interrupt"]
+    fn interrupt(&self, context_id: ContextId) -> ();
+
+    /// Restart the program execution.
+    #[MethodInput=RecomputeInput, rpc_name="executionContext/recompute"]
+    fn recompute(&self, context_id: ContextId) -> ();
+
     /// Obtain the full suggestions database.
     #[MethodInput=GetSuggestionsDatabaseInput, rpc_name="search/getSuggestionsDatabase"]
     fn get_suggestions_database(&self) -> response::GetSuggestionDatabase;

app/gui/docs/product/shortcuts.md

@@ -48,6 +48,8 @@ broken and require further investigation.
 | <kbd>ctrl</kbd>+<kbd>w</kbd>                                | Close the application (Windows, Linux)                                                                                                                                                                                                               |
 | :warning: <kbd>ctrl</kbd>+<kbd>p</kbd>                      | Toggle profiling mode                                                                                                                                                                                                                                |
 | <kbd>escape</kbd>                                           | Cancel current action. For example, drop currently dragged connection.                                                                                                                                                                               |
+| <kbd>cmd</kbd>+<kbd>shift</kbd>+<kbd>t</kbd>                | Terminate the program execution                                                                                                                                                                                                                      |
+| <kbd>cmd</kbd>+<kbd>shift</kbd>+<kbd>r</kbd>                | Re-execute the program                                                                                                                                                                                                                               |
 
 #### Navigation
 

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

@@ -75,17 +75,17 @@ pub enum Notification {
 #[derive(Clone, CloneRef, Debug)]
 pub struct Handle {
     #[allow(missing_docs)]
-    pub logger:    Logger,
+    pub logger:        Logger,
     /// A handle to basic graph operations.
-    graph:         Rc<RefCell<controller::Graph>>,
+    graph:             Rc<RefCell<controller::Graph>>,
     /// Execution Context handle, its call stack top contains `graph`'s definition.
-    execution_ctx: model::ExecutionContext,
+    pub execution_ctx: model::ExecutionContext,
     /// The handle to project controller is necessary, as entering nodes might need to switch
     /// modules, and only the project can provide their controllers.
-    project:       model::Project,
+    project:           model::Project,
     /// The publisher allowing sending notification to subscribed entities. Note that its outputs
     /// is merged with publishers from the stored graph and execution controllers.
-    notifier:      crate::notification::Publisher<Notification>,
+    notifier:          crate::notification::Publisher<Notification>,
 }
 
 impl Handle {

app/gui/src/model/execution_context.rs

@@ -493,6 +493,14 @@ pub trait API: Debug {
         let detach_actions = visualizations.into_iter().map(move |v| self.detach_visualization(v));
         futures::future::join_all(detach_actions).boxed_local()
     }
+
+    /// Interrupt the program execution.
+    #[allow(clippy::needless_lifetimes)] // Note: Needless lifetimes
+    fn interrupt<'a>(&'a self) -> BoxFuture<'a, FallibleResult>;
+
+    /// Restart the program execution.
+    #[allow(clippy::needless_lifetimes)] // Note: Needless lifetimes
+    fn restart<'a>(&'a self) -> BoxFuture<'a, FallibleResult>;
 }
 
 // Note: Needless lifetimes

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

@@ -250,6 +250,14 @@ impl model::execution_context::API for ExecutionContext {
             Err(InvalidVisualizationId(visualization_id).into())
         }
     }
+
+    fn interrupt(&self) -> BoxFuture<FallibleResult> {
+        futures::future::ready(Ok(())).boxed_local()
+    }
+
+    fn restart(&self) -> BoxFuture<FallibleResult> {
+        futures::future::ready(Ok(())).boxed_local()
+    }
 }
 
 

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

@@ -289,6 +289,22 @@ impl model::execution_context::API for ExecutionContext {
         debug!("Dispatching visualization update through the context {}", self.id());
         self.model.dispatch_visualization_update(visualization_id, data)
     }
+
+    fn interrupt(&self) -> BoxFuture<FallibleResult> {
+        async move {
+            self.language_server.client.interrupt(&self.id).await?;
+            Ok(())
+        }
+        .boxed_local()
+    }
+
+    fn restart(&self) -> BoxFuture<FallibleResult> {
+        async move {
+            self.language_server.client.recompute(&self.id).await?;
+            Ok(())
+        }
+        .boxed_local()
+    }
 }
 
 impl Drop for ExecutionContext {

app/gui/src/presenter/project.rs

@@ -177,6 +177,24 @@ impl Model {
             }
         })
     }
+
+    fn execution_context_interrupt(&self) {
+        let controller = self.graph_controller.clone_ref();
+        executor::global::spawn(async move {
+            if let Err(err) = controller.execution_ctx.interrupt().await {
+                error!("Error interrupting execution context: {err}");
+            }
+        })
+    }
+
+    fn execution_context_restart(&self) {
+        let controller = self.graph_controller.clone_ref();
+        executor::global::spawn(async move {
+            if let Err(err) = controller.execution_ctx.restart().await {
+                error!("Error restarting execution context: {err}");
+            }
+        })
+    }
 }
 
 
@@ -246,6 +264,10 @@ impl Project {
             view.values_updated <+ values_computed;
 
             eval_ view.save_project_snapshot(model.save_project_snapshot());
+
+            eval_ view.execution_context_interrupt(model.execution_context_interrupt());
+
+            eval_ view.execution_context_restart(model.execution_context_restart());
         }
 
         let graph_controller = self.model.graph_controller.clone_ref();

app/gui/view/src/project.rs

@@ -84,6 +84,10 @@ ensogl::define_endpoints! {
         disable_debug_mode(),
         /// A set of value updates has been processed and rendered.
         values_updated(),
+        /// Interrupt the running program.
+        execution_context_interrupt(),
+        /// Restart the program execution.
+        execution_context_restart(),
     }
 
     Output {
@@ -834,6 +838,8 @@ impl application::View for View {
             (Press, "", "cmd y", "redo"),
             (Press, "!debug_mode", DEBUG_MODE_SHORTCUT, "enable_debug_mode"),
             (Press, "debug_mode", DEBUG_MODE_SHORTCUT, "disable_debug_mode"),
+            (Press, "", "cmd shift t", "execution_context_interrupt"),
+            (Press, "", "cmd shift r", "execution_context_restart"),
         ]
         .iter()
         .map(|(a, b, c, d)| Self::self_shortcut_when(*a, *c, *d, *b))