deja_vu/config/config.json5

@@ -87,41 +87,5 @@
       "<Ctrl-c>": "Quit", // Yet another way to quit
       "<Ctrl-z>": "Suspend" // Suspend the application
     },
-    // Diagnostic modes
-    "DiagMenu": {
-      "<Enter>": "Process",
-      "<q>": "Quit", // Quit the application
-      "<Ctrl-d>": "Quit", // Another way to quit
-      "<Ctrl-c>": "Quit", // Yet another way to quit
-      "<Ctrl-z>": "Suspend" // Suspend the application
-    },
-    "BootDiags": {
-      "<Enter>": "Process",
-      "<q>": "Quit", // Quit the application
-      "<Ctrl-d>": "Quit", // Another way to quit
-      "<Ctrl-c>": "Quit", // Yet another way to quit
-      "<Ctrl-z>": "Suspend" // Suspend the application
-    },
-    "BootSetup": {
-      "<Enter>": "Process",
-      "<q>": "Quit", // Quit the application
-      "<Ctrl-d>": "Quit", // Another way to quit
-      "<Ctrl-c>": "Quit", // Yet another way to quit
-      "<Ctrl-z>": "Suspend" // Suspend the application
-    },
-    "InjectDrivers": {
-      "<Enter>": "Process",
-      "<q>": "Quit", // Quit the application
-      "<Ctrl-d>": "Quit", // Another way to quit
-      "<Ctrl-c>": "Quit", // Yet another way to quit
-      "<Ctrl-z>": "Suspend" // Suspend the application
-    },
-    "ToggleSafeBoot": {
-      "<Enter>": "Process",
-      "<q>": "Quit", // Quit the application
-      "<Ctrl-d>": "Quit", // Another way to quit
-      "<Ctrl-c>": "Quit", // Yet another way to quit
-      "<Ctrl-z>": "Suspend" // Suspend the application
-    },
   }
 }

deja_vu/src/app.rs

@@ -31,7 +31,6 @@ use tracing::{debug, info};
 
 use crate::{
     action::Action,
-    cli,
     components::{
         footer::Footer, fps::FpsCounter, left::Left, popup, right::Right, title::Title, Component,
     },
@@ -58,7 +57,6 @@ pub struct App {
     should_suspend: bool,
     tick_rate: f64,
     // App
-    cli_cmd: cli::Command,
     cur_mode: Mode,
     disk_index_dest: Option<usize>,
     disk_index_source: Option<usize>,
@@ -86,16 +84,10 @@ pub enum Mode {
     PostClone,
     Done,
     Failed,
-    // Diagnostic modes
-    DiagMenu,
-    BootDiags,
-    BootSetup,
-    InjectDrivers,
-    ToggleSafeBoot,
 }
 
 impl App {
-    pub fn new(cli_cmd: cli::Command, tick_rate: f64, frame_rate: f64) -> Result<Self> {
+    pub fn new(tick_rate: f64, frame_rate: f64) -> Result<Self> {
         let (action_tx, action_rx) = mpsc::unbounded_channel();
         let disk_list_arc = Arc::new(Mutex::new(Vec::new()));
         let mut tasks = Tasks::new(action_tx.clone(), disk_list_arc.clone());
@@ -105,14 +97,13 @@ impl App {
             action_rx,
             action_tx,
             components: vec![
-                Box::new(Title::new(cli_cmd)),
+                Box::new(Title::new()),
                 Box::new(FpsCounter::new()),
                 Box::new(Left::new()),
                 Box::new(Right::new()),
                 Box::new(Footer::new()),
                 Box::new(popup::Popup::new()),
             ],
-            cli_cmd,
             config: Config::new()?,
             frame_rate,
             last_tick_key_events: Vec::new(),
@@ -120,10 +111,7 @@ impl App {
             should_suspend: false,
             tick_rate,
             // App
-            cur_mode: match cli_cmd {
+            cur_mode: Mode::ScanDisks,
-                cli::Command::Clone => Mode::ScanDisks,
-                cli::Command::Diagnose => Mode::DiagMenu,
-            },
             disk_index_dest: None,
             disk_index_source: None,
             disk_list: disk_list_arc,
@@ -139,7 +127,6 @@ impl App {
 
     pub fn next_mode(&mut self) -> Option<Mode> {
         let new_mode = match (self.prev_mode, self.cur_mode) {
-            // Clone states
             (_, Mode::InstallDrivers) => Mode::ScanDisks,
             (_, Mode::ScanDisks) => Mode::SelectDisks,
             (_, Mode::SelectDisks | Mode::SelectTableType | Mode::SelectParts) => {
@@ -156,14 +143,6 @@ impl App {
             (Mode::SelectParts, Mode::Confirm) => Mode::PostClone,
             (_, Mode::PostClone | Mode::Done) => Mode::Done,
             (_, Mode::Failed) => Mode::Failed,
-
-            // Diagnostic states
-            (_, Mode::DiagMenu) => Mode::BootDiags,
-            (_, Mode::BootDiags) => Mode::BootSetup,
-            (_, Mode::BootSetup) => Mode::InjectDrivers,
-            (_, Mode::InjectDrivers) => Mode::ToggleSafeBoot,
-            (_, Mode::ToggleSafeBoot) => Mode::Done,
-
             // Invalid states
             (_, Mode::Confirm) => panic!("This shouldn't happen."),
         };
@@ -268,7 +247,7 @@ impl App {
 
                         // Inject driver(s) (if selected)
                         if let Some(driver) = &self.driver {
-                            if let Ok(task) = boot::inject_driver(driver, &letter_os, &system32) {
+                            if let Ok(task) = boot::inject_driver(&driver, &letter_os, &system32) {
                                 self.tasks.add(task);
                             } else {
                                 self.action_tx.send(Action::Error(format!(
@@ -309,16 +288,6 @@ impl App {
         }
 
         let action_tx = self.action_tx.clone();
-        // Init based on cli::Command
-        match self.cli_cmd {
-            cli::Command::Clone => {
-                action_tx.send(Action::SetMode(Mode::ScanDisks))?;
-            }
-            cli::Command::Diagnose => {
-                action_tx.send(Action::SetMode(Mode::DiagMenu))?;
-            }
-        }
-
         loop {
             self.handle_events(&mut tui).await?;
             self.handle_actions(&mut tui)?;

deja_vu/src/cli.rs

@@ -13,17 +13,13 @@
 // You should have received a copy of the GNU General Public License
 // along with Deja-vu. If not, see <https://www.gnu.org/licenses/>.
 //
-use clap::{Parser, Subcommand};
+use clap::Parser;
 
 use crate::config::{get_config_dir, get_data_dir};
 
 #[derive(Parser, Debug)]
 #[command(author, version = version(), about)]
 pub struct Cli {
-    /// App mode
-    #[command(subcommand)]
-    pub cli_cmd: Command,
-
     /// Tick rate, i.e. number of ticks per second
     #[arg(short, long, value_name = "FLOAT", default_value_t = 4.0)]
     pub tick_rate: f64,
@@ -33,15 +29,6 @@ pub struct Cli {
     pub frame_rate: f64,
 }
 
-#[derive(Clone, Copy, Debug, Subcommand)]
-pub enum Command {
-    /// Clone Windows from one disk to another
-    Clone,
-
-    /// Diagnose Windows boot issues
-    Diagnose,
-}
-
 const VERSION_MESSAGE: &str = concat!(
     env!("CARGO_PKG_VERSION"),
     "-",

deja_vu/src/components/footer.rs

@@ -53,7 +53,6 @@ impl Component for Footer {
     fn update(&mut self, action: Action) -> Result<Option<Action>> {
         if let Action::SetMode(new_mode) = action {
             self.text = match new_mode {
-                // Clone modes
                 Mode::ScanDisks | Mode::PreClone | Mode::Clone | Mode::PostClone => {
                     String::from("(q) to quit")
                 }
@@ -70,13 +69,6 @@ impl Component for Footer {
                 Mode::Done | Mode::Failed | Mode::InstallDrivers => {
                     String::from("(Enter) or (q) to quit")
                 }
-
-                // Diagnostic modes
-                Mode::DiagMenu
-                | Mode::BootDiags
-                | Mode::BootSetup
-                | Mode::InjectDrivers
-                | Mode::ToggleSafeBoot => String::from("(q) to quit"),
             }
         }
         Ok(None)

deja_vu/src/components/left.rs

@@ -163,15 +163,6 @@ impl Component for Left {
                         }
                     }
                 }
-                Mode::DiagMenu
-                | Mode::BootDiags
-                | Mode::BootSetup
-                | Mode::InjectDrivers
-                | Mode::ToggleSafeBoot => {
-                    if let Some(command_tx) = self.command_tx.clone() {
-                        command_tx.send(Action::NextScreen)?;
-                    }
-                }
                 _ => {}
             },
             Action::Select(Some(index), None) => self.selections[0] = Some(index),
@@ -227,13 +218,6 @@ impl Component for Left {
                         self.title_text = String::from("Confirm Selections (Again)");
                     }
                     (_, Mode::Done | Mode::Failed) => self.title_text = String::from("Done"),
-                    // Diagnostic states
-                    (_, Mode::DiagMenu) => self.title_text = String::from("Main Menu"),
-                    (_, Mode::BootDiags) => self.title_text = String::from("Boot Diagnostics"),
-                    (_, Mode::BootSetup) => self.title_text = String::from("Boot Setup"),
-                    (_, Mode::InjectDrivers) => self.title_text = String::from("Inject Drivers"),
-                    (_, Mode::ToggleSafeBoot) => self.title_text = String::from("Toggle Safe Mode"),
-
                     // Invalid states
                     (_, Mode::Confirm) => panic!("This shouldn't happen."),
                 }
@@ -286,18 +270,10 @@ impl Component for Left {
 
         // Body
         match self.mode {
-            // Clone modes
             Mode::ScanDisks
             | Mode::PreClone
             | Mode::Clone
             | Mode::PostClone
-            // Diagnostic modes
-            | Mode::DiagMenu
-            | Mode::BootDiags
-            | Mode::BootSetup
-            | Mode::InjectDrivers
-            | Mode::ToggleSafeBoot
-            // Done
             | Mode::Done
             | Mode::Failed => {
                 // Leave blank

deja_vu/src/components/popup.rs

@@ -45,7 +45,7 @@ pub struct Popup {
 impl Popup {
     pub fn new() -> Self {
         Self {
-            popup_text: String::new(),
+            popup_text: String::from("Scanning Disks..."),
             ..Default::default()
         }
     }

deja_vu/src/components/right.rs

@@ -86,7 +86,7 @@ impl Component for Right {
             },
             Action::Process => {
                 if self.prev_mode == Mode::SelectDisks && self.cur_mode == Mode::Confirm {
-                    self.selected_disks.clone_from(&self.selections);
+                    self.selected_disks = self.selections.clone();
                 }
             }
             Action::Select(one, two) => {

deja_vu/src/components/title.rs

@@ -21,25 +21,17 @@ use ratatui::{
 use tokio::sync::mpsc::UnboundedSender;
 
 use super::Component;
-use crate::{action::Action, cli, config::Config};
+use crate::{action::Action, config::Config};
 
 #[derive(Default)]
 pub struct Title {
     command_tx: Option<UnboundedSender<Action>>,
     config: Config,
-    title_text: String,
 }
 
 impl Title {
-    pub fn new(cli_cmd: cli::Command) -> Self {
+    pub fn new() -> Self {
-        let title_text = match cli_cmd {
+        Self::default()
-            cli::Command::Clone => String::from("Deja-Vu: Clone"),
-            cli::Command::Diagnose => String::from("Deja-Vu: Diagnostics"),
-        };
-        Self {
-            title_text,
-            ..Default::default()
-        }
     }
 }
 
@@ -54,16 +46,19 @@ impl Component for Title {
         Ok(())
     }
 
-    // fn update(&mut self, action: Action) -> Result<Option<Action>> {
+    fn update(&mut self, action: Action) -> Result<Option<Action>> {
-    //     match action {
+        match action {
-    //         _ => {}
+            _ => {}
-    //     }
+        }
-    //     Ok(None)
+        Ok(None)
-    // }
+    }
 
     fn draw(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
         // Title Block
-        let title_text = Span::styled(&self.title_text, Style::default().fg(Color::LightCyan));
+        let title_text = Span::styled(
+            "WizardKit: Clone Tool",
+            Style::default().fg(Color::LightCyan),
+        );
         let title = Paragraph::new(Line::from(title_text).centered())
             .block(Block::default().borders(Borders::ALL));
         frame.render_widget(title, area);

deja_vu/src/main.rs

@@ -37,7 +37,7 @@ async fn main() -> Result<()> {
     crate::logging::init()?;
 
     let args = Cli::parse();
-    let mut app = App::new(args.cli_cmd, args.tick_rate, args.frame_rate)?;
+    let mut app = App::new(args.tick_rate, args.frame_rate)?;
     app.run().await?;
     Ok(())
 }