The RawFd has been slain...

src/main.rs

@@ -23,6 +23,7 @@ use std::thread;
 
 use serde::{Deserialize, Serialize};
 use structopt::StructOpt;
+use terminal_pane::PaneId;
 
 use crate::command_is_executing::CommandIsExecuting;
 use crate::errors::{AppContext, ContextType, ErrorContext, PtyContext, ScreenContext};
@@ -222,21 +223,21 @@ pub fn start(mut os_input: Box<dyn OsApi>, opts: Opt) {
                                 let pid = pty_bus.spawn_terminal(file_to_open);
                                 pty_bus
                                     .send_screen_instructions
-                                    .send(ScreenInstruction::NewPane(pid))
+                                    .send(ScreenInstruction::NewPane(PaneId::Terminal(pid)))
                                     .unwrap();
                             }
                             PtyInstruction::SpawnTerminalVertically(file_to_open) => {
                                 let pid = pty_bus.spawn_terminal(file_to_open);
                                 pty_bus
                                     .send_screen_instructions
-                                    .send(ScreenInstruction::VerticalSplit(pid))
+                                    .send(ScreenInstruction::VerticalSplit(PaneId::Terminal(pid)))
                                     .unwrap();
                             }
                             PtyInstruction::SpawnTerminalHorizontally(file_to_open) => {
                                 let pid = pty_bus.spawn_terminal(file_to_open);
                                 pty_bus
                                     .send_screen_instructions
-                                    .send(ScreenInstruction::HorizontalSplit(pid))
+                                    .send(ScreenInstruction::HorizontalSplit(PaneId::Terminal(pid)))
                                     .unwrap();
                             }
                             PtyInstruction::NewTab => {
@@ -378,7 +379,7 @@ pub fn start(mut os_input: Box<dyn OsApi>, opts: Opt) {
                                 screen
                                     .get_active_tab_mut()
                                     .unwrap()
-                                    .toggle_active_terminal_fullscreen();
+                                    .toggle_active_pane_fullscreen();
                             }
                             ScreenInstruction::NewTab(pane_id) => {
                                 screen.new_tab(pane_id);

src/pty_bus.rs

@@ -9,10 +9,13 @@ use ::std::time::{Duration, Instant};
 use ::vte;
 use std::path::PathBuf;
 
-use crate::errors::{ContextType, ErrorContext};
 use crate::layout::Layout;
 use crate::os_input_output::OsApi;
 use crate::utils::logging::debug_to_file;
+use crate::{
+    errors::{ContextType, ErrorContext},
+    terminal_pane::PaneId,
+};
 use crate::{ScreenInstruction, SenderWithContext, OPENCALLS};
 
 pub struct ReadFromPid {
@@ -148,8 +151,8 @@ pub enum PtyInstruction {
     SpawnTerminalVertically(Option<PathBuf>),
     SpawnTerminalHorizontally(Option<PathBuf>),
     NewTab,
-    ClosePane(RawFd),
+    ClosePane(PaneId),
-    CloseTab(Vec<RawFd>),
+    CloseTab(Vec<PaneId>),
     Quit,
 }
 
@@ -231,7 +234,7 @@ fn stream_terminal_bytes(
             // we read everything, rather than hanging until there is new data
             // a better solution would be to fix the test fakes, but this will do for now
             send_screen_instructions
-                .send(ScreenInstruction::ClosePane(pid))
+                .send(ScreenInstruction::ClosePane(PaneId::Terminal(pid)))
                 .unwrap();
         }
     });
@@ -287,11 +290,13 @@ impl PtyBus {
             );
         }
     }
-    pub fn close_pane(&mut self, id: RawFd) {
+    pub fn close_pane(&mut self, id: PaneId) {
+        if let PaneId::Terminal(id) = id {
             let child_pid = self.id_to_child_pid.get(&id).unwrap();
             self.os_input.kill(*child_pid).unwrap();
         }
-    pub fn close_tab(&mut self, ids: Vec<RawFd>) {
+    }
+    pub fn close_tab(&mut self, ids: Vec<PaneId>) {
         ids.iter().for_each(|id| self.close_pane(*id));
     }
 }

src/screen.rs

@@ -2,12 +2,12 @@ use std::collections::BTreeMap;
 use std::os::unix::io::RawFd;
 use std::sync::mpsc::Receiver;
 
-use crate::layout::Layout;
 use crate::os_input_output::OsApi;
 use crate::pty_bus::{PtyInstruction, VteEvent};
 use crate::tab::Tab;
 use crate::terminal_pane::PositionAndSize;
 use crate::{errors::ErrorContext, wasm_vm::PluginInstruction};
+use crate::{layout::Layout, terminal_pane::PaneId};
 use crate::{AppInstruction, SenderWithContext};
 
 /*
@@ -23,9 +23,9 @@ use crate::{AppInstruction, SenderWithContext};
 pub enum ScreenInstruction {
     Pty(RawFd, VteEvent),
     Render,
-    NewPane(RawFd),
+    NewPane(PaneId),
-    HorizontalSplit(RawFd),
+    HorizontalSplit(PaneId),
-    VerticalSplit(RawFd),
+    VerticalSplit(PaneId),
     WriteCharacter(Vec<u8>),
     ResizeLeft,
     ResizeRight,
@@ -42,7 +42,7 @@ pub enum ScreenInstruction {
     ClearScroll,
     CloseFocusedPane,
     ToggleActiveTerminalFullscreen,
-    ClosePane(RawFd),
+    ClosePane(PaneId),
     ApplyLayout((Layout, Vec<RawFd>)),
     NewTab(RawFd),
     SwitchTabNext,
@@ -94,7 +94,7 @@ impl Screen {
             self.send_plugin_instructions.clone(),
             self.send_app_instructions.clone(),
             self.max_panes,
-            Some(pane_id),
+            Some(PaneId::Terminal(pane_id)),
         );
         self.active_tab_index = Some(tab_index);
         self.tabs.insert(tab_index, tab);
@@ -139,7 +139,7 @@ impl Screen {
             self.switch_tab_prev();
         }
         let mut active_tab = self.tabs.remove(&active_tab_index).unwrap();
-        let pane_ids = active_tab.get_terminal_pane_ids();
+        let pane_ids = active_tab.get_pane_ids();
         self.send_pty_instructions
             .send(PtyInstruction::CloseTab(pane_ids))
             .unwrap();

src/terminal_pane/plugin_pane.rs

@@ -1,12 +1,10 @@
 #![allow(clippy::clippy::if_same_then_else)]
 
-use crate::{
+use crate::{pty_bus::VteEvent, tab::Pane, wasm_vm::PluginInstruction, SenderWithContext};
-    pty_bus::VteEvent, tab::Pane, utils::shared::*, wasm_vm::PluginInstruction, SenderWithContext,
-};
 
-use std::{iter, os::unix::prelude::RawFd, sync::mpsc::channel};
+use std::{sync::mpsc::channel, unimplemented};
 
-use crate::terminal_pane::PositionAndSize;
+use crate::terminal_pane::{PaneId, PositionAndSize};
 
 pub struct PluginPane {
     pub pid: u32,
@@ -75,14 +73,14 @@ impl Pane for PluginPane {
         self.position_and_size_override = Some(position_and_size_override);
         self.should_render = true;
     }
-    fn handle_event(&mut self, event: VteEvent) {
+    fn handle_event(&mut self, _event: VteEvent) {
-        todo!()
+        unimplemented!()
     }
     fn cursor_coordinates(&self) -> Option<(usize, usize)> {
         None
     }
-    fn adjust_input_to_terminal(&self, input_bytes: Vec<u8>) -> Vec<u8> {
+    fn adjust_input_to_terminal(&self, _input_bytes: Vec<u8>) -> Vec<u8> {
-        todo!() // FIXME: Shouldn't need this implmented?
+        unimplemented!() // FIXME: Shouldn't need this implmented?
     }
 
     fn position_and_size_override(&self) -> Option<PositionAndSize> {
@@ -118,10 +116,8 @@ impl Pane for PluginPane {
             None
         }
     }
-    // FIXME: Really shouldn't be in this trait...
+    fn pid(&self) -> PaneId {
-    fn pid(&self) -> RawFd {
+        PaneId::Plugin(self.pid)
-        // FIXME: This looks like a really bad idea!
-        100 + self.pid as RawFd
     }
     fn reduce_height_down(&mut self, count: usize) {
         self.position_and_size.y += count;
@@ -159,13 +155,13 @@ impl Pane for PluginPane {
         self.position_and_size.columns += count;
         self.should_render = true;
     }
-    fn scroll_up(&mut self, count: usize) {
+    fn scroll_up(&mut self, _count: usize) {
-        todo!()
+        unimplemented!()
     }
-    fn scroll_down(&mut self, count: usize) {
+    fn scroll_down(&mut self, _count: usize) {
-        todo!()
+        unimplemented!()
     }
     fn clear_scroll(&mut self) {
-        todo!()
+        unimplemented!()
     }
 }

src/terminal_pane/terminal_pane.rs

@@ -1,15 +1,22 @@
 #![allow(clippy::clippy::if_same_then_else)]
 
-use crate::{tab::Pane, utils::shared::ansi_len};
+use crate::tab::Pane;
 use ::nix::pty::Winsize;
 use ::std::os::unix::io::RawFd;
 use ::vte::Perform;
 
-use crate::terminal_pane::terminal_character::{CharacterStyles, NamedColor, TerminalCharacter};
+use crate::terminal_pane::terminal_character::{CharacterStyles, TerminalCharacter};
 use crate::terminal_pane::Scroll;
 use crate::utils::logging::debug_log_to_file;
 use crate::VteEvent;
 
+#[derive(PartialEq, Eq, Ord, PartialOrd, Hash, Clone, Copy, Debug)]
+pub enum PaneId {
+    Terminal(RawFd),
+    Plugin(u32), // FIXME: Drop the trait object, make this a wrapper for the struct?
+    BuiltIn(u32),
+}
+
 #[derive(Clone, Copy, Debug)]
 pub struct PositionAndSize {
     pub x: usize,
@@ -200,8 +207,8 @@ impl Pane for TerminalPane {
             None
         }
     }
-    fn pid(&self) -> RawFd {
+    fn pid(&self) -> PaneId {
-        self.pid
+        PaneId::Terminal(self.pid)
     }
     fn reduce_height_down(&mut self, count: usize) {
         self.position_and_size.y += count;
@@ -279,7 +286,8 @@ impl TerminalPane {
     pub fn mark_for_rerender(&mut self) {
         self.should_render = true;
     }
-    pub fn handle_event(&mut self, event: VteEvent) {
+    // FIXME: Should this be removed?
+    pub fn _handle_event(&mut self, event: VteEvent) {
         match event {
             VteEvent::Print(c) => {
                 self.print(c);

src/utils/shared.rs

@@ -4,7 +4,10 @@ use strip_ansi_escapes::strip;
 
 // FIXME: Should this be an extension trait? Or here at all?
 pub fn ansi_len(s: &str) -> usize {
-    from_utf8(&strip(s.as_bytes()).unwrap()).unwrap().chars().count()
+    from_utf8(&strip(s.as_bytes()).unwrap())
+        .unwrap()
+        .chars()
+        .count()
 }
 
 pub fn pad_to_size(s: &str, rows: usize, columns: usize) -> String {