Konata app integration

Makefile.toml

@@ -165,7 +165,7 @@ description = "Install Tauri CLI (tauri) locally"
 command = "cargo"
 args = [
     "install", 
-    "tauri-cli@=2.1.0", 
+    "tauri-cli@=2.0.0-beta.17", 
     "--locked",
     "--root",
     "tauri",

README.md

@@ -69,16 +69,6 @@
   <img width="800" src="docs/video_diagrams.gif" alt="Fastwave - Diagrams" />
 </p>
 
-<p align="center">Diagram Connector Demo</p> 
-<p align="center">
-  <img width="800" src="docs/video_diagram_connector.gif" alt="Fastwave - Diagram Connector demo" />
-</p>
-
-<p align="center">Diagram Connector Code snippet</p>
-<p align="center">
-  <img width="500" src="docs/screenshot_diagram_connector_rs.png" alt="Fastwave - Diagram Connector Code snippet" />
-</p>
-
 ---
 
 ### Installation (desktop version):

frontend/Cargo.toml

@@ -14,7 +14,6 @@ wasm-bindgen-test = "0.3.19"
 unexpected_cfgs = { level = "allow", check-cfg = ['cfg(FASTWAVE_PLATFORM)'] }
 
 [dependencies]
-unicode-segmentation = "1.10"
 zoon.workspace = true
 wellen.workspace = true
 shared = { path = "../shared", features = ["frontend"] }

frontend/src/header_panel.rs

@@ -1,7 +1,6 @@
 use crate::{platform, theme::*, Filename, Layout, Mode};
 use std::sync::Arc;
 use zoon::*;
-use crate::term::TERM_OPEN;
 
 pub struct HeaderPanel {
     hierarchy: Mutable<Option<Arc<wellen::Hierarchy>>>,
@@ -38,7 +37,6 @@ impl HeaderPanel {
                     .item(self.load_button())
                     .item(self.layout_switcher())
                     .item(self.mode_switcher())
-                    .item(self.open_terminal())
                     .item(self.open_konata_file()),
             )
     }
@@ -214,26 +212,4 @@ impl HeaderPanel {
             .on_hovered_change(move |is_hovered| hovered.set_neq(is_hovered))
             .on_press(move || Task::start(platform::open_konata_file()))
     }
-
-    fn open_terminal(&self) -> impl Element {
-        let (hovered, hovered_signal) = Mutable::new_and_signal(false);
-        Button::new()
-            .s(Padding::new().x(20).y(10))
-            .s(Background::new().color_signal(
-                hovered_signal.map_bool(|| COLOR_MEDIUM_SLATE_BLUE, || COLOR_SLATE_BLUE),
-            ))
-            .s(Align::new().left())
-            .s(RoundedCorners::all(15))
-            .label(
-                El::new()
-                    .s(Font::new().no_wrap())
-                    .child("Open Terminal"),
-            )
-            .on_hovered_change(move |is_hovered| hovered.set_neq(is_hovered))
-            .on_press(move || {
-                let term_open = TERM_OPEN.get();
-                TERM_OPEN.set(!term_open);
-
-            })
-    }
 }

frontend/src/main.rs

@@ -1,5 +1,4 @@
 use shared::DiagramConnectorMessage;
-use term::TERM_OPEN;
 use std::{mem, sync::Arc};
 use zoon::*;
 
@@ -24,9 +23,6 @@ use command_panel::CommandPanel;
 pub mod theme;
 use theme::*;
 
-pub mod term;
-use shared::term::{TerminalDownMsg, TerminalScreen};
-
 #[derive(Clone, Copy, Default)]
 enum Layout {
     Tree,
@@ -102,10 +98,8 @@ fn main() {
                     .unwrap_throw()
                     .set_component_text(&component_id, &text),
             }
-        }).await;
+        })
-        platform::listen_term_update(|down_msg| {
+        .await
-            term::TERMINAL_STATE.set(down_msg);
-        }).await;
     });
 }
 
@@ -187,20 +181,4 @@ fn root() -> impl Element {
             }
         })))
         .item(CommandPanel::new())
-        .item_signal(
-            TERM_OPEN.signal_cloned().map(
-                |term_open| {
-                    match term_open {
-                        true =>
-                            El::new()
-                                .s(Height::fill().max(400).min(400))
-                                .s(Padding::all(5))
-                                .child(term::root()),
-                        false =>
-                            El::new()
-                                .child("")
-                    }
-                }
-            )
-        )
 }

frontend/src/platform.rs

@@ -29,8 +29,6 @@ type DiagramConnectorPath = String;
 type DiagramConnectorName = String;
 type ComponentId = String;
 
-use shared::term::{TerminalDownMsg, TerminalScreen};
-
 pub async fn show_window() {
     platform::show_window().await
 }
@@ -74,10 +72,6 @@ pub async fn unload_signal(signal_ref: wellen::SignalRef) {
     platform::unload_signal(signal_ref).await
 }
 
-pub async fn send_char(c : String) {
-    platform::send_char(c).await
-}
-
 pub async fn add_decoders(decoder_paths: Vec<DecoderPath>) -> AddedDecodersCount {
     let count = platform::add_decoders(decoder_paths).await;
     if count > 0 {
@@ -118,12 +112,6 @@ pub async fn listen_diagram_connectors_messages(
     platform::listen_diagram_connectors_messages(on_message).await;
 }
 
-pub async fn listen_term_update(
-    on_message: impl FnMut(TerminalDownMsg) + 'static,
-) {
-    platform::listen_term_update(on_message).await;
-}
-
 pub async fn notify_diagram_connector_text_change(
     diagram_connector: DiagramConnectorName,
     component_id: ComponentId,

frontend/src/platform/tauri.rs

@@ -1,5 +1,4 @@
 use shared::DiagramConnectorMessage;
-use shared::term::{TerminalDownMsg, TerminalScreen};
 use zoon::*;
 
 pub(super) async fn show_window() {
@@ -58,12 +57,6 @@ pub(super) async fn unload_signal(signal_ref: wellen::SignalRef) {
         .unwrap_throw()
 }
 
-pub(super) async fn send_char(c : String) {
-    tauri_glue::send_char(c)
-        .await
-        .unwrap_throw()
-}
-
 pub(super) async fn add_decoders(
     decoder_paths: Vec<super::DecoderPath>,
 ) -> super::AddedDecodersCount {
@@ -104,14 +97,6 @@ pub(super) async fn listen_diagram_connectors_messages(
     tauri_glue::listen_diagram_connectors_messages(Closure::new(on_message).into_js_value()).await
 }
 
-pub(super) async fn listen_term_update(
-    mut on_message: impl FnMut(TerminalDownMsg) + 'static,
-) {
-    let on_message =
-        move |message: JsValue| on_message(serde_wasm_bindgen::from_value(message).unwrap_throw());
-    tauri_glue::listen_term_update(Closure::new(on_message).into_js_value()).await
-}
-
 pub(super) async fn notify_diagram_connector_text_change(
     diagram_connector: super::DiagramConnectorName,
     component_id: super::ComponentId,
@@ -157,9 +142,6 @@ mod tauri_glue {
         #[wasm_bindgen(catch)]
         pub async fn unload_signal(signal_ref_index: usize) -> Result<(), JsValue>;
 
-        #[wasm_bindgen(catch)]
-        pub async fn send_char(c : String) -> Result<(), JsValue>;
-
         #[wasm_bindgen(catch)]
         pub async fn add_decoders(
             decoder_paths: Vec<super::super::DecoderPath>,
@@ -178,8 +160,6 @@ mod tauri_glue {
 
         pub async fn listen_diagram_connectors_messages(on_event: JsValue);
 
-        pub async fn listen_term_update(on_event: JsValue);
-
         #[wasm_bindgen(catch)]
         pub async fn notify_diagram_connector_text_change(
             diagram_connector: super::super::DiagramConnectorName,

frontend/src/term.rs

@@ -1,142 +0,0 @@
-use std::ops::Index;
-
-use chrono::format;
-use zoon::*;
-use zoon::{println, eprintln, *};
-use shared::term::{TerminalDownMsg, TerminalScreen, TerminalUpMsg};
-use unicode_segmentation::UnicodeSegmentation;
-
-// use tokio::time::timeout;
-pub static TERM_OPEN: Lazy<Mutable<bool>> = Lazy::new(|| {false.into()});
-
-pub const TERMINAL_COLOR: Oklch = color!("oklch(20% 0.125 262.26)");
-
-pub static  TERMINAL_STATE: Lazy<Mutable<TerminalDownMsg>> =
-    Lazy::new(|| {
-        Mutable::new(TerminalDownMsg::TermNotStarted)
-    });
-
-pub fn root() -> impl Element {
-    let terminal =
-        El::new()
-            .s(Width::fill())
-            .s(Height::fill())
-            .s(Background::new().color(TERMINAL_COLOR))
-            .s(RoundedCorners::all(7))
-            .s(Font::new().family([
-                FontFamily::new("Lucida Console"),
-                FontFamily::new("Courier"),
-                FontFamily::new("monospace")
-                ]))
-            .update_raw_el(|raw_el| {
-                raw_el.global_event_handler(|event: events::KeyDown| {
-                    send_char(
-                        (&event).key().as_str(),
-                        (&event).ctrl_key(),
-                    );
-                })
-            })
-            .child_signal(TERMINAL_STATE.signal_cloned().map(
-                |down_msg| {
-                    match down_msg {
-                        TerminalDownMsg::FullTermUpdate(term) => {
-                            make_grid_with_newlines(&term)
-                        },
-                        TerminalDownMsg::TermNotStarted => {
-                            "Term not yet started!".to_string()
-                        },
-                        TerminalDownMsg::BackendTermStartFailure(msg) => {
-                            format!("Error: BackendTermStartFailure: {}", msg)
-                        }
-                    }
-                }
-                )
-            )
-            ;
-    let root = Column::new()
-        .s(Width::fill())
-        .s(Height::fill())
-        .s(Align::new().top())
-        .item(terminal);
-    root
-}
-
-fn send_char(
-    s           : &str,
-    has_control : bool,
-    ) {
-    match process_str(s, has_control) {
-        Some(c) => {
-            let send_c = c.clone();
-            Task::start(async move {
-                crate::platform::send_char(send_c.to_string()).await;
-            });
-        }
-        None => {}
-    }
-
-}
-
-
-fn make_grid_with_newlines(term: &TerminalScreen) -> String {
-    let mut formatted = String::with_capacity(term.content.len() + (term.content.len() / term.cols as usize));
-
-    term.content.chars().enumerate().for_each(|(i, c)| {
-        formatted.push(c);
-        if (i + 1) as u16 % term.cols == 0 {
-            formatted.push('\n');
-        }
-    });
-
-    formatted
-}
-
-
-fn process_str(s: &str, has_ctrl: bool) -> Option<char> {
-    match s {
-        "Enter"         => {return Some('\n');}
-        "Escape"        => {return Some('\x1B');}
-        "Backspace"     => {return Some('\x08');}
-        "ArrowUp"       => {return Some('\x10');}
-        "ArrowDown"     => {return Some('\x0E');}
-        "ArrowLeft"     => {return Some('\x02');}
-        "ArrowRight"    => {return Some('\x06');}
-        "Control"       => {return None;}
-        "Shift"         => {return None;}
-        "Meta"          => {return None;}
-        "Alt"           => {return None;}
-        _ => {}
-    }
-
-    let mut graphemes = s.graphemes(true);
-    let first = graphemes.next();
-
-    if let Some(g) = first {
-        if g.len() == 1 {
-            if let Some(c) = g.chars().next() {
-                let c = process_for_ctrl_char(c, has_ctrl);
-                return Some(c);
-            }
-        }
-    }
-
-    None
-}
-
-// Helper function to process control characters
-
-fn is_lowercase_alpha(c: char) -> bool {
-    char_is_between_inclusive(c, 'a', 'z')
-}
-
-fn process_for_ctrl_char(c: char, has_ctrl: bool) -> char {
-    if has_ctrl {
-        (c as u8 & 0x1F) as char
-    } else {
-        c
-    }
-}
-
-fn char_is_between_inclusive(c : char, lo_char : char, hi_char : char) -> bool {
-    c >= lo_char && c <= hi_char
-}

frontend/typescript/tauri_glue/tauri_glue.ts

@@ -38,20 +38,20 @@ export async function get_hierarchy(): Promise<WellenHierarchy> {
 }
 
 export async function load_signal_and_get_timeline(
-    signal_ref_index: number,
+    signal_ref_index: number, 
     timeline_zoom: number,
     timeline_viewport_width: number,
-    timeline_viewport_x: number,
+    timeline_viewport_x: number, 
     block_height: number,
     var_format: VarFormat,
 ): Promise<Timeline> {
-    return await invoke("load_signal_and_get_timeline", {
+    return await invoke("load_signal_and_get_timeline", { 
-        signal_ref_index,
+        signal_ref_index, 
-        timeline_zoom,
+        timeline_zoom, 
         timeline_viewport_width,
         timeline_viewport_x,
-        block_height,
+        block_height, 
-        var_format
+        var_format 
     });
 }
 
@@ -59,10 +59,6 @@ export async function unload_signal(signal_ref_index: number): Promise<void> {
     return await invoke("unload_signal", { signal_ref_index });
 }
 
-export async function send_char(c : string): Promise<void> {
-    return await invoke("send_char", { c });
-}
-
 export async function add_decoders(decoder_paths: Array<DecoderPath>): Promise<AddedDecodersCount> {
     return await invoke("add_decoders", { decoder_paths });
 }
@@ -83,10 +79,6 @@ export async function listen_diagram_connectors_messages(on_message: (message: a
     return await listen("diagram_connector_message", (message) => on_message(message.payload));
 }
 
-export async function listen_term_update(on_message: (message: any) => void) {
-    return await listen("term_content", (message) => on_message(message.payload));
-}
-
 export async function notify_diagram_connector_text_change(diagram_connector: DiagramConnectorName, component_id: ComponentId, text: string): Promise<void> {
     return await invoke("notify_diagram_connector_text_change", { diagram_connector, component_id, text });
 }

shared/src/lib.rs

@@ -7,7 +7,6 @@ mod signal_to_timeline;
 pub use signal_to_timeline::signal_to_timeline;
 
 pub mod wellen_helpers;
-pub mod term;
 
 #[derive(Serialize, Deserialize, Debug, Default)]
 #[serde(crate = "serde")]

shared/src/term.rs

@@ -1,25 +0,0 @@
-use moonlight::*;
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(crate = "serde")]
-pub enum TerminalUpMsg {
-    RequestFullTermState,
-    RequestIncrementalTermStateUpdate,
-    SendCharacter(char),
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(crate = "serde")]
-pub enum TerminalDownMsg {
-    FullTermUpdate(TerminalScreen),
-    BackendTermStartFailure(String),
-    TermNotStarted
-}
-
-#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
-#[serde(crate = "serde")]
-pub struct TerminalScreen {
-    pub cols    : u16,
-    pub rows    : u16,
-    pub content : String,
-}

src-tauri/Cargo.toml

@@ -13,21 +13,19 @@ name = "app_lib"
 crate-type = ["staticlib", "cdylib", "rlib"]
 
 [build-dependencies]
-tauri-build = { version = "2.0.3", features = [] }
+tauri-build = { version = "=2.0.0-beta.17", features = [] }
 
 [dependencies]
 wellen.workspace = true
-alacritty_terminal = { git = "https://github.com/alacritty/alacritty", rev = "cacdb5bb3b72bad2c729227537979d95af75978f" }
 shared = { path = "../shared", features = ["backend"] }
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
-tauri = { version = "2.1.1", features = ["macos-private-api"] }
+tauri = { version = "=2.0.0-beta.22", features = ["macos-private-api", "linux-ipc-protocol"] }
-tauri-plugin-window-state = "2.0.2"
+tauri-plugin-window-state = "=2.0.0-beta.9"
-tauri-plugin-dialog = "2.0.4"
+tauri-plugin-dialog = "=2.0.0-beta.9"
 once_cell = "1.19.0"
 futures = "0.3.30"
 reqwest = "0.12.9"
-tokio = "*"
 
 # wasmtime = "22.0.0"
 # wasmtime-wasi = "22.0.0"

src-tauri/capabilities/default.json

@@ -4,6 +4,14 @@
   "description": "enables the default permissions",
   "windows": ["main"],
   "permissions": [
-    "core:default"
+    "path:default",
+    "event:default",
+    "window:default",
+    "webview:default",
+    "app:default",
+    "resources:default",
+    "image:default",
+    "menu:default",
+    "tray:default"
   ]
 }

src-tauri/f.txt

@@ -1,2 +0,0 @@
-Hello, I'm typing a file in vim!!
-

src-tauri/src/aterm.rs

@@ -1,116 +0,0 @@
-use std::result;
-use std::sync::{mpsc, Arc};
-
-use alacritty_terminal::event::{Event, EventListener};
-use alacritty_terminal::event_loop::{EventLoop, Notifier};
-use alacritty_terminal::sync::FairMutex;
-use alacritty_terminal::term::{self, Term};
-use alacritty_terminal::term::cell::Cell;
-use alacritty_terminal::{tty, Grid};
-use tauri::Emitter;
-use shared::term::{TerminalDownMsg, TerminalScreen};
-
-use crate::terminal_size;
-
-#[derive(Clone)]
-pub struct EventProxy(mpsc::Sender<Event>);
-impl EventListener for EventProxy {
-    fn send_event(&self, event: Event) {
-        let _ = self.0.send(event.clone());
-    }
-}
-
-pub struct ATerm {
-    pub term: Arc<FairMutex<Term<EventProxy>>>,
-
-    pub rows : u16,
-    pub cols : u16,
-
-    /// Use tx to write things to terminal instance from outside world
-    pub tx: Notifier,
-
-    /// Use rx to read things from terminal instance.
-    /// Rx only has data when terminal state has changed,
-    /// otherwise, `std::sync::mpsc::recv` will block and sleep
-    /// until there is data.
-    pub rx: mpsc::Receiver<(u64, Event)>,
-}
-
-impl ATerm {
-    pub fn new() -> result::Result<ATerm, std::io::Error> {
-        let (rows, cols) = (21, 85);
-        let id = 1;
-        let pty_config = tty::Options {
-            shell: Some(tty::Shell::new("/bin/bash".to_string(), vec![])),
-            ..tty::Options::default()
-        };
-        let config = term::Config::default();
-        let terminal_size = terminal_size::TerminalSize::new(rows, cols);
-        let pty = tty::new(&pty_config, terminal_size.into(), id)?;
-        let (event_sender, event_receiver) = mpsc::channel();
-        let event_proxy = EventProxy(event_sender);
-        let term = Term::new::<terminal_size::TerminalSize>(
-            config,
-            &terminal_size.into(),
-            event_proxy.clone(),
-        );
-        let term = Arc::new(FairMutex::new(term));
-        let pty_event_loop = EventLoop::new(term.clone(), event_proxy, pty, false, false)?;
-        let notifier = Notifier(pty_event_loop.channel());
-        let (pty_proxy_sender, pty_proxy_receiver) = std::sync::mpsc::channel();
-        // Start pty event loop
-        pty_event_loop.spawn();
-        std::thread::Builder::new()
-            .name(format!("pty_event_subscription_{}", id))
-            .spawn(move || loop {
-                if let Ok(event) = event_receiver.recv() {
-                    if let Event::Exit = event {
-                        break;
-                    }
-                    else {
-                        if let Some(app_handle) = crate::APP_HANDLE.read().unwrap().clone() {
-                            let term = crate::TERM.lock().unwrap();
-                            let content = terminal_instance_to_string(&term);
-                            let payload = TerminalScreen {
-                                cols: term.cols,
-                                rows: term.rows,
-                                content: content
-                            };
-                            let payload = TerminalDownMsg::FullTermUpdate(payload);
-                            let payload = serde_json::json!(payload);
-                            app_handle.emit("term_content", payload).unwrap();
-                        }
-                    }
-                }
-            })?;
-        Ok(ATerm {
-            term,
-            rows,
-            cols,
-            tx: notifier,
-            rx: pty_proxy_receiver,
-        })
-    }
-}
-
-pub fn terminal_instance_to_string(terminal_instance: &ATerm) -> String {
-    let (rows, cols) = (terminal_instance.rows, terminal_instance.cols);
-    let term = terminal_instance.term.lock();
-    let grid = term.grid().clone();
-
-    return term_grid_to_string(&grid, rows, cols);
-}
-
-fn term_grid_to_string(grid: &Grid<Cell>, rows: u16, cols: u16) -> String {
-    let mut term_content = String::with_capacity((rows*cols) as usize);
-
-    // Populate string from grid
-    for indexed in grid.display_iter() {
-        let x = indexed.point.column.0 as usize;
-        let y = indexed.point.line.0 as usize;
-        if y < rows as usize && x < cols as usize {
-            term_content.push(indexed.c);
-        }
-    }
-    return term_content;
-}

src-tauri/src/component_manager/diagram_connectors.rs

@@ -6,7 +6,7 @@ use once_cell::sync::Lazy;
 use shared::{DiagramConnectorMessage, VarFormat};
 use std::sync::Arc;
 use tauri::async_runtime::{Mutex, RwLock};
-use tauri::Emitter;
+use tauri::Manager;
 use wasmtime::component::{Component as WasmtimeComponent, *};
 use wasmtime::{AsContextMut, Engine, Store};
 use wasmtime_wasi::{WasiCtx, WasiView};

src-tauri/src/lib.rs

@@ -5,10 +5,8 @@ use std::sync::{Arc, RwLock as StdRwLock};
 use std::time::Duration;
 use tauri::{async_runtime::RwLock, AppHandle};
 use tauri_plugin_dialog::DialogExt;
-use tokio::time::sleep;
 use wasmtime::AsContextMut;
 use wellen::simple::Waveform;
-use tauri::Emitter;
 
 type Filename = String;
 type JavascriptCode = String;
@@ -22,25 +20,15 @@ type RemovedDiagramConnectorsCount = usize;
 type DiagramConnectorPath = String;
 type DiagramConnectorName = String;
 type ComponentId = String;
-use alacritty_terminal::event::Notify;
-use shared::term::{TerminalDownMsg, TerminalScreen};
 
 mod component_manager;
-mod aterm;
-mod terminal_size;
-use std::sync::Mutex;
 
 pub static APP_HANDLE: Lazy<Arc<StdRwLock<Option<AppHandle>>>> = Lazy::new(<_>::default);
 pub static WAVEFORM: Lazy<StdRwLock<Arc<RwLock<Option<Waveform>>>>> = Lazy::new(<_>::default);
 
-static TERM: Lazy<Mutex<aterm::ATerm>> = Lazy::new(|| {
-    Mutex::new(aterm::ATerm::new().expect("Failed to initialize ATerm"))
-});
-
 #[derive(Default)]
 struct Store {
     waveform: Arc<RwLock<Option<Waveform>>>,
-    val     : Arc<RwLock<bool>>,
 }
 
 #[tauri::command(rename_all = "snake_case")]
@@ -53,30 +41,27 @@ async fn pick_and_load_waveform(
     store: tauri::State<'_, Store>,
     app: tauri::AppHandle,
 ) -> Result<Option<Filename>, ()> {
-    let Some(file_path) = app.dialog().file().blocking_pick_file() else {
+    let Some(file_response) = app.dialog().file().blocking_pick_file() else {
         return Ok(None);
     };
-    let file_buf = file_path.into_path().unwrap();
+    let file_path = file_response.path.as_os_str().to_str().unwrap();
-    let file_str = file_buf.as_os_str().to_str().unwrap();
     // @TODO `read` should accept `Path` instead of `&str`
-    let waveform = wellen::simple::read(file_str);
+    let waveform = wellen::simple::read(file_path);
     let Ok(waveform) = waveform else {
         panic!("Waveform file reading failed")
     };
     *store.waveform.write().await = Some(waveform);
     *WAVEFORM.write().unwrap() = Arc::clone(&store.waveform);
-    Ok(Some(
+    Ok(Some(file_response.name.unwrap()))
-        file_buf.file_name().unwrap().to_string_lossy().to_string(),
-    ))
 }
 
 #[tauri::command(rename_all = "snake_case")]
 async fn load_file_with_selected_vars(app: tauri::AppHandle) -> Result<Option<JavascriptCode>, ()> {
-    let Some(file_path) = app.dialog().file().blocking_pick_file() else {
+    let Some(file_response) = app.dialog().file().blocking_pick_file() else {
         return Ok(None);
     };
     // @TODO Tokio's `fs` or a Tauri `fs`?
-    let Ok(javascript_code) = fs::read_to_string(file_path.into_path().unwrap()) else {
+    let Ok(javascript_code) = fs::read_to_string(file_response.path) else {
         panic!("Selected vars file reading failed")
     };
     Ok(Some(javascript_code))
@@ -155,17 +140,6 @@ async fn unload_signal(signal_ref_index: usize, store: tauri::State<'_, Store>)
     Ok(())
 }
 
-#[tauri::command(rename_all = "snake_case")]
-async fn send_char(c : String) -> Result<(), ()> {
-    if c.len() == 1 {
-        let term = TERM.lock().unwrap();
-        term.tx.notify(c.into_bytes());
-        Ok(())
-    } else {
-        Err(())
-    }
-}
-
 #[tauri::command(rename_all = "snake_case")]
 async fn add_decoders(decoder_paths: Vec<DecoderPath>) -> Result<AddedDecodersCount, ()> {
     Ok(component_manager::decoders::add_decoders(decoder_paths).await)
@@ -209,66 +183,44 @@ async fn notify_diagram_connector_text_change(
 
 #[tauri::command(rename_all = "snake_case")]
 async fn open_konata_file(app: tauri::AppHandle) {
-    let Some(file_path) = app.dialog().file().blocking_pick_file() else {
+    let Some(file_response) = app.dialog().file().blocking_pick_file() else {
         return;
     };
-    let file_str = file_path
+    let file_path = file_response.path.into_os_string().into_string().unwrap();
-        .into_path()
+
-        .unwrap()
+    spawn_konata_app();
-        .into_os_string()
-        .into_string()
-        .unwrap();
 
     let port = 30000;
     let base_url = format!("http://localhost:{port}");
     let client = reqwest::Client::builder()
-        .connect_timeout(Duration::from_secs(1))
+        .timeout(Duration::from_secs(30))
         .build()
         .unwrap();
-
+    if client
-    let mut konata_server_ready = false;
+        .get(format!("{base_url}/status"))
-
-    let is_konata_server_ready = || async {
-        client
-            .get(format!("{base_url}/status"))
-            .send()
-            .await
-            .is_ok()
-    };
-
-    if is_konata_server_ready().await {
-        konata_server_ready = true;
-    } else {
-        spawn_konata_app();
-    }
-
-    let mut attempts = 1;
-    while !konata_server_ready {
-        attempts += 1;
-        if attempts > 5 {
-            eprintln!("Failed to get Konata server status (5 attempts)");
-            return;
-        }
-        konata_server_ready = is_konata_server_ready().await;
-        sleep(Duration::from_secs(1)).await;
-    }
-
-    client
-        .post(format!("{base_url}/open-konata-file"))
-        .json(&serde_json::json!({
-            "file_path": file_str
-        }))
         .send()
         .await
-        .unwrap()
+        .is_ok()
-        .error_for_status()
+    {
-        .unwrap();
+        client
+            .post(format!("{base_url}/open-konata-file"))
+            .json(&serde_json::json!({
+                "file_path": file_path
+            }))
+            .send()
+            .await
+            .unwrap()
+            .error_for_status()
+            .unwrap();
+    } else {
+        println!("Failed to get Konata server status");
+    }
 }
 
 #[cfg(target_family = "windows")]
 fn spawn_konata_app() {
     Command::new("cscript")
-        .current_dir("../../Konata")
+        .current_dir("../../konata")
         .arg("konata.vbs")
         .spawn()
         .unwrap();
@@ -277,7 +229,7 @@ fn spawn_konata_app() {
 #[cfg(target_family = "unix")]
 fn spawn_konata_app() {
     Command::new("sh")
-        .current_dir("../../Konata")
+        .current_dir("../../konata")
         .arg("konata.sh")
         .spawn()
         .unwrap();
@@ -301,7 +253,6 @@ pub fn run() {
             get_hierarchy,
             load_signal_and_get_timeline,
             unload_signal,
-            send_char,
             add_decoders,
             remove_all_decoders,
             add_diagram_connectors,
@@ -311,27 +262,6 @@ pub fn run() {
         ])
         .setup(|app| {
             *APP_HANDLE.write().unwrap() = Some(app.handle().to_owned());
-            println!("Setting up yay!");
-
-            std::thread::spawn(move || {
-                // Simulate emitting a message after a delay
-                std::thread::sleep(std::time::Duration::from_secs(1));
-
-                //tart term and send initial update to backend
-                if let Some(app_handle) = crate::APP_HANDLE.read().unwrap().clone() {
-                    let term = crate::TERM.lock().unwrap();
-                    let content = crate::aterm::terminal_instance_to_string(&term);
-                    let payload = TerminalScreen {
-                        cols: term.cols,
-                        rows: term.rows,
-                        content: content
-                    };
-                    let payload = TerminalDownMsg::FullTermUpdate(payload);
-                    let payload = serde_json::json!(payload);
-                    app_handle.emit("term_content", payload).unwrap();
-                }
-            });
-
             Ok(())
         })
         .run(tauri::generate_context!())

src-tauri/src/main.rs

@@ -1,8 +1,6 @@
 // Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-mod terminal_size;
-
 fn main() {
     app_lib::run();
 }

src-tauri/src/terminal_size.rs

@@ -1,55 +0,0 @@
-use alacritty_terminal::event::{WindowSize};
-use alacritty_terminal::grid::{Dimensions};
-use alacritty_terminal::index::{Column, Line};
-
-#[derive(Clone, Copy, Debug)]
-pub struct TerminalSize {
-    pub cell_width: u16,
-    pub cell_height: u16,
-    pub num_cols: u16,
-    pub num_lines: u16,
-}
-
-impl TerminalSize {
-    pub fn new(rows : u16, cols : u16) -> Self {
-        Self {
-            cell_width: 1,
-            cell_height: 1,
-            num_cols: cols,
-            num_lines: rows,
-        }
-    }
-}
-
-impl Dimensions for TerminalSize {
-    fn total_lines(&self) -> usize {
-        self.screen_lines()
-    }
-
-    fn screen_lines(&self) -> usize {
-        self.num_lines as usize
-    }
-
-    fn columns(&self) -> usize {
-        self.num_cols as usize
-    }
-
-    fn last_column(&self) -> Column {
-        Column(self.num_cols as usize - 1)
-    }
-
-    fn bottommost_line(&self) -> Line {
-        Line(self.num_lines as i32 - 1)
-    }
-}
-
-impl From<TerminalSize> for WindowSize {
-    fn from(size: TerminalSize) -> Self {
-        Self {
-            num_lines: size.num_lines,
-            num_cols: size.num_cols,
-            cell_width: size.cell_width,
-            cell_height: size.cell_height,
-        }
-    }
-}