Forward script messages from IPC to client

apps/magpie/src/service/ipc.rs

@@ -91,7 +91,8 @@ pub struct Client {
 impl Drop for Client {
     fn drop(&mut self) {
         println!("Client #{} disconnected", self.token.0);
-        let data = self.data.write();
+
+        let mut data = self.data.write();
         let _ = data
             .poll
             .registry()
@@ -100,13 +101,16 @@ impl Drop for Client {
         for (_id, window) in self.id_to_window.drain() {
             let msg = WindowMessage::CloseWindow { id: window };
             let _ = self.window_sender.send_event(msg);
+            data.window_to_client_panel.remove(&window);
         }
     }
 }
 
 impl Client {
     pub fn on_readable(&mut self) -> std::io::Result<bool> {
-        self.messenger.flush_recv()?;
+        if let Err(err) = self.messenger.flush_recv() {
+            eprintln!("flush_recv() error: {:?}", err);
+        }
 
         while let Some(msg) = self.messenger.recv() {
             println!("Client #{}: {:?}", self.token.0, msg);
@@ -116,7 +120,11 @@ impl Client {
                     protocol,
                     script,
                 }) => {
-                    let window = self.data.write().new_window_id();
+                    let mut data = self.data.write();
+
+                    let window = data.new_window_id();
+                    data.window_to_client_panel
+                        .insert(window, (self.token.0, id));
 
                     if let Some(old_id) = self.id_to_window.insert(id, window) {
                         let msg = WindowMessage::CloseWindow { id: old_id };
@@ -147,7 +155,6 @@ pub struct Ipc {
     pub data: Arc<RwLock<IpcData>>,
     pub window_sender: WindowMessageSender,
     pub message_recv: Receiver<IpcMessage>,
-    pub events: Events,
     pub quit: bool,
     pub listener: Listener,
     pub signals: Signals,
@@ -171,7 +178,6 @@ impl Ipc {
 
         let mut signals = Signals::new(Signal::Interrupt | Signal::Quit)?;
 
-        let events = Events::with_capacity(128);
         let poll = Poll::new()?;
         let listener_token = Token(usize::MAX);
         let signals_token = Token(listener_token.0 - 1);
@@ -199,7 +205,6 @@ impl Ipc {
             data: Arc::new(RwLock::new(data)),
             window_sender,
             message_recv,
-            events,
             quit: false,
             listener,
             signals,
@@ -212,10 +217,29 @@ impl Ipc {
         Ok((ipc, sender))
     }
 
-    pub fn poll(&mut self, timeout: Option<Duration>) -> std::io::Result<()> {
-        self.data.write().poll.poll(&mut self.events, timeout)?;
+    pub fn on_message(&mut self, msg: IpcMessage) -> std::io::Result<()> {
+        match msg {
+            IpcMessage::PanelMessage { window, message } => {
+                let data = self.data.read();
+                let (client, panel) = *data.window_to_client_panel.get(&window).unwrap();
+                let client = self.clients.get_mut(client).unwrap();
+                let reply = RecvMessage {
+                    id: panel,
+                    msg: message,
+                };
+                client
+                    .messenger
+                    .send(&MagpieClientMsg::RecvMessage(reply))?;
+            }
+        }
 
-        for event in self.events.iter() {
+        Ok(())
+    }
+
+    pub fn poll(&mut self, events: &mut Events, timeout: Option<Duration>) -> std::io::Result<()> {
+        self.data.write().poll.poll(events, timeout)?;
+
+        for event in events.iter() {
             if event.token() == self.listener_token {
                 loop {
                     match self.listener.accept() {
@@ -251,6 +275,10 @@ impl Ipc {
                     let _ = self.window_sender.send_event(WindowMessage::Quit);
                     self.quit = true;
                 }
+            } else if event.token() == self.message_recv_token {
+                while let Ok(received) = self.message_recv.try_recv() {
+                    self.on_message(received)?;
+                }
             } else if let Some(client) = self.clients.get_mut(event.token().0) {
                 let disconnected = client.on_readable()?;
                 if disconnected {
@@ -265,9 +293,10 @@ impl Ipc {
     }
 
     pub fn run(mut self) {
+        let mut events = Events::with_capacity(128);
         while !self.quit {
             let wait = Duration::from_millis(100);
-            match self.poll(Some(wait)) {
+            match self.poll(&mut events, Some(wait)) {
                 Ok(_) => {}
                 Err(e) => {
                     eprintln!("IPC poll error: {:?}", e);