1  use dioxus::prelude::*;
  2  
  3  #[derive(Clone, Copy, PartialEq)]
  4  pub struct FlashDeviceState {
  5      pub is_connected: Signal<bool>,
  6      pub connecting: Signal<bool>,
  7      pub monitor_active: Signal<bool>,
  8      pub device_lost: Signal<bool>,
  9  }
 10  
 11  impl FlashDeviceState {
 12      pub fn new() -> Self {
 13          Self {
 14              is_connected: use_signal(|| false),
 15              connecting: use_signal(|| false),
 16              monitor_active: use_signal(|| false),
 17              device_lost: use_signal(|| false),
 18          }
 19      }
 20  }
 21  
 22  #[derive(Clone, Copy, PartialEq)]
 23  pub struct FlashChipInfo {
 24      pub chip_name: Signal<String>,
 25      pub chip_description: Signal<String>,
 26      pub chip_features: Signal<Vec<String>>,
 27      pub chip_mac: Signal<String>,
 28      pub chip_flash_sizes: Signal<Vec<String>>,
 29      pub chip_flash_freqs: Signal<Vec<String>>,
 30      pub bootloader_offset: Signal<u32>,
 31  }
 32  
 33  impl FlashChipInfo {
 34      pub fn new() -> Self {
 35          Self {
 36              chip_name: use_signal(String::new),
 37              chip_description: use_signal(String::new),
 38              chip_features: use_signal(Vec::new),
 39              chip_mac: use_signal(String::new),
 40              chip_flash_sizes: use_signal(Vec::new),
 41              chip_flash_freqs: use_signal(Vec::new),
 42              bootloader_offset: use_signal(|| 0u32),
 43          }
 44      }
 45  
 46      pub fn clear(&mut self) {
 47          self.chip_name.set(String::new());
 48          self.chip_description.set(String::new());
 49          self.chip_features.set(Vec::new());
 50          self.chip_mac.set(String::new());
 51          self.chip_flash_sizes.set(Vec::new());
 52          self.chip_flash_freqs.set(Vec::new());
 53          self.bootloader_offset.set(0);
 54      }
 55  }
 56  
 57  #[derive(Clone, Copy, PartialEq)]
 58  pub struct FlashFirmwareState {
 59      pub firmware_name: Signal<String>,
 60      pub firmware_size: Signal<usize>,
 61      pub flashing: Signal<bool>,
 62      pub progress: Signal<u8>,
 63  }
 64  
 65  impl FlashFirmwareState {
 66      pub fn new() -> Self {
 67          Self {
 68              firmware_name: use_signal(String::new),
 69              firmware_size: use_signal(|| 0usize),
 70              flashing: use_signal(|| false),
 71              progress: use_signal(|| 0u8),
 72          }
 73      }
 74  
 75      pub fn clear(&mut self) {
 76          self.firmware_name.set(String::new());
 77          self.firmware_size.set(0);
 78          self.flashing.set(false);
 79          self.progress.set(0);
 80      }
 81  }
 82  
 83  #[derive(Clone, Copy, PartialEq)]
 84  pub struct FlashConfig {
 85      pub baud: Signal<String>,
 86      pub mode: Signal<String>,
 87      pub freq: Signal<String>,
 88      pub size: Signal<String>,
 89      pub address: Signal<String>,
 90      pub compress: Signal<bool>,
 91      pub erase_first: Signal<bool>,
 92      pub wifi_ssid: Signal<String>,
 93      pub wifi_pass: Signal<String>,
 94  }
 95  
 96  impl FlashConfig {
 97      pub fn new() -> Self {
 98          Self {
 99              baud: use_signal(|| "921600".to_string()),
100              mode: use_signal(|| "keep".to_string()),
101              freq: use_signal(|| "keep".to_string()),
102              size: use_signal(|| "detect".to_string()),
103              address: use_signal(|| "0x10000".to_string()),
104              compress: use_signal(|| true),
105              erase_first: use_signal(|| false),
106              wifi_ssid: use_signal(String::new),
107              wifi_pass: use_signal(String::new),
108          }
109      }
110  }