egui: put sender and receiver in wrapper objects

src/bin/topola-egui/app.rs

@@ -41,8 +41,8 @@ use topola::{
 };
 
 use crate::{
-    bottom::Bottom, layers::Layers, overlay::Overlay, painter::Painter, top::Top,
+    bottom::Bottom, file_receiver::FileReceiver, layers::Layers, overlay::Overlay,
-    viewport::Viewport,
+    painter::Painter, top::Top, viewport::Viewport,
 };
 
 /// Deserialize/Serialize is needed to persist app state between restarts.
@@ -59,7 +59,7 @@ pub struct App {
     maybe_execute: Option<ExecuteWithStatus>,
 
     #[serde(skip)]
-    text_channel: (Sender<String>, Receiver<String>),
+    content_channel: (Sender<String>, Receiver<String>),
 
     #[serde(skip)]
     viewport: Viewport,
@@ -83,7 +83,7 @@ impl Default for App {
             maybe_overlay: None,
             arc_mutex_maybe_invoker: Arc::new(Mutex::new(None)),
             maybe_execute: None,
-            text_channel: channel(),
+            content_channel: channel(),
             viewport: Viewport::new(),
             top: Top::new(),
             bottom: Bottom::new(),
@@ -113,29 +113,16 @@ impl App {
 
         self.update_counter = 0.0;
 
-        if cfg!(target_arch = "wasm32") {
+        let mut file_receiver = FileReceiver::new(&self.content_channel.1);
-            if let Ok(file_contents) = self.text_channel.1.try_recv() {
+
-                let design = SpecctraDesign::load(file_contents.as_bytes()).unwrap();
+        if let Ok(bufread) = file_receiver.try_recv() {
-                let board = design.make_board();
+            let design = SpecctraDesign::load(bufread).unwrap();
-                self.maybe_overlay = Some(Overlay::new(&board).unwrap());
+            let board = design.make_board();
-                self.maybe_layers = Some(Layers::new(&board));
+            self.maybe_overlay = Some(Overlay::new(&board).unwrap());
-                self.arc_mutex_maybe_invoker = Arc::new(Mutex::new(Some(Invoker::new(
+            self.maybe_layers = Some(Layers::new(&board));
-                    Autorouter::new(board).unwrap(),
+            self.arc_mutex_maybe_invoker = Arc::new(Mutex::new(Some(Invoker::new(
-                ))));
+                Autorouter::new(board).unwrap(),
-            }
+            ))))
-        } else {
-            if let Ok(path) = self.text_channel.1.try_recv() {
-                let design = SpecctraDesign::load(&mut std::io::BufReader::new(
-                    std::fs::File::open(path).unwrap(),
-                ))
-                .unwrap();
-                let board = design.make_board();
-                self.maybe_overlay = Some(Overlay::new(&board).unwrap());
-                self.maybe_layers = Some(Layers::new(&board));
-                self.arc_mutex_maybe_invoker = Arc::new(Mutex::new(Some(Invoker::new(
-                    Autorouter::new(board).unwrap(),
-                ))));
-            }
         }
 
         if let Some(invoker) = self.arc_mutex_maybe_invoker.lock().unwrap().as_mut() {
@@ -161,7 +148,7 @@ impl eframe::App for App {
 
         self.top.update(
             ctx,
-            self.text_channel.0.clone(),
+            self.content_channel.0.clone(),
             self.arc_mutex_maybe_invoker.clone(),
             &mut self.maybe_execute,
             &mut self.maybe_overlay,

src/bin/topola-egui/file_receiver.rs

@@ -0,0 +1,24 @@
+use std::io::BufReader;
+use std::sync::mpsc::{Receiver, TryRecvError};
+
+pub struct FileReceiver<'a> {
+    receiver: &'a Receiver<String>,
+}
+
+impl<'a> FileReceiver<'a> {
+    pub fn new(receiver: &'a Receiver<String>) -> Self {
+        Self { receiver }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn try_recv(&mut self) -> Result<BufReader<std::fs::File>, TryRecvError> {
+        Ok(std::io::BufReader::new(
+            std::fs::File::open(self.receiver.try_recv()?).unwrap(),
+        ))
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub fn try_recv(&mut self) -> Result<&[u8], TryRecvError> {
+        self.receiver.try_recv().unwrap().as_bytes()
+    }
+}

src/bin/topola-egui/file_sender.rs

@@ -0,0 +1,27 @@
+use std::sync::mpsc::{SendError, Sender};
+
+pub struct FileSender {
+    sender: Sender<String>,
+}
+
+impl FileSender {
+    pub fn new(sender: Sender<String>) -> Self {
+        Self { sender }
+    }
+
+    pub async fn send(&self, file_handle: rfd::FileHandle) -> Result<(), SendError<String>> {
+        self.sender.send(self.handle_text(&file_handle).await)
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    async fn handle_text(&self, file_handle: &rfd::FileHandle) -> String {
+        file_handle.path().to_str().unwrap().to_string()
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    async fn handle_text(&self, file_handle: &rfd::FileHandle) {
+        std::str::from_utf8(&file_handle.read().await)
+            .unwrap()
+            .to_string()
+    }
+}

src/bin/topola-egui/main.rs

@@ -2,6 +2,8 @@
 
 mod app;
 mod bottom;
+mod file_receiver;
+mod file_sender;
 mod layers;
 mod overlay;
 mod painter;

src/bin/topola-egui/top.rs

@@ -10,6 +10,7 @@ use topola::{
 
 use crate::{
     app::{channel_text, execute},
+    file_sender::FileSender,
     overlay::Overlay,
 };
 
@@ -47,7 +48,8 @@ impl Top {
 
                         execute(async move {
                             if let Some(file_handle) = task.await {
-                                sender.send(channel_text(file_handle).await);
+                                let file_sender = FileSender::new(sender);
+                                file_sender.send(file_handle).await;
                                 ctx.request_repaint();
                             }
                         });