Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
bc9f847689 | ||
|
|
71cdf2d988 | ||
|
|
4fea3becf6 | ||
|
|
7781ff71d3 | ||
|
|
86e4761316 | ||
|
|
c1234f6df7 | ||
|
|
b6afe08a5f |
@@ -0,0 +1,127 @@
|
||||
//! Optional saved miner credentials, applied to every asic-rs discovery call.
|
||||
//!
|
||||
//! asic-rs has no single global credential field on `MinerFactory`: auth is set
|
||||
//! per firmware backend via `with_firmware_discovery_auth`. `configured_factory`
|
||||
//! is the one place that fans a saved username/password out across the whole
|
||||
//! firmware registry, so `scan`'s callers never have to think about it.
|
||||
|
||||
use std::io::Write;
|
||||
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
|
||||
|
||||
use asic_rs::MinerFactory;
|
||||
use asic_rs::core::traits::miner::MinerAuth;
|
||||
|
||||
use crate::scan::config_path;
|
||||
|
||||
pub const CREDENTIALS_FILE: &str = "scan-credentials.txt";
|
||||
|
||||
/// Load the saved miner username/password, if any were saved.
|
||||
pub fn load_credentials() -> Option<(String, String)> {
|
||||
let s = std::fs::read_to_string(config_path(CREDENTIALS_FILE)).ok()?;
|
||||
let mut lines = s.lines();
|
||||
let user = lines.next()?.to_string();
|
||||
let pass = lines.next().unwrap_or("").to_string();
|
||||
Some((user, pass))
|
||||
}
|
||||
|
||||
/// Save the miner username/password, restricting the file to owner
|
||||
/// read/write (credentials are plaintext on disk, so the mode matters).
|
||||
pub fn save_credentials(user: &str, pass: &str) -> std::io::Result<()> {
|
||||
let p = config_path(CREDENTIALS_FILE);
|
||||
if let Some(dir) = p.parent() {
|
||||
std::fs::create_dir_all(dir)?;
|
||||
}
|
||||
// Open (and create) with mode 0600 up front so a freshly created file is
|
||||
// never world/group-readable, even for the instant before the write. For a
|
||||
// pre-existing file the create mode is ignored, so also tighten it to 0600
|
||||
// while it is still empty (post-truncate, pre-write) -- the plaintext is
|
||||
// never on disk under a looser mode.
|
||||
let mut f = std::fs::OpenOptions::new()
|
||||
.write(true)
|
||||
.create(true)
|
||||
.truncate(true)
|
||||
.mode(0o600)
|
||||
.open(&p)?;
|
||||
f.set_permissions(std::fs::Permissions::from_mode(0o600))?;
|
||||
f.write_all(format!("{user}\n{pass}\n").as_bytes())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Remove the saved credentials, if any. Not an error if none were saved.
|
||||
pub fn clear_credentials() -> std::io::Result<()> {
|
||||
match std::fs::remove_file(config_path(CREDENTIALS_FILE)) {
|
||||
Ok(()) => Ok(()),
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
|
||||
Err(e) => Err(e),
|
||||
}
|
||||
}
|
||||
|
||||
/// Build a `MinerFactory` with the saved credentials (if any) applied as
|
||||
/// discovery auth for every firmware backend, so scans, refreshes, config
|
||||
/// actions, and firmware flashes all authenticate against a non-default
|
||||
/// login the same way. With no saved credentials this is plain `MinerFactory::new()`
|
||||
/// and every backend falls back to its own default auth.
|
||||
pub fn configured_factory() -> MinerFactory {
|
||||
let mut factory = MinerFactory::new();
|
||||
if let Some((user, pass)) = load_credentials() {
|
||||
for fw in asic_rs::factory::default_firmware_registry() {
|
||||
factory = factory.with_firmware_discovery_auth(fw.as_ref(), MinerAuth::new(user.clone(), pass.clone()));
|
||||
}
|
||||
}
|
||||
factory
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn credentials_round_trip_and_file_perms() {
|
||||
// config_path() reads $HOME; point it at a private temp dir. HOME is
|
||||
// process-global, so this stays one test and restores HOME afterward
|
||||
// (matching the pattern used by scan::tests::auto_secs_round_trip_and_defaults).
|
||||
let prev = std::env::var_os("HOME");
|
||||
let dir = std::env::temp_dir().join(format!("alkane-cred-test-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
std::env::set_var("HOME", &dir);
|
||||
|
||||
assert_eq!(load_credentials(), None, "no file -> None");
|
||||
|
||||
save_credentials("admin", "hunter2").unwrap();
|
||||
assert_eq!(load_credentials(), Some(("admin".to_string(), "hunter2".to_string())));
|
||||
|
||||
let meta = std::fs::metadata(config_path(CREDENTIALS_FILE)).unwrap();
|
||||
assert_eq!(meta.permissions().mode() & 0o777, 0o600, "credentials file must be 0600");
|
||||
|
||||
// configured_factory() must construct in both branches without panicking:
|
||||
// with saved credentials (fans auth across every firmware backend) ...
|
||||
let _ = configured_factory();
|
||||
|
||||
// A pre-existing, world-readable credentials file must be tightened to
|
||||
// 0600 by save_credentials (the create-mode is ignored for an existing
|
||||
// file, so the explicit set_permissions is what protects it).
|
||||
let path = config_path(CREDENTIALS_FILE);
|
||||
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644)).unwrap();
|
||||
save_credentials("admin2", "s3cr3t").unwrap();
|
||||
let meta = std::fs::metadata(&path).unwrap();
|
||||
assert_eq!(
|
||||
meta.permissions().mode() & 0o777,
|
||||
0o600,
|
||||
"save over a pre-existing 0644 file must re-tighten to 0600"
|
||||
);
|
||||
assert_eq!(load_credentials(), Some(("admin2".to_string(), "s3cr3t".to_string())));
|
||||
|
||||
clear_credentials().unwrap();
|
||||
// ... and with no saved credentials (plain MinerFactory::new()).
|
||||
let _ = configured_factory();
|
||||
assert_eq!(load_credentials(), None, "cleared -> None");
|
||||
clear_credentials().unwrap(); // idempotent: clearing an already-clear store is not an error
|
||||
|
||||
match prev {
|
||||
Some(v) => std::env::set_var("HOME", v),
|
||||
None => std::env::remove_var("HOME"),
|
||||
}
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,8 @@
|
||||
//! 10.255.1.0/24 (see ../../../HANDOFF.md section 7 and the parent project's
|
||||
//! [removed]). These are the reference values the workflow tests compare
|
||||
//! the application's actual output against, and the rows the offline
|
||||
//! `ALKANE_FAKE_SCAN` demo mode renders.
|
||||
//! `ALKANE_FAKE_SCAN` demo mode renders. Only miners that respond become rows,
|
||||
//! so there is no synthetic "offline" fixture.
|
||||
//!
|
||||
//! Hashrate/power/temp are representative per-model figures (the bench boards
|
||||
//! are not always energised); the point of the fixtures is a fixed, known input
|
||||
@@ -24,6 +25,10 @@ struct Board {
|
||||
fan: f64,
|
||||
worker: &'static str,
|
||||
mining: bool,
|
||||
/// True for the bench board deliberately rebucketed into the "paused"
|
||||
/// status/KPI bucket (not-mining but operator-paused, distinct from a
|
||||
/// unit that is simply idle/not-hashing).
|
||||
paused: bool,
|
||||
}
|
||||
|
||||
impl Board {
|
||||
@@ -37,6 +42,18 @@ impl Board {
|
||||
} else {
|
||||
(None, None, 0.0)
|
||||
};
|
||||
let fan_rpms = if self.mining {
|
||||
vec![self.fan, self.fan * 0.95, self.fan * 1.02]
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
// Firmware-flash capability is modeled on the real Bitmain/Antminer
|
||||
// upgrade path (S17/S19/S21 family); WhatsMiner boards in this fleet
|
||||
// don't advertise it, so both true and false show up and the
|
||||
// firmware menu item is testable.
|
||||
let firmware_flash = self.model == "Antminer S17"
|
||||
|| self.model.starts_with("Antminer S19")
|
||||
|| self.model.starts_with("Antminer S21");
|
||||
MinerRow {
|
||||
ip: self.ip.to_string(),
|
||||
selected: false,
|
||||
@@ -47,10 +64,12 @@ impl Board {
|
||||
efficiency,
|
||||
power_w: self.power,
|
||||
chip_temp_c: self.temp,
|
||||
fan_rpm: self.fan,
|
||||
fan_rpms,
|
||||
worker: self.worker.to_string(),
|
||||
is_mining: self.mining,
|
||||
slow,
|
||||
paused: self.paused,
|
||||
// offline defaults to false (online); these bench rows are reachable.
|
||||
mac: format!("AA:BB:CC:00:{:02X}:{last_octet:02X}", last_octet.wrapping_mul(3)),
|
||||
hostname: format!("miner-{last_octet}"),
|
||||
hashboards: boards,
|
||||
@@ -68,7 +87,13 @@ impl Board {
|
||||
("stratum+tcp://backup.blueflare:3333".to_string(), format!("{}_bak", self.worker)),
|
||||
]
|
||||
},
|
||||
operating_state: if self.mining { "mining".to_string() } else { "idle".to_string() },
|
||||
operating_state: if self.paused {
|
||||
"paused".to_string()
|
||||
} else if self.mining {
|
||||
"mining".to_string()
|
||||
} else {
|
||||
"idle".to_string()
|
||||
},
|
||||
// Synthetic capabilities so the right-click config menu is
|
||||
// exercisable offline: mining units support everything, idle ones
|
||||
// only the fault light + restart (to show the capability intersection).
|
||||
@@ -79,47 +104,83 @@ impl Board {
|
||||
resume: self.mining,
|
||||
power_limit: self.mining,
|
||||
tuning: self.mining,
|
||||
firmware_flash,
|
||||
},
|
||||
// Demo values for the round-8 columns (synthetic, so the columns
|
||||
// show variety offline).
|
||||
control_board: if self.model.contains("S17") {
|
||||
"Xilinx".to_string()
|
||||
} else if self.model.contains("S19j") || self.model.contains("S19k") {
|
||||
"AMLogic".to_string()
|
||||
} else if self.model.contains("S19") {
|
||||
"BeagleBone Black".to_string()
|
||||
} else if self.model.contains("S21") {
|
||||
"CVITek".to_string()
|
||||
} else {
|
||||
String::new()
|
||||
},
|
||||
pic_present: if self.model.contains("S21") {
|
||||
Some(false) // noPIC example
|
||||
} else if self.model.starts_with("Antminer") {
|
||||
Some(true)
|
||||
} else {
|
||||
None // WhatsMiner: unknown over the network
|
||||
},
|
||||
// Access: idle/view-only units (no worker) shown locked; the rest
|
||||
// unlocked. (Live rows infer this from control capabilities.)
|
||||
write_locked: Some(self.worker.is_empty()),
|
||||
errors: if self.model.contains("S21 Pro") {
|
||||
vec![
|
||||
"[Warning] hashrate 70% below expected".to_string(),
|
||||
"[Warning] chip temperature high (HashBoard 2)".to_string(),
|
||||
]
|
||||
} else {
|
||||
Vec::new()
|
||||
},
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The 9 bench boards. Two are idle (S17 stock, WardenOS dev), one is slow
|
||||
/// (S21 Pro aml stock at ~30% of expected); the other six hash normally.
|
||||
/// The 9 bench boards (9 rows total). One is idle/not-hashing (S17 stock,
|
||||
/// .112); one is paused (WardenOS dev, .115 - deliberately rebucketed from idle
|
||||
/// so the "paused" status/KPI bucket is exercisable offline); one is slow (S21
|
||||
/// Pro aml stock at ~30% of expected); the other six hash normally.
|
||||
///
|
||||
/// Derived totals (used by the workflow tests):
|
||||
/// total = 9, hashing = 6, slow = 1, not hashing = 2,
|
||||
/// total = 9, hashing = 6, slow = 1, not hashing = 1, paused = 1,
|
||||
/// total hashrate = 685.0 TH/s, total power = 21300 W.
|
||||
pub fn bench_fleet() -> Vec<MinerRow> {
|
||||
let boards = [
|
||||
Board { ip: "10.255.1.112", model: "Antminer S17", firmware: "Stock",
|
||||
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
|
||||
worker: "", mining: false },
|
||||
worker: "", mining: false, paused: false },
|
||||
Board { ip: "10.255.1.166", model: "Antminer S19", firmware: "[removed] 1.2",
|
||||
hashrate: 95.0, expected: 96.0, power: 3250.0, temp: 65.0, fan: 4200.0,
|
||||
worker: "blueflare.s19", mining: true },
|
||||
worker: "blueflare.s19", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.152", model: "Antminer S19j Pro", firmware: "[removed] 1.2",
|
||||
hashrate: 100.0, expected: 104.0, power: 3100.0, temp: 62.0, fan: 3900.0,
|
||||
worker: "blueflare.s19jpro", mining: true },
|
||||
worker: "blueflare.s19jpro", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.167", model: "Antminer S19k Pro", firmware: "[removed] 1.2",
|
||||
hashrate: 120.0, expected: 128.0, power: 3300.0, temp: 68.0, fan: 4500.0,
|
||||
worker: "blueflare.s19kpro", mining: true },
|
||||
worker: "blueflare.s19kpro", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.149", model: "Antminer S21 Pro", firmware: "Stock",
|
||||
hashrate: 60.0, expected: 200.0, power: 1500.0, temp: 55.0, fan: 3000.0,
|
||||
worker: "blueflare.s21pro", mining: true }, // slow: 60/200 = 30%
|
||||
worker: "blueflare.s21pro", mining: true, paused: false }, // slow: 60/200 = 30%
|
||||
Board { ip: "10.255.1.126", model: "WhatsMiner M30S", firmware: "WMOS H3",
|
||||
hashrate: 92.0, expected: 96.0, power: 3400.0, temp: 70.0, fan: 4800.0,
|
||||
worker: "blueflare.h3", mining: true },
|
||||
worker: "blueflare.h3", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.131", model: "WhatsMiner M30S+", firmware: "WMOS H616",
|
||||
hashrate: 100.0, expected: 100.0, power: 3450.0, temp: 71.0, fan: 4900.0,
|
||||
worker: "blueflare.h616", mining: true },
|
||||
worker: "blueflare.h616", mining: true, paused: false },
|
||||
Board { ip: "10.255.1.148", model: "WhatsMiner M50", firmware: "WMOS CB4",
|
||||
hashrate: 118.0, expected: 122.0, power: 3300.0, temp: 66.0, fan: 4600.0,
|
||||
worker: "blueflare.m50", mining: true },
|
||||
worker: "blueflare.m50", mining: true, paused: false },
|
||||
// Rebucketed from idle/not-hashing to paused so the "paused"
|
||||
// status/KPI bucket is exercisable in the fake-scan/offline demo.
|
||||
Board { ip: "10.255.1.115", model: "Antminer S19", firmware: "WardenOS dev",
|
||||
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
|
||||
worker: "", mining: false },
|
||||
worker: "", mining: false, paused: true },
|
||||
];
|
||||
boards.into_iter().map(Board::into_row).collect()
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! alkane-toolkit — primary view (docs/UI-SPEC.md).
|
||||
//! Pure-Rust wxWidgets app on the vendored, patched wx-rs.
|
||||
|
||||
mod credentials;
|
||||
mod fixtures;
|
||||
mod model;
|
||||
mod scan;
|
||||
|
||||
+486
-78
@@ -14,13 +14,15 @@ pub fn is_slow(is_mining: bool, hashrate_ths: f64, expected_ths: f64) -> bool {
|
||||
is_mining && expected_ths > 0.0 && hashrate_ths < SLOW_THRESHOLD * expected_ths
|
||||
}
|
||||
|
||||
/// Format a value in its base unit with an SI prefix chosen so the number stays
|
||||
/// compact: the prefix puts the mantissa in [1, 1000), then it is shown with 1
|
||||
/// decimal below 100 and no decimal from 100 up (so 21300 W -> "21.3 kW",
|
||||
/// 685e12 H/s -> "685 TH/s", 6.8e12 -> "6.8 TH/s"). Zero renders as "0 <unit>".
|
||||
pub fn format_si(value_base: f64, unit: &str) -> String {
|
||||
/// Choose an SI prefix and a max-3-significant-digit mantissa string for a
|
||||
/// base value, shared by `format_si` and `format_fan_rpm`: the prefix puts
|
||||
/// the mantissa in [1, 1000), shown with 1 decimal below 100 and no decimal
|
||||
/// from 100 up. `None` for a non-finite or non-positive value -- the caller
|
||||
/// renders its own "absent" form ("0 <unit>" for `format_si`, "-" for
|
||||
/// `format_fan_rpm`).
|
||||
fn si_mantissa_and_prefix(value_base: f64) -> Option<(String, &'static str)> {
|
||||
if !value_base.is_finite() || value_base <= 0.0 {
|
||||
return format!("0 {unit}");
|
||||
return None;
|
||||
}
|
||||
const PREFIXES: [&str; 8] = ["", "k", "M", "G", "T", "P", "E", "Z"];
|
||||
let mut v = value_base;
|
||||
@@ -42,7 +44,94 @@ pub fn format_si(value_base: f64, unit: &str) -> String {
|
||||
} else if num == "100.0" {
|
||||
num = "100".to_string();
|
||||
}
|
||||
format!("{num} {}{unit}", PREFIXES[i])
|
||||
Some((num, PREFIXES[i]))
|
||||
}
|
||||
|
||||
/// Format a value in its base unit with an SI prefix chosen so the number stays
|
||||
/// compact: the prefix puts the mantissa in [1, 1000), then it is shown with 1
|
||||
/// decimal below 100 and no decimal from 100 up (so 21300 W -> "21.3 kW",
|
||||
/// 685e12 H/s -> "685 TH/s", 6.8e12 -> "6.8 TH/s"). Zero renders as "0 <unit>".
|
||||
pub fn format_si(value_base: f64, unit: &str) -> String {
|
||||
match si_mantissa_and_prefix(value_base) {
|
||||
Some((num, prefix)) => format!("{num} {prefix}{unit}"),
|
||||
None => format!("0 {unit}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Like `format_si` but for a cooling-fan RPM reading: no unit/space suffix,
|
||||
/// and "-" (rather than "0") for an absent/non-positive reading, since a fan
|
||||
/// column packs several of these per cell (see `Column::Cooling`).
|
||||
pub fn format_fan_rpm(rpm: f64) -> String {
|
||||
match si_mantissa_and_prefix(rpm) {
|
||||
Some((num, prefix)) => format!("{num}{prefix}"),
|
||||
None => "-".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// A hashrate reading (in TH/s) for the combined Hashrate column: mantissa + SI
|
||||
/// prefix only, no unit and no space (80.5 TH/s -> "80.5T", 102 TH/s -> "102T"),
|
||||
/// or `None` for an absent/non-positive reading.
|
||||
pub fn format_hashrate_ths(ths: f64) -> Option<String> {
|
||||
si_mantissa_and_prefix(ths * 1e12).map(|(num, prefix)| format!("{num}{prefix}"))
|
||||
}
|
||||
|
||||
/// The actual/expected ratio, or `None` when the expected value is unknown
|
||||
/// (<= 0.0) so a ratio-based color/warning never divides by zero or treats an
|
||||
/// unknown expectation as a 0% shortfall.
|
||||
pub fn actual_expected_ratio(actual: f64, expected: f64) -> Option<f64> {
|
||||
if expected > 0.0 { Some(actual / expected) } else { None }
|
||||
}
|
||||
|
||||
/// Render the combined Hashrate cell "actual/expected" (no spaces around the
|
||||
/// slash, prefix-only unit): blank when neither is known, the bare actual when
|
||||
/// only it is known, "-/<expected>" when only the expected is known, and
|
||||
/// "<actual>/<expected>" when both are (e.g. "80.5T/95.0T").
|
||||
fn combined_si(actual_ths: f64, expected_ths: f64) -> String {
|
||||
match (format_hashrate_ths(actual_ths), format_hashrate_ths(expected_ths)) {
|
||||
(None, None) => String::new(),
|
||||
(Some(a), None) => a,
|
||||
(None, Some(e)) => format!("-/{e}"),
|
||||
(Some(a), Some(e)) => format!("{a}/{e}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Same combined rendering as `combined_si`, for a plain integer count
|
||||
/// (hashboards, total chips) instead of an SI-formatted rate.
|
||||
fn combined_count(actual: Option<u32>, expected: Option<u32>) -> String {
|
||||
match (actual, expected) {
|
||||
(None, None) => String::new(),
|
||||
(Some(a), None) => a.to_string(),
|
||||
(None, Some(e)) => format!("- / {e}"),
|
||||
(Some(a), Some(e)) => format!("{a} / {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Encode colored text segments for a custom-rendered cell (see the wx-rs
|
||||
/// `SegmentRenderer`): segments are joined by U+001F, and within a segment an
|
||||
/// optional uppercase RRGGBB color is separated from its text by U+001E.
|
||||
/// `decode_segments_plain` is the inverse for anything that just wants the
|
||||
/// plain text (filtering, sorting, tests).
|
||||
pub fn encode_segments(segs: &[(Option<(u8, u8, u8)>, String)]) -> String {
|
||||
segs.iter()
|
||||
.map(|(color, text)| {
|
||||
let hex = color.map(|(r, g, b)| format!("{r:02X}{g:02X}{b:02X}")).unwrap_or_default();
|
||||
format!("{hex}\u{1e}{text}")
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("\u{1f}")
|
||||
}
|
||||
|
||||
/// Strip the encoding `encode_segments` applies, returning just the
|
||||
/// concatenated text. A plain string with no U+001E in it (i.e. never passed
|
||||
/// through `encode_segments`) round-trips unchanged, so this is safe to call
|
||||
/// on any cell value.
|
||||
pub fn decode_segments_plain(s: &str) -> String {
|
||||
if !s.contains('\u{1e}') {
|
||||
return s.to_string();
|
||||
}
|
||||
s.split('\u{1f}')
|
||||
.map(|seg| seg.split_once('\u{1e}').map(|(_, text)| text).unwrap_or(seg))
|
||||
.collect::<String>()
|
||||
}
|
||||
|
||||
/// Compact human duration (e.g. "3d 4h", "5h 12m", "42m", "18s").
|
||||
@@ -67,8 +156,9 @@ pub fn format_uptime(secs: u64) -> String {
|
||||
|
||||
/// Pack a dotted-quad IPv4 string into a u32 for numeric ordering, so
|
||||
/// "10.255.1.9" sorts before "10.255.1.10" (a plain string sort gets this
|
||||
/// wrong). Anything unparseable sorts first (0).
|
||||
fn ip_to_u32(s: &str) -> u32 {
|
||||
/// wrong). Anything unparseable sorts first (0). `pub(crate)` so the headless
|
||||
/// self-test can build the same numeric order it asserts the view against.
|
||||
pub(crate) fn ip_to_u32(s: &str) -> u32 {
|
||||
let mut parts = s.split('.');
|
||||
let mut acc = 0u32;
|
||||
for _ in 0..4 {
|
||||
@@ -89,6 +179,9 @@ pub struct MinerCaps {
|
||||
pub resume: bool,
|
||||
pub power_limit: bool,
|
||||
pub tuning: bool,
|
||||
/// Whether this miner's asic-rs driver supports `upgrade_firmware`
|
||||
/// (probed via `supports_upgrade_firmware()` at scan time).
|
||||
pub firmware_flash: bool,
|
||||
}
|
||||
|
||||
impl MinerCaps {
|
||||
@@ -101,6 +194,7 @@ impl MinerCaps {
|
||||
resume: self.resume && other.resume,
|
||||
power_limit: self.power_limit && other.power_limit,
|
||||
tuning: self.tuning && other.tuning,
|
||||
firmware_flash: self.firmware_flash && other.firmware_flash,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -118,6 +212,18 @@ impl MinerCaps {
|
||||
pub fn is_empty(self) -> bool {
|
||||
self == MinerCaps::default()
|
||||
}
|
||||
|
||||
/// Whether the miner exposes any writable control action at all. Used to
|
||||
/// infer the "Access" (locked/unlocked) column: no control -> view-only.
|
||||
pub fn any_control(self) -> bool {
|
||||
self.fault_light
|
||||
|| self.restart
|
||||
|| self.pause
|
||||
|| self.resume
|
||||
|| self.power_limit
|
||||
|| self.tuning
|
||||
|| self.firmware_flash
|
||||
}
|
||||
}
|
||||
|
||||
/// One miner's telemetry snapshot, flattened from asic-rs `MinerData` into the
|
||||
@@ -137,6 +243,19 @@ pub struct MinerRow {
|
||||
pub firmware: String,
|
||||
pub api_version: String,
|
||||
pub control_board: String,
|
||||
/// Whether the hashboards carry a PIC MCU. asic-rs does not report this over
|
||||
/// the network, so it is a best-effort inference (model-string heuristic):
|
||||
/// `None` = unknown, `Some(true)` = PIC, `Some(false)` = noPIC. True
|
||||
/// detection needs an on-board SSH/I2C probe (a separate feature).
|
||||
pub pic_present: Option<bool>,
|
||||
/// Whether this miner is locked to view-only (no command writes). Inferred
|
||||
/// from whether any control capability is available: `None` = unknown,
|
||||
/// `Some(true)` = locked, `Some(false)` = unlocked/writable.
|
||||
pub write_locked: Option<bool>,
|
||||
/// Structured error/event lines from the miner (severity + text), most
|
||||
/// severe first. Empty means none. The Error column shows a summary; the
|
||||
/// full list is the hover tooltip (added with the tooltip bridge support).
|
||||
pub errors: Vec<String>,
|
||||
// performance
|
||||
pub hashrate_ths: f64,
|
||||
pub expected_ths: f64,
|
||||
@@ -148,7 +267,9 @@ pub struct MinerRow {
|
||||
pub chip_temp_c: f64,
|
||||
pub fluid_temp_c: f64,
|
||||
pub outlet_temp_c: f64,
|
||||
pub fan_rpm: f64,
|
||||
/// Individual cooling-fan RPMs (empty if unknown). PSU fan is tracked
|
||||
/// separately below since it is not part of the cooling-fan set.
|
||||
pub fan_rpms: Vec<f64>,
|
||||
pub psu_fan_rpm: f64,
|
||||
pub fan_count: Option<u32>,
|
||||
pub expected_fans: Option<u32>,
|
||||
@@ -171,12 +292,20 @@ pub struct MinerRow {
|
||||
pub operating_state: String,
|
||||
pub is_mining: bool,
|
||||
pub slow: bool,
|
||||
/// Not-mining because an operator paused it (distinct from simply idle);
|
||||
/// see `is_paused`.
|
||||
pub paused: bool,
|
||||
}
|
||||
|
||||
impl MinerRow {
|
||||
/// The row's status label. Only miners that actually responded to a scan
|
||||
/// become rows, so there is no "offline" state: a responding miner that is
|
||||
/// not mining is "not hashing".
|
||||
pub fn status(&self) -> &'static str {
|
||||
if self.slow {
|
||||
"slow"
|
||||
} else if self.paused {
|
||||
"paused"
|
||||
} else if self.is_mining {
|
||||
"hashing"
|
||||
} else {
|
||||
@@ -197,6 +326,22 @@ impl MinerRow {
|
||||
}
|
||||
}
|
||||
|
||||
/// The single source of truth for the "paused" classification: a miner is
|
||||
/// counted as operator-paused when it is not currently mining and its raw
|
||||
/// operating-state string says so (case-insensitively), shared by the live
|
||||
/// scan (`scan::to_row`) and the fixtures/tests.
|
||||
pub fn is_paused(operating_state: &str, is_mining: bool) -> bool {
|
||||
!is_mining && operating_state.to_lowercase().contains("pause")
|
||||
}
|
||||
|
||||
/// The typed-confirmation gate for the irreversible firmware-flash action: the
|
||||
/// operator must type exactly "FLASH" (surrounding whitespace ignored, but not
|
||||
/// case-folded and not a prefix). Pure so the guard is unit-testable without a
|
||||
/// live dialog.
|
||||
pub fn flash_confirmed(input: &str) -> bool {
|
||||
input.trim() == "FLASH"
|
||||
}
|
||||
|
||||
/// Model columns. Ip is fixed (always shown first); the rest map 1:1 to a
|
||||
/// scannable metric and can be shown/hidden/reordered. Row selection replaces
|
||||
/// the old checkbox column.
|
||||
@@ -211,7 +356,6 @@ pub enum Column {
|
||||
Worker,
|
||||
Model,
|
||||
Status,
|
||||
ExpectedHashrate,
|
||||
Efficiency,
|
||||
FluidTemp,
|
||||
OutletTemp,
|
||||
@@ -219,14 +363,15 @@ pub enum Column {
|
||||
FanCount,
|
||||
ExpectedFans,
|
||||
TotalChips,
|
||||
ExpectedChips,
|
||||
Hashboards,
|
||||
ExpectedHashboards,
|
||||
Mac,
|
||||
Hostname,
|
||||
Serial,
|
||||
ApiVersion,
|
||||
ControlBoard,
|
||||
Pic,
|
||||
Locked,
|
||||
Error,
|
||||
Uptime,
|
||||
Light,
|
||||
OperatingState,
|
||||
@@ -254,7 +399,6 @@ pub const ALL_COLUMNS: [Column; 38] = [
|
||||
Column::Worker,
|
||||
Column::Model,
|
||||
Column::Status,
|
||||
Column::ExpectedHashrate,
|
||||
Column::Efficiency,
|
||||
Column::FluidTemp,
|
||||
Column::OutletTemp,
|
||||
@@ -262,14 +406,15 @@ pub const ALL_COLUMNS: [Column; 38] = [
|
||||
Column::FanCount,
|
||||
Column::ExpectedFans,
|
||||
Column::TotalChips,
|
||||
Column::ExpectedChips,
|
||||
Column::Hashboards,
|
||||
Column::ExpectedHashboards,
|
||||
Column::Mac,
|
||||
Column::Hostname,
|
||||
Column::Serial,
|
||||
Column::ApiVersion,
|
||||
Column::ControlBoard,
|
||||
Column::Pic,
|
||||
Column::Locked,
|
||||
Column::Error,
|
||||
Column::Uptime,
|
||||
Column::Light,
|
||||
Column::OperatingState,
|
||||
@@ -309,7 +454,6 @@ impl Column {
|
||||
Column::Worker => "Pool worker",
|
||||
Column::Model => "Model",
|
||||
Column::Status => "Status",
|
||||
Column::ExpectedHashrate => "Expected HR",
|
||||
Column::Efficiency => "Efficiency (J/TH)",
|
||||
Column::FluidTemp => "Fluid temp",
|
||||
Column::OutletTemp => "Outlet temp",
|
||||
@@ -317,16 +461,17 @@ impl Column {
|
||||
Column::FanCount => "Fans",
|
||||
Column::ExpectedFans => "Fans (exp)",
|
||||
Column::TotalChips => "Chips",
|
||||
Column::ExpectedChips => "Chips (exp)",
|
||||
Column::Hashboards => "Boards",
|
||||
Column::ExpectedHashboards => "Boards (exp)",
|
||||
Column::Mac => "MAC",
|
||||
Column::Hostname => "Hostname",
|
||||
Column::Serial => "Serial",
|
||||
Column::ApiVersion => "API ver",
|
||||
Column::ControlBoard => "Control board",
|
||||
Column::Pic => "PIC",
|
||||
Column::Locked => "Access",
|
||||
Column::Error => "Errors",
|
||||
Column::Uptime => "Uptime",
|
||||
Column::Light => "Fault light",
|
||||
Column::Light => "Light",
|
||||
Column::OperatingState => "State",
|
||||
Column::BestShare => "Best share",
|
||||
Column::SessionBestShare => "Session best",
|
||||
@@ -344,7 +489,7 @@ impl Column {
|
||||
pub fn width(self) -> i32 {
|
||||
match self {
|
||||
Column::Ip => 130,
|
||||
Column::Hashrate | Column::ExpectedHashrate => 110,
|
||||
Column::Hashrate => 110,
|
||||
Column::Power => 90,
|
||||
Column::ChipTemp | Column::FluidTemp | Column::OutletTemp => 95,
|
||||
Column::Cooling | Column::PsuFan => 100,
|
||||
@@ -354,13 +499,13 @@ impl Column {
|
||||
Column::Status => 95,
|
||||
Column::Efficiency => 120,
|
||||
Column::FanCount | Column::TotalChips | Column::Hashboards => 70,
|
||||
Column::ExpectedFans
|
||||
| Column::ExpectedChips
|
||||
| Column::ExpectedHashboards
|
||||
| Column::TuningPercent => 90,
|
||||
Column::ExpectedFans | Column::TuningPercent => 90,
|
||||
Column::Mac | Column::Hostname | Column::Serial => 150,
|
||||
Column::ApiVersion | Column::Light => 90,
|
||||
Column::ControlBoard => 130,
|
||||
Column::Pic => 70,
|
||||
Column::Locked => 90,
|
||||
Column::Error => 160,
|
||||
Column::Uptime => 100,
|
||||
Column::OperatingState => 100,
|
||||
Column::BestShare | Column::SessionBestShare => 110,
|
||||
@@ -376,7 +521,6 @@ impl Column {
|
||||
matches!(
|
||||
self,
|
||||
Column::Hashrate
|
||||
| Column::ExpectedHashrate
|
||||
| Column::Power
|
||||
| Column::Efficiency
|
||||
| Column::ChipTemp
|
||||
@@ -387,9 +531,7 @@ impl Column {
|
||||
| Column::FanCount
|
||||
| Column::ExpectedFans
|
||||
| Column::TotalChips
|
||||
| Column::ExpectedChips
|
||||
| Column::Hashboards
|
||||
| Column::ExpectedHashboards
|
||||
| Column::Uptime
|
||||
| Column::BestShare
|
||||
| Column::SessionBestShare
|
||||
@@ -404,6 +546,16 @@ impl Column {
|
||||
/// here so a filter like "ChipTemp <= 50" cannot match a miner with no
|
||||
/// temperature reading.
|
||||
pub fn num_value(&self, r: &MinerRow) -> Option<f64> {
|
||||
// The 3 combined (actual/expected) columns must never let a numeric
|
||||
// filter match a row that only has an expected value: their cell()
|
||||
// renders "- / <expected>" (non-empty) in that case, so the generic
|
||||
// blank check below is not enough on its own.
|
||||
match self {
|
||||
Column::Hashrate if r.hashrate_ths <= 0.0 => return None,
|
||||
Column::Hashboards if r.hashboards.is_none() => return None,
|
||||
Column::TotalChips if r.total_chips.is_none() => return None,
|
||||
_ => {}
|
||||
}
|
||||
if !self.is_numeric() || self.cell(r).is_empty() {
|
||||
return None;
|
||||
}
|
||||
@@ -420,22 +572,21 @@ impl Column {
|
||||
let none = f64::NEG_INFINITY;
|
||||
match self {
|
||||
Column::Hashrate => SortKey::Num(r.hashrate_ths),
|
||||
Column::ExpectedHashrate => SortKey::Num(r.expected_ths),
|
||||
Column::Power => SortKey::Num(r.power_w),
|
||||
Column::Efficiency => SortKey::Num(if r.efficiency > 0.0 { r.efficiency } else { none }),
|
||||
Column::ChipTemp => SortKey::Num(r.chip_temp_c),
|
||||
Column::FluidTemp => SortKey::Num(r.fluid_temp_c),
|
||||
Column::OutletTemp => SortKey::Num(r.outlet_temp_c),
|
||||
Column::Cooling => SortKey::Num(r.fan_rpm),
|
||||
Column::Cooling => SortKey::Num(if r.fan_rpms.is_empty() {
|
||||
none
|
||||
} else {
|
||||
r.fan_rpms.iter().cloned().fold(f64::INFINITY, f64::min)
|
||||
}),
|
||||
Column::PsuFan => SortKey::Num(r.psu_fan_rpm),
|
||||
Column::FanCount => SortKey::Num(r.fan_count.map(|v| v as f64).unwrap_or(none)),
|
||||
Column::ExpectedFans => SortKey::Num(r.expected_fans.map(|v| v as f64).unwrap_or(none)),
|
||||
Column::TotalChips => SortKey::Num(r.total_chips.map(|v| v as f64).unwrap_or(none)),
|
||||
Column::ExpectedChips => SortKey::Num(r.expected_chips.map(|v| v as f64).unwrap_or(none)),
|
||||
Column::Hashboards => SortKey::Num(r.hashboards.map(|v| v as f64).unwrap_or(none)),
|
||||
Column::ExpectedHashboards => {
|
||||
SortKey::Num(r.expected_hashboards.map(|v| v as f64).unwrap_or(none))
|
||||
}
|
||||
Column::Uptime => SortKey::Num(if r.uptime_secs > 0 { r.uptime_secs as f64 } else { none }),
|
||||
Column::BestShare => SortKey::Num(r.best_share.unwrap_or(none)),
|
||||
Column::SessionBestShare => SortKey::Num(r.session_best_share.unwrap_or(none)),
|
||||
@@ -464,20 +615,7 @@ impl Column {
|
||||
let pool_worker = |i: usize| r.pools.get(i).map(|(_, w)| w.clone()).unwrap_or_default();
|
||||
match self {
|
||||
Column::Ip => r.ip.clone(),
|
||||
Column::Hashrate => {
|
||||
if r.hashrate_ths > 0.0 {
|
||||
format_si(r.hashrate_ths * 1e12, "H/s")
|
||||
} else {
|
||||
String::new()
|
||||
}
|
||||
}
|
||||
Column::ExpectedHashrate => {
|
||||
if r.expected_ths > 0.0 {
|
||||
format_si(r.expected_ths * 1e12, "H/s")
|
||||
} else {
|
||||
String::new()
|
||||
}
|
||||
}
|
||||
Column::Hashrate => combined_si(r.hashrate_ths, r.expected_ths),
|
||||
Column::Power => {
|
||||
if r.power_w > 0.0 {
|
||||
format_si(r.power_w, "W")
|
||||
@@ -489,14 +627,14 @@ impl Column {
|
||||
Column::ChipTemp => num(r.chip_temp_c, 1, " C"),
|
||||
Column::FluidTemp => num(r.fluid_temp_c, 1, " C"),
|
||||
Column::OutletTemp => num(r.outlet_temp_c, 1, " C"),
|
||||
Column::Cooling => num(r.fan_rpm, 0, ""),
|
||||
Column::Cooling => {
|
||||
r.fan_rpms.iter().map(|&v| format_fan_rpm(v)).collect::<Vec<_>>().join("/")
|
||||
}
|
||||
Column::PsuFan => num(r.psu_fan_rpm, 0, ""),
|
||||
Column::FanCount => count(r.fan_count),
|
||||
Column::ExpectedFans => count(r.expected_fans),
|
||||
Column::TotalChips => count(r.total_chips),
|
||||
Column::ExpectedChips => count(r.expected_chips),
|
||||
Column::Hashboards => count(r.hashboards),
|
||||
Column::ExpectedHashboards => count(r.expected_hashboards),
|
||||
Column::TotalChips => combined_count(r.total_chips, r.expected_chips),
|
||||
Column::Hashboards => combined_count(r.hashboards, r.expected_hashboards),
|
||||
Column::Firmware => r.firmware.clone(),
|
||||
Column::Worker => r.worker.clone(),
|
||||
Column::PoolUrl => r.pool_url.clone(),
|
||||
@@ -506,6 +644,21 @@ impl Column {
|
||||
Column::Serial => r.serial.clone(),
|
||||
Column::ApiVersion => r.api_version.clone(),
|
||||
Column::ControlBoard => r.control_board.clone(),
|
||||
Column::Pic => match r.pic_present {
|
||||
Some(true) => "PIC".to_string(),
|
||||
Some(false) => "noPIC".to_string(),
|
||||
None => "?".to_string(),
|
||||
},
|
||||
Column::Locked => match r.write_locked {
|
||||
Some(true) => "locked".to_string(),
|
||||
Some(false) => "unlocked".to_string(),
|
||||
None => "?".to_string(),
|
||||
},
|
||||
Column::Error => match r.errors.len() {
|
||||
0 => String::new(),
|
||||
1 => r.errors[0].clone(),
|
||||
n => format!("{n} errors"),
|
||||
},
|
||||
Column::Status => r.status().to_string(),
|
||||
Column::Uptime => format_uptime(r.uptime_secs),
|
||||
Column::Light => match r.light_flashing {
|
||||
@@ -687,26 +840,38 @@ impl ViewState {
|
||||
}
|
||||
}
|
||||
|
||||
/// The six KPIs (UI-SPEC header), derived from the filtered view.
|
||||
/// The KPIs (UI-SPEC header), derived from the filtered view. Every row is a
|
||||
/// miner that responded to a scan; a responding non-mining miner counts as
|
||||
/// `not_hashing`.
|
||||
pub struct Kpis {
|
||||
pub total: usize,
|
||||
pub hashing: usize,
|
||||
pub slow: usize,
|
||||
pub not_hashing: usize,
|
||||
pub paused: usize,
|
||||
pub total_hashrate_ths: f64,
|
||||
pub total_power_w: f64,
|
||||
}
|
||||
|
||||
pub fn compute_kpis(rows: &[MinerRow], view_idx: &[usize]) -> Kpis {
|
||||
let mut k = Kpis { total: view_idx.len(), hashing: 0, slow: 0, not_hashing: 0, total_hashrate_ths: 0.0, total_power_w: 0.0 };
|
||||
let mut k = Kpis {
|
||||
total: view_idx.len(),
|
||||
hashing: 0,
|
||||
slow: 0,
|
||||
not_hashing: 0,
|
||||
paused: 0,
|
||||
total_hashrate_ths: 0.0,
|
||||
total_power_w: 0.0,
|
||||
};
|
||||
for &i in view_idx {
|
||||
let r = &rows[i];
|
||||
if r.slow {
|
||||
k.slow += 1;
|
||||
} else if r.is_mining {
|
||||
k.hashing += 1;
|
||||
} else {
|
||||
k.not_hashing += 1;
|
||||
// Bucket by the same precedence status() uses, so the KPI header can
|
||||
// never disagree with a row's own status text.
|
||||
match r.status() {
|
||||
"slow" => k.slow += 1,
|
||||
"paused" => k.paused += 1,
|
||||
"hashing" => k.hashing += 1,
|
||||
_ => k.not_hashing += 1,
|
||||
}
|
||||
k.total_hashrate_ths += r.hashrate_ths;
|
||||
k.total_power_w += r.power_w;
|
||||
@@ -731,15 +896,35 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn kpis_match_expected_hardware_output() {
|
||||
// This does not hardcode fixture counts: it independently recomputes
|
||||
// each expected KPI bucket and sum straight from the rows (via
|
||||
// `status()`) and cross-checks `compute_kpis`'s output against that.
|
||||
let (rows, _v, idx) = full_view();
|
||||
let k = compute_kpis(&rows, &idx);
|
||||
assert_eq!(k.total, 9, "total miners");
|
||||
assert_eq!(k.hashing, 6, "hashing");
|
||||
assert_eq!(k.slow, 1, "slow");
|
||||
assert_eq!(k.not_hashing, 2, "not hashing");
|
||||
assert!((k.total_hashrate_ths - 685.0).abs() < 1e-9, "hashrate {}", k.total_hashrate_ths);
|
||||
assert!((k.total_power_w - 21300.0).abs() < 1e-9, "power {}", k.total_power_w);
|
||||
assert_eq!(k.total, k.hashing + k.slow + k.not_hashing);
|
||||
|
||||
let mut exp_hashing = 0usize;
|
||||
let mut exp_slow = 0usize;
|
||||
let mut exp_paused = 0usize;
|
||||
let mut exp_not_hashing = 0usize;
|
||||
for &i in &idx {
|
||||
match rows[i].status() {
|
||||
"slow" => exp_slow += 1,
|
||||
"paused" => exp_paused += 1,
|
||||
"hashing" => exp_hashing += 1,
|
||||
"not hashing" => exp_not_hashing += 1,
|
||||
other => panic!("unexpected status: {other}"),
|
||||
}
|
||||
}
|
||||
assert_eq!(k.hashing, exp_hashing, "hashing");
|
||||
assert_eq!(k.slow, exp_slow, "slow");
|
||||
assert_eq!(k.paused, exp_paused, "paused");
|
||||
assert_eq!(k.not_hashing, exp_not_hashing, "not hashing");
|
||||
|
||||
let exp_hashrate: f64 = idx.iter().map(|&i| rows[i].hashrate_ths).sum();
|
||||
let exp_power: f64 = idx.iter().map(|&i| rows[i].power_w).sum();
|
||||
assert!((k.total_hashrate_ths - exp_hashrate).abs() < 1e-9, "hashrate {}", k.total_hashrate_ths);
|
||||
assert!((k.total_power_w - exp_power).abs() < 1e-9, "power {}", k.total_power_w);
|
||||
assert_eq!(k.total, k.hashing + k.slow + k.not_hashing + k.paused);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -771,20 +956,23 @@ mod tests {
|
||||
assert_eq!(Column::Status.cell(s17), "not hashing");
|
||||
|
||||
let s21 = rows.iter().find(|r| r.ip == "10.255.1.149").unwrap();
|
||||
assert_eq!(Column::Hashrate.cell(s21), "60.0 TH/s");
|
||||
// Combined hashrate cell: both known -> "<actual>/<expected>" (no spaces).
|
||||
assert_eq!(Column::Hashrate.cell(s21), "60.0T/200T");
|
||||
assert_eq!(Column::Power.cell(s21), "1.5 kW");
|
||||
assert_eq!(Column::Status.cell(s21), "slow");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_view_sorts_by_ip_ascending() {
|
||||
// Fixture count/IPs are not hardcoded here (round-6 fixtures are being
|
||||
// extended concurrently): recompute the expected numeric-IP order
|
||||
// straight from the rows instead.
|
||||
let (rows, _v, idx) = full_view();
|
||||
let ips: Vec<String> = idx.iter().map(|&i| rows[i].ip.clone()).collect();
|
||||
assert_eq!(ips.len(), 9);
|
||||
let mut sorted = ips.clone();
|
||||
sorted.sort();
|
||||
assert_eq!(ips, sorted, "default view should be IP-ascending");
|
||||
assert_eq!(ips[0], "10.255.1.112");
|
||||
assert_eq!(ips.len(), rows.len(), "the default view has no filters");
|
||||
let mut expected: Vec<String> = rows.iter().map(|r| r.ip.clone()).collect();
|
||||
expected.sort_by_key(|ip| ip_to_u32(ip));
|
||||
assert_eq!(ips, expected, "default view should be IP-ascending (numeric)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -886,7 +1074,7 @@ mod tests {
|
||||
expected_ths: 200.0,
|
||||
power_w: 3000.0 + (i % 500) as f64,
|
||||
chip_temp_c: 55.0 + (i % 25) as f64,
|
||||
fan_rpm: 4000.0 + (i % 900) as f64,
|
||||
fan_rpms: vec![4000.0 + (i % 900) as f64],
|
||||
is_mining: i % 7 != 0,
|
||||
model: format!("Model-{}", i % 12),
|
||||
firmware: format!("fw-{}", i % 6),
|
||||
@@ -998,6 +1186,39 @@ mod tests {
|
||||
assert_eq!(format_uptime(90_061), "1d 1h");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pic_locked_error_columns_render() {
|
||||
// PIC (best-effort): known -> PIC/noPIC, unknown -> "?".
|
||||
let pic = MinerRow { pic_present: Some(true), ..Default::default() };
|
||||
let nopic = MinerRow { pic_present: Some(false), ..Default::default() };
|
||||
let pic_unknown = MinerRow { pic_present: None, ..Default::default() };
|
||||
assert_eq!(Column::Pic.cell(&pic), "PIC");
|
||||
assert_eq!(Column::Pic.cell(&nopic), "noPIC");
|
||||
assert_eq!(Column::Pic.cell(&pic_unknown), "?");
|
||||
|
||||
// Access column.
|
||||
let locked = MinerRow { write_locked: Some(true), ..Default::default() };
|
||||
let unlocked = MinerRow { write_locked: Some(false), ..Default::default() };
|
||||
assert_eq!(Column::Locked.cell(&locked), "locked");
|
||||
assert_eq!(Column::Locked.cell(&unlocked), "unlocked");
|
||||
assert_eq!(Column::Locked.cell(&MinerRow::default()), "?");
|
||||
|
||||
// Error column: blank / single message / count.
|
||||
let none = MinerRow { errors: vec![], ..Default::default() };
|
||||
let one = MinerRow { errors: vec!["[Error] boom".into()], ..Default::default() };
|
||||
let many = MinerRow { errors: vec!["a".into(), "b".into(), "c".into()], ..Default::default() };
|
||||
assert_eq!(Column::Error.cell(&none), "");
|
||||
assert_eq!(Column::Error.cell(&one), "[Error] boom");
|
||||
assert_eq!(Column::Error.cell(&many), "3 errors");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn caps_any_control() {
|
||||
assert!(!MinerCaps::default().any_control(), "no caps -> view-only");
|
||||
assert!(MinerCaps { restart: true, ..Default::default() }.any_control());
|
||||
assert!(MinerCaps { firmware_flash: true, ..Default::default() }.any_control());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ip_column_sorts_numerically() {
|
||||
// A plain string sort puts "10.255.1.10" before "10.255.1.2"; the IP
|
||||
@@ -1070,14 +1291,16 @@ mod tests {
|
||||
#[test]
|
||||
fn passes_filters_ors_within_one_column() {
|
||||
let rows = bench_fleet();
|
||||
// Not hardcoded (fixture composition is changing concurrently):
|
||||
// recompute the expected count straight from the rows' own status().
|
||||
let expected = rows.iter().filter(|r| matches!(r.status(), "slow" | "not hashing")).count();
|
||||
let mut view = ViewState::default();
|
||||
view.filters.insert(
|
||||
Column::Status,
|
||||
ColFilter::Values(HashSet::from(["slow".to_string(), "not hashing".to_string()])),
|
||||
);
|
||||
let idx = view.view(&rows);
|
||||
// fixtures: 1 slow + 2 not-hashing.
|
||||
assert_eq!(idx.len(), 3);
|
||||
assert_eq!(idx.len(), expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -1227,7 +1450,15 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn caps_intersection_is_the_common_actions() {
|
||||
let full = MinerCaps { fault_light: true, restart: true, pause: true, resume: true, power_limit: true, tuning: true };
|
||||
let full = MinerCaps {
|
||||
fault_light: true,
|
||||
restart: true,
|
||||
pause: true,
|
||||
resume: true,
|
||||
power_limit: true,
|
||||
tuning: true,
|
||||
firmware_flash: true,
|
||||
};
|
||||
let idle = MinerCaps { fault_light: true, restart: true, ..Default::default() };
|
||||
// Two full miners keep every action.
|
||||
assert_eq!(MinerCaps::intersect_all([full, full]), full);
|
||||
@@ -1256,4 +1487,181 @@ mod tests {
|
||||
let live = MinerRow { chip_temp_c: 45.0, is_mining: true, ..Default::default() };
|
||||
assert!(ColFilter::Num { op: NumOp::Le, a: 50.0, b: 0.0 }.matches(Column::ChipTemp, &live));
|
||||
}
|
||||
|
||||
// ---- round 6: offline/paused rows, combined columns, fan RPMs, segments ----
|
||||
|
||||
#[test]
|
||||
fn format_fan_rpm_boundaries() {
|
||||
assert_eq!(format_fan_rpm(0.0), "-");
|
||||
assert_eq!(format_fan_rpm(-100.0), "-");
|
||||
assert_eq!(format_fan_rpm(f64::NAN), "-");
|
||||
assert_eq!(format_fan_rpm(f64::INFINITY), "-");
|
||||
assert_eq!(format_fan_rpm(950.0), "950");
|
||||
assert_eq!(format_fan_rpm(4200.0), "4.2k");
|
||||
// Shares format_si's rounding-rollover and >=100 rules.
|
||||
assert_eq!(format_fan_rpm(99.95), "100");
|
||||
assert_eq!(format_fan_rpm(999.9), "1.0k");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn combined_cell_all_four_cases() {
|
||||
let neither = MinerRow::default();
|
||||
assert_eq!(Column::Hashrate.cell(&neither), "", "both unknown -> blank");
|
||||
assert_eq!(Column::Hashboards.cell(&neither), "");
|
||||
assert_eq!(Column::TotalChips.cell(&neither), "");
|
||||
|
||||
let actual_only = MinerRow {
|
||||
hashrate_ths: 60.0,
|
||||
hashboards: Some(3),
|
||||
total_chips: Some(210),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.cell(&actual_only), "60.0T", "only actual -> bare actual");
|
||||
assert_eq!(Column::Hashboards.cell(&actual_only), "3");
|
||||
assert_eq!(Column::TotalChips.cell(&actual_only), "210");
|
||||
|
||||
let expected_only = MinerRow {
|
||||
expected_ths: 200.0,
|
||||
expected_hashboards: Some(3),
|
||||
expected_chips: Some(228),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.cell(&expected_only), "-/200T", "only expected -> '-/<expected>'");
|
||||
assert_eq!(Column::Hashboards.cell(&expected_only), "- / 3");
|
||||
assert_eq!(Column::TotalChips.cell(&expected_only), "- / 228");
|
||||
|
||||
let both = MinerRow {
|
||||
hashrate_ths: 60.0,
|
||||
expected_ths: 200.0,
|
||||
hashboards: Some(3),
|
||||
expected_hashboards: Some(3),
|
||||
total_chips: Some(190),
|
||||
expected_chips: Some(228),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.cell(&both), "60.0T/200T", "both known -> '<actual>/<expected>'");
|
||||
assert_eq!(Column::Hashboards.cell(&both), "3 / 3");
|
||||
assert_eq!(Column::TotalChips.cell(&both), "190 / 228");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn num_value_none_when_only_expected_known() {
|
||||
// A numeric filter must never match a row that only has an expected
|
||||
// value -- there is no actual reading to compare.
|
||||
let expected_only = MinerRow {
|
||||
expected_ths: 200.0,
|
||||
expected_hashboards: Some(3),
|
||||
expected_chips: Some(228),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.num_value(&expected_only), None);
|
||||
assert_eq!(Column::Hashboards.num_value(&expected_only), None);
|
||||
assert_eq!(Column::TotalChips.num_value(&expected_only), None);
|
||||
|
||||
let both = MinerRow {
|
||||
hashrate_ths: 60.0,
|
||||
expected_ths: 200.0,
|
||||
hashboards: Some(3),
|
||||
expected_hashboards: Some(3),
|
||||
total_chips: Some(190),
|
||||
expected_chips: Some(228),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.num_value(&both), Some(60.0));
|
||||
assert_eq!(Column::Hashboards.num_value(&both), Some(3.0));
|
||||
assert_eq!(Column::TotalChips.num_value(&both), Some(190.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cooling_column_joins_fan_rpms_and_sorts_by_min() {
|
||||
let r = MinerRow { fan_rpms: vec![4200.0, 3990.0, 4500.0], ..Default::default() };
|
||||
assert_eq!(Column::Cooling.cell(&r), "4.2k/4.0k/4.5k");
|
||||
assert_eq!(Column::Cooling.num_value(&r), Some(3990.0));
|
||||
|
||||
let none = MinerRow::default();
|
||||
assert_eq!(Column::Cooling.cell(&none), "");
|
||||
assert_eq!(Column::Cooling.num_value(&none), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn segments_round_trip_and_plain_passthrough() {
|
||||
let segs = vec![(Some((255u8, 0u8, 0u8)), "Err".to_string()), (None, ": offline".to_string())];
|
||||
let encoded = encode_segments(&segs);
|
||||
assert_eq!(encoded, "FF0000\u{1e}Err\u{1f}\u{1e}: offline");
|
||||
assert_eq!(decode_segments_plain(&encoded), "Err: offline");
|
||||
|
||||
// A plain string with no segment markers round-trips unchanged.
|
||||
assert_eq!(decode_segments_plain("10.255.1.9"), "10.255.1.9");
|
||||
assert_eq!(decode_segments_plain(""), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn actual_expected_ratio_handles_unknown_expected() {
|
||||
// 50/200 = 0.25 is exactly representable, so this is a safe exact
|
||||
// comparison (unlike e.g. 60/200, whose nearest-double result is not
|
||||
// guaranteed to bit-match a decimal literal).
|
||||
assert_eq!(actual_expected_ratio(50.0, 200.0), Some(0.25));
|
||||
assert_eq!(actual_expected_ratio(60.0, 0.0), None);
|
||||
assert_eq!(actual_expected_ratio(0.0, 0.0), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn status_precedence() {
|
||||
// A plain default row is a reachable, non-mining miner.
|
||||
let default_row = MinerRow { ..Default::default() };
|
||||
assert_eq!(default_row.status(), "not hashing");
|
||||
|
||||
let paused = MinerRow { paused: true, ..Default::default() };
|
||||
assert_eq!(paused.status(), "paused");
|
||||
|
||||
let hashing = MinerRow { is_mining: true, ..Default::default() };
|
||||
assert_eq!(hashing.status(), "hashing");
|
||||
|
||||
// slow outranks paused (and hashing).
|
||||
let slow_and_paused = MinerRow { slow: true, paused: true, is_mining: true, ..Default::default() };
|
||||
assert_eq!(slow_and_paused.status(), "slow");
|
||||
|
||||
// paused outranks hashing.
|
||||
let paused_but_mining = MinerRow { paused: true, is_mining: true, ..Default::default() };
|
||||
assert_eq!(paused_but_mining.status(), "paused");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn is_paused_detection() {
|
||||
assert!(is_paused("Paused", false));
|
||||
assert!(is_paused("PAUSED (manual)", false));
|
||||
assert!(!is_paused("Paused", true), "mining overrides an even stale 'paused' state string");
|
||||
assert!(!is_paused("Mining", false));
|
||||
assert!(!is_paused("", false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn kpis_bucket_by_status_not_raw_flags() {
|
||||
// compute_kpis must bucket by status()'s precedence, so a row's KPI
|
||||
// bucket can never disagree with its status text.
|
||||
let rows = vec![
|
||||
MinerRow { slow: true, paused: true, is_mining: true, ..Default::default() }, // slow wins
|
||||
MinerRow { paused: true, is_mining: true, ..Default::default() }, // paused over hashing
|
||||
MinerRow { is_mining: true, ..Default::default() }, // hashing
|
||||
MinerRow { ..Default::default() }, // not hashing
|
||||
];
|
||||
let idx: Vec<usize> = (0..rows.len()).collect();
|
||||
let k = compute_kpis(&rows, &idx);
|
||||
assert_eq!(k.slow, 1);
|
||||
assert_eq!(k.paused, 1, "paused outranks the mining flag");
|
||||
assert_eq!(k.hashing, 1);
|
||||
assert_eq!(k.not_hashing, 1);
|
||||
assert_eq!(k.total, 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flash_confirmed_requires_exact_word() {
|
||||
assert!(flash_confirmed("FLASH"));
|
||||
assert!(flash_confirmed(" FLASH "), "surrounding whitespace is trimmed");
|
||||
assert!(!flash_confirmed("flash"), "case-sensitive");
|
||||
assert!(!flash_confirmed("Flash"));
|
||||
assert!(!flash_confirmed("FLASHING"), "not a prefix match");
|
||||
assert!(!flash_confirmed("FLASH NOW"));
|
||||
assert!(!flash_confirmed(""));
|
||||
}
|
||||
}
|
||||
|
||||
+461
-12
@@ -2,7 +2,7 @@
|
||||
//! streams MinerRow snapshots to the UI thread via a std channel.
|
||||
|
||||
use crate::model::{MinerCaps, MinerRow};
|
||||
use asic_rs::MinerFactory;
|
||||
use asic_rs::core::data::firmware::FirmwareImage;
|
||||
use asic_rs::core::traits::miner::Miner;
|
||||
use futures_util::StreamExt;
|
||||
use measurements::Power;
|
||||
@@ -120,6 +120,32 @@ pub fn parse_line(line: &str) -> Result<Vec<Ipv4Addr>, String> {
|
||||
}
|
||||
return Ok((0..count).map(|i| Ipv4Addr::from(base + i as u32)).collect());
|
||||
}
|
||||
// Per-octet ranges: each of the four octets may be a single number or an
|
||||
// inclusive `a-b` range, e.g. "10.1-9.1.1-255" scans the cartesian product
|
||||
// (the 9 /24s: 10.1.1.x .. 10.9.1.x). This also subsumes a plain single
|
||||
// address and a bare last-octet range like "10.253.1.3-234".
|
||||
let parts: Vec<&str> = line.split('.').collect();
|
||||
if parts.len() == 4 && parts.iter().all(|p| is_octet_spec(p)) {
|
||||
let r: Vec<(u8, u8)> =
|
||||
parts.iter().map(|p| parse_octet_spec(p)).collect::<Result<_, String>>()?;
|
||||
let count: u64 = r.iter().map(|(lo, hi)| (*hi as u64 - *lo as u64 + 1)).product();
|
||||
if count > MAX_ADDRS {
|
||||
return Err(format!("range too large (> {MAX_ADDRS} addresses): {line}"));
|
||||
}
|
||||
let mut out = Vec::with_capacity(count as usize);
|
||||
for a in r[0].0..=r[0].1 {
|
||||
for b in r[1].0..=r[1].1 {
|
||||
for c in r[2].0..=r[2].1 {
|
||||
for d in r[3].0..=r[3].1 {
|
||||
out.push(Ipv4Addr::new(a, b, c, d));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return Ok(out);
|
||||
}
|
||||
// Full A-B range across two dotted addresses (e.g. "10.0.0.1-10.7.255.254"),
|
||||
// which the per-octet form above cannot express.
|
||||
if let Some((start_s, end_s)) = line.split_once('-') {
|
||||
let start: Ipv4Addr = start_s
|
||||
.trim()
|
||||
@@ -148,6 +174,27 @@ pub fn parse_line(line: &str) -> Result<Vec<Ipv4Addr>, String> {
|
||||
Ok(vec![addr])
|
||||
}
|
||||
|
||||
/// Parse one octet spec: `"n"` -> `(n, n)`, or `"a-b"` -> `(a, b)` inclusive
|
||||
/// (rejecting `a > b`). Used by the per-octet range form in `parse_line`.
|
||||
fn parse_octet_spec(s: &str) -> Result<(u8, u8), String> {
|
||||
let s = s.trim();
|
||||
if let Some((lo, hi)) = s.split_once('-') {
|
||||
let lo: u8 = lo.trim().parse().map_err(|_| format!("bad octet range: {s}"))?;
|
||||
let hi: u8 = hi.trim().parse().map_err(|_| format!("bad octet range: {s}"))?;
|
||||
if lo > hi {
|
||||
return Err(format!("octet range start after end: {s}"));
|
||||
}
|
||||
Ok((lo, hi))
|
||||
} else {
|
||||
let n: u8 = s.parse().map_err(|_| format!("bad octet: {s}"))?;
|
||||
Ok((n, n))
|
||||
}
|
||||
}
|
||||
|
||||
fn is_octet_spec(s: &str) -> bool {
|
||||
parse_octet_spec(s).is_ok()
|
||||
}
|
||||
|
||||
fn prefix_mask(prefix: u8) -> u32 {
|
||||
if prefix == 0 {
|
||||
0
|
||||
@@ -306,7 +353,7 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
|
||||
}
|
||||
};
|
||||
rt.block_on(async move {
|
||||
let mut factory = MinerFactory::new();
|
||||
let mut factory = crate::credentials::configured_factory();
|
||||
for (ip, prefix) in &cidrs {
|
||||
factory = match factory.with_subnet(&format!("{ip}/{prefix}")) {
|
||||
Ok(f) => f,
|
||||
@@ -326,8 +373,13 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
|
||||
return; // Stop / re-scan requested
|
||||
}
|
||||
done += 1;
|
||||
if let Some(miner) = miner {
|
||||
let row = to_row(&*miner).await;
|
||||
// Only surface a row for an address that actually has a miner
|
||||
// behind it. A non-responding address is not shown -- we never
|
||||
// fabricate a phantom "offline" row for an empty IP; a miner is
|
||||
// reported as "not hashing" only when it responds and we can see
|
||||
// it is not mining.
|
||||
if let Some(m) = miner {
|
||||
let row = to_row(&*m).await;
|
||||
if tx.send(ScanMsg::Row(row)).is_err() {
|
||||
return; // UI gone
|
||||
}
|
||||
@@ -345,6 +397,34 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
|
||||
ScanHandle { rx, cancel }
|
||||
}
|
||||
|
||||
/// Flatten a miner's structured messages into display lines, most severe first
|
||||
/// ("[Error] text (component)"), for the Errors column + hover tooltip.
|
||||
fn summarize_messages(messages: &[asic_rs::core::data::message::MinerMessage]) -> Vec<String> {
|
||||
use asic_rs::core::data::message::MessageSeverity;
|
||||
let rank = |s: &MessageSeverity| match s {
|
||||
MessageSeverity::Error => 0u8,
|
||||
MessageSeverity::Warning => 1,
|
||||
MessageSeverity::Info => 2,
|
||||
};
|
||||
let mut ranked: Vec<(u8, String)> = messages
|
||||
.iter()
|
||||
.map(|m| {
|
||||
let sev = match m.severity {
|
||||
MessageSeverity::Error => "Error",
|
||||
MessageSeverity::Warning => "Warning",
|
||||
MessageSeverity::Info => "Info",
|
||||
};
|
||||
let line = match &m.component {
|
||||
Some(c) => format!("[{sev}] {} ({c})", m.message),
|
||||
None => format!("[{sev}] {}", m.message),
|
||||
};
|
||||
(rank(&m.severity), line)
|
||||
})
|
||||
.collect();
|
||||
ranked.sort_by_key(|(r, _)| *r);
|
||||
ranked.into_iter().map(|(_, s)| s).collect()
|
||||
}
|
||||
|
||||
async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
let data = miner.get_data().await;
|
||||
let hashrate_ths = data
|
||||
@@ -363,11 +443,11 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
.as_ref()
|
||||
.map(|t| t.as_celsius())
|
||||
.unwrap_or(0.0);
|
||||
let fan_rpm = data
|
||||
let fan_rpms: Vec<f64> = data
|
||||
.fans
|
||||
.iter()
|
||||
.filter_map(|f| f.rpm.as_ref().map(|r| r.as_rpm()))
|
||||
.fold(0.0f64, f64::max);
|
||||
.map(|f| f.rpm.as_ref().map(|r| r.as_rpm()).unwrap_or(0.0))
|
||||
.collect();
|
||||
let worker = data
|
||||
.pools
|
||||
.iter()
|
||||
@@ -420,6 +500,8 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
.fold(0.0f64, f64::max);
|
||||
let is_mining = data.is_mining;
|
||||
let slow = crate::model::is_slow(is_mining, hashrate_ths, expected_ths);
|
||||
let operating_state = data.operating_state.as_ref().map(|s| s.to_string()).unwrap_or_default();
|
||||
let paused = crate::model::is_paused(&operating_state, is_mining);
|
||||
// Probe what this miner supports being told to do (sync, no extra I/O).
|
||||
let caps = MinerCaps {
|
||||
fault_light: miner.supports_set_fault_light(),
|
||||
@@ -428,11 +510,24 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
resume: miner.supports_resume(),
|
||||
power_limit: miner.supports_set_power_limit(),
|
||||
tuning: miner.supports_set_tuning_percent(),
|
||||
firmware_flash: miner.supports_upgrade_firmware(),
|
||||
};
|
||||
// PIC vs noPIC is not reported over the network by asic-rs; best-effort
|
||||
// heuristic from the model string, else unknown (true detection needs an
|
||||
// on-board SSH/I2C probe -- a separate feature).
|
||||
let pic_present = if model.to_lowercase().contains("nopic") { Some(false) } else { None };
|
||||
// Access: locked/view-only when the miner exposes no writable control at
|
||||
// all, otherwise unlocked. Inferred from capabilities (asic-rs has no direct
|
||||
// lock-state field).
|
||||
let write_locked = Some(!caps.any_control());
|
||||
let errors = summarize_messages(&data.messages);
|
||||
MinerRow {
|
||||
ip: data.ip.to_string(),
|
||||
selected: false,
|
||||
caps,
|
||||
pic_present,
|
||||
write_locked,
|
||||
errors,
|
||||
model,
|
||||
mac: data.mac.map(|m| m.to_string()).unwrap_or_default(),
|
||||
hostname: data.hostname.clone().unwrap_or_default(),
|
||||
@@ -448,7 +543,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
chip_temp_c,
|
||||
fluid_temp_c,
|
||||
outlet_temp_c,
|
||||
fan_rpm,
|
||||
fan_rpms,
|
||||
psu_fan_rpm,
|
||||
fan_count: (!data.fans.is_empty()).then_some(data.fans.len() as u32),
|
||||
expected_fans: data.expected_fans.map(|v| v as u32),
|
||||
@@ -463,9 +558,10 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
session_best_share: data.session_best_share,
|
||||
uptime_secs: data.uptime.map(|d| d.as_secs()).unwrap_or(0),
|
||||
light_flashing: data.light_flashing,
|
||||
operating_state: data.operating_state.as_ref().map(|s| s.to_string()).unwrap_or_default(),
|
||||
operating_state,
|
||||
is_mining,
|
||||
slow,
|
||||
paused,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -485,8 +581,8 @@ impl ConfigAction {
|
||||
/// Short label for status text and summaries.
|
||||
pub fn label(&self) -> String {
|
||||
match self {
|
||||
ConfigAction::FaultLight(true) => "fault light on".into(),
|
||||
ConfigAction::FaultLight(false) => "fault light off".into(),
|
||||
ConfigAction::FaultLight(true) => "flash lights on".into(),
|
||||
ConfigAction::FaultLight(false) => "flash lights off".into(),
|
||||
ConfigAction::Restart => "restart".into(),
|
||||
ConfigAction::Pause => "pause".into(),
|
||||
ConfigAction::Resume => "resume".into(),
|
||||
@@ -538,9 +634,13 @@ pub fn start_config_action(ips: Vec<String>, action: ConfigAction) -> ActionHand
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let err_tx = tx.clone();
|
||||
let thread_cancel = cancel.clone();
|
||||
let res = std::thread::Builder::new().name("fake-action".into()).spawn(move || {
|
||||
let mut ok = 0usize;
|
||||
for ip in ips {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let _ = tx.send(ActionMsg::Result { ip, ok: true, detail: "simulated".into() });
|
||||
ok += 1;
|
||||
}
|
||||
@@ -565,7 +665,7 @@ pub fn start_config_action(ips: Vec<String>, action: ConfigAction) -> ActionHand
|
||||
}
|
||||
};
|
||||
rt.block_on(async move {
|
||||
let factory = MinerFactory::new();
|
||||
let factory = crate::credentials::configured_factory();
|
||||
let mut ok = 0usize;
|
||||
for ip_s in ips {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
@@ -599,7 +699,211 @@ pub fn start_config_action(ips: Vec<String>, action: ConfigAction) -> ActionHand
|
||||
ActionHandle { rx, cancel }
|
||||
}
|
||||
|
||||
/// Progress/results from a background refresh of a specific, already-known
|
||||
/// set of miners (re-poll on a timer or after a right-click "Refresh" action,
|
||||
/// as opposed to `start_scan`'s full subnet sweep).
|
||||
pub enum RefreshMsg {
|
||||
Started { total: usize },
|
||||
/// A miner's telemetry was re-read successfully.
|
||||
Row(MinerRow),
|
||||
/// A miner could not be reached or re-identified.
|
||||
Failed { ip: String, detail: String },
|
||||
Done { ok: usize, total: usize },
|
||||
}
|
||||
|
||||
/// A running refresh; `stop` cancels the remaining miners.
|
||||
pub struct RefreshHandle {
|
||||
pub rx: Receiver<RefreshMsg>,
|
||||
cancel: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl RefreshHandle {
|
||||
pub fn stop(&self) {
|
||||
self.cancel.store(true, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
/// Re-poll a specific list of already-known miner IPs on a background thread:
|
||||
/// re-discover each one (asic-rs `scan_miner`) and report its fresh row. In
|
||||
/// fake-scan mode it reports the matching bench-fleet fixture row per IP.
|
||||
pub fn start_refresh(ips: Vec<String>) -> RefreshHandle {
|
||||
let (tx, rx) = channel();
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
let total = ips.len();
|
||||
let _ = tx.send(RefreshMsg::Started { total });
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let err_tx = tx.clone();
|
||||
let thread_cancel = cancel.clone();
|
||||
let res = std::thread::Builder::new().name("fake-refresh".into()).spawn(move || {
|
||||
let fleet = crate::fixtures::bench_fleet();
|
||||
let mut ok = 0usize;
|
||||
for ip in ips {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
match fleet.iter().find(|r| r.ip == ip) {
|
||||
Some(row) => {
|
||||
if tx.send(RefreshMsg::Row(row.clone())).is_err() {
|
||||
return; // UI gone
|
||||
}
|
||||
ok += 1;
|
||||
}
|
||||
None => {
|
||||
if tx.send(RefreshMsg::Failed { ip, detail: "offline".into() }).is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let _ = tx.send(RefreshMsg::Done { ok, total });
|
||||
});
|
||||
if res.is_err() {
|
||||
let _ = err_tx.send(RefreshMsg::Done { ok: 0, total });
|
||||
}
|
||||
return RefreshHandle { rx, cancel };
|
||||
}
|
||||
|
||||
let thread_cancel = cancel.clone();
|
||||
let err_tx = tx.clone();
|
||||
let res = std::thread::Builder::new().name("miner-refresh".into()).spawn(move || {
|
||||
// A single-threaded runtime: the loop applies to one miner at a time, so
|
||||
// a worker-per-CPU pool would be wasted.
|
||||
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
|
||||
Ok(rt) => rt,
|
||||
Err(_) => {
|
||||
let _ = tx.send(RefreshMsg::Done { ok: 0, total });
|
||||
return;
|
||||
}
|
||||
};
|
||||
rt.block_on(async move {
|
||||
let factory = crate::credentials::configured_factory();
|
||||
let mut ok = 0usize;
|
||||
for ip_s in ips {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let msg = match ip_s.parse::<std::net::IpAddr>() {
|
||||
Err(_) => RefreshMsg::Failed { ip: ip_s, detail: "bad IP".to_string() },
|
||||
Ok(ip) => match factory.scan_miner(ip).await {
|
||||
Ok(Some(miner)) => {
|
||||
ok += 1;
|
||||
RefreshMsg::Row(to_row(&*miner).await)
|
||||
}
|
||||
Ok(None) => RefreshMsg::Failed { ip: ip_s, detail: "offline".to_string() },
|
||||
Err(e) => RefreshMsg::Failed { ip: ip_s, detail: format!("{e}") },
|
||||
},
|
||||
};
|
||||
if tx.send(msg).is_err() {
|
||||
return; // UI gone
|
||||
}
|
||||
}
|
||||
let _ = tx.send(RefreshMsg::Done { ok, total });
|
||||
});
|
||||
});
|
||||
if res.is_err() {
|
||||
let _ = err_tx.send(RefreshMsg::Done { ok: 0, total });
|
||||
}
|
||||
RefreshHandle { rx, cancel }
|
||||
}
|
||||
|
||||
/// Prepare (if the backend supports it) then upload a firmware image to one
|
||||
/// miner. Never interrupted once started: `start_firmware_flash_action` only
|
||||
/// checks its cancel flag between miners, not while this is running.
|
||||
async fn flash_one(miner: &dyn Miner, image: &FirmwareImage) -> Result<bool, String> {
|
||||
let image = if miner.supports_prepare_firmware() {
|
||||
miner.prepare_firmware(image.clone()).await.map_err(|e| e.to_string())?
|
||||
} else {
|
||||
image.clone()
|
||||
};
|
||||
miner.upgrade_firmware(image).await.map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
/// Flash `image` to each miner in `ips` on a background thread: re-discover the
|
||||
/// miner (asic-rs `scan_miner`), then prepare (if supported) and upload the
|
||||
/// firmware, reporting per-IP results. Backends that don't implement firmware
|
||||
/// upgrade report "unsupported" rather than attempting anything. The cancel
|
||||
/// flag is only checked between miners: a flash in progress always runs to
|
||||
/// completion instead of being interrupted mid-upload. In fake-scan mode it
|
||||
/// reports simulated successes so the flow works offline.
|
||||
pub fn start_firmware_flash_action(ips: Vec<String>, image: FirmwareImage) -> ActionHandle {
|
||||
let (tx, rx) = channel();
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
let total = ips.len();
|
||||
let _ = tx.send(ActionMsg::Started { total });
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let err_tx = tx.clone();
|
||||
let thread_cancel = cancel.clone();
|
||||
let res = std::thread::Builder::new().name("fake-firmware-flash".into()).spawn(move || {
|
||||
let mut ok = 0usize;
|
||||
for ip in ips {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let _ = tx.send(ActionMsg::Result { ip, ok: true, detail: "simulated".into() });
|
||||
ok += 1;
|
||||
}
|
||||
let _ = tx.send(ActionMsg::Done { ok, total });
|
||||
});
|
||||
if res.is_err() {
|
||||
let _ = err_tx.send(ActionMsg::Done { ok: 0, total });
|
||||
}
|
||||
return ActionHandle { rx, cancel };
|
||||
}
|
||||
|
||||
let thread_cancel = cancel.clone();
|
||||
let err_tx = tx.clone();
|
||||
let res = std::thread::Builder::new().name("firmware-flash".into()).spawn(move || {
|
||||
// A single-threaded runtime: flashes run one miner at a time by
|
||||
// design (see the cancel-between-miners note above).
|
||||
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
|
||||
Ok(rt) => rt,
|
||||
Err(_) => {
|
||||
let _ = tx.send(ActionMsg::Done { ok: 0, total });
|
||||
return;
|
||||
}
|
||||
};
|
||||
rt.block_on(async move {
|
||||
let factory = crate::credentials::configured_factory();
|
||||
let mut ok = 0usize;
|
||||
for ip_s in ips {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let (success, detail) = match ip_s.parse::<std::net::IpAddr>() {
|
||||
Err(_) => (false, "bad IP".to_string()),
|
||||
Ok(ip) => match factory.scan_miner(ip).await {
|
||||
Ok(Some(miner)) => {
|
||||
if !miner.supports_upgrade_firmware() {
|
||||
(false, "unsupported".to_string())
|
||||
} else {
|
||||
match flash_one(&*miner, &image).await {
|
||||
Ok(true) => (true, "ok".to_string()),
|
||||
Ok(false) => (false, "refused".to_string()),
|
||||
Err(e) => (false, format!("{e}")),
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(None) => (false, "no miner at IP".to_string()),
|
||||
Err(e) => (false, format!("{e}")),
|
||||
},
|
||||
};
|
||||
if success {
|
||||
ok += 1;
|
||||
}
|
||||
if tx.send(ActionMsg::Result { ip: ip_s, ok: success, detail }).is_err() {
|
||||
return; // UI gone
|
||||
}
|
||||
}
|
||||
let _ = tx.send(ActionMsg::Done { ok, total });
|
||||
});
|
||||
});
|
||||
if res.is_err() {
|
||||
let _ = err_tx.send(ActionMsg::Done { ok: 0, total });
|
||||
}
|
||||
ActionHandle { rx, cancel }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
@@ -634,6 +938,31 @@ mod tests {
|
||||
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(10, 253, 1, 234));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_per_octet_ranges() {
|
||||
// The user's example: 9 /24s (octet2 1..9), each with .1.1-255.
|
||||
let ips = parse_line("10.1-9.1.1-255").unwrap();
|
||||
assert_eq!(ips.len(), 9 * 255, "9 /24 ranges of 255 addresses each");
|
||||
assert_eq!(ips[0], Ipv4Addr::new(10, 1, 1, 1), "ascending, first combo");
|
||||
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(10, 9, 1, 255));
|
||||
// Ordered by octet: the second address is .1.1.2, the 256th is .2.1.1.
|
||||
assert_eq!(ips[1], Ipv4Addr::new(10, 1, 1, 2));
|
||||
assert_eq!(ips[255], Ipv4Addr::new(10, 2, 1, 1));
|
||||
|
||||
// Ranges in more than one octet.
|
||||
let ips = parse_line("192.168.0-1.10-12").unwrap();
|
||||
assert_eq!(ips.len(), 2 * 3);
|
||||
assert_eq!(ips[0], Ipv4Addr::new(192, 168, 0, 10));
|
||||
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(192, 168, 1, 12));
|
||||
|
||||
// A single address still works through the per-octet path.
|
||||
assert_eq!(parse_line("10.0.0.5").unwrap(), vec![Ipv4Addr::new(10, 0, 0, 5)]);
|
||||
// Reversed octet range is an error.
|
||||
assert!(parse_line("10.9-1.1.1").is_err());
|
||||
// Out-of-range octet falls through and is reported.
|
||||
assert!(parse_line("10.1.1.999").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_cross_octet_range() {
|
||||
let ips = parse_line("10.253.1.250-10.253.2.5").unwrap();
|
||||
@@ -835,4 +1164,124 @@ mod tests {
|
||||
println!("bench_targets_to_cidrs_large_range: {} addrs -> {sink} cidrs, {:?}/op", ips.len(), per);
|
||||
assert!(per.as_millis() < 200, "targets_to_cidrs regressed: {per:?}/op");
|
||||
}
|
||||
|
||||
/// Exercise the round-6 background actions through their fake-scan branch:
|
||||
/// offline-row emission (start_scan), per-IP refresh (start_refresh),
|
||||
/// firmware flash (start_firmware_flash_action), and that a cancelled run
|
||||
/// still terminates. ALKANE_FAKE_SCAN is process-global, but no other test
|
||||
/// calls these functions, so setting it here only affects this one
|
||||
/// (sequential) test; all fake-mode assertions live in a single #[test] so
|
||||
/// they never race each other over the env var.
|
||||
#[test]
|
||||
fn fake_mode_background_actions() {
|
||||
use std::sync::mpsc::RecvTimeoutError;
|
||||
use std::time::Duration;
|
||||
let deadline = Duration::from_secs(5);
|
||||
std::env::set_var(FAKE_SCAN_ENV, "1");
|
||||
|
||||
// start_scan (fake): streams exactly the bench-fleet fixtures, one Row
|
||||
// per fixture, and no fabricated rows for empty addresses.
|
||||
{
|
||||
let h = start_scan(vec!["10.255.1.0/30".into()]);
|
||||
let mut rows = Vec::new();
|
||||
let mut total = 0usize;
|
||||
loop {
|
||||
match h.rx.recv_timeout(deadline) {
|
||||
Ok(ScanMsg::Started { total: t, .. }) => total = t,
|
||||
Ok(ScanMsg::Row(r)) => rows.push(r),
|
||||
Ok(ScanMsg::Done(_)) => break,
|
||||
Ok(_) => {}
|
||||
Err(RecvTimeoutError::Timeout) => panic!("fake start_scan hung"),
|
||||
Err(RecvTimeoutError::Disconnected) => break,
|
||||
}
|
||||
}
|
||||
let fleet = crate::fixtures::bench_fleet();
|
||||
assert_eq!(rows.len(), fleet.len(), "one Row per fixture, no phantom offline rows");
|
||||
assert_eq!(total, fleet.len());
|
||||
assert!(rows.iter().all(|r| r.status() != "offline"), "no 'offline' status exists");
|
||||
}
|
||||
|
||||
// start_refresh: a known fixture IP re-reads as a Row, an unknown IP is
|
||||
// reported Failed{offline}, and the run ends with Done{ok:1,total:2}.
|
||||
{
|
||||
let known = "10.255.1.112".to_string(); // an S17 in bench_fleet
|
||||
let unknown = "10.0.0.250".to_string();
|
||||
let h = start_refresh(vec![known.clone(), unknown.clone()]);
|
||||
let (mut rows, mut failed, mut done) = (0usize, 0usize, None);
|
||||
loop {
|
||||
match h.rx.recv_timeout(deadline) {
|
||||
Ok(RefreshMsg::Started { .. }) => {}
|
||||
Ok(RefreshMsg::Row(r)) => {
|
||||
assert_eq!(r.ip, known);
|
||||
rows += 1;
|
||||
}
|
||||
Ok(RefreshMsg::Failed { ip, detail }) => {
|
||||
assert_eq!(ip, unknown);
|
||||
assert_eq!(detail, "offline");
|
||||
failed += 1;
|
||||
}
|
||||
Ok(RefreshMsg::Done { ok, total }) => {
|
||||
done = Some((ok, total));
|
||||
break;
|
||||
}
|
||||
Err(RecvTimeoutError::Timeout) => panic!("fake start_refresh hung"),
|
||||
Err(RecvTimeoutError::Disconnected) => break,
|
||||
}
|
||||
}
|
||||
assert_eq!(rows, 1);
|
||||
assert_eq!(failed, 1);
|
||||
assert_eq!(done, Some((1, 2)));
|
||||
}
|
||||
|
||||
// start_firmware_flash_action: fake mode reports one simulated success
|
||||
// per IP and a matching Done summary.
|
||||
{
|
||||
let image = FirmwareImage::new("fw.bin".to_string(), vec![0u8; 8]);
|
||||
let h = start_firmware_flash_action(
|
||||
vec!["10.255.1.166".into(), "10.255.1.149".into()],
|
||||
image,
|
||||
);
|
||||
let (mut results, mut done) = (0usize, None);
|
||||
loop {
|
||||
match h.rx.recv_timeout(deadline) {
|
||||
Ok(ActionMsg::Started { .. }) => {}
|
||||
Ok(ActionMsg::Result { ok, detail, .. }) => {
|
||||
assert!(ok);
|
||||
assert_eq!(detail, "simulated");
|
||||
results += 1;
|
||||
}
|
||||
Ok(ActionMsg::Done { ok, total }) => {
|
||||
done = Some((ok, total));
|
||||
break;
|
||||
}
|
||||
Err(RecvTimeoutError::Timeout) => panic!("fake flash hung"),
|
||||
Err(RecvTimeoutError::Disconnected) => break,
|
||||
}
|
||||
}
|
||||
assert_eq!(results, 2);
|
||||
assert_eq!(done, Some((2, 2)));
|
||||
}
|
||||
|
||||
// Cancellation contract: stopping a run still delivers a terminal Done
|
||||
// rather than hanging (the fake branches now honour the cancel flag).
|
||||
{
|
||||
let big: Vec<String> = (0..200).map(|i| format!("10.9.0.{}", i % 256)).collect();
|
||||
let h = start_refresh(big);
|
||||
h.stop();
|
||||
let mut saw_done = false;
|
||||
loop {
|
||||
match h.rx.recv_timeout(deadline) {
|
||||
Ok(RefreshMsg::Done { .. }) => {
|
||||
saw_done = true;
|
||||
break;
|
||||
}
|
||||
Ok(_) => {}
|
||||
Err(_) => break,
|
||||
}
|
||||
}
|
||||
assert!(saw_done, "a cancelled fake refresh must still emit Done, not hang");
|
||||
}
|
||||
|
||||
std::env::remove_var(FAKE_SCAN_ENV);
|
||||
}
|
||||
}
|
||||
|
||||
+902
-92
File diff suppressed because it is too large
Load Diff
+77
-1
@@ -10,7 +10,7 @@
|
||||
+pub use widgets::*;
|
||||
--- a/src/widgets.rs
|
||||
+++ b/src/widgets.rs
|
||||
@@ -0,0 +1,644 @@
|
||||
@@ -0,0 +1,720 @@
|
||||
+// widgets.rs — alkane-toolkit extension: Rust bindings for the widget bridge
|
||||
+// in cpp_src/widgets_bridge.cpp. Handles are opaque pointers owned by the
|
||||
+// wxWidgets object tree (parents own children; nothing to free in Rust).
|
||||
@@ -28,6 +28,7 @@
|
||||
+ pub fn wxbr_main_frame() -> *mut c_void;
|
||||
+ pub fn wxbr_panel(parent: *mut c_void) -> *mut c_void;
|
||||
+ pub fn wxbr_box_sizer(vertical: c_int) -> *mut c_void;
|
||||
+ pub fn wxbr_wrap_sizer(vertical: c_int) -> *mut c_void;
|
||||
+ pub fn wxbr_sizer_add(sizer: *mut c_void, win: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
|
||||
+ pub fn wxbr_sizer_add_sizer(sizer: *mut c_void, subsizer: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
|
||||
+ pub fn wxbr_sizer_add_spacer(sizer: *mut c_void, px: c_int);
|
||||
@@ -43,6 +44,7 @@
|
||||
+ pub fn wxbr_set_bold(win: *mut c_void);
|
||||
+ pub fn wxbr_set_font_size(win: *mut c_void, pts: c_int);
|
||||
+ pub fn wxbr_button(parent: *mut c_void, label: *const c_char, id: c_int) -> *mut c_void;
|
||||
+ pub fn wxbr_bind_click(win: *mut c_void, id: c_int);
|
||||
+ pub fn wxbr_text_ctrl(parent: *mut c_void, multiline: c_int) -> *mut c_void;
|
||||
+ pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
+ pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
|
||||
@@ -59,8 +61,10 @@
|
||||
+ pub fn wxbr_dialog(parent: *mut c_void, title: *const c_char) -> *mut c_void;
|
||||
+ pub fn wxbr_dialog_show_modal(win: *mut c_void) -> c_int;
|
||||
+ pub fn wxbr_dialog_close(win: *mut c_void, code: c_int);
|
||||
+ pub fn wxbr_file_dialog(parent: *mut c_void, title: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
+ pub fn wxbr_dvlc(parent: *mut c_void) -> *mut c_void;
|
||||
+ pub fn wxbr_dvlc_append_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int);
|
||||
+ pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int) -> *mut c_void;
|
||||
+ pub fn wxbr_dvlc_append_toggle_col(win: *mut c_void, width: c_int);
|
||||
+ pub fn wxbr_dvlc_append_row(win: *mut c_void, nvals: c_int, vals: *const *const c_char);
|
||||
+ pub fn wxbr_dvlc_delete_row(win: *mut c_void, row: usize);
|
||||
@@ -69,6 +73,7 @@
|
||||
+ pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
|
||||
+ pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
+ pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
|
||||
+ pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
|
||||
+ pub fn wxbr_dvlc_set_col_title(win: *mut c_void, col: c_int, title: *const c_char);
|
||||
+ pub fn wxbr_dvlc_set_sort_indicator(win: *mut c_void, col: c_int, active: c_int, ascending: c_int);
|
||||
+ pub fn wxbr_dvlc_col_at_pos(win: *mut c_void, pos: c_int) -> c_int;
|
||||
@@ -78,6 +83,9 @@
|
||||
+ pub fn wxbr_dvlc_select_rows(win: *mut c_void, rows: *const c_int, n: c_int);
|
||||
+ pub fn wxbr_dvlc_set_alt_row_color(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
+ pub fn wxbr_dvlc_set_row_color(win: *mut c_void, row: usize, r: c_int, g: c_int, b: c_int);
|
||||
+ pub fn wxbr_dvlc_set_zebra(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
+ pub fn wxbr_dvlc_get_top_row(win: *mut c_void) -> c_int;
|
||||
+ pub fn wxbr_dvlc_ensure_visible(win: *mut c_void, row: usize);
|
||||
+ pub fn wxbr_apply_zebra_css(r: c_int, g: c_int, b: c_int);
|
||||
+ pub fn wxbr_rearrange_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
|
||||
+ pub fn wxbr_rearrange_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
|
||||
@@ -142,6 +150,7 @@
|
||||
+ ChoiceChanged,
|
||||
+ SysColour,
|
||||
+ Deferred,
|
||||
+ DvlcHeaderRightClick,
|
||||
+}
|
||||
+
|
||||
+impl WxEventKind {
|
||||
@@ -160,6 +169,7 @@
|
||||
+ 12 => WxEventKind::ChoiceChanged,
|
||||
+ 13 => WxEventKind::SysColour,
|
||||
+ 14 => WxEventKind::Deferred,
|
||||
+ 15 => WxEventKind::DvlcHeaderRightClick,
|
||||
+ _ => return None,
|
||||
+ })
|
||||
+ }
|
||||
@@ -252,6 +262,14 @@
|
||||
+ Widget(unsafe { notsafe::wxbr_box_sizer(vertical as c_int) })
|
||||
+ }
|
||||
+
|
||||
+ /// A box sizer that wraps overflowing items onto additional lines instead
|
||||
+ /// of shrinking them. wxWrapSizer is a wxBoxSizer subclass, so the result
|
||||
+ /// accepts the same add/add_sizer/add_spacer/add_stretch/set_sizer_on
|
||||
+ /// calls as `box_sizer`'s.
|
||||
+ pub fn wrap_sizer(vertical: bool) -> Widget {
|
||||
+ Widget(unsafe { notsafe::wxbr_wrap_sizer(vertical as c_int) })
|
||||
+ }
|
||||
+
|
||||
+ pub fn add(&self, win: Widget, proportion: i32, flags: i32, border: i32) {
|
||||
+ unsafe { notsafe::wxbr_sizer_add(self.0, win.0, proportion, flags, border) }
|
||||
+ }
|
||||
@@ -328,6 +346,15 @@
|
||||
+ Widget(unsafe { notsafe::wxbr_button(parent.0, c.as_ptr(), id) })
|
||||
+ }
|
||||
+
|
||||
+ /// Make this window clickable: a left mouse down on it emits the same
|
||||
+ /// `ButtonClicked` event a real button would, carrying `id`. Bind each
|
||||
+ /// child that should also count as part of the click target (e.g. the
|
||||
+ /// static text labels on a KPI card), since a child window swallows its
|
||||
+ /// own mouse events rather than letting them propagate to the parent.
|
||||
+ pub fn bind_click(&self, id: i32) {
|
||||
+ unsafe { notsafe::wxbr_bind_click(self.0, id) }
|
||||
+ }
|
||||
+
|
||||
+ pub fn text_ctrl(parent: Widget, multiline: bool) -> Widget {
|
||||
+ Widget(unsafe { notsafe::wxbr_text_ctrl(parent.0, multiline as c_int) })
|
||||
+ }
|
||||
@@ -407,6 +434,21 @@
|
||||
+ unsafe { notsafe::wxbr_dialog_close(self.0, code) }
|
||||
+ }
|
||||
+
|
||||
+ /// Show a native "open file, must exist" dialog. Returns the chosen path,
|
||||
+ /// or `None` if the dialog was cancelled.
|
||||
+ pub fn file_dialog(parent: Widget, title: &str) -> Option<String> {
|
||||
+ let c = CString::new(title).unwrap_or_default();
|
||||
+ let mut buf = vec![0i8; 4096];
|
||||
+ let n = unsafe {
|
||||
+ notsafe::wxbr_file_dialog(parent.0, c.as_ptr(), buf.as_mut_ptr(), buf.len() as c_int)
|
||||
+ };
|
||||
+ if n <= 0 {
|
||||
+ return None;
|
||||
+ }
|
||||
+ let bytes: Vec<u8> = buf[..(n - 1) as usize].iter().map(|&b| b as u8).collect();
|
||||
+ Some(String::from_utf8_lossy(&bytes).into_owned())
|
||||
+ }
|
||||
+
|
||||
+ // ---- data view list ctrl ----
|
||||
+
|
||||
+ pub fn dvlc(parent: Widget) -> Widget {
|
||||
@@ -418,6 +460,14 @@
|
||||
+ unsafe { notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int) }
|
||||
+ }
|
||||
+
|
||||
+ /// Like `dvlc_append_text_col`, but the column renders cell values through
|
||||
+ /// the SegmentRenderer, so a value built with `model::encode_segments` is
|
||||
+ /// drawn as coloured text runs (a plain string still renders normally).
|
||||
+ pub fn dvlc_append_colored_col(&self, title: &str, width: i32, reorderable: bool) {
|
||||
+ let c = CString::new(title).unwrap_or_default();
|
||||
+ unsafe { notsafe::wxbr_dvlc_append_colored_col(self.0, c.as_ptr(), width, reorderable as c_int) };
|
||||
+ }
|
||||
+
|
||||
+ pub fn dvlc_append_toggle_col(&self, width: i32) {
|
||||
+ unsafe { notsafe::wxbr_dvlc_append_toggle_col(self.0, width) }
|
||||
+ }
|
||||
@@ -461,6 +511,11 @@
|
||||
+ unsafe { notsafe::wxbr_dvlc_col_count(self.0).max(0) as usize }
|
||||
+ }
|
||||
+
|
||||
+ /// Auto-size the column at display position `pos` to fit its content.
|
||||
+ pub fn dvlc_autosize_col(&self, pos: usize) {
|
||||
+ unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
|
||||
+ }
|
||||
+
|
||||
+ /// Model column index shown at display position `pos` (after drag reorder).
|
||||
+ pub fn dvlc_col_at_pos(&self, pos: usize) -> Option<usize> {
|
||||
+ let v = unsafe { notsafe::wxbr_dvlc_col_at_pos(self.0, pos as c_int) };
|
||||
@@ -504,6 +559,27 @@
|
||||
+ unsafe { notsafe::wxbr_dvlc_set_row_color(self.0, row, r, g, b) }
|
||||
+ }
|
||||
+
|
||||
+ /// Set the alternating-row (zebra) background colour applied to odd rows.
|
||||
+ /// Pass `None` to turn zebra striping off.
|
||||
+ pub fn dvlc_set_zebra(&self, color: Option<(u8, u8, u8)>) {
|
||||
+ let (r, g, b) = match color {
|
||||
+ Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
|
||||
+ None => (-1, -1, -1),
|
||||
+ };
|
||||
+ unsafe { notsafe::wxbr_dvlc_set_zebra(self.0, r, g, b) }
|
||||
+ }
|
||||
+
|
||||
+ /// The model-row index of the top (first visible) row, or `None` if empty.
|
||||
+ pub fn dvlc_get_top_row(&self) -> Option<usize> {
|
||||
+ let r = unsafe { notsafe::wxbr_dvlc_get_top_row(self.0) };
|
||||
+ (r >= 0).then_some(r as usize)
|
||||
+ }
|
||||
+
|
||||
+ /// Scroll so `row` is visible (used to restore scroll position after a refill).
|
||||
+ pub fn dvlc_ensure_visible(&self, row: usize) {
|
||||
+ unsafe { notsafe::wxbr_dvlc_ensure_visible(self.0, row) }
|
||||
+ }
|
||||
+
|
||||
+ // ---- rearrangeable check-list ----
|
||||
+
|
||||
+ /// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
|
||||
|
||||
+258
-11
@@ -1,6 +1,6 @@
|
||||
--- a/cpp_src/widgets_bridge.cpp
|
||||
+++ b/cpp_src/widgets_bridge.cpp
|
||||
@@ -0,0 +1,742 @@
|
||||
@@ -0,0 +1,989 @@
|
||||
+// widgets_bridge.cpp — alkane-toolkit extension to wx-rs
|
||||
+// Adds the widget/event surface the toolkit UI needs on top of the upstream
|
||||
+// render-callback bridge (which is kept untouched).
|
||||
@@ -30,16 +30,19 @@
|
||||
+#include <wx/dcmemory.h>
|
||||
+#include <wx/dcgraph.h>
|
||||
+#include <wx/graphics.h>
|
||||
+#include <wx/wrapsizer.h>
|
||||
+#include <wx/filedlg.h>
|
||||
+#include <cstring>
|
||||
+#ifdef __WXGTK__
|
||||
+#include <gtk/gtk.h>
|
||||
+#endif
|
||||
+#include <cstdio>
|
||||
+#include <map>
|
||||
+#include <vector>
|
||||
+
|
||||
+typedef void (*WxWidgetEventFn)(int kind, long p1, long p2);
|
||||
+static WxWidgetEventFn g_widget_event = nullptr;
|
||||
+
|
||||
+// Anchor row per data-view control for rubber-band (click-drag) range select.
|
||||
+static std::map<wxDataViewCtrl*, int> g_drag_anchor;
|
||||
+
|
||||
+// Event kinds (must match Rust WxEventKind in src/widgets.rs)
|
||||
+enum WxWidgetEventKind {
|
||||
+ WxEV_BUTTON_CLICKED = 1,
|
||||
@@ -55,26 +58,131 @@
|
||||
+ WxEV_CHOICE_CHANGED = 12,
|
||||
+ WxEV_SYS_COLOUR = 13,
|
||||
+ WxEV_DEFERRED = 14,
|
||||
+ WxEV_DVLC_HEADER_RIGHT_CLICK = 15,
|
||||
+};
|
||||
+
|
||||
+// A list store that carries an optional per-row foreground colour, surfaced to
|
||||
+// the native control via GetAttrByRow. This is how the miner table paints each
|
||||
+// row's text by status and separates rows on GTK (where SetAlternateRowColour
|
||||
+// and :nth-child CSS are unreliable and fight the selection highlight).
|
||||
+// A list store that carries an optional per-row foreground colour plus an
|
||||
+// alternating-row (zebra) background, surfaced to the native control via
|
||||
+// GetAttrByRow. The zebra background is set on odd rows only; because it is a
|
||||
+// BACKGROUND attr (not a foreground one), it does not affect the SegmentRenderer
|
||||
+// "no explicit colour -> default text colour" path, and the native selection
|
||||
+// highlight still paints over it for selected rows.
|
||||
+class AttrListStore : public wxDataViewListStore {
|
||||
+ public:
|
||||
+ std::vector<wxColour> row_fg;
|
||||
+ wxColour zebra; // odd-row background; unset (=off) unless the app sets it
|
||||
+ bool GetAttrByRow(unsigned int row, unsigned int col,
|
||||
+ wxDataViewItemAttr& attr) const override {
|
||||
+ (void)col;
|
||||
+ bool set = false;
|
||||
+ if (row < row_fg.size() && row_fg[row].IsOk()) {
|
||||
+ attr.SetColour(row_fg[row]);
|
||||
+ return true;
|
||||
+ set = true;
|
||||
+ }
|
||||
+ return false;
|
||||
+ if (zebra.IsOk() && (row % 2 == 1)) {
|
||||
+ attr.SetBackgroundColour(zebra);
|
||||
+ set = true;
|
||||
+ }
|
||||
+ return set;
|
||||
+ }
|
||||
+};
|
||||
+
|
||||
+// A wxDataViewCustomRenderer that draws a cell value made of coloured text
|
||||
+// runs. The encoding matches alkane_gui::model::encode_segments: segments are
|
||||
+// joined by U+001F (ASCII unit separator); each segment is an optional
|
||||
+// 6-hex-digit RRGGBB colour followed by U+001E (ASCII record separator) and
|
||||
+// then its plain text. A value containing no U+001E at all -- e.g. any
|
||||
+// ordinary string -- is drawn as a single run in the default text colour, so
|
||||
+// this renderer is safe to use in place of a plain text column.
|
||||
+namespace {
|
||||
+
|
||||
+struct ColorSegment {
|
||||
+ bool has_colour = false;
|
||||
+ wxColour colour;
|
||||
+ wxString text;
|
||||
+};
|
||||
+
|
||||
+std::vector<ColorSegment> ParseColorSegments(const wxString& value) {
|
||||
+ std::vector<ColorSegment> segs;
|
||||
+ if (value.Find(wxUniChar(0x1e)) == wxNOT_FOUND) {
|
||||
+ ColorSegment s;
|
||||
+ s.text = value;
|
||||
+ segs.push_back(s);
|
||||
+ return segs;
|
||||
+ }
|
||||
+ wxString rest = value;
|
||||
+ for (;;) {
|
||||
+ int sep = rest.Find(wxUniChar(0x1f));
|
||||
+ wxString piece = (sep == wxNOT_FOUND) ? rest : rest.Left(sep);
|
||||
+ ColorSegment s;
|
||||
+ int csep = piece.Find(wxUniChar(0x1e));
|
||||
+ if (csep == wxNOT_FOUND) {
|
||||
+ s.text = piece;
|
||||
+ } else {
|
||||
+ wxString hex = piece.Left(csep);
|
||||
+ s.text = piece.Mid(csep + 1);
|
||||
+ unsigned long v;
|
||||
+ if (hex.length() == 6 && hex.ToULong(&v, 16)) {
|
||||
+ s.colour = wxColour((unsigned char)((v >> 16) & 0xff),
|
||||
+ (unsigned char)((v >> 8) & 0xff),
|
||||
+ (unsigned char)(v & 0xff));
|
||||
+ s.has_colour = true;
|
||||
+ }
|
||||
+ }
|
||||
+ segs.push_back(s);
|
||||
+ if (sep == wxNOT_FOUND) break;
|
||||
+ rest = rest.Mid(sep + 1);
|
||||
+ }
|
||||
+ return segs;
|
||||
+}
|
||||
+
|
||||
+} // namespace
|
||||
+
|
||||
+class SegmentRenderer : public wxDataViewCustomRenderer {
|
||||
+ public:
|
||||
+ SegmentRenderer()
|
||||
+ : wxDataViewCustomRenderer(wxASCII_STR("string"), wxDATAVIEW_CELL_INERT) {}
|
||||
+
|
||||
+ bool SetValue(const wxVariant& value) override {
|
||||
+ m_value = value.GetString();
|
||||
+ return true;
|
||||
+ }
|
||||
+
|
||||
+ bool GetValue(wxVariant& value) const override {
|
||||
+ value = m_value;
|
||||
+ return true;
|
||||
+ }
|
||||
+
|
||||
+ bool Render(wxRect cell, wxDC* dc, int state) override {
|
||||
+ bool selected = (state & wxDATAVIEW_CELL_SELECTED) != 0;
|
||||
+ wxColour highlight = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
|
||||
+ wxColour plain = GetAttr().HasColour()
|
||||
+ ? GetAttr().GetColour()
|
||||
+ : wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
|
||||
+ wxCoord x = cell.x;
|
||||
+ for (const ColorSegment& seg : ParseColorSegments(m_value)) {
|
||||
+ if (seg.text.IsEmpty()) continue;
|
||||
+ dc->SetTextForeground(selected ? highlight : (seg.has_colour ? seg.colour : plain));
|
||||
+ wxSize extent = dc->GetTextExtent(seg.text);
|
||||
+ wxCoord y = cell.y + (cell.height - extent.GetHeight()) / 2;
|
||||
+ dc->DrawText(seg.text, x, y);
|
||||
+ x += extent.GetWidth();
|
||||
+ }
|
||||
+ return true;
|
||||
+ }
|
||||
+
|
||||
+ wxSize GetSize() const override {
|
||||
+ wxString plain;
|
||||
+ for (const ColorSegment& seg : ParseColorSegments(m_value)) plain += seg.text;
|
||||
+ wxSize sz = GetTextExtent(plain);
|
||||
+ if (sz.GetWidth() < 1) sz.SetWidth(1);
|
||||
+ return sz;
|
||||
+ }
|
||||
+
|
||||
+ private:
|
||||
+ wxString m_value;
|
||||
+};
|
||||
+
|
||||
+extern "C" {
|
||||
+
|
||||
+void wxbr_set_widget_event_fn(WxWidgetEventFn f) { g_widget_event = f; }
|
||||
@@ -91,6 +199,18 @@
|
||||
+ return (void*)new wxBoxSizer(vertical ? wxVERTICAL : wxHORIZONTAL);
|
||||
+}
|
||||
+
|
||||
+// A box sizer that wraps its items onto additional lines instead of shrinking
|
||||
+// them when the available space runs out. wxWrapSizer is a wxBoxSizer
|
||||
+// subclass, so it accepts the same add/add_sizer/add_spacer/add_stretch and
|
||||
+// set_sizer_on calls as wxbr_box_sizer's result.
|
||||
+void* wxbr_wrap_sizer(int vertical) {
|
||||
+ // wxREMOVE_LEADING_SPACES only: drop the default wxEXTEND_LAST_ON_EACH_LINE so
|
||||
+ // the last item on a line is NOT stretched to fill the row (keeps fixed-size
|
||||
+ // items -- e.g. the uniform KPI cards -- the same size).
|
||||
+ return (void*)new wxWrapSizer(vertical ? wxVERTICAL : wxHORIZONTAL,
|
||||
+ wxREMOVE_LEADING_SPACES);
|
||||
+}
|
||||
+
|
||||
+// flag bits (must match Rust sizer_flags):
|
||||
+// 1 = EXPAND, 2 = ALIGN_CENTRE_VERTICAL, 4 = wxALL, 8 = wxTOP,
|
||||
+// 16 = wxBOTTOM, 32 = wxLEFT, 64 = wxRIGHT
|
||||
@@ -199,6 +319,17 @@
|
||||
+ return (void*)b;
|
||||
+}
|
||||
+
|
||||
+// Make an arbitrary window (e.g. a KPI card panel) clickable: a left mouse
|
||||
+// down on it emits the same WxEV_BUTTON_CLICKED event a real button would,
|
||||
+// carrying `id`. Bind this on the panel itself; a child wxStaticText label
|
||||
+// swallows its own mouse events, so the caller binds each child that should
|
||||
+// also act as part of the click target rather than relying on propagation.
|
||||
+void wxbr_bind_click(void* win, int id) {
|
||||
+ ((wxWindow*)win)->Bind(wxEVT_LEFT_DOWN, [id](wxMouseEvent&) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_BUTTON_CLICKED, id, 0);
|
||||
+ });
|
||||
+}
|
||||
+
|
||||
+// ---- text ctrl ------------------------------------------------------------
|
||||
+
|
||||
+void* wxbr_text_ctrl(void* parent, int multiline) {
|
||||
@@ -297,6 +428,25 @@
|
||||
+ ((wxDialog*)win)->EndModal(code);
|
||||
+}
|
||||
+
|
||||
+// ---- file dialog -------------------------------------------------------------
|
||||
+
|
||||
+// Show a native "open file, must exist" dialog. On OK, copies the chosen
|
||||
+// path (UTF-8) into buf (capped at cap) and returns its length + 1, like the
|
||||
+// other buffer-filling bridge functions; on Cancel returns 0 and leaves buf
|
||||
+// untouched.
|
||||
+int wxbr_file_dialog(void* parent, const char* title, char* buf, int cap) {
|
||||
+ wxFileDialog dlg((wxWindow*)parent, wxString::FromUTF8(title), wxEmptyString,
|
||||
+ wxEmptyString, wxFileSelectorDefaultWildcardStr,
|
||||
+ wxFD_OPEN | wxFD_FILE_MUST_EXIST);
|
||||
+ if (dlg.ShowModal() != wxID_OK) return 0;
|
||||
+ wxCharBuffer b = dlg.GetPath().ToUTF8();
|
||||
+ int n = (int)strlen(b.data());
|
||||
+ if (n >= cap) n = cap - 1;
|
||||
+ memcpy(buf, b.data(), n);
|
||||
+ buf[n] = 0;
|
||||
+ return n + 1;
|
||||
+}
|
||||
+
|
||||
+// ---- data view list ctrl ------------------------------------------------------
|
||||
+
|
||||
+static AttrListStore* dvlc_store(void* win) {
|
||||
@@ -309,7 +459,8 @@
|
||||
+ // status while the native selection highlight still shows through.
|
||||
+ wxDataViewCtrl* dv =
|
||||
+ new wxDataViewCtrl((wxWindow*)parent, wxID_ANY, wxDefaultPosition,
|
||||
+ wxSize(-1, -1), wxDV_ROW_LINES | wxDV_MULTIPLE);
|
||||
+ wxSize(-1, -1),
|
||||
+ wxDV_ROW_LINES | wxDV_VERT_RULES | wxDV_MULTIPLE);
|
||||
+ AttrListStore* store = new AttrListStore();
|
||||
+ dv->AssociateModel(store);
|
||||
+ store->DecRef(); // the control owns a reference now
|
||||
@@ -332,9 +483,57 @@
|
||||
+ dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_CLICK, [](wxDataViewEvent& e) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_CLICK, (long)e.GetColumn(), 0);
|
||||
+ });
|
||||
+ // Right-click on a column header: Excel-style per-column menu (hide/sort/...).
|
||||
+ dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, [](wxDataViewEvent& e) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_RIGHT_CLICK, (long)e.GetColumn(), 0);
|
||||
+ });
|
||||
+ dv->Bind(wxEVT_DATAVIEW_COLUMN_REORDERED, [](wxDataViewEvent&) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_REORDERED, 0, 0);
|
||||
+ });
|
||||
+ // Rubber-band (click-drag) range selection: wxDataViewCtrl has none natively
|
||||
+ // (only ctrl/shift-click), so track it here. LEFT_DOWN records the anchor row
|
||||
+ // (and lets the native handler select it); dragging with the button down
|
||||
+ // extends the selection to the row under the cursor.
|
||||
+ dv->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent& e) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
+ if (!dv) { e.Skip(); return; }
|
||||
+ // Leave modifier-clicks to the native ctrl/shift multi-select behaviour.
|
||||
+ if (e.ControlDown() || e.ShiftDown()) { g_drag_anchor.erase(dv); e.Skip(); return; }
|
||||
+ wxDataViewItem item;
|
||||
+ wxDataViewColumn* col = nullptr;
|
||||
+ dv->HitTest(e.GetPosition(), item, col);
|
||||
+ if (item.IsOk()) {
|
||||
+ g_drag_anchor[dv] =
|
||||
+ (int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
+ } else {
|
||||
+ g_drag_anchor.erase(dv);
|
||||
+ }
|
||||
+ e.Skip(); // let the native handler select the anchor row
|
||||
+ });
|
||||
+ dv->Bind(wxEVT_MOTION, [](wxMouseEvent& e) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
+ if (!dv || !e.LeftIsDown()) { e.Skip(); return; }
|
||||
+ auto it = g_drag_anchor.find(dv);
|
||||
+ if (it == g_drag_anchor.end()) { e.Skip(); return; }
|
||||
+ wxDataViewItem item;
|
||||
+ wxDataViewColumn* col = nullptr;
|
||||
+ dv->HitTest(e.GetPosition(), item, col);
|
||||
+ if (!item.IsOk()) { e.Skip(); return; }
|
||||
+ wxDataViewIndexListModel* model = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
+ int cur = (int)model->GetRow(item);
|
||||
+ int lo = it->second < cur ? it->second : cur;
|
||||
+ int hi = it->second < cur ? cur : it->second;
|
||||
+ dv->UnselectAll();
|
||||
+ for (int r = lo; r <= hi; ++r) dv->Select(model->GetItem((unsigned)r));
|
||||
+ // Selecting programmatically does not emit SELECTION_CHANGED, so notify.
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_SELECTION_CHANGED, 0, 0);
|
||||
+ e.Skip();
|
||||
+ });
|
||||
+ dv->Bind(wxEVT_LEFT_UP, [](wxMouseEvent& e) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
+ if (dv) g_drag_anchor.erase(dv);
|
||||
+ e.Skip();
|
||||
+ });
|
||||
+ // Row activation (double-click / Enter): report the row + column so the app
|
||||
+ // can, e.g., open the miner's IP in a browser.
|
||||
+ dv->Bind(wxEVT_DATAVIEW_ITEM_ACTIVATED, [](wxDataViewEvent& e) {
|
||||
@@ -360,6 +559,23 @@
|
||||
+ width, wxALIGN_NOT, flags);
|
||||
+}
|
||||
+
|
||||
+// Same bookkeeping as wxbr_dvlc_append_text_col, but the column is drawn by a
|
||||
+// SegmentRenderer so its cell values can carry the '\x1f'/'\x1e' colour-run
|
||||
+// encoding produced by alkane_gui::model::encode_segments. An ordinary string
|
||||
+// with no encoding in it still renders fine (single default-coloured run).
|
||||
+void* wxbr_dvlc_append_colored_col(void* win, const char* title, int width, int reorderable) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ int flags = wxDATAVIEW_COL_RESIZABLE;
|
||||
+ if (reorderable) flags |= wxDATAVIEW_COL_REORDERABLE;
|
||||
+ unsigned col = dv->GetColumnCount(); // next model column index
|
||||
+ dvlc_store(win)->AppendColumn("string");
|
||||
+ SegmentRenderer* renderer = new SegmentRenderer();
|
||||
+ wxDataViewColumn* c = new wxDataViewColumn(wxString::FromUTF8(title), renderer, col,
|
||||
+ width, wxALIGN_NOT, flags);
|
||||
+ dv->AppendColumn(c);
|
||||
+ return (void*)c;
|
||||
+}
|
||||
+
|
||||
+void wxbr_dvlc_append_toggle_col(void* win, int width) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ unsigned col = dv->GetColumnCount();
|
||||
@@ -399,6 +615,29 @@
|
||||
+ store->RowChanged(row);
|
||||
+}
|
||||
+
|
||||
+// Set (or clear, when r<0) the alternating-row (zebra) background colour. The
|
||||
+// app passes a theme-aware colour; odd rows get it (see AttrListStore).
|
||||
+void wxbr_dvlc_set_zebra(void* win, int r, int g, int b) {
|
||||
+ dvlc_store(win)->zebra = (r < 0) ? wxColour() : wxColour(r, g, b);
|
||||
+}
|
||||
+
|
||||
+// The model-row index of the first (top) visible row, or -1 if none. Used to
|
||||
+// hold the scroll position across a full clear+refill during a live scan.
|
||||
+int wxbr_dvlc_get_top_row(void* win) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ wxDataViewItem item = dv->GetTopItem();
|
||||
+ if (!item.IsOk()) return -1;
|
||||
+ return (int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
+}
|
||||
+
|
||||
+// Scroll so `row` is visible (used with wxbr_dvlc_get_top_row to restore the
|
||||
+// scroll position after a refill). Out-of-range rows are ignored.
|
||||
+void wxbr_dvlc_ensure_visible(void* win, unsigned row) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ wxDataViewItem item = ((wxDataViewIndexListModel*)dv->GetModel())->GetItem(row);
|
||||
+ if (item.IsOk()) dv->EnsureVisible(item);
|
||||
+}
|
||||
+
|
||||
+int wxbr_dvlc_row_count(void* win) {
|
||||
+ return (int)dvlc_store(win)->GetItemCount();
|
||||
+}
|
||||
@@ -429,6 +668,14 @@
|
||||
+ return (int)((wxDataViewCtrl*)win)->GetColumnCount();
|
||||
+}
|
||||
+
|
||||
+// Auto-size a column (by display position) to fit its content + header.
|
||||
+void wxbr_dvlc_autosize_col(void* win, int pos) {
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ if (pos < 0 || (unsigned)pos >= dv->GetColumnCount()) return;
|
||||
+ wxDataViewColumn* c = dv->GetColumn((unsigned)pos);
|
||||
+ if (c) c->SetWidth(wxCOL_WIDTH_AUTOSIZE);
|
||||
+}
|
||||
+
|
||||
+// Update a column's header text in place (creation index) without recreating
|
||||
+// the control -- used to refresh the ASCII sort marker on a sort click.
|
||||
+void wxbr_dvlc_set_col_title(void* win, int col, const char* title) {
|
||||
|
||||
+257
-10
@@ -27,16 +27,19 @@
|
||||
#include <wx/dcmemory.h>
|
||||
#include <wx/dcgraph.h>
|
||||
#include <wx/graphics.h>
|
||||
#include <wx/wrapsizer.h>
|
||||
#include <wx/filedlg.h>
|
||||
#include <cstring>
|
||||
#ifdef __WXGTK__
|
||||
#include <gtk/gtk.h>
|
||||
#endif
|
||||
#include <cstdio>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
typedef void (*WxWidgetEventFn)(int kind, long p1, long p2);
|
||||
static WxWidgetEventFn g_widget_event = nullptr;
|
||||
|
||||
// Anchor row per data-view control for rubber-band (click-drag) range select.
|
||||
static std::map<wxDataViewCtrl*, int> g_drag_anchor;
|
||||
|
||||
// Event kinds (must match Rust WxEventKind in src/widgets.rs)
|
||||
enum WxWidgetEventKind {
|
||||
WxEV_BUTTON_CLICKED = 1,
|
||||
@@ -52,26 +55,131 @@ enum WxWidgetEventKind {
|
||||
WxEV_CHOICE_CHANGED = 12,
|
||||
WxEV_SYS_COLOUR = 13,
|
||||
WxEV_DEFERRED = 14,
|
||||
WxEV_DVLC_HEADER_RIGHT_CLICK = 15,
|
||||
};
|
||||
|
||||
// A list store that carries an optional per-row foreground colour, surfaced to
|
||||
// the native control via GetAttrByRow. This is how the miner table paints each
|
||||
// row's text by status and separates rows on GTK (where SetAlternateRowColour
|
||||
// and :nth-child CSS are unreliable and fight the selection highlight).
|
||||
// A list store that carries an optional per-row foreground colour plus an
|
||||
// alternating-row (zebra) background, surfaced to the native control via
|
||||
// GetAttrByRow. The zebra background is set on odd rows only; because it is a
|
||||
// BACKGROUND attr (not a foreground one), it does not affect the SegmentRenderer
|
||||
// "no explicit colour -> default text colour" path, and the native selection
|
||||
// highlight still paints over it for selected rows.
|
||||
class AttrListStore : public wxDataViewListStore {
|
||||
public:
|
||||
std::vector<wxColour> row_fg;
|
||||
wxColour zebra; // odd-row background; unset (=off) unless the app sets it
|
||||
bool GetAttrByRow(unsigned int row, unsigned int col,
|
||||
wxDataViewItemAttr& attr) const override {
|
||||
(void)col;
|
||||
bool set = false;
|
||||
if (row < row_fg.size() && row_fg[row].IsOk()) {
|
||||
attr.SetColour(row_fg[row]);
|
||||
return true;
|
||||
set = true;
|
||||
}
|
||||
return false;
|
||||
if (zebra.IsOk() && (row % 2 == 1)) {
|
||||
attr.SetBackgroundColour(zebra);
|
||||
set = true;
|
||||
}
|
||||
return set;
|
||||
}
|
||||
};
|
||||
|
||||
// A wxDataViewCustomRenderer that draws a cell value made of coloured text
|
||||
// runs. The encoding matches alkane_gui::model::encode_segments: segments are
|
||||
// joined by U+001F (ASCII unit separator); each segment is an optional
|
||||
// 6-hex-digit RRGGBB colour followed by U+001E (ASCII record separator) and
|
||||
// then its plain text. A value containing no U+001E at all -- e.g. any
|
||||
// ordinary string -- is drawn as a single run in the default text colour, so
|
||||
// this renderer is safe to use in place of a plain text column.
|
||||
namespace {
|
||||
|
||||
struct ColorSegment {
|
||||
bool has_colour = false;
|
||||
wxColour colour;
|
||||
wxString text;
|
||||
};
|
||||
|
||||
std::vector<ColorSegment> ParseColorSegments(const wxString& value) {
|
||||
std::vector<ColorSegment> segs;
|
||||
if (value.Find(wxUniChar(0x1e)) == wxNOT_FOUND) {
|
||||
ColorSegment s;
|
||||
s.text = value;
|
||||
segs.push_back(s);
|
||||
return segs;
|
||||
}
|
||||
wxString rest = value;
|
||||
for (;;) {
|
||||
int sep = rest.Find(wxUniChar(0x1f));
|
||||
wxString piece = (sep == wxNOT_FOUND) ? rest : rest.Left(sep);
|
||||
ColorSegment s;
|
||||
int csep = piece.Find(wxUniChar(0x1e));
|
||||
if (csep == wxNOT_FOUND) {
|
||||
s.text = piece;
|
||||
} else {
|
||||
wxString hex = piece.Left(csep);
|
||||
s.text = piece.Mid(csep + 1);
|
||||
unsigned long v;
|
||||
if (hex.length() == 6 && hex.ToULong(&v, 16)) {
|
||||
s.colour = wxColour((unsigned char)((v >> 16) & 0xff),
|
||||
(unsigned char)((v >> 8) & 0xff),
|
||||
(unsigned char)(v & 0xff));
|
||||
s.has_colour = true;
|
||||
}
|
||||
}
|
||||
segs.push_back(s);
|
||||
if (sep == wxNOT_FOUND) break;
|
||||
rest = rest.Mid(sep + 1);
|
||||
}
|
||||
return segs;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
class SegmentRenderer : public wxDataViewCustomRenderer {
|
||||
public:
|
||||
SegmentRenderer()
|
||||
: wxDataViewCustomRenderer(wxASCII_STR("string"), wxDATAVIEW_CELL_INERT) {}
|
||||
|
||||
bool SetValue(const wxVariant& value) override {
|
||||
m_value = value.GetString();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GetValue(wxVariant& value) const override {
|
||||
value = m_value;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Render(wxRect cell, wxDC* dc, int state) override {
|
||||
bool selected = (state & wxDATAVIEW_CELL_SELECTED) != 0;
|
||||
wxColour highlight = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
|
||||
wxColour plain = GetAttr().HasColour()
|
||||
? GetAttr().GetColour()
|
||||
: wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
|
||||
wxCoord x = cell.x;
|
||||
for (const ColorSegment& seg : ParseColorSegments(m_value)) {
|
||||
if (seg.text.IsEmpty()) continue;
|
||||
dc->SetTextForeground(selected ? highlight : (seg.has_colour ? seg.colour : plain));
|
||||
wxSize extent = dc->GetTextExtent(seg.text);
|
||||
wxCoord y = cell.y + (cell.height - extent.GetHeight()) / 2;
|
||||
dc->DrawText(seg.text, x, y);
|
||||
x += extent.GetWidth();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
wxSize GetSize() const override {
|
||||
wxString plain;
|
||||
for (const ColorSegment& seg : ParseColorSegments(m_value)) plain += seg.text;
|
||||
wxSize sz = GetTextExtent(plain);
|
||||
if (sz.GetWidth() < 1) sz.SetWidth(1);
|
||||
return sz;
|
||||
}
|
||||
|
||||
private:
|
||||
wxString m_value;
|
||||
};
|
||||
|
||||
extern "C" {
|
||||
|
||||
void wxbr_set_widget_event_fn(WxWidgetEventFn f) { g_widget_event = f; }
|
||||
@@ -88,6 +196,18 @@ void* wxbr_box_sizer(int vertical) {
|
||||
return (void*)new wxBoxSizer(vertical ? wxVERTICAL : wxHORIZONTAL);
|
||||
}
|
||||
|
||||
// A box sizer that wraps its items onto additional lines instead of shrinking
|
||||
// them when the available space runs out. wxWrapSizer is a wxBoxSizer
|
||||
// subclass, so it accepts the same add/add_sizer/add_spacer/add_stretch and
|
||||
// set_sizer_on calls as wxbr_box_sizer's result.
|
||||
void* wxbr_wrap_sizer(int vertical) {
|
||||
// wxREMOVE_LEADING_SPACES only: drop the default wxEXTEND_LAST_ON_EACH_LINE so
|
||||
// the last item on a line is NOT stretched to fill the row (keeps fixed-size
|
||||
// items -- e.g. the uniform KPI cards -- the same size).
|
||||
return (void*)new wxWrapSizer(vertical ? wxVERTICAL : wxHORIZONTAL,
|
||||
wxREMOVE_LEADING_SPACES);
|
||||
}
|
||||
|
||||
// flag bits (must match Rust sizer_flags):
|
||||
// 1 = EXPAND, 2 = ALIGN_CENTRE_VERTICAL, 4 = wxALL, 8 = wxTOP,
|
||||
// 16 = wxBOTTOM, 32 = wxLEFT, 64 = wxRIGHT
|
||||
@@ -196,6 +316,17 @@ void* wxbr_button(void* parent, const char* label, int id) {
|
||||
return (void*)b;
|
||||
}
|
||||
|
||||
// Make an arbitrary window (e.g. a KPI card panel) clickable: a left mouse
|
||||
// down on it emits the same WxEV_BUTTON_CLICKED event a real button would,
|
||||
// carrying `id`. Bind this on the panel itself; a child wxStaticText label
|
||||
// swallows its own mouse events, so the caller binds each child that should
|
||||
// also act as part of the click target rather than relying on propagation.
|
||||
void wxbr_bind_click(void* win, int id) {
|
||||
((wxWindow*)win)->Bind(wxEVT_LEFT_DOWN, [id](wxMouseEvent&) {
|
||||
if (g_widget_event) g_widget_event(WxEV_BUTTON_CLICKED, id, 0);
|
||||
});
|
||||
}
|
||||
|
||||
// ---- text ctrl ------------------------------------------------------------
|
||||
|
||||
void* wxbr_text_ctrl(void* parent, int multiline) {
|
||||
@@ -294,6 +425,25 @@ void wxbr_dialog_close(void* win, int code) {
|
||||
((wxDialog*)win)->EndModal(code);
|
||||
}
|
||||
|
||||
// ---- file dialog -------------------------------------------------------------
|
||||
|
||||
// Show a native "open file, must exist" dialog. On OK, copies the chosen
|
||||
// path (UTF-8) into buf (capped at cap) and returns its length + 1, like the
|
||||
// other buffer-filling bridge functions; on Cancel returns 0 and leaves buf
|
||||
// untouched.
|
||||
int wxbr_file_dialog(void* parent, const char* title, char* buf, int cap) {
|
||||
wxFileDialog dlg((wxWindow*)parent, wxString::FromUTF8(title), wxEmptyString,
|
||||
wxEmptyString, wxFileSelectorDefaultWildcardStr,
|
||||
wxFD_OPEN | wxFD_FILE_MUST_EXIST);
|
||||
if (dlg.ShowModal() != wxID_OK) return 0;
|
||||
wxCharBuffer b = dlg.GetPath().ToUTF8();
|
||||
int n = (int)strlen(b.data());
|
||||
if (n >= cap) n = cap - 1;
|
||||
memcpy(buf, b.data(), n);
|
||||
buf[n] = 0;
|
||||
return n + 1;
|
||||
}
|
||||
|
||||
// ---- data view list ctrl ------------------------------------------------------
|
||||
|
||||
static AttrListStore* dvlc_store(void* win) {
|
||||
@@ -306,7 +456,8 @@ void* wxbr_dvlc(void* parent) {
|
||||
// status while the native selection highlight still shows through.
|
||||
wxDataViewCtrl* dv =
|
||||
new wxDataViewCtrl((wxWindow*)parent, wxID_ANY, wxDefaultPosition,
|
||||
wxSize(-1, -1), wxDV_ROW_LINES | wxDV_MULTIPLE);
|
||||
wxSize(-1, -1),
|
||||
wxDV_ROW_LINES | wxDV_VERT_RULES | wxDV_MULTIPLE);
|
||||
AttrListStore* store = new AttrListStore();
|
||||
dv->AssociateModel(store);
|
||||
store->DecRef(); // the control owns a reference now
|
||||
@@ -329,9 +480,57 @@ void* wxbr_dvlc(void* parent) {
|
||||
dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_CLICK, [](wxDataViewEvent& e) {
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_CLICK, (long)e.GetColumn(), 0);
|
||||
});
|
||||
// Right-click on a column header: Excel-style per-column menu (hide/sort/...).
|
||||
dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, [](wxDataViewEvent& e) {
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_RIGHT_CLICK, (long)e.GetColumn(), 0);
|
||||
});
|
||||
dv->Bind(wxEVT_DATAVIEW_COLUMN_REORDERED, [](wxDataViewEvent&) {
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_REORDERED, 0, 0);
|
||||
});
|
||||
// Rubber-band (click-drag) range selection: wxDataViewCtrl has none natively
|
||||
// (only ctrl/shift-click), so track it here. LEFT_DOWN records the anchor row
|
||||
// (and lets the native handler select it); dragging with the button down
|
||||
// extends the selection to the row under the cursor.
|
||||
dv->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent& e) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
if (!dv) { e.Skip(); return; }
|
||||
// Leave modifier-clicks to the native ctrl/shift multi-select behaviour.
|
||||
if (e.ControlDown() || e.ShiftDown()) { g_drag_anchor.erase(dv); e.Skip(); return; }
|
||||
wxDataViewItem item;
|
||||
wxDataViewColumn* col = nullptr;
|
||||
dv->HitTest(e.GetPosition(), item, col);
|
||||
if (item.IsOk()) {
|
||||
g_drag_anchor[dv] =
|
||||
(int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
} else {
|
||||
g_drag_anchor.erase(dv);
|
||||
}
|
||||
e.Skip(); // let the native handler select the anchor row
|
||||
});
|
||||
dv->Bind(wxEVT_MOTION, [](wxMouseEvent& e) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
if (!dv || !e.LeftIsDown()) { e.Skip(); return; }
|
||||
auto it = g_drag_anchor.find(dv);
|
||||
if (it == g_drag_anchor.end()) { e.Skip(); return; }
|
||||
wxDataViewItem item;
|
||||
wxDataViewColumn* col = nullptr;
|
||||
dv->HitTest(e.GetPosition(), item, col);
|
||||
if (!item.IsOk()) { e.Skip(); return; }
|
||||
wxDataViewIndexListModel* model = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
int cur = (int)model->GetRow(item);
|
||||
int lo = it->second < cur ? it->second : cur;
|
||||
int hi = it->second < cur ? cur : it->second;
|
||||
dv->UnselectAll();
|
||||
for (int r = lo; r <= hi; ++r) dv->Select(model->GetItem((unsigned)r));
|
||||
// Selecting programmatically does not emit SELECTION_CHANGED, so notify.
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_SELECTION_CHANGED, 0, 0);
|
||||
e.Skip();
|
||||
});
|
||||
dv->Bind(wxEVT_LEFT_UP, [](wxMouseEvent& e) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
if (dv) g_drag_anchor.erase(dv);
|
||||
e.Skip();
|
||||
});
|
||||
// Row activation (double-click / Enter): report the row + column so the app
|
||||
// can, e.g., open the miner's IP in a browser.
|
||||
dv->Bind(wxEVT_DATAVIEW_ITEM_ACTIVATED, [](wxDataViewEvent& e) {
|
||||
@@ -357,6 +556,23 @@ void wxbr_dvlc_append_text_col(void* win, const char* title, int width, int reor
|
||||
width, wxALIGN_NOT, flags);
|
||||
}
|
||||
|
||||
// Same bookkeeping as wxbr_dvlc_append_text_col, but the column is drawn by a
|
||||
// SegmentRenderer so its cell values can carry the '\x1f'/'\x1e' colour-run
|
||||
// encoding produced by alkane_gui::model::encode_segments. An ordinary string
|
||||
// with no encoding in it still renders fine (single default-coloured run).
|
||||
void* wxbr_dvlc_append_colored_col(void* win, const char* title, int width, int reorderable) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
int flags = wxDATAVIEW_COL_RESIZABLE;
|
||||
if (reorderable) flags |= wxDATAVIEW_COL_REORDERABLE;
|
||||
unsigned col = dv->GetColumnCount(); // next model column index
|
||||
dvlc_store(win)->AppendColumn("string");
|
||||
SegmentRenderer* renderer = new SegmentRenderer();
|
||||
wxDataViewColumn* c = new wxDataViewColumn(wxString::FromUTF8(title), renderer, col,
|
||||
width, wxALIGN_NOT, flags);
|
||||
dv->AppendColumn(c);
|
||||
return (void*)c;
|
||||
}
|
||||
|
||||
void wxbr_dvlc_append_toggle_col(void* win, int width) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
unsigned col = dv->GetColumnCount();
|
||||
@@ -396,6 +612,29 @@ void wxbr_dvlc_set_row_color(void* win, unsigned row, int r, int g, int b) {
|
||||
store->RowChanged(row);
|
||||
}
|
||||
|
||||
// Set (or clear, when r<0) the alternating-row (zebra) background colour. The
|
||||
// app passes a theme-aware colour; odd rows get it (see AttrListStore).
|
||||
void wxbr_dvlc_set_zebra(void* win, int r, int g, int b) {
|
||||
dvlc_store(win)->zebra = (r < 0) ? wxColour() : wxColour(r, g, b);
|
||||
}
|
||||
|
||||
// The model-row index of the first (top) visible row, or -1 if none. Used to
|
||||
// hold the scroll position across a full clear+refill during a live scan.
|
||||
int wxbr_dvlc_get_top_row(void* win) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
wxDataViewItem item = dv->GetTopItem();
|
||||
if (!item.IsOk()) return -1;
|
||||
return (int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
}
|
||||
|
||||
// Scroll so `row` is visible (used with wxbr_dvlc_get_top_row to restore the
|
||||
// scroll position after a refill). Out-of-range rows are ignored.
|
||||
void wxbr_dvlc_ensure_visible(void* win, unsigned row) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
wxDataViewItem item = ((wxDataViewIndexListModel*)dv->GetModel())->GetItem(row);
|
||||
if (item.IsOk()) dv->EnsureVisible(item);
|
||||
}
|
||||
|
||||
int wxbr_dvlc_row_count(void* win) {
|
||||
return (int)dvlc_store(win)->GetItemCount();
|
||||
}
|
||||
@@ -426,6 +665,14 @@ int wxbr_dvlc_col_count(void* win) {
|
||||
return (int)((wxDataViewCtrl*)win)->GetColumnCount();
|
||||
}
|
||||
|
||||
// Auto-size a column (by display position) to fit its content + header.
|
||||
void wxbr_dvlc_autosize_col(void* win, int pos) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
if (pos < 0 || (unsigned)pos >= dv->GetColumnCount()) return;
|
||||
wxDataViewColumn* c = dv->GetColumn((unsigned)pos);
|
||||
if (c) c->SetWidth(wxCOL_WIDTH_AUTOSIZE);
|
||||
}
|
||||
|
||||
// Update a column's header text in place (creation index) without recreating
|
||||
// the control -- used to refresh the ASCII sort marker on a sort click.
|
||||
void wxbr_dvlc_set_col_title(void* win, int col, const char* title) {
|
||||
|
||||
@@ -15,6 +15,7 @@ mod notsafe {
|
||||
pub fn wxbr_main_frame() -> *mut c_void;
|
||||
pub fn wxbr_panel(parent: *mut c_void) -> *mut c_void;
|
||||
pub fn wxbr_box_sizer(vertical: c_int) -> *mut c_void;
|
||||
pub fn wxbr_wrap_sizer(vertical: c_int) -> *mut c_void;
|
||||
pub fn wxbr_sizer_add(sizer: *mut c_void, win: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
|
||||
pub fn wxbr_sizer_add_sizer(sizer: *mut c_void, subsizer: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
|
||||
pub fn wxbr_sizer_add_spacer(sizer: *mut c_void, px: c_int);
|
||||
@@ -30,6 +31,7 @@ mod notsafe {
|
||||
pub fn wxbr_set_bold(win: *mut c_void);
|
||||
pub fn wxbr_set_font_size(win: *mut c_void, pts: c_int);
|
||||
pub fn wxbr_button(parent: *mut c_void, label: *const c_char, id: c_int) -> *mut c_void;
|
||||
pub fn wxbr_bind_click(win: *mut c_void, id: c_int);
|
||||
pub fn wxbr_text_ctrl(parent: *mut c_void, multiline: c_int) -> *mut c_void;
|
||||
pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
|
||||
@@ -46,8 +48,10 @@ mod notsafe {
|
||||
pub fn wxbr_dialog(parent: *mut c_void, title: *const c_char) -> *mut c_void;
|
||||
pub fn wxbr_dialog_show_modal(win: *mut c_void) -> c_int;
|
||||
pub fn wxbr_dialog_close(win: *mut c_void, code: c_int);
|
||||
pub fn wxbr_file_dialog(parent: *mut c_void, title: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
pub fn wxbr_dvlc(parent: *mut c_void) -> *mut c_void;
|
||||
pub fn wxbr_dvlc_append_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int);
|
||||
pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int) -> *mut c_void;
|
||||
pub fn wxbr_dvlc_append_toggle_col(win: *mut c_void, width: c_int);
|
||||
pub fn wxbr_dvlc_append_row(win: *mut c_void, nvals: c_int, vals: *const *const c_char);
|
||||
pub fn wxbr_dvlc_delete_row(win: *mut c_void, row: usize);
|
||||
@@ -56,6 +60,7 @@ mod notsafe {
|
||||
pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
|
||||
pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
|
||||
pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
|
||||
pub fn wxbr_dvlc_set_col_title(win: *mut c_void, col: c_int, title: *const c_char);
|
||||
pub fn wxbr_dvlc_set_sort_indicator(win: *mut c_void, col: c_int, active: c_int, ascending: c_int);
|
||||
pub fn wxbr_dvlc_col_at_pos(win: *mut c_void, pos: c_int) -> c_int;
|
||||
@@ -65,6 +70,9 @@ mod notsafe {
|
||||
pub fn wxbr_dvlc_select_rows(win: *mut c_void, rows: *const c_int, n: c_int);
|
||||
pub fn wxbr_dvlc_set_alt_row_color(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_dvlc_set_row_color(win: *mut c_void, row: usize, r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_dvlc_set_zebra(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_dvlc_get_top_row(win: *mut c_void) -> c_int;
|
||||
pub fn wxbr_dvlc_ensure_visible(win: *mut c_void, row: usize);
|
||||
pub fn wxbr_apply_zebra_css(r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_rearrange_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
|
||||
pub fn wxbr_rearrange_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
|
||||
@@ -129,6 +137,7 @@ pub enum WxEventKind {
|
||||
ChoiceChanged,
|
||||
SysColour,
|
||||
Deferred,
|
||||
DvlcHeaderRightClick,
|
||||
}
|
||||
|
||||
impl WxEventKind {
|
||||
@@ -147,6 +156,7 @@ impl WxEventKind {
|
||||
12 => WxEventKind::ChoiceChanged,
|
||||
13 => WxEventKind::SysColour,
|
||||
14 => WxEventKind::Deferred,
|
||||
15 => WxEventKind::DvlcHeaderRightClick,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
@@ -239,6 +249,14 @@ impl Widget {
|
||||
Widget(unsafe { notsafe::wxbr_box_sizer(vertical as c_int) })
|
||||
}
|
||||
|
||||
/// A box sizer that wraps overflowing items onto additional lines instead
|
||||
/// of shrinking them. wxWrapSizer is a wxBoxSizer subclass, so the result
|
||||
/// accepts the same add/add_sizer/add_spacer/add_stretch/set_sizer_on
|
||||
/// calls as `box_sizer`'s.
|
||||
pub fn wrap_sizer(vertical: bool) -> Widget {
|
||||
Widget(unsafe { notsafe::wxbr_wrap_sizer(vertical as c_int) })
|
||||
}
|
||||
|
||||
pub fn add(&self, win: Widget, proportion: i32, flags: i32, border: i32) {
|
||||
unsafe { notsafe::wxbr_sizer_add(self.0, win.0, proportion, flags, border) }
|
||||
}
|
||||
@@ -315,6 +333,15 @@ impl Widget {
|
||||
Widget(unsafe { notsafe::wxbr_button(parent.0, c.as_ptr(), id) })
|
||||
}
|
||||
|
||||
/// Make this window clickable: a left mouse down on it emits the same
|
||||
/// `ButtonClicked` event a real button would, carrying `id`. Bind each
|
||||
/// child that should also count as part of the click target (e.g. the
|
||||
/// static text labels on a KPI card), since a child window swallows its
|
||||
/// own mouse events rather than letting them propagate to the parent.
|
||||
pub fn bind_click(&self, id: i32) {
|
||||
unsafe { notsafe::wxbr_bind_click(self.0, id) }
|
||||
}
|
||||
|
||||
pub fn text_ctrl(parent: Widget, multiline: bool) -> Widget {
|
||||
Widget(unsafe { notsafe::wxbr_text_ctrl(parent.0, multiline as c_int) })
|
||||
}
|
||||
@@ -394,6 +421,21 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_dialog_close(self.0, code) }
|
||||
}
|
||||
|
||||
/// Show a native "open file, must exist" dialog. Returns the chosen path,
|
||||
/// or `None` if the dialog was cancelled.
|
||||
pub fn file_dialog(parent: Widget, title: &str) -> Option<String> {
|
||||
let c = CString::new(title).unwrap_or_default();
|
||||
let mut buf = vec![0i8; 4096];
|
||||
let n = unsafe {
|
||||
notsafe::wxbr_file_dialog(parent.0, c.as_ptr(), buf.as_mut_ptr(), buf.len() as c_int)
|
||||
};
|
||||
if n <= 0 {
|
||||
return None;
|
||||
}
|
||||
let bytes: Vec<u8> = buf[..(n - 1) as usize].iter().map(|&b| b as u8).collect();
|
||||
Some(String::from_utf8_lossy(&bytes).into_owned())
|
||||
}
|
||||
|
||||
// ---- data view list ctrl ----
|
||||
|
||||
pub fn dvlc(parent: Widget) -> Widget {
|
||||
@@ -405,6 +447,14 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int) }
|
||||
}
|
||||
|
||||
/// Like `dvlc_append_text_col`, but the column renders cell values through
|
||||
/// the SegmentRenderer, so a value built with `model::encode_segments` is
|
||||
/// drawn as coloured text runs (a plain string still renders normally).
|
||||
pub fn dvlc_append_colored_col(&self, title: &str, width: i32, reorderable: bool) {
|
||||
let c = CString::new(title).unwrap_or_default();
|
||||
unsafe { notsafe::wxbr_dvlc_append_colored_col(self.0, c.as_ptr(), width, reorderable as c_int) };
|
||||
}
|
||||
|
||||
pub fn dvlc_append_toggle_col(&self, width: i32) {
|
||||
unsafe { notsafe::wxbr_dvlc_append_toggle_col(self.0, width) }
|
||||
}
|
||||
@@ -448,6 +498,11 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_dvlc_col_count(self.0).max(0) as usize }
|
||||
}
|
||||
|
||||
/// Auto-size the column at display position `pos` to fit its content.
|
||||
pub fn dvlc_autosize_col(&self, pos: usize) {
|
||||
unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
|
||||
}
|
||||
|
||||
/// Model column index shown at display position `pos` (after drag reorder).
|
||||
pub fn dvlc_col_at_pos(&self, pos: usize) -> Option<usize> {
|
||||
let v = unsafe { notsafe::wxbr_dvlc_col_at_pos(self.0, pos as c_int) };
|
||||
@@ -491,6 +546,27 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_dvlc_set_row_color(self.0, row, r, g, b) }
|
||||
}
|
||||
|
||||
/// Set the alternating-row (zebra) background colour applied to odd rows.
|
||||
/// Pass `None` to turn zebra striping off.
|
||||
pub fn dvlc_set_zebra(&self, color: Option<(u8, u8, u8)>) {
|
||||
let (r, g, b) = match color {
|
||||
Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
|
||||
None => (-1, -1, -1),
|
||||
};
|
||||
unsafe { notsafe::wxbr_dvlc_set_zebra(self.0, r, g, b) }
|
||||
}
|
||||
|
||||
/// The model-row index of the top (first visible) row, or `None` if empty.
|
||||
pub fn dvlc_get_top_row(&self) -> Option<usize> {
|
||||
let r = unsafe { notsafe::wxbr_dvlc_get_top_row(self.0) };
|
||||
(r >= 0).then_some(r as usize)
|
||||
}
|
||||
|
||||
/// Scroll so `row` is visible (used to restore scroll position after a refill).
|
||||
pub fn dvlc_ensure_visible(&self, row: usize) {
|
||||
unsafe { notsafe::wxbr_dvlc_ensure_visible(self.0, row) }
|
||||
}
|
||||
|
||||
// ---- rearrangeable check-list ----
|
||||
|
||||
/// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
|
||||
|
||||
Reference in New Issue
Block a user