Add support for opening multiple editor windows (#5)

Also remove log statements found during debugging

Author: RBogie

src-tauri/capabilities/default.json

@@ -3,7 +3,7 @@
   "identifier": "default",
   "description": "Capability for the main window",
   "windows": [
-    "main",
+    "main*",
     "settings"
   ],
   "permissions": [

src-tauri/src/lib.rs

@@ -6,16 +6,35 @@ use crate::scripts::commands::{get_script_commands, reply_editor_request, run_sc
 use crate::scripts::loader::scripts::ScriptManager;
 use crate::settings::{get_settings, set_preferred_language, set_theme, set_wrap_lines, Settings};
 use crate::window::Windows;
-use tauri::async_runtime::Mutex;
-use tauri::menu::{AboutMetadataBuilder, Menu, MenuItemBuilder, SubmenuBuilder};
+use tauri::async_runtime::{spawn, Mutex};
+use tauri::menu::{AboutMetadataBuilder, Menu, MenuItemBuilder, Submenu, SubmenuBuilder};
 use tauri::path::BaseDirectory;
 use tauri::Error::WebviewLabelAlreadyExists;
-use tauri::{AppHandle, Emitter, Manager, WebviewUrl, WebviewWindowBuilder, WindowEvent};
+use tauri::{
+    AppHandle, Emitter, Manager, State, WebviewUrl, WebviewWindowBuilder, WindowEvent, Wry,
+};
 use tauri_plugin_store::StoreExt;
 
+const MENU_ITEM_ID_SETTINGS: &str = "settings";
+const MENU_ITEM_ID_NEW_WINDOW: &str = "window_new";
+const MENU_ITEM_ID_SCRIPTS_OPEN_PICKER: &str = "scripts_open_picker";
+const MENU_ITEM_ID_SCRIPTS_REEXECUTE_LAST: &str = "scripts_reexecute_last";
+
+fn get_file_sub_menu(app: &AppHandle, in_settings: bool) -> Result<Submenu<Wry>, tauri::Error> {
+    let mut builder = SubmenuBuilder::new(app, "File");
+    if !in_settings {
+        let new_window_item = MenuItemBuilder::new("New Window")
+            .id(MENU_ITEM_ID_NEW_WINDOW)
+            .accelerator("CmdOrCtrl+N")
+            .build(app)?;
+        builder = builder.item(&new_window_item).separator();
+    }
+    builder.close_window().build()
+}
+
 fn setup_menu(app: &AppHandle, in_settings: bool) -> Result<(), tauri::Error> {
     let settings = MenuItemBuilder::new("Settings...")
-        .id("settings")
+        .id(MENU_ITEM_ID_SETTINGS)
         .accelerator("CmdOrCtrl+,")
         .enabled(!in_settings)
         .build(app)?;
@@ -38,8 +57,8 @@ fn setup_menu(app: &AppHandle, in_settings: bool) -> Result<(), tauri::Error> {
         .separator()
         .quit()
         .build()?;
-    let file_sub_menu = SubmenuBuilder::new(app, "File").close_window().build()?;
 
+    let file_sub_menu = get_file_sub_menu(app, in_settings)?;
     let app_menu = Menu::new(app)?;
 
     if !in_settings {
@@ -54,11 +73,11 @@ fn setup_menu(app: &AppHandle, in_settings: bool) -> Result<(), tauri::Error> {
             .build()?;
 
         let open_script_picker_item = MenuItemBuilder::new("Open Picker")
-            .id("scripts_open_picker")
+            .id(MENU_ITEM_ID_SCRIPTS_OPEN_PICKER)
             .accelerator("CmdOrCtrl+B")
             .build(app)?;
         let reexecute_last_script_item = MenuItemBuilder::new("Re-execute Last Script")
-            .id("scripts_reexecute_last")
+            .id(MENU_ITEM_ID_SCRIPTS_REEXECUTE_LAST)
             .accelerator("CmdOrCtrl+Shift+B")
             .enabled(false)
             .build(app)?;
@@ -73,34 +92,6 @@ fn setup_menu(app: &AppHandle, in_settings: bool) -> Result<(), tauri::Error> {
             &edit_sub_menu,
             &scripts_sub_menu,
         ])?;
-
-        app.on_menu_event(move |app, event| {
-            if event.id() == settings.id() {
-                let settings_window_result = WebviewWindowBuilder::new(
-                    app,
-                    "settings".to_string(),
-                    WebviewUrl::App("windows/settings.html".parse().unwrap()),
-                )
-                .min_inner_size(200.0, 400.0)
-                .title("Snip Settings")
-                .build();
-                if let Err(WebviewLabelAlreadyExists(_)) = settings_window_result {
-                    let webview_windows = app.webview_windows();
-                    let settings_window = webview_windows.get("settings").unwrap();
-                    settings_window.unminimize().unwrap(); // Must use it if window is minimized
-                    settings_window.set_focus().unwrap();
-                    settings_window.show().unwrap();
-                }
-            } else if event.id() == open_script_picker_item.id() {
-                let focused_window = app.get_focused_window();
-                if let Some(focused_window) = focused_window {
-                    if focused_window.label() != "settings" {
-                        app.emit_to(focused_window.label(), "open_picker", true)
-                            .unwrap()
-                    }
-                }
-            }
-        });
     } else {
         app_menu.append_items(&[&app_sub_menu, &file_sub_menu])?;
     }
@@ -113,7 +104,14 @@ fn setup_menu(app: &AppHandle, in_settings: bool) -> Result<(), tauri::Error> {
 pub fn run() {
     tauri::Builder::default()
         .plugin(tauri_plugin_os::init())
-        .plugin(tauri_plugin_single_instance::init(|_, _, _| {}))
+        .plugin(tauri_plugin_single_instance::init(|app, _, _| {
+            let app = app.clone();
+            spawn(async move {
+                let windows: State<'_, Mutex<Windows>> = app.state();
+                let mut windows = windows.lock().await;
+                windows.create_window(&app).unwrap();
+            });
+        }))
         .plugin(
             tauri_plugin_log::Builder::new()
                 .clear_targets()
@@ -151,13 +149,54 @@ pub fn run() {
             app.manage(Mutex::new(settings));
             app.manage(Mutex::new(windows));
             app.manage(Mutex::new(script_manager));
+
+            app.on_menu_event(move |app, event| {
+                match event.id().0.as_str() {
+                    MENU_ITEM_ID_SETTINGS => {
+                        let settings_window_result = WebviewWindowBuilder::new(
+                            app,
+                            "settings".to_string(),
+                            WebviewUrl::App("windows/settings.html".parse().unwrap()),
+                        )
+                        .min_inner_size(200.0, 400.0)
+                        .title("Snip Settings")
+                        .build();
+                        if let Err(WebviewLabelAlreadyExists(_)) = settings_window_result {
+                            let webview_windows = app.webview_windows();
+                            let settings_window = webview_windows.get("settings").unwrap();
+                            settings_window.unminimize().unwrap(); // Must use it if window is minimized
+                            settings_window.set_focus().unwrap();
+                            settings_window.show().unwrap();
+                        }
+                    }
+                    MENU_ITEM_ID_SCRIPTS_OPEN_PICKER => {
+                        let focused_window = app.get_focused_window();
+                        if let Some(focused_window) = focused_window {
+                            if focused_window.label() != "settings" {
+                                app.emit_to(focused_window.label(), "open_picker", true)
+                                    .unwrap()
+                            }
+                        }
+                    }
+                    MENU_ITEM_ID_NEW_WINDOW => {
+                        let windows: State<'_, Mutex<Windows>> = app.state();
+                        let mut windows = windows.blocking_lock();
+                        windows.create_window(app).unwrap();
+                    }
+                    _ => {}
+                }
+            });
+
             setup_menu(app.handle(), false)?;
 
             Ok(())
         })
         .on_window_event(|window, event| match event {
             WindowEvent::Destroyed => {
-                if window.label() == "main" {
+                let windows: State<'_, Mutex<Windows>> = window.app_handle().state();
+                let windows = &mut windows.blocking_lock();
+                windows.destroy_window(window.label());
+                if !windows.has_open() {
                     window.app_handle().exit(0);
                 }
             }

src-tauri/src/scripts/commands.rs

@@ -186,7 +186,7 @@ pub async fn reply_editor_request(
 ) -> Result<(), String> {
     let state = &mut state.lock().await;
     let script_state = state
-        .get_script_state(&webview_window.label().to_string())
+        .get_script_state(webview_window.label())
         .expect("Window should have script state");
 
     let reply_sender = script_state.reply_senders.remove(&reply.id);

src-tauri/src/window.rs

@@ -9,6 +9,7 @@ use tokio::sync::mpsc::{channel, Receiver, Sender};
 
 pub enum WindowTask {
     Script(ScriptTask),
+    Close,
 }
 
 pub struct WindowState {
@@ -19,6 +20,7 @@ pub struct WindowState {
 
 pub struct Windows {
     window_states: HashMap<String, WindowState>,
+    last_window_id: u32,
 }
 
 fn window_task_listener(mut task_receiver: Receiver<WindowTask>) {
@@ -32,6 +34,7 @@ fn window_task_listener(mut task_receiver: Receiver<WindowTask>) {
             if let Some(task) = task {
                 match task {
                     WindowTask::Script(script_event) => handle_script_task(script_event).await,
+                    WindowTask::Close => break,
                 }
             } else {
                 break;
@@ -44,11 +47,13 @@ impl Windows {
     pub fn new() -> Self {
         Self {
             window_states: HashMap::new(),
+            last_window_id: 0,
         }
     }
 
     pub fn create_window(&mut self, app_handle: &AppHandle) -> Result<(), Error> {
-        let id = String::from("main");
+        self.last_window_id += 1;
+        let id = format!("main_{}", self.last_window_id);
 
         let (task_sender, task_receiver) = channel(8);
 
@@ -71,7 +76,7 @@ impl Windows {
             WebviewUrl::App("windows/index.html".parse().unwrap()),
         )
         .min_inner_size(800.0, 600.0)
-        .title("Snip")
+        .title(format!("Snip - Untitled {}", self.last_window_id))
         .build()?;
 
         Ok(())
@@ -91,12 +96,26 @@ impl Windows {
         }
     }
 
-    pub fn get_script_state(&mut self, window_id: &String) -> Option<&mut WindowScriptState> {
+    pub fn get_script_state(&mut self, window_id: &str) -> Option<&mut WindowScriptState> {
         let window_state = self.window_states.get_mut(window_id);
         if let Some(window_state) = window_state {
             Some(&mut window_state.script_state)
         } else {
             None
         }
     }
+
+    pub fn destroy_window(&mut self, window_id: &str) {
+        if let Some(window_state) = self.window_states.remove(window_id) {
+            window_state
+                .task_sender
+                .blocking_send(WindowTask::Close)
+                .unwrap();
+            window_state.thread_join_handle.join().unwrap();
+        }
+    }
+
+    pub fn has_open(&self) -> bool {
+        !self.window_states.is_empty()
+    }
 }

src/modules/getShades.ts

@@ -118,25 +118,14 @@ function convertHexToHsl(hex: string) {
 
 function convertHslToHex(hue: number, saturation: number, luminosity: number) {
   const { r, g, b } = convertHslToRgb(hue, saturation, luminosity)
-  const result = convertRgbToHex(r, g, b)
-  console.log({
-    hue,
-    saturation,
-    luminosity,
-    r,
-    g,
-    b,
-    result,
-  })
-  return result
+  return convertRgbToHex(r, g, b)
 }
 
 export default function getShades(
   baseColorHex: string,
   darkMode: boolean = false,
 ) {
   const baseHSL = convertHexToHsl(baseColorHex)
-  console.log(baseHSL)
   const {
     hue: baseHue,
     saturation: baseSaturation,