696 lines
30 KiB
Rust
696 lines
30 KiB
Rust
// src/app.rs
|
|
use crate::config::Config;
|
|
use crate::error::Result;
|
|
use crate::executor;
|
|
use crate::menu::{Action, InteractionMode, MenuItem, MenuItemKind, MenuRoot};
|
|
use crate::network;
|
|
use crate::updater;
|
|
use crossterm::event::{Event as CrosstermEvent, KeyCode, KeyEventKind};
|
|
use tokio::sync::mpsc::UnboundedSender;
|
|
|
|
#[derive(Debug)]
|
|
pub enum Event {
|
|
Crossterm(CrosstermEvent),
|
|
MenuLoaded(Result<MenuRoot>),
|
|
ActionCompleted,
|
|
Error(String),
|
|
StructuredCommand(executor::StructuredCommand),
|
|
StructuredOutput(String),
|
|
StructuredFinished(i32),
|
|
UpdateAvailable(updater::UpdateInfo),
|
|
UpdateProgress(u64),
|
|
/// Carries the exe path captured before the binary was replaced.
|
|
UpdateDone(std::path::PathBuf),
|
|
UpdateError(String),
|
|
}
|
|
|
|
/// A pending request to hand the terminal to an external interactive process.
|
|
/// Set by the structured-protocol handler; consumed by the main event loop.
|
|
pub struct PendingExec {
|
|
pub shell: String,
|
|
pub reply_tx: tokio::sync::mpsc::UnboundedSender<String>,
|
|
}
|
|
|
|
pub struct App {
|
|
pub config: Config,
|
|
pub menu: Option<MenuRoot>,
|
|
pub error: Option<String>,
|
|
pub breadcrumbs: Vec<usize>,
|
|
pub selected_index: usize,
|
|
pub popup: Option<Popup>,
|
|
pub event_tx: UnboundedSender<Event>,
|
|
/// When set, main loop suspends ratatui, runs the command, then restores.
|
|
pub pending_exec: Option<PendingExec>,
|
|
/// Exe path to exec after update; captured before the binary was replaced.
|
|
pub pending_restart: Option<std::path::PathBuf>,
|
|
}
|
|
|
|
pub enum Popup {
|
|
Confirming {
|
|
action: Action,
|
|
item_title: String,
|
|
confirm_message: Option<String>,
|
|
},
|
|
ExecutingBashTerminal { child: tokio::process::Child },
|
|
ExecutingStructured {
|
|
reply_tx: tokio::sync::mpsc::UnboundedSender<String>,
|
|
/// Fires SIGTERM to the script's process group on Esc.
|
|
kill_tx: Option<tokio::sync::oneshot::Sender<()>>,
|
|
log_buffer: Vec<String>,
|
|
current_command: Option<executor::StructuredCommand>,
|
|
input_buffer: String,
|
|
/// Cursor position for Menu-type commands.
|
|
menu_selected_index: usize,
|
|
/// Index of the first visible line in log_buffer (0 = top of output).
|
|
log_scroll_pos: usize,
|
|
/// When true, keep position pinned to the bottom as new output arrives.
|
|
log_follow_bottom: bool,
|
|
/// Set when the process has exited; popup stays open until Esc.
|
|
finished: Option<i32>,
|
|
},
|
|
Downloading { progress: f32, message: String },
|
|
Message { text: String, level: MessageLevel },
|
|
UpdateConfirm {
|
|
info: updater::UpdateInfo,
|
|
},
|
|
Updating {
|
|
info: updater::UpdateInfo,
|
|
downloaded: u64,
|
|
status: UpdatingStatus,
|
|
},
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub enum UpdatingStatus {
|
|
Downloading,
|
|
Applying,
|
|
Done,
|
|
Failed(String),
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub enum MessageLevel {
|
|
Info,
|
|
Warn,
|
|
Error,
|
|
}
|
|
|
|
impl App {
|
|
pub fn new(config: Config, event_tx: UnboundedSender<Event>) -> Self {
|
|
Self {
|
|
config,
|
|
menu: None,
|
|
error: None,
|
|
breadcrumbs: Vec::new(),
|
|
selected_index: 0,
|
|
popup: None,
|
|
event_tx,
|
|
pending_exec: None,
|
|
pending_restart: None,
|
|
}
|
|
}
|
|
|
|
pub fn check_update(&mut self) {
|
|
let api_base = match &self.config.update_api {
|
|
Some(url) => url.clone(),
|
|
None => return,
|
|
};
|
|
let timeout = self.config.timeout_sec;
|
|
let tx = self.event_tx.clone();
|
|
|
|
tokio::spawn(async move {
|
|
if let Ok(Some(info)) = updater::check(&api_base, timeout).await {
|
|
let _ = tx.send(Event::UpdateAvailable(info));
|
|
}
|
|
});
|
|
}
|
|
|
|
pub async fn load_menu(&mut self) {
|
|
let server_url = self.config.server_url.clone();
|
|
let timeout = self.config.timeout_sec;
|
|
let tx = self.event_tx.clone();
|
|
|
|
tokio::spawn(async move {
|
|
let result = network::fetch_menu(&server_url, timeout).await;
|
|
let _ = tx.send(Event::MenuLoaded(result));
|
|
});
|
|
}
|
|
|
|
pub fn current_items(&self) -> Vec<&MenuItem> {
|
|
if self.breadcrumbs.is_empty() {
|
|
self.menu
|
|
.as_ref()
|
|
.map(|root| root.menu.iter().collect())
|
|
.unwrap_or_default()
|
|
} else {
|
|
let mut items = &self.menu.as_ref().unwrap().menu;
|
|
for &idx in &self.breadcrumbs {
|
|
if let MenuItemKind::Category { children } = &items[idx].kind {
|
|
items = children;
|
|
} else {
|
|
return vec![];
|
|
}
|
|
}
|
|
items.iter().collect()
|
|
}
|
|
}
|
|
|
|
pub fn selected_item(&self) -> Option<&MenuItem> {
|
|
let items = self.current_items();
|
|
items.get(self.selected_index).copied()
|
|
}
|
|
|
|
pub async fn handle_event(&mut self, event: Event) -> Result<bool> {
|
|
match event {
|
|
Event::Crossterm(evt) => self.handle_crossterm_event(evt).await,
|
|
Event::MenuLoaded(Ok(menu)) => {
|
|
self.menu = Some(menu);
|
|
self.error = None;
|
|
Ok(false)
|
|
}
|
|
Event::MenuLoaded(Err(e)) => {
|
|
self.error = Some(format!("Ошибка загрузки меню: {}", e));
|
|
Ok(false)
|
|
}
|
|
Event::Error(msg) => {
|
|
self.error = Some(msg);
|
|
Ok(false)
|
|
}
|
|
Event::ActionCompleted => {
|
|
self.popup = None;
|
|
Ok(false)
|
|
}
|
|
Event::StructuredCommand(cmd) => {
|
|
// Exec hands the terminal to an external process — clone reply_tx,
|
|
// store as pending_exec, and skip setting current_command so the
|
|
// main loop can suspend ratatui immediately.
|
|
if let executor::StructuredCommand::Exec { shell } = &cmd {
|
|
if let Some(Popup::ExecutingStructured { reply_tx, .. }) = &self.popup {
|
|
self.pending_exec = Some(PendingExec {
|
|
shell: shell.clone(),
|
|
reply_tx: reply_tx.clone(),
|
|
});
|
|
}
|
|
return Ok(false);
|
|
}
|
|
|
|
if let Some(Popup::ExecutingStructured {
|
|
current_command,
|
|
menu_selected_index,
|
|
..
|
|
}) = &mut self.popup
|
|
{
|
|
if matches!(cmd, executor::StructuredCommand::Menu { .. }) {
|
|
*menu_selected_index = 0;
|
|
}
|
|
*current_command = Some(cmd);
|
|
}
|
|
Ok(false)
|
|
}
|
|
Event::StructuredOutput(line) => {
|
|
if let Some(Popup::ExecutingStructured {
|
|
log_buffer,
|
|
log_follow_bottom,
|
|
log_scroll_pos,
|
|
..
|
|
}) = &mut self.popup
|
|
{
|
|
log_buffer.push(line);
|
|
// log_follow_bottom: render will pin pos to bottom.
|
|
// Otherwise pos stays fixed → new line appears off-screen.
|
|
let _ = (log_follow_bottom, log_scroll_pos); // used by render
|
|
}
|
|
Ok(false)
|
|
}
|
|
Event::StructuredFinished(exit_code) => {
|
|
if let Some(Popup::ExecutingStructured { finished, .. }) = &mut self.popup {
|
|
*finished = Some(exit_code);
|
|
}
|
|
// If popup was already closed (user pressed Esc to kill the
|
|
// script), we silently discard the exit event.
|
|
Ok(false)
|
|
}
|
|
Event::UpdateAvailable(info) => {
|
|
// Only show if no popup is currently open (don't interrupt running scripts)
|
|
if self.popup.is_none() {
|
|
self.popup = Some(Popup::UpdateConfirm { info });
|
|
}
|
|
Ok(false)
|
|
}
|
|
Event::UpdateProgress(bytes) => {
|
|
if let Some(Popup::Updating { downloaded, .. }) = &mut self.popup {
|
|
*downloaded = bytes;
|
|
}
|
|
Ok(false)
|
|
}
|
|
Event::UpdateDone(exe_path) => {
|
|
if let Some(Popup::Updating { status, .. }) = &mut self.popup {
|
|
*status = UpdatingStatus::Done;
|
|
}
|
|
self.pending_restart = Some(exe_path);
|
|
Ok(false)
|
|
}
|
|
Event::UpdateError(msg) => {
|
|
if let Some(Popup::Updating { status, .. }) = &mut self.popup {
|
|
*status = UpdatingStatus::Failed(msg);
|
|
}
|
|
Ok(false)
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn handle_crossterm_event(&mut self, evt: CrosstermEvent) -> Result<bool> {
|
|
match evt {
|
|
CrosstermEvent::Key(key) if key.kind == KeyEventKind::Press => {
|
|
if let Some(popup) = &mut self.popup {
|
|
match popup {
|
|
Popup::Confirming { action, .. } => {
|
|
match key.code {
|
|
KeyCode::Char('y') | KeyCode::Char('Y') => {
|
|
let action = action.clone();
|
|
self.popup = None;
|
|
self.run_action(action).await?;
|
|
}
|
|
KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
|
|
self.popup = None;
|
|
}
|
|
_ => {}
|
|
}
|
|
return Ok(false);
|
|
}
|
|
|
|
Popup::ExecutingStructured {
|
|
reply_tx,
|
|
kill_tx,
|
|
input_buffer,
|
|
current_command,
|
|
menu_selected_index,
|
|
log_scroll_pos,
|
|
log_follow_bottom,
|
|
log_buffer,
|
|
finished,
|
|
} => {
|
|
let is_menu = matches!(
|
|
current_command,
|
|
Some(executor::StructuredCommand::Menu { .. })
|
|
);
|
|
let is_confirm = matches!(
|
|
current_command,
|
|
Some(executor::StructuredCommand::Confirm { .. })
|
|
);
|
|
let has_command = current_command.is_some();
|
|
// Vim motions are disabled only when free text input is active.
|
|
let is_text_input = matches!(
|
|
current_command,
|
|
Some(executor::StructuredCommand::Input { .. })
|
|
);
|
|
|
|
match key.code {
|
|
// ── Log scrolling (PageUp / PageDown always work) ─
|
|
KeyCode::PageUp => {
|
|
*log_scroll_pos = log_scroll_pos.saturating_sub(10);
|
|
*log_follow_bottom = false;
|
|
}
|
|
KeyCode::PageDown => {
|
|
*log_scroll_pos = log_scroll_pos.saturating_add(10);
|
|
// Render will clamp to max; if we're at the
|
|
// bottom, mark as following.
|
|
*log_follow_bottom =
|
|
*log_scroll_pos + 1 >= log_buffer.len();
|
|
}
|
|
|
|
// ── Arrow keys ────────────────────────────────────
|
|
KeyCode::Up if is_menu => {
|
|
if *menu_selected_index > 0 {
|
|
*menu_selected_index -= 1;
|
|
}
|
|
}
|
|
KeyCode::Down if is_menu => {
|
|
if let Some(executor::StructuredCommand::Menu {
|
|
options, ..
|
|
}) = current_command
|
|
{
|
|
if *menu_selected_index + 1 < options.len() {
|
|
*menu_selected_index += 1;
|
|
}
|
|
}
|
|
}
|
|
// Scroll log one line when no interactive command pending
|
|
KeyCode::Up if !has_command => {
|
|
*log_scroll_pos = log_scroll_pos.saturating_sub(1);
|
|
*log_follow_bottom = false;
|
|
}
|
|
KeyCode::Down if !has_command => {
|
|
*log_scroll_pos = log_scroll_pos.saturating_add(1);
|
|
*log_follow_bottom =
|
|
*log_scroll_pos + 1 >= log_buffer.len();
|
|
}
|
|
|
|
// ── Confirm shortcuts (immediate, no Enter needed) ─
|
|
KeyCode::Char('y') | KeyCode::Char('Y') if is_confirm => {
|
|
let _ = current_command.take();
|
|
let _ = reply_tx.send("y".to_string());
|
|
input_buffer.clear();
|
|
}
|
|
KeyCode::Char('n') | KeyCode::Char('N') if is_confirm => {
|
|
let _ = current_command.take();
|
|
let _ = reply_tx.send("n".to_string());
|
|
input_buffer.clear();
|
|
}
|
|
|
|
// ── Text input ────────────────────────────────────
|
|
// Vim motion keys (j/k/l/h) are excluded here so they
|
|
// fall through to the vim-motion arms below.
|
|
KeyCode::Char(c)
|
|
if !is_menu
|
|
&& !is_confirm
|
|
&& (is_text_input
|
|
|| !matches!(c, 'j' | 'k' | 'l' | 'h')) =>
|
|
{
|
|
input_buffer.push(c);
|
|
}
|
|
KeyCode::Backspace if !is_menu => {
|
|
input_buffer.pop();
|
|
}
|
|
|
|
// ── Enter: commit response ────────────────────────
|
|
KeyCode::Enter => {
|
|
if let Some(cmd) = current_command.take() {
|
|
let response = match &cmd {
|
|
executor::StructuredCommand::Input { .. } => {
|
|
input_buffer.clone()
|
|
}
|
|
executor::StructuredCommand::Confirm { .. } => {
|
|
if input_buffer.to_lowercase().starts_with('y') {
|
|
"y".to_string()
|
|
} else {
|
|
"n".to_string()
|
|
}
|
|
}
|
|
executor::StructuredCommand::Menu {
|
|
options, ..
|
|
} => options
|
|
.get(*menu_selected_index)
|
|
.map(|opt| opt.id.clone())
|
|
.unwrap_or_default(),
|
|
// Message / Progress: send empty ack.
|
|
_ => String::new(),
|
|
};
|
|
let _ = reply_tx.send(response);
|
|
input_buffer.clear();
|
|
*menu_selected_index = 0;
|
|
}
|
|
}
|
|
|
|
// ── Esc ──────────────────────────────────────────
|
|
KeyCode::Esc => {
|
|
if is_confirm {
|
|
let _ = current_command.take();
|
|
let _ = reply_tx.send("n".to_string());
|
|
} else {
|
|
if let Some(kx) = kill_tx.take() {
|
|
let _ = kx.send(());
|
|
}
|
|
self.popup = None;
|
|
}
|
|
}
|
|
|
|
// ── Vim motions (off during text input) ───────────
|
|
KeyCode::Char('k') if !is_text_input => {
|
|
if is_menu {
|
|
if *menu_selected_index > 0 {
|
|
*menu_selected_index -= 1;
|
|
}
|
|
} else if !has_command {
|
|
*log_scroll_pos = log_scroll_pos.saturating_sub(1);
|
|
*log_follow_bottom = false;
|
|
}
|
|
}
|
|
KeyCode::Char('j') if !is_text_input => {
|
|
if is_menu {
|
|
if let Some(executor::StructuredCommand::Menu {
|
|
options, ..
|
|
}) = current_command
|
|
{
|
|
if *menu_selected_index + 1 < options.len() {
|
|
*menu_selected_index += 1;
|
|
}
|
|
}
|
|
} else if !has_command {
|
|
*log_scroll_pos = log_scroll_pos.saturating_add(1);
|
|
*log_follow_bottom =
|
|
*log_scroll_pos + 1 >= log_buffer.len();
|
|
}
|
|
}
|
|
KeyCode::Char('l') if !is_text_input => {
|
|
// Forward / confirm — same logic as Enter.
|
|
if let Some(cmd) = current_command.take() {
|
|
let response = match &cmd {
|
|
executor::StructuredCommand::Confirm { .. } => {
|
|
"y".to_string()
|
|
}
|
|
executor::StructuredCommand::Menu {
|
|
options, ..
|
|
} => options
|
|
.get(*menu_selected_index)
|
|
.map(|o| o.id.clone())
|
|
.unwrap_or_default(),
|
|
_ => String::new(),
|
|
};
|
|
let _ = reply_tx.send(response);
|
|
input_buffer.clear();
|
|
*menu_selected_index = 0;
|
|
}
|
|
}
|
|
KeyCode::Char('h') if !is_text_input => {
|
|
// Back / cancel — same logic as Esc.
|
|
if is_confirm {
|
|
let _ = current_command.take();
|
|
let _ = reply_tx.send("n".to_string());
|
|
} else {
|
|
if let Some(kx) = kill_tx.take() {
|
|
let _ = kx.send(());
|
|
}
|
|
self.popup = None;
|
|
}
|
|
}
|
|
|
|
_ => {}
|
|
}
|
|
return Ok(false);
|
|
}
|
|
|
|
Popup::Message { .. } => {
|
|
self.popup = None;
|
|
return Ok(false);
|
|
}
|
|
|
|
Popup::UpdateConfirm { info } => {
|
|
match key.code {
|
|
KeyCode::Char('y') | KeyCode::Char('Y') | KeyCode::Char('l') => {
|
|
let info = info.clone();
|
|
self.popup = Some(Popup::Updating {
|
|
info: info.clone(),
|
|
downloaded: 0,
|
|
status: UpdatingStatus::Downloading,
|
|
});
|
|
|
|
let (progress_tx, mut progress_rx) =
|
|
tokio::sync::mpsc::unbounded_channel::<u64>();
|
|
let tx = self.event_tx.clone();
|
|
let info_clone = info.clone();
|
|
|
|
// Forward progress events
|
|
tokio::spawn(async move {
|
|
while let Some(bytes) = progress_rx.recv().await {
|
|
let _ = tx.send(Event::UpdateProgress(bytes));
|
|
}
|
|
});
|
|
|
|
// Download and apply
|
|
let tx2 = self.event_tx.clone();
|
|
tokio::spawn(async move {
|
|
match updater::download_and_apply(
|
|
&info_clone,
|
|
progress_tx,
|
|
)
|
|
.await
|
|
{
|
|
Ok(exe_path) => {
|
|
let _ = tx2.send(Event::UpdateDone(exe_path));
|
|
}
|
|
Err(e) => {
|
|
let _ =
|
|
tx2.send(Event::UpdateError(e.to_string()));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
KeyCode::Char('n') | KeyCode::Char('N')
|
|
| KeyCode::Esc | KeyCode::Char('h') => {
|
|
self.popup = None;
|
|
}
|
|
_ => {}
|
|
}
|
|
return Ok(false);
|
|
}
|
|
|
|
Popup::Updating { status, .. } => {
|
|
if key.code == KeyCode::Esc {
|
|
if matches!(status, UpdatingStatus::Failed(_)) {
|
|
self.popup = None;
|
|
}
|
|
// Ignore Esc while downloading/applying
|
|
}
|
|
return Ok(false);
|
|
}
|
|
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
// ── Main menu navigation ─────────────────────────────────────────
|
|
match key.code {
|
|
KeyCode::Char('q') => return Ok(true),
|
|
KeyCode::Up | KeyCode::Char('k') => {
|
|
let len = self.current_items().len();
|
|
if len > 0 {
|
|
self.selected_index = (self.selected_index + len - 1) % len;
|
|
}
|
|
}
|
|
KeyCode::Down | KeyCode::Char('j') => {
|
|
let len = self.current_items().len();
|
|
if len > 0 {
|
|
self.selected_index = (self.selected_index + 1) % len;
|
|
}
|
|
}
|
|
KeyCode::Enter | KeyCode::Char('l') => {
|
|
if let Some(item) = self.selected_item().cloned() {
|
|
self.activate_item(item).await?;
|
|
}
|
|
}
|
|
KeyCode::Esc | KeyCode::Char('h') => {
|
|
if !self.breadcrumbs.is_empty() {
|
|
self.breadcrumbs.pop();
|
|
self.selected_index = 0;
|
|
}
|
|
}
|
|
KeyCode::Char('r') | KeyCode::Char('R') => {
|
|
self.load_menu().await;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
Ok(false)
|
|
}
|
|
|
|
async fn activate_item(&mut self, item: MenuItem) -> Result<()> {
|
|
match item.kind {
|
|
MenuItemKind::Category { children: _ } => {
|
|
if let Some(idx) = self.current_items().iter().position(|i| i.id == item.id) {
|
|
self.breadcrumbs.push(idx);
|
|
self.selected_index = 0;
|
|
}
|
|
}
|
|
MenuItemKind::Action { action } => {
|
|
if action.confirm() {
|
|
let confirm_message = action.confirm_message();
|
|
self.popup = Some(Popup::Confirming {
|
|
action,
|
|
item_title: item.title,
|
|
confirm_message,
|
|
});
|
|
} else {
|
|
self.run_action(action).await?;
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
async fn run_action(&mut self, action: Action) -> Result<()> {
|
|
match action {
|
|
Action::Bash {
|
|
script,
|
|
interaction,
|
|
confirm: _,
|
|
confirm_message: _,
|
|
} => match interaction {
|
|
InteractionMode::Terminal => {
|
|
self.run_bash_terminal(&script).await?;
|
|
}
|
|
InteractionMode::Structured => {
|
|
self.run_bash_structured(&script).await?;
|
|
}
|
|
},
|
|
Action::Download {
|
|
url,
|
|
confirm: _,
|
|
..
|
|
} => {
|
|
self.popup = Some(Popup::Message {
|
|
text: format!("Скачивание {} пока не реализовано", url),
|
|
level: MessageLevel::Info,
|
|
});
|
|
}
|
|
Action::DownloadAndRun { .. } => {}
|
|
Action::HttpRequest { .. } => {}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
async fn run_bash_terminal(&mut self, script: &str) -> Result<()> {
|
|
use tokio::process::Command;
|
|
let child = Command::new("bash").arg("-c").arg(script).spawn()?;
|
|
self.popup = Some(Popup::ExecutingBashTerminal { child });
|
|
Ok(())
|
|
}
|
|
|
|
async fn run_bash_structured(&mut self, script: &str) -> Result<()> {
|
|
let (output_rx, command_rx, finished_rx, reply_tx, kill_tx) =
|
|
executor::structured::spawn(script)?;
|
|
|
|
let tx_output = self.event_tx.clone();
|
|
tokio::spawn(async move {
|
|
let mut rx = output_rx;
|
|
while let Some(line) = rx.recv().await {
|
|
if tx_output.send(Event::StructuredOutput(line)).is_err() {
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
let tx_cmd = self.event_tx.clone();
|
|
tokio::spawn(async move {
|
|
let mut rx = command_rx;
|
|
while let Some(cmd) = rx.recv().await {
|
|
if tx_cmd.send(Event::StructuredCommand(cmd)).is_err() {
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
let tx_finished = self.event_tx.clone();
|
|
tokio::spawn(async move {
|
|
let code = finished_rx.await.unwrap_or(1);
|
|
let _ = tx_finished.send(Event::StructuredFinished(code));
|
|
});
|
|
|
|
self.popup = Some(Popup::ExecutingStructured {
|
|
reply_tx,
|
|
kill_tx: Some(kill_tx),
|
|
log_buffer: Vec::new(),
|
|
current_command: None,
|
|
input_buffer: String::new(),
|
|
menu_selected_index: 0,
|
|
log_scroll_pos: 0,
|
|
log_follow_bottom: false,
|
|
finished: None,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
}
|