Expand boot diagnostic sections

deja_vu/config/config.json5

@@ -87,5 +87,41 @@
       "<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,6 +31,7 @@ use tracing::{debug, info};
 
 use crate::{
     action::Action,
+    cli,
     components::{
         footer::Footer, fps::FpsCounter, left::Left, popup, right::Right, title::Title, Component,
     },
@@ -57,6 +58,7 @@ 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>,
@@ -84,10 +86,16 @@ pub enum Mode {
     PostClone,
     Done,
     Failed,
+    // Diagnostic modes
+    DiagMenu,
+    BootDiags,
+    BootSetup,
+    InjectDrivers,
+    ToggleSafeBoot,
 }
 
 impl App {
-    pub fn new(tick_rate: f64, frame_rate: f64) -> Result<Self> {
+    pub fn new(cli_cmd: cli::Command, 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());
@@ -97,13 +105,14 @@ impl App {
             action_rx,
             action_tx,
             components: vec![
-                Box::new(Title::new()),
+                Box::new(Title::new(cli_cmd)),
                 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(),
@@ -111,7 +120,10 @@ impl App {
             should_suspend: false,
             tick_rate,
             // App
-            cur_mode: Mode::ScanDisks,
+            cur_mode: match cli_cmd {
+                cli::Command::Clone => Mode::ScanDisks,
+                cli::Command::Diagnose => Mode::DiagMenu,
+            },
             disk_index_dest: None,
             disk_index_source: None,
             disk_list: disk_list_arc,
@@ -127,6 +139,7 @@ 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) => {
@@ -143,6 +156,14 @@ 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."),
         };
@@ -247,7 +268,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!(
@@ -288,6 +309,16 @@ 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,13 +13,17 @@
 // 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;
+use clap::{Parser, Subcommand};
 
 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,
@@ -29,6 +33,15 @@ 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,6 +53,7 @@ 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")
                 }
@@ -69,6 +70,13 @@ 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,6 +163,15 @@ 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),
@@ -218,6 +227,13 @@ 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."),
                 }
@@ -270,10 +286,18 @@ 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::from("Scanning Disks..."),
+            popup_text: String::new(),
             ..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 = self.selections.clone();
+                    self.selected_disks.clone_from(&self.selections);
                 }
             }
             Action::Select(one, two) => {

deja_vu/src/components/title.rs

@@ -21,17 +21,25 @@ use ratatui::{
 use tokio::sync::mpsc::UnboundedSender;
 
 use super::Component;
-use crate::{action::Action, config::Config};
+use crate::{action::Action, cli, config::Config};
 
 #[derive(Default)]
 pub struct Title {
     command_tx: Option<UnboundedSender<Action>>,
     config: Config,
+    title_text: String,
 }
 
 impl Title {
-    pub fn new() -> Self {
-        Self::default()
+    pub fn new(cli_cmd: cli::Command) -> Self {
+        let title_text = match cli_cmd {
+            cli::Command::Clone => String::from("Deja-Vu: Clone"),
+            cli::Command::Diagnose => String::from("Deja-Vu: Diagnostics"),
+        };
+        Self {
+            title_text,
+            ..Default::default()
+        }
     }
 }
 
@@ -46,19 +54,16 @@ impl Component for Title {
         Ok(())
     }
 
-    fn update(&mut self, action: Action) -> Result<Option<Action>> {
-        match action {
-            _ => {}
-        }
-        Ok(None)
-    }
+    // fn update(&mut self, action: Action) -> Result<Option<Action>> {
+    //     match action {
+    //         _ => {}
+    //     }
+    //     Ok(None)
+    // }
 
     fn draw(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
         // Title Block
-        let title_text = Span::styled(
-            "WizardKit: Clone Tool",
-            Style::default().fg(Color::LightCyan),
-        );
+        let title_text = Span::styled(&self.title_text, 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.tick_rate, args.frame_rate)?;
+    let mut app = App::new(args.cli_cmd, args.tick_rate, args.frame_rate)?;
     app.run().await?;
     Ok(())
 }