389 lines
16 KiB
Rust
389 lines
16 KiB
Rust
// This file is part of Deja-vu.
|
|
//
|
|
// Deja-vu is free software: you can redistribute it and/or modify it
|
|
// under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Deja-vu is distributed in the hope that it will be useful, but
|
|
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// 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 color_eyre::Result;
|
|
use crossterm::event::KeyEvent;
|
|
use ratatui::{
|
|
prelude::*,
|
|
widgets::{Block, Borders, HighlightSpacing, List, ListItem, Padding, Paragraph},
|
|
};
|
|
use tokio::sync::mpsc::UnboundedSender;
|
|
use tracing::info;
|
|
|
|
use super::{popup, state::StatefulList, Component};
|
|
use crate::{
|
|
action::Action,
|
|
app::Mode,
|
|
config::Config,
|
|
system::{
|
|
disk::{Disk, Partition, PartitionTableType},
|
|
drivers::{self, Driver},
|
|
},
|
|
};
|
|
|
|
#[derive(Default)]
|
|
pub struct Left {
|
|
command_tx: Option<UnboundedSender<Action>>,
|
|
config: Config,
|
|
disk_id_dest: Option<usize>,
|
|
table_type: Option<PartitionTableType>,
|
|
title_text: String,
|
|
list_disks: StatefulList<Disk>,
|
|
list_drivers: StatefulList<Driver>,
|
|
list_parts: StatefulList<Partition>,
|
|
list_table_types: StatefulList<PartitionTableType>,
|
|
mode: Mode,
|
|
selections: Vec<Option<usize>>,
|
|
}
|
|
|
|
impl Left {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
selections: vec![None, None],
|
|
title_text: String::from("Home"),
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Component for Left {
|
|
fn handle_key_event(&mut self, key: KeyEvent) -> Result<Option<Action>> {
|
|
let _ = key; // to appease clippy
|
|
Ok(None)
|
|
}
|
|
|
|
fn register_action_handler(&mut self, tx: UnboundedSender<Action>) -> Result<()> {
|
|
self.command_tx = Some(tx);
|
|
Ok(())
|
|
}
|
|
|
|
fn register_config_handler(&mut self, config: Config) -> Result<()> {
|
|
self.config = config;
|
|
Ok(())
|
|
}
|
|
|
|
fn update(&mut self, action: Action) -> Result<Option<Action>> {
|
|
match action {
|
|
Action::KeyUp => match self.mode {
|
|
Mode::InstallDrivers => self.list_drivers.previous(),
|
|
Mode::SelectDisks => self.list_disks.previous(),
|
|
Mode::SelectTableType => self.list_table_types.previous(),
|
|
Mode::SelectParts => self.list_parts.previous(),
|
|
_ => {}
|
|
},
|
|
Action::KeyDown => match self.mode {
|
|
Mode::InstallDrivers => self.list_drivers.next(),
|
|
Mode::SelectDisks => self.list_disks.next(),
|
|
Mode::SelectTableType => self.list_table_types.next(),
|
|
Mode::SelectParts => self.list_parts.next(),
|
|
_ => {}
|
|
},
|
|
Action::Process => match self.mode {
|
|
// NOTE: Remove all variants except Mode::Confirm?
|
|
Mode::Confirm => {
|
|
if let Some(command_tx) = self.command_tx.clone() {
|
|
command_tx.send(Action::NextScreen)?;
|
|
}
|
|
}
|
|
Mode::InstallDrivers
|
|
| Mode::SelectDisks
|
|
| Mode::SelectTableType
|
|
| Mode::SelectParts => {
|
|
// Menu selection sections
|
|
let selection: Option<usize> = match self.mode {
|
|
Mode::InstallDrivers => self.list_drivers.selected(),
|
|
Mode::SelectDisks => self.list_disks.selected(),
|
|
Mode::SelectTableType => self.list_table_types.selected(),
|
|
Mode::SelectParts => self.list_parts.selected(),
|
|
_ => panic!("This shouldn't happen!"),
|
|
};
|
|
if let Some(index) = selection {
|
|
if let Some(command_tx) = self.command_tx.clone() {
|
|
let mut selection_one: Option<usize> = None;
|
|
let mut selection_two: Option<usize> = None;
|
|
|
|
// Get selection(s)
|
|
if self.selections[0].is_none() {
|
|
// First selection
|
|
selection_one = Some(index);
|
|
selection_two = None;
|
|
} else {
|
|
// Second selection
|
|
if let Some(source_index) = self.selections[0] {
|
|
if index == source_index {
|
|
// Toggle first selection
|
|
selection_one = None;
|
|
self.selections[0] = None;
|
|
} else {
|
|
selection_one = self.selections[0];
|
|
selection_two = Some(index);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Send selection(s) if needed
|
|
// NOTE: This is needed to keep the app and all components in sync
|
|
match self.mode {
|
|
Mode::InstallDrivers => {
|
|
// Only need to select one entry
|
|
if let Some(driver) = self.list_drivers.get_selected() {
|
|
command_tx.send(Action::SelectDriver(driver.clone()))?;
|
|
}
|
|
}
|
|
Mode::SelectTableType => {
|
|
// Only need to select one entry
|
|
if let Some(table_type) = self.list_table_types.get_selected() {
|
|
self.table_type = Some(table_type.clone());
|
|
command_tx.send(Action::SelectTableType(table_type))?;
|
|
}
|
|
}
|
|
Mode::SelectDisks | Mode::SelectParts => {
|
|
command_tx
|
|
.send(Action::Select(selection_one, selection_two))?;
|
|
|
|
// Advance screen if both selections made
|
|
if selection_two.is_some() {
|
|
command_tx.send(Action::NextScreen)?;
|
|
}
|
|
}
|
|
_ => {}
|
|
};
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
},
|
|
Action::Select(Some(index), None) => self.selections[0] = Some(index),
|
|
Action::Select(_, Some(index)) => {
|
|
if self.mode == Mode::SelectDisks {
|
|
self.disk_id_dest = Some(index);
|
|
}
|
|
}
|
|
Action::SetMode(new_mode) => {
|
|
let prev_mode = self.mode;
|
|
self.mode = new_mode;
|
|
match (prev_mode, new_mode) {
|
|
(_, Mode::ScanDisks) => {
|
|
self.list_disks.clear_items();
|
|
self.title_text = String::new();
|
|
}
|
|
(_, Mode::InstallDrivers) => {
|
|
self.list_drivers.set_items(drivers::scan());
|
|
self.selections[0] = None;
|
|
self.selections[1] = None;
|
|
self.title_text = String::from("Install Drivers");
|
|
if self.list_drivers.is_empty() {
|
|
if let Some(command_tx) = self.command_tx.clone() {
|
|
command_tx.send(Action::DisplayPopup(
|
|
popup::Type::Error,
|
|
String::from("No drivers available to install"),
|
|
))?;
|
|
}
|
|
}
|
|
}
|
|
(_, Mode::SelectDisks) => {
|
|
self.selections[0] = None;
|
|
self.selections[1] = None;
|
|
self.title_text = String::from("Select Source and Destination Disks");
|
|
}
|
|
(_, Mode::SelectTableType) => {
|
|
self.list_table_types
|
|
.set_items(vec![PartitionTableType::Guid, PartitionTableType::Legacy]);
|
|
self.selections[0] = None;
|
|
self.selections[1] = None;
|
|
self.title_text = String::from("Select Partition Table Type");
|
|
}
|
|
(_, Mode::PreClone | Mode::Clone | Mode::PostClone) => {
|
|
self.title_text = String::from("Processing");
|
|
}
|
|
(_, Mode::SelectParts) => {
|
|
self.title_text = String::from("Select Boot and OS Partitions");
|
|
}
|
|
(Mode::SelectDisks | Mode::SelectParts, Mode::Confirm) => {
|
|
self.title_text = String::from("Confirm Selections");
|
|
}
|
|
(Mode::SelectTableType, Mode::Confirm) => {
|
|
self.title_text = String::from("Confirm Selections (Again)");
|
|
}
|
|
(_, Mode::Done | Mode::Failed) => self.title_text = String::from("Done"),
|
|
// Invalid states
|
|
(_, Mode::Confirm) => panic!("This shouldn't happen."),
|
|
}
|
|
}
|
|
Action::UpdateDiskList(disks) => {
|
|
info!("Updating disk list");
|
|
self.list_disks.set_items(disks);
|
|
if self.mode == Mode::Clone {
|
|
if let Some(index) = self.disk_id_dest {
|
|
if let Some(disk) = self.list_disks.get(index) {
|
|
self.list_parts.set_items(disk.get_parts());
|
|
|
|
// Auto-select first partition and highlight likely OS partition
|
|
if let Some(table_type) = &self.table_type {
|
|
match table_type {
|
|
PartitionTableType::Guid => {
|
|
if disk.num_parts() >= 3 {
|
|
self.selections[0] = Some(0);
|
|
self.list_parts.select(2);
|
|
}
|
|
}
|
|
PartitionTableType::Legacy => {
|
|
if disk.num_parts() >= 2 {
|
|
self.selections[0] = Some(0);
|
|
self.list_parts.select(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
Ok(None)
|
|
}
|
|
|
|
fn draw(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
|
|
let [title_area, body_area] = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([Constraint::Length(1), Constraint::Min(1)])
|
|
.areas(area);
|
|
|
|
// Title
|
|
let title =
|
|
Paragraph::new(Line::from(Span::styled(&self.title_text, Style::default())).centered())
|
|
.block(Block::default().borders(Borders::NONE));
|
|
frame.render_widget(title, title_area);
|
|
|
|
// Body
|
|
match self.mode {
|
|
Mode::ScanDisks
|
|
| Mode::PreClone
|
|
| Mode::Clone
|
|
| Mode::PostClone
|
|
| Mode::Done
|
|
| Mode::Failed => {
|
|
// Leave blank
|
|
let paragraph = Paragraph::new(String::new()).block(
|
|
Block::default()
|
|
.borders(Borders::ALL)
|
|
.padding(Padding::new(1, 1, 1, 1)),
|
|
);
|
|
frame.render_widget(paragraph, body_area);
|
|
|
|
// Bail early
|
|
return Ok(());
|
|
}
|
|
Mode::Confirm => {
|
|
// Nag the user
|
|
let paragraph = Paragraph::new(String::from("Are the listed selections correct?"))
|
|
.block(
|
|
Block::default()
|
|
.borders(Borders::ALL)
|
|
.padding(Padding::new(1, 1, 1, 1)),
|
|
);
|
|
frame.render_widget(paragraph, body_area);
|
|
|
|
// Bail early
|
|
return Ok(());
|
|
}
|
|
Mode::InstallDrivers
|
|
| Mode::SelectDisks
|
|
| Mode::SelectTableType
|
|
| Mode::SelectParts => {
|
|
// List modes
|
|
let mut list_items = Vec::<ListItem>::new();
|
|
let list_items_strings: Vec<String> = match self.mode {
|
|
Mode::InstallDrivers => self
|
|
.list_drivers
|
|
.items
|
|
.iter()
|
|
.map(|i| format!("{i}"))
|
|
.collect(),
|
|
Mode::SelectDisks => self
|
|
.list_disks
|
|
.items
|
|
.iter()
|
|
.map(|i| format!("{i}"))
|
|
.collect(),
|
|
Mode::SelectTableType => self
|
|
.list_table_types
|
|
.items
|
|
.iter()
|
|
.map(|i| format!("{i}"))
|
|
.collect(),
|
|
Mode::SelectParts => self
|
|
.list_parts
|
|
.items
|
|
.iter()
|
|
.map(|i| format!("{i}"))
|
|
.collect(),
|
|
_ => panic!("This shouldn't happen."),
|
|
};
|
|
if !list_items_strings.is_empty() {
|
|
for (index, item) in list_items_strings.iter().enumerate() {
|
|
let mut item_style = Style::default();
|
|
let mut item_text_tail = "";
|
|
if let Some(selection_one) = self.selections[0] {
|
|
if selection_one == index {
|
|
item_style = Style::new().yellow();
|
|
item_text_tail = match self.mode {
|
|
Mode::SelectDisks => " ~source disk~",
|
|
Mode::SelectParts => " ~boot volume~",
|
|
_ => "",
|
|
}
|
|
}
|
|
}
|
|
list_items.push(
|
|
ListItem::new(format!(" {item}\n{item_text_tail}\n\n"))
|
|
.style(item_style),
|
|
);
|
|
}
|
|
}
|
|
let list = List::new(list_items)
|
|
.block(
|
|
Block::default()
|
|
.borders(Borders::ALL)
|
|
.padding(Padding::new(1, 1, 1, 1)),
|
|
)
|
|
.highlight_spacing(HighlightSpacing::Always)
|
|
.highlight_style(Style::new().green().bold())
|
|
.highlight_symbol(" --> ")
|
|
.repeat_highlight_symbol(false);
|
|
match self.mode {
|
|
Mode::InstallDrivers => {
|
|
frame.render_stateful_widget(list, body_area, &mut self.list_drivers.state);
|
|
}
|
|
Mode::SelectDisks => {
|
|
frame.render_stateful_widget(list, body_area, &mut self.list_disks.state);
|
|
}
|
|
Mode::SelectTableType => frame.render_stateful_widget(
|
|
list,
|
|
body_area,
|
|
&mut self.list_table_types.state,
|
|
),
|
|
Mode::SelectParts => {
|
|
frame.render_stateful_widget(list, body_area, &mut self.list_parts.state);
|
|
}
|
|
_ => panic!("This shouldn't happen."),
|
|
}
|
|
}
|
|
}
|
|
|
|
// Done
|
|
Ok(())
|
|
}
|
|
}
|