Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
86e4761316 | ||
|
|
c1234f6df7 | ||
|
|
b6afe08a5f | ||
|
|
eb08a9ef97 | ||
|
|
297e21a519 | ||
|
|
7fac0ce726 | ||
|
|
8e9c5e7105 |
@@ -21,6 +21,10 @@ jobs:
|
||||
id: ver
|
||||
run: bash ci/compute-version.sh | tee -a "$GITHUB_OUTPUT"
|
||||
|
||||
- name: Test version logic
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
run: bash ci/test-compute-version.sh
|
||||
|
||||
- name: Install build dependencies
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
run: |
|
||||
@@ -71,9 +75,9 @@ jobs:
|
||||
|
||||
- name: Headless UI self-test
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
continue-on-error: true
|
||||
run: |
|
||||
apt-get update -qq && apt-get install -y -qq --no-install-recommends xvfb dbus-x11 fonts-dejavu-core >/dev/null
|
||||
apt-get update -qq && apt-get install -y -qq --no-install-recommends \
|
||||
xvfb xauth dbus-x11 fonts-dejavu-core >/dev/null
|
||||
BIN=target/release/alkane-toolkit
|
||||
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 "$BIN"
|
||||
|
||||
|
||||
+2
-2
@@ -1,3 +1,3 @@
|
||||
/target
|
||||
|
||||
|
||||
**/target
|
||||
.claude/
|
||||
|
||||
Generated
+1
@@ -80,6 +80,7 @@ dependencies = [
|
||||
"alkane-discovery",
|
||||
"asic-rs",
|
||||
"futures-util",
|
||||
"measurements",
|
||||
"tokio",
|
||||
"wx-rs",
|
||||
]
|
||||
|
||||
Executable
+101
@@ -0,0 +1,101 @@
|
||||
#!/usr/bin/env bash
|
||||
# Tests for ci/compute-version.sh (the X.Y.Z versioning logic). Each case builds
|
||||
# a throwaway git repo in a scratch tmp dir (never inside this repo / the Ultron
|
||||
# mount), lays out a scenario, runs compute-version.sh inside it, and asserts the
|
||||
# emitted KEY=VALUE lines. Run: bash ci/test-compute-version.sh
|
||||
set -euo pipefail
|
||||
|
||||
SCRIPT="$(cd "$(dirname "$0")" && pwd)/compute-version.sh"
|
||||
[ -f "$SCRIPT" ] || { echo "cannot find compute-version.sh at $SCRIPT"; exit 2; }
|
||||
|
||||
pass=0
|
||||
fail=0
|
||||
|
||||
# new_repo: fresh git repo in a scratch dir, echoes its path.
|
||||
new_repo() {
|
||||
local r
|
||||
r="$(mktemp -d "${TMPDIR:-/tmp}/alkane-cv-XXXXXX")"
|
||||
git -C "$r" init -q
|
||||
git -C "$r" config user.email t@t
|
||||
git -C "$r" config user.name t
|
||||
echo "$r"
|
||||
}
|
||||
|
||||
commit() { # commit <repo> <msg>
|
||||
git -C "$1" add -A
|
||||
git -C "$1" commit -q -m "$2"
|
||||
}
|
||||
|
||||
# run_case: <name> <repo> then key=value expectations as remaining args.
|
||||
run_case() {
|
||||
local name="$1" repo="$2"; shift 2
|
||||
local out get k v ok=1
|
||||
out="$(cd "$repo" && bash "$SCRIPT")"
|
||||
get() { echo "$out" | grep "^$1=" | cut -d= -f2-; }
|
||||
for kv in "$@"; do
|
||||
k="${kv%%=*}"; v="${kv#*=}"
|
||||
if [ "$(get "$k")" != "$v" ]; then
|
||||
echo "FAIL [$name]: expected $k=$v, got $k=$(get "$k")"
|
||||
ok=0
|
||||
fi
|
||||
done
|
||||
if [ "$ok" = 1 ]; then echo "PASS [$name]"; pass=$((pass + 1)); else fail=$((fail + 1)); fi
|
||||
rm -rf "$repo"
|
||||
}
|
||||
|
||||
# 1. First release, no tag, X=0 -> 0.1.0
|
||||
R="$(new_repo)"; mkdir -p "$R/ci"; printf '0' > "$R/ci/version-x.txt"
|
||||
printf 'x' > "$R/README.md"; commit "$R" init
|
||||
run_case first_release "$R" version=0.1.0 tag=v0.1.0 bump=initial release=true last_tag=none
|
||||
|
||||
# 2. First release with a pre-bumped major (X=2, no tag) -> 2.0.0
|
||||
R="$(new_repo)"; mkdir -p "$R/ci"; printf '2' > "$R/ci/version-x.txt"
|
||||
printf 'x' > "$R/README.md"; commit "$R" init
|
||||
run_case first_release_prebumped_x "$R" version=2.0.0 bump=initial release=true
|
||||
|
||||
# 3. Backend path change bumps Y
|
||||
R="$(new_repo)"; mkdir -p "$R/ci" "$R/crates/alkane-gui/src"; printf '0' > "$R/ci/version-x.txt"
|
||||
printf 'x' > "$R/README.md"; commit "$R" init; git -C "$R" tag v1.2.3
|
||||
printf 'fn x(){}' > "$R/crates/alkane-gui/src/scan.rs"; commit "$R" backend
|
||||
run_case backend_bump "$R" version=1.3.0 tag=v1.3.0 bump=backend release=true last_tag=v1.2.3
|
||||
|
||||
# 4. UI path change bumps Z
|
||||
R="$(new_repo)"; mkdir -p "$R/ci" "$R/crates/alkane-gui/src"; printf '0' > "$R/ci/version-x.txt"
|
||||
printf 'x' > "$R/README.md"; commit "$R" init; git -C "$R" tag v1.2.3
|
||||
printf 'fn x(){}' > "$R/crates/alkane-gui/src/fixtures.rs"; commit "$R" ui
|
||||
run_case ui_bump "$R" version=1.2.4 bump=ui release=true
|
||||
|
||||
# 5. Docs-only change -> no release
|
||||
R="$(new_repo)"; mkdir -p "$R/ci"; printf '0' > "$R/ci/version-x.txt"
|
||||
printf 'x' > "$R/README.md"; commit "$R" init; git -C "$R" tag v1.2.3
|
||||
printf 'more docs' > "$R/README.md"; commit "$R" docs
|
||||
run_case no_release_docs_only "$R" version=1.2.3 bump=none release=false
|
||||
|
||||
# 6. Manual major bump wins over a simultaneous UI change
|
||||
R="$(new_repo)"; mkdir -p "$R/ci" "$R/crates/alkane-gui/src"; printf '0' > "$R/ci/version-x.txt"
|
||||
printf 'x' > "$R/README.md"; commit "$R" init; git -C "$R" tag v1.2.3
|
||||
printf '2' > "$R/ci/version-x.txt"; printf 'fn x(){}' > "$R/crates/alkane-gui/src/fixtures.rs"; commit "$R" bumpx
|
||||
run_case manual_major_wins_over_ui "$R" version=2.0.0 bump=major release=true
|
||||
|
||||
# 7. Backend wins over UI when both change in the same diff
|
||||
R="$(new_repo)"; mkdir -p "$R/ci" "$R/crates/alkane-gui/src"; printf '0' > "$R/ci/version-x.txt"
|
||||
printf 'x' > "$R/README.md"; commit "$R" init; git -C "$R" tag v1.2.3
|
||||
printf 'a' > "$R/crates/alkane-gui/src/scan.rs"
|
||||
printf 'b' > "$R/crates/alkane-gui/src/fixtures.rs"; commit "$R" both
|
||||
run_case backend_wins_over_ui "$R" version=1.3.0 bump=backend release=true
|
||||
|
||||
# 8. Nested ci/ path classified as backend (also covers editing compute-version.sh)
|
||||
R="$(new_repo)"; mkdir -p "$R/ci"; printf '0' > "$R/ci/version-x.txt"
|
||||
printf 'x' > "$R/README.md"; commit "$R" init; git -C "$R" tag v1.2.3
|
||||
printf '# tweak' >> "$R/ci/compute-version.sh"; commit "$R" ci
|
||||
run_case ci_nested_is_backend "$R" version=1.3.0 bump=backend release=true
|
||||
|
||||
# 9. Nested thirdparty/wx-rs path classified as UI
|
||||
R="$(new_repo)"; mkdir -p "$R/ci" "$R/thirdparty/wx-rs/src/deep"; printf '0' > "$R/ci/version-x.txt"
|
||||
printf 'x' > "$R/README.md"; commit "$R" init; git -C "$R" tag v1.2.3
|
||||
printf 'x' > "$R/thirdparty/wx-rs/src/deep/nested.rs"; commit "$R" wx
|
||||
run_case wx_rs_nested_is_ui "$R" version=1.2.4 bump=ui release=true
|
||||
|
||||
echo "----"
|
||||
echo "compute-version tests: $pass passed, $fail failed"
|
||||
[ "$fail" -eq 0 ]
|
||||
@@ -14,5 +14,6 @@ alkane-discovery = { path = "../alkane-discovery" }
|
||||
# vendored + patched wx-rs (see vendor/wx-rs/patches/)
|
||||
wx-rs = { path = "../../thirdparty/wx-rs/wx-rs-0.2.0-patched" }
|
||||
asic-rs = "0.8.1"
|
||||
measurements = "0.11"
|
||||
tokio = { version = "1", features = ["rt"] }
|
||||
futures-util = "0.3"
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -1,8 +1,10 @@
|
||||
//! Bench-fleet fixtures: the expected hardware output of the 9 boards on
|
||||
//! 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.
|
||||
//! [removed]), plus one synthetic unreachable IP rendered via
|
||||
//! `MinerRow::offline()` so the "offline" status/row shape is exercisable
|
||||
//! offline too (10 rows total). 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.
|
||||
//!
|
||||
//! 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 +26,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 +43,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 +65,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,47 +88,81 @@ 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).
|
||||
caps: crate::model::MinerCaps {
|
||||
fault_light: true,
|
||||
restart: true,
|
||||
pause: self.mining,
|
||||
resume: self.mining,
|
||||
power_limit: self.mining,
|
||||
tuning: self.mining,
|
||||
firmware_flash,
|
||||
},
|
||||
..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 plus one synthetic offline entry (10 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; the last row is an
|
||||
/// unreachable IP rendered via `MinerRow::offline()` (blank fields,
|
||||
/// `offline: true`).
|
||||
///
|
||||
/// Derived totals (used by the workflow tests):
|
||||
/// total = 9, hashing = 6, slow = 1, not hashing = 2,
|
||||
/// total hashrate = 685.0 TH/s, total power = 21300 W.
|
||||
/// total = 10, hashing = 6, slow = 1, not hashing = 1, paused = 1, offline = 1,
|
||||
/// total hashrate = 685.0 TH/s, total power = 21300 W (offline row is all zero).
|
||||
///
|
||||
/// Note: `compute_kpis` has no separate "offline" bucket - an offline row is
|
||||
/// `!is_mining && !paused && !slow`, so it folds into the "not hashing" KPI
|
||||
/// alongside the idle S17, giving `Kpis.not_hashing == 2`. The per-row
|
||||
/// `status()` text still distinguishes them ("not hashing" for .112 vs.
|
||||
/// "offline" for .199).
|
||||
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()
|
||||
let mut rows: Vec<MinerRow> = boards.into_iter().map(Board::into_row).collect();
|
||||
// Synthetic offline board: unreachable IP, blank/zeroed fields, offline: true.
|
||||
rows.push(MinerRow::offline("10.255.1.199".into()));
|
||||
rows
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
+888
-91
File diff suppressed because it is too large
Load Diff
+737
-67
@@ -1,14 +1,17 @@
|
||||
//! Scan engine: drives vendored asic-rs over the configured subnets and
|
||||
//! streams MinerRow snapshots to the UI thread via a std channel.
|
||||
|
||||
use crate::model::MinerRow;
|
||||
use asic_rs::MinerFactory;
|
||||
use crate::model::{MinerCaps, MinerRow};
|
||||
use asic_rs::core::data::firmware::FirmwareImage;
|
||||
use asic_rs::core::traits::miner::Miner;
|
||||
use futures_util::StreamExt;
|
||||
use measurements::Power;
|
||||
use std::collections::HashSet;
|
||||
use std::net::Ipv4Addr;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::mpsc::{channel, Receiver};
|
||||
use std::sync::Arc;
|
||||
|
||||
pub enum ScanMsg {
|
||||
/// A new scan started: `total` addresses to probe, and the exact set of
|
||||
@@ -228,27 +231,63 @@ pub fn fake_scan_enabled() -> bool {
|
||||
/// tells the UI which addresses are in range (so out-of-range miners can be
|
||||
/// dropped), then streams identified miners plus progress updates. In fake-scan
|
||||
/// mode it streams the bench-fleet fixtures instead, needing no network.
|
||||
pub fn start_scan(lines: Vec<String>) -> Receiver<ScanMsg> {
|
||||
///
|
||||
/// The returned [`ScanHandle`] carries the message stream plus a cancel flag the
|
||||
/// background thread checks each iteration, so Stop / re-scan can end a scan
|
||||
/// promptly instead of leaving a thread probing dead hosts (each probe waits out
|
||||
/// an asic-rs per-host timeout).
|
||||
pub struct ScanHandle {
|
||||
pub rx: Receiver<ScanMsg>,
|
||||
cancel: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl ScanHandle {
|
||||
/// Signal the scan thread to stop at its next loop iteration. Idempotent;
|
||||
/// dropping the handle's `rx` alone does NOT stop the thread.
|
||||
pub fn stop(&self) {
|
||||
self.cancel.store(true, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn start_scan(lines: Vec<String>) -> ScanHandle {
|
||||
let (tx, rx) = channel();
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
|
||||
if fake_scan_enabled() {
|
||||
std::thread::Builder::new()
|
||||
.name("fake-scan".into())
|
||||
.spawn(move || {
|
||||
let rows = crate::fixtures::bench_fleet();
|
||||
let targets: HashSet<String> = rows.iter().map(|r| r.ip.clone()).collect();
|
||||
let total = rows.len();
|
||||
let _ = tx.send(ScanMsg::Started { total, targets });
|
||||
for (i, row) in rows.into_iter().enumerate() {
|
||||
if tx.send(ScanMsg::Row(row)).is_err() {
|
||||
return;
|
||||
}
|
||||
let _ = tx.send(ScanMsg::Progress { done: i + 1, total, ip: String::new() });
|
||||
let thread_cancel = cancel.clone();
|
||||
let err_tx = tx.clone();
|
||||
let res = std::thread::Builder::new().name("fake-scan".into()).spawn(move || {
|
||||
let rows = crate::fixtures::bench_fleet();
|
||||
// A synthetic unreachable host, so the offline-recognition path
|
||||
// (a probed address with no miner behind it) is exercised even
|
||||
// when running fully offline against fixtures.
|
||||
let offline_ip = "10.255.1.254".to_string();
|
||||
let mut targets: HashSet<String> = rows.iter().map(|r| r.ip.clone()).collect();
|
||||
targets.insert(offline_ip.clone());
|
||||
let total = rows.len() + 1;
|
||||
let _ = tx.send(ScanMsg::Started { total, targets });
|
||||
for (i, row) in rows.into_iter().enumerate() {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
return;
|
||||
}
|
||||
let _ = tx.send(ScanMsg::Done("fixtures".into()));
|
||||
})
|
||||
.expect("spawn fake-scan thread");
|
||||
return rx;
|
||||
if tx.send(ScanMsg::Row(row)).is_err() {
|
||||
return;
|
||||
}
|
||||
let _ = tx.send(ScanMsg::Progress { done: i + 1, total, ip: String::new() });
|
||||
}
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
return;
|
||||
}
|
||||
if tx.send(ScanMsg::Row(MinerRow::offline(offline_ip))).is_err() {
|
||||
return;
|
||||
}
|
||||
let _ = tx.send(ScanMsg::Progress { done: total, total, ip: String::new() });
|
||||
let _ = tx.send(ScanMsg::Done("fixtures".into()));
|
||||
});
|
||||
if let Err(e) = res {
|
||||
let _ = err_tx.send(ScanMsg::Failed(format!("spawn fake-scan thread: {e}")));
|
||||
}
|
||||
return ScanHandle { rx, cancel };
|
||||
}
|
||||
|
||||
// Resolve the target addresses up front so we can report total + membership.
|
||||
@@ -256,11 +295,11 @@ pub fn start_scan(lines: Vec<String>) -> Receiver<ScanMsg> {
|
||||
Ok(t) if !t.is_empty() => t,
|
||||
Ok(_) => {
|
||||
let _ = tx.send(ScanMsg::Failed("no addresses in the given ranges".into()));
|
||||
return rx;
|
||||
return ScanHandle { rx, cancel };
|
||||
}
|
||||
Err(e) => {
|
||||
let _ = tx.send(ScanMsg::Failed(e));
|
||||
return rx;
|
||||
return ScanHandle { rx, cancel };
|
||||
}
|
||||
};
|
||||
let total = targets.len();
|
||||
@@ -268,49 +307,58 @@ pub fn start_scan(lines: Vec<String>) -> Receiver<ScanMsg> {
|
||||
let _ = tx.send(ScanMsg::Started { total, targets: target_set });
|
||||
let cidrs = targets_to_cidrs(&targets);
|
||||
|
||||
std::thread::Builder::new()
|
||||
.name("asic-rs-scan".into())
|
||||
.spawn(move || {
|
||||
let rt = match tokio::runtime::Runtime::new() {
|
||||
Ok(rt) => rt,
|
||||
Err(e) => {
|
||||
let _ = tx.send(ScanMsg::Failed(format!("tokio runtime: {e}")));
|
||||
return;
|
||||
}
|
||||
};
|
||||
rt.block_on(async move {
|
||||
let mut factory = MinerFactory::new();
|
||||
for (ip, prefix) in &cidrs {
|
||||
factory = match factory.with_subnet(&format!("{ip}/{prefix}")) {
|
||||
Ok(f) => f,
|
||||
Err(e) => {
|
||||
let _ = tx.send(ScanMsg::Failed(format!("{ip}/{prefix}: {e}")));
|
||||
return;
|
||||
}
|
||||
};
|
||||
}
|
||||
// scan_stream_with_ip yields one item per probed address, so we
|
||||
// get accurate progress plus the responders.
|
||||
let mut stream = factory.scan_stream_with_ip();
|
||||
let mut done = 0usize;
|
||||
let step = (total / 100).max(1); // throttle progress messages
|
||||
while let Some((ip, miner)) = stream.next().await {
|
||||
done += 1;
|
||||
if let Some(miner) = miner {
|
||||
let row = to_row(&*miner).await;
|
||||
if tx.send(ScanMsg::Row(row)).is_err() {
|
||||
return; // UI gone
|
||||
}
|
||||
}
|
||||
if done % step == 0 || done == total {
|
||||
let _ = tx.send(ScanMsg::Progress { done, total, ip: ip.to_string() });
|
||||
let thread_cancel = cancel.clone();
|
||||
let err_tx = tx.clone();
|
||||
let res = std::thread::Builder::new().name("asic-rs-scan".into()).spawn(move || {
|
||||
let rt = match tokio::runtime::Runtime::new() {
|
||||
Ok(rt) => rt,
|
||||
Err(e) => {
|
||||
let _ = tx.send(ScanMsg::Failed(format!("tokio runtime: {e}")));
|
||||
return;
|
||||
}
|
||||
};
|
||||
rt.block_on(async move {
|
||||
let mut factory = crate::credentials::configured_factory();
|
||||
for (ip, prefix) in &cidrs {
|
||||
factory = match factory.with_subnet(&format!("{ip}/{prefix}")) {
|
||||
Ok(f) => f,
|
||||
Err(e) => {
|
||||
let _ = tx.send(ScanMsg::Failed(format!("{ip}/{prefix}: {e}")));
|
||||
return;
|
||||
}
|
||||
};
|
||||
}
|
||||
// scan_stream_with_ip yields one item per probed address, so we
|
||||
// get accurate progress plus the responders.
|
||||
let mut stream = factory.scan_stream_with_ip();
|
||||
let mut done = 0usize;
|
||||
let step = (total / 100).max(1); // throttle progress messages
|
||||
while let Some((ip, miner)) = stream.next().await {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
return; // Stop / re-scan requested
|
||||
}
|
||||
let _ = tx.send(ScanMsg::Done(format!("{total} addresses")));
|
||||
});
|
||||
})
|
||||
.expect("spawn scan thread");
|
||||
rx
|
||||
done += 1;
|
||||
// Always report a row, even for an address that answered no
|
||||
// miner protocol: `MinerRow::offline` keeps it visible (and
|
||||
// distinct from a row the scan simply never reached).
|
||||
let row = match miner {
|
||||
Some(m) => to_row(&*m).await,
|
||||
None => MinerRow::offline(ip.to_string()),
|
||||
};
|
||||
if tx.send(ScanMsg::Row(row)).is_err() {
|
||||
return; // UI gone
|
||||
}
|
||||
if done % step == 0 || done == total {
|
||||
let _ = tx.send(ScanMsg::Progress { done, total, ip: ip.to_string() });
|
||||
}
|
||||
}
|
||||
let _ = tx.send(ScanMsg::Done(format!("{total} addresses")));
|
||||
});
|
||||
});
|
||||
if let Err(e) = res {
|
||||
let _ = err_tx.send(ScanMsg::Failed(format!("spawn scan thread: {e}")));
|
||||
}
|
||||
ScanHandle { rx, cancel }
|
||||
}
|
||||
|
||||
async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
@@ -331,11 +379,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()
|
||||
@@ -388,9 +436,24 @@ 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(),
|
||||
restart: miner.supports_restart(),
|
||||
pause: miner.supports_pause(),
|
||||
resume: miner.supports_resume(),
|
||||
power_limit: miner.supports_set_power_limit(),
|
||||
tuning: miner.supports_set_tuning_percent(),
|
||||
firmware_flash: miner.supports_upgrade_firmware(),
|
||||
};
|
||||
MinerRow {
|
||||
ip: data.ip.to_string(),
|
||||
selected: false,
|
||||
// A miner that responded to the scan is reachable.
|
||||
offline: false,
|
||||
caps,
|
||||
model,
|
||||
mac: data.mac.map(|m| m.to_string()).unwrap_or_default(),
|
||||
hostname: data.hostname.clone().unwrap_or_default(),
|
||||
@@ -406,7 +469,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),
|
||||
@@ -421,13 +484,352 @@ 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,
|
||||
}
|
||||
}
|
||||
|
||||
/// A one-shot configuration action applied to a set of miners from the
|
||||
/// right-click menu.
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum ConfigAction {
|
||||
FaultLight(bool),
|
||||
Restart,
|
||||
Pause,
|
||||
Resume,
|
||||
PowerLimit(f64), // watts
|
||||
TuningPercent(u8),
|
||||
}
|
||||
|
||||
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::Restart => "restart".into(),
|
||||
ConfigAction::Pause => "pause".into(),
|
||||
ConfigAction::Resume => "resume".into(),
|
||||
ConfigAction::PowerLimit(w) => format!("power limit {w:.0} W"),
|
||||
ConfigAction::TuningPercent(p) => format!("tuning {p}%"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Progress/results from a running config action.
|
||||
pub enum ActionMsg {
|
||||
Started { total: usize },
|
||||
Result { ip: String, ok: bool, detail: String },
|
||||
Done { ok: usize, total: usize },
|
||||
}
|
||||
|
||||
/// A running config action; `stop` cancels the remaining miners.
|
||||
pub struct ActionHandle {
|
||||
pub rx: Receiver<ActionMsg>,
|
||||
cancel: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl ActionHandle {
|
||||
pub fn stop(&self) {
|
||||
self.cancel.store(true, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
async fn apply_action(miner: &dyn Miner, action: &ConfigAction) -> Result<bool, String> {
|
||||
let result = match action {
|
||||
ConfigAction::FaultLight(on) => miner.set_fault_light(*on).await,
|
||||
ConfigAction::Restart => miner.restart().await,
|
||||
ConfigAction::Pause => miner.pause(None).await,
|
||||
ConfigAction::Resume => miner.resume(None).await,
|
||||
ConfigAction::PowerLimit(w) => miner.set_power_limit(Power::from_watts(*w)).await,
|
||||
ConfigAction::TuningPercent(p) => miner.set_tuning_percent(*p).await,
|
||||
};
|
||||
result.map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
/// Apply `action` to each miner in `ips` on a background thread: re-discover the
|
||||
/// miner (asic-rs `scan_miner`), run the setter, and report per-IP results. In
|
||||
/// fake-scan mode it reports simulated successes so the flow works offline.
|
||||
pub fn start_config_action(ips: Vec<String>, action: ConfigAction) -> 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-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;
|
||||
}
|
||||
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("config-action".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(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)) => match apply_action(&*miner, &action).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 }
|
||||
}
|
||||
|
||||
/// 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 {
|
||||
@@ -518,4 +920,272 @@ mod tests {
|
||||
covered.sort();
|
||||
assert_eq!(covered, ips);
|
||||
}
|
||||
|
||||
// ---- harness-driven additions (coverage) ----
|
||||
|
||||
#[test]
|
||||
fn parse_cidr_bare_and_rejections() {
|
||||
assert_eq!(parse_cidr("10.1.2.3"), Some((Ipv4Addr::new(10, 1, 2, 3), 32)));
|
||||
assert_eq!(parse_cidr("10.0.0.1/24"), Some((Ipv4Addr::new(10, 0, 0, 1), 24)));
|
||||
assert_eq!(parse_cidr("10.0.0.1/33"), None);
|
||||
assert_eq!(parse_cidr("10.0.0.1/abc"), None);
|
||||
assert_eq!(parse_cidr("bad/24"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prefix_mask_boundaries() {
|
||||
assert_eq!(prefix_mask(0), 0);
|
||||
assert_eq!(prefix_mask(24), 0xFFFF_FF00);
|
||||
assert_eq!(prefix_mask(32), u32::MAX);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_line_single_host_cidr_slash_32() {
|
||||
assert_eq!(parse_line("10.1.2.3/32").unwrap(), vec![Ipv4Addr::new(10, 1, 2, 3)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_line_empty_and_whitespace() {
|
||||
assert_eq!(parse_line("").unwrap(), Vec::<Ipv4Addr>::new());
|
||||
assert_eq!(parse_line(" ").unwrap(), Vec::<Ipv4Addr>::new());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_line_short_range_single_address_and_reversed() {
|
||||
assert_eq!(parse_line("10.253.1.5-5").unwrap(), vec![Ipv4Addr::new(10, 253, 1, 5)]);
|
||||
// short form whose end octet precedes the start is an inverted range.
|
||||
assert!(parse_line("10.253.1.200-50").is_err());
|
||||
assert!(parse_line("10.253.1.3-300").is_err()); // 300 is not a u8
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_targets_aggregate_cap_and_errors() {
|
||||
// Each /13 (524288) is under the cap; together they exceed 1,000,000.
|
||||
let over = parse_targets(&["10.0.0.0/13".into(), "11.0.0.0/13".into()]);
|
||||
assert!(over.is_err(), "aggregate over MAX_ADDRS must be rejected");
|
||||
// One bad line among good ones propagates.
|
||||
assert!(parse_targets(&["10.0.0.1".into(), "not-an-ip".into()]).is_err());
|
||||
// Empty input is an empty (Ok) set.
|
||||
assert!(parse_targets(&[]).unwrap().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn validate_ranges_empty_ok_and_bad() {
|
||||
assert!(validate_ranges(&[]).is_err()); // no addresses
|
||||
assert!(validate_ranges(&["10.0.0.0/30".into()]).is_ok());
|
||||
assert!(validate_ranges(&["garbage".into()]).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn targets_to_cidrs_splits_noncontiguous_runs() {
|
||||
let cidrs = targets_to_cidrs(&[Ipv4Addr::new(10, 0, 0, 5), Ipv4Addr::new(10, 0, 0, 10)]);
|
||||
assert_eq!(cidrs, vec![(Ipv4Addr::new(10, 0, 0, 5), 32), (Ipv4Addr::new(10, 0, 0, 10), 32)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn auto_secs_round_trip_and_defaults() {
|
||||
// config_path() reads $HOME; point it at a private temp dir. HOME is
|
||||
// process-global, so this stays one test and restores HOME afterward.
|
||||
let prev = std::env::var_os("HOME");
|
||||
let dir = std::env::temp_dir().join(format!("alkane-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_auto_secs(), DEFAULT_AUTO_SECS, "missing file -> default");
|
||||
save_auto_secs(150).unwrap();
|
||||
assert_eq!(load_auto_secs(), 150, "round-trip");
|
||||
std::fs::write(config_path(AUTO_FILE), "not-a-number").unwrap();
|
||||
assert_eq!(load_auto_secs(), DEFAULT_AUTO_SECS, "malformed -> default");
|
||||
std::fs::write(config_path(AUTO_FILE), " 42 \n").unwrap();
|
||||
assert_eq!(load_auto_secs(), 42, "whitespace tolerated");
|
||||
|
||||
match prev {
|
||||
Some(v) => std::env::set_var("HOME", v),
|
||||
None => std::env::remove_var("HOME"),
|
||||
}
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
// ---- microbenchmarks (perf-regression gates; run with --ignored) ----
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn bench_parse_line_near_max_addrs() {
|
||||
use std::time::Instant;
|
||||
let start = Ipv4Addr::new(10, 0, 0, 0);
|
||||
let end = Ipv4Addr::from(u32::from(start) + (MAX_ADDRS as u32 - 2));
|
||||
let line = format!("{start}-{end}");
|
||||
let iters = 5u32;
|
||||
let t = Instant::now();
|
||||
let mut sink = 0usize;
|
||||
for _ in 0..iters {
|
||||
sink += parse_line(&line).unwrap().len();
|
||||
}
|
||||
let per = t.elapsed() / iters;
|
||||
println!("bench_parse_line_near_max_addrs: {sink} addrs, {:?}/op", per);
|
||||
assert!(per.as_millis() < 400, "parse_line near MAX_ADDRS regressed: {per:?}/op");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn bench_parse_targets_many_ranges_near_cap() {
|
||||
use std::time::Instant;
|
||||
let mut lines = Vec::new();
|
||||
let mut total = 0u64;
|
||||
let mut b = 0u32;
|
||||
while total + 65536 < MAX_ADDRS && b < 200 {
|
||||
lines.push(format!("10.{b}.0.0/16"));
|
||||
total += 65536;
|
||||
b += 1;
|
||||
}
|
||||
let iters = 5u32;
|
||||
let t = Instant::now();
|
||||
let mut sink = 0usize;
|
||||
for _ in 0..iters {
|
||||
sink += parse_targets(&lines).unwrap().len();
|
||||
}
|
||||
let per = t.elapsed() / iters;
|
||||
println!("bench_parse_targets_many_ranges_near_cap: {} lines, {sink} addrs, {:?}/op", lines.len(), per);
|
||||
assert!(per.as_millis() < 800, "parse_targets regressed: {per:?}/op");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn bench_targets_to_cidrs_large_range() {
|
||||
use std::time::Instant;
|
||||
let ips = parse_line("10.0.0.1-10.7.255.254").unwrap(); // ~524k addrs, odd start
|
||||
let iters = 20u32;
|
||||
let t = Instant::now();
|
||||
let mut sink = 0usize;
|
||||
for _ in 0..iters {
|
||||
sink += targets_to_cidrs(&ips).len();
|
||||
}
|
||||
let per = t.elapsed() / iters;
|
||||
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: every probed IP produces a Row, including a synthetic
|
||||
// unreachable host that must come back as an offline row.
|
||||
{
|
||||
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,
|
||||
}
|
||||
}
|
||||
assert_eq!(rows.len(), total, "one Row per probed target, incl. the offline host");
|
||||
let offline = rows
|
||||
.iter()
|
||||
.find(|r| r.ip == "10.255.1.254")
|
||||
.expect("synthetic offline row must be emitted");
|
||||
assert!(offline.offline);
|
||||
assert_eq!(offline.status(), "offline");
|
||||
}
|
||||
|
||||
// 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);
|
||||
}
|
||||
}
|
||||
|
||||
+1454
-134
File diff suppressed because it is too large
Load Diff
+128
-1
@@ -10,7 +10,7 @@
|
||||
+pub use widgets::*;
|
||||
--- a/src/widgets.rs
|
||||
+++ b/src/widgets.rs
|
||||
@@ -0,0 +1,561 @@
|
||||
@@ -0,0 +1,688 @@
|
||||
+// 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);
|
||||
@@ -77,6 +81,7 @@
|
||||
+ pub fn wxbr_dvlc_get_selections(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
|
||||
+ 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_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;
|
||||
@@ -96,7 +101,16 @@
|
||||
+ pub fn wxbr_system_color(which: c_int, r: *mut u8, g: *mut u8, b: *mut u8);
|
||||
+ pub fn wxbr_set_bg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
+ pub fn wxbr_set_fg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
+ pub fn wxbr_choice(parent: *mut c_void, id: c_int) -> *mut c_void;
|
||||
+ pub fn wxbr_choice_append(win: *mut c_void, label: *const c_char);
|
||||
+ pub fn wxbr_choice_clear(win: *mut c_void);
|
||||
+ pub fn wxbr_choice_get_selection(win: *mut c_void) -> c_int;
|
||||
+ pub fn wxbr_choice_set_selection(win: *mut c_void, i: c_int);
|
||||
+ pub fn wxbr_media_button(parent: *mut c_void, id: c_int, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
|
||||
+ pub fn wxbr_bind_sys_colour(win: *mut c_void);
|
||||
+ pub fn wxbr_destroy(win: *mut c_void);
|
||||
+ pub fn wxbr_destroy_children(win: *mut c_void);
|
||||
+ pub fn wxbr_call_after(id: c_int);
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
@@ -129,6 +143,9 @@
|
||||
+ DvlcSelectionChanged,
|
||||
+ DvlcContextMenu,
|
||||
+ MenuItem,
|
||||
+ ChoiceChanged,
|
||||
+ SysColour,
|
||||
+ Deferred,
|
||||
+}
|
||||
+
|
||||
+impl WxEventKind {
|
||||
@@ -144,6 +161,9 @@
|
||||
+ 9 => WxEventKind::DvlcSelectionChanged,
|
||||
+ 10 => WxEventKind::DvlcContextMenu,
|
||||
+ 11 => WxEventKind::MenuItem,
|
||||
+ 12 => WxEventKind::ChoiceChanged,
|
||||
+ 13 => WxEventKind::SysColour,
|
||||
+ 14 => WxEventKind::Deferred,
|
||||
+ _ => return None,
|
||||
+ })
|
||||
+ }
|
||||
@@ -154,6 +174,13 @@
|
||||
+ unsafe { notsafe::wxbr_apply_zebra_css(r as c_int, g as c_int, b as c_int) }
|
||||
+}
|
||||
+
|
||||
+/// Schedule a deferred action: a `Deferred` event carrying `id` is delivered
|
||||
+/// from the event loop after the current event finishes. Use this to rebuild or
|
||||
+/// destroy a control from outside its own event handler.
|
||||
+pub fn call_after(id: i32) {
|
||||
+ unsafe { notsafe::wxbr_call_after(id as c_int) }
|
||||
+}
|
||||
+
|
||||
+/// Open a URL in the system default browser. Returns true on success.
|
||||
+pub fn launch_browser(url: &str) -> bool {
|
||||
+ let c = CString::new(url).unwrap_or_default();
|
||||
@@ -229,6 +256,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) }
|
||||
+ }
|
||||
@@ -305,6 +340,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) })
|
||||
+ }
|
||||
@@ -384,6 +428,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 {
|
||||
@@ -395,6 +454,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) }
|
||||
+ }
|
||||
@@ -472,6 +539,15 @@
|
||||
+ unsafe { notsafe::wxbr_dvlc_set_alt_row_color(self.0, r as c_int, g as c_int, b as c_int) }
|
||||
+ }
|
||||
+
|
||||
+ /// Set a row's text colour (e.g. by miner status). Pass `None` to clear it.
|
||||
+ pub fn dvlc_set_row_color(&self, row: usize, 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_row_color(self.0, row, r, g, b) }
|
||||
+ }
|
||||
+
|
||||
+ // ---- rearrangeable check-list ----
|
||||
+
|
||||
+ /// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
|
||||
@@ -566,9 +642,60 @@
|
||||
+ unsafe { notsafe::wxbr_set_fg(self.0, r as c_int, g as c_int, b as c_int) }
|
||||
+ }
|
||||
+
|
||||
+ // ---- choice (dropdown) ----
|
||||
+
|
||||
+ /// Create a dropdown; selection changes emit `ChoiceChanged` with this id.
|
||||
+ pub fn choice(parent: Widget, id: i32) -> Widget {
|
||||
+ Widget(unsafe { notsafe::wxbr_choice(parent.0, id) })
|
||||
+ }
|
||||
+
|
||||
+ pub fn choice_append(&self, label: &str) {
|
||||
+ let c = CString::new(label).unwrap_or_default();
|
||||
+ unsafe { notsafe::wxbr_choice_append(self.0, c.as_ptr()) }
|
||||
+ }
|
||||
+
|
||||
+ pub fn choice_clear(&self) {
|
||||
+ unsafe { notsafe::wxbr_choice_clear(self.0) }
|
||||
+ }
|
||||
+
|
||||
+ pub fn choice_get_selection(&self) -> i32 {
|
||||
+ unsafe { notsafe::wxbr_choice_get_selection(self.0) }
|
||||
+ }
|
||||
+
|
||||
+ pub fn choice_set_selection(&self, i: i32) {
|
||||
+ unsafe { notsafe::wxbr_choice_set_selection(self.0, i) }
|
||||
+ }
|
||||
+
|
||||
+ // ---- media (icon) button ----
|
||||
+
|
||||
+ /// A coloured icon button: `kind` 0=play, 1=pause, 2=stop. Clicks emit
|
||||
+ /// `ButtonClicked` with `id`, like a normal button.
|
||||
+ pub fn media_button(parent: Widget, id: i32, kind: i32, color: (u8, u8, u8)) -> Widget {
|
||||
+ Widget(unsafe {
|
||||
+ notsafe::wxbr_media_button(
|
||||
+ parent.0,
|
||||
+ id,
|
||||
+ kind,
|
||||
+ color.0 as c_int,
|
||||
+ color.1 as c_int,
|
||||
+ color.2 as c_int,
|
||||
+ )
|
||||
+ })
|
||||
+ }
|
||||
+
|
||||
+ /// Listen for OS light/dark theme changes on this window (emits `SysColour`).
|
||||
+ pub fn bind_sys_colour(&self) {
|
||||
+ unsafe { notsafe::wxbr_bind_sys_colour(self.0) }
|
||||
+ }
|
||||
+
|
||||
+ /// Deferred destruction (safe from event handlers); used to rebuild
|
||||
+ /// the table when its column set changes.
|
||||
+ pub fn destroy(&self) {
|
||||
+ unsafe { notsafe::wxbr_destroy(self.0) }
|
||||
+ }
|
||||
+
|
||||
+ /// Destroy this window's children (to rebuild dynamic panel contents).
|
||||
+ pub fn destroy_children(&self) {
|
||||
+ unsafe { notsafe::wxbr_destroy_children(self.0) }
|
||||
+ }
|
||||
+}
|
||||
|
||||
+359
-65
@@ -1,6 +1,6 @@
|
||||
--- a/cpp_src/widgets_bridge.cpp
|
||||
+++ b/cpp_src/widgets_bridge.cpp
|
||||
@@ -0,0 +1,598 @@
|
||||
@@ -0,0 +1,892 @@
|
||||
+// 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).
|
||||
@@ -23,10 +23,18 @@
|
||||
+#include <wx/app.h>
|
||||
+#include <wx/rearrangectrl.h>
|
||||
+#include <wx/menu.h>
|
||||
+#ifdef __WXGTK__
|
||||
+#include <gtk/gtk.h>
|
||||
+#endif
|
||||
+#include <wx/choice.h>
|
||||
+#include <wx/bmpbuttn.h>
|
||||
+#include <wx/bitmap.h>
|
||||
+#include <wx/image.h>
|
||||
+#include <wx/dcmemory.h>
|
||||
+#include <wx/dcgraph.h>
|
||||
+#include <wx/graphics.h>
|
||||
+#include <wx/wrapsizer.h>
|
||||
+#include <wx/filedlg.h>
|
||||
+#include <cstring>
|
||||
+#include <cstdio>
|
||||
+#include <vector>
|
||||
+
|
||||
+typedef void (*WxWidgetEventFn)(int kind, long p1, long p2);
|
||||
+static WxWidgetEventFn g_widget_event = nullptr;
|
||||
@@ -43,6 +51,123 @@
|
||||
+ WxEV_DVLC_SELECTION_CHANGED = 9,
|
||||
+ WxEV_DVLC_CONTEXT_MENU = 10,
|
||||
+ WxEV_MENU_ITEM = 11,
|
||||
+ WxEV_CHOICE_CHANGED = 12,
|
||||
+ WxEV_SYS_COLOUR = 13,
|
||||
+ WxEV_DEFERRED = 14,
|
||||
+};
|
||||
+
|
||||
+// 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).
|
||||
+class AttrListStore : public wxDataViewListStore {
|
||||
+ public:
|
||||
+ std::vector<wxColour> row_fg;
|
||||
+ bool GetAttrByRow(unsigned int row, unsigned int col,
|
||||
+ wxDataViewItemAttr& attr) const override {
|
||||
+ (void)col;
|
||||
+ if (row < row_fg.size() && row_fg[row].IsOk()) {
|
||||
+ attr.SetColour(row_fg[row]);
|
||||
+ return true;
|
||||
+ }
|
||||
+ return false;
|
||||
+ }
|
||||
+};
|
||||
+
|
||||
+// 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" {
|
||||
@@ -61,6 +186,14 @@
|
||||
+ 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) {
|
||||
+ return (void*)new wxWrapSizer(vertical ? wxVERTICAL : wxHORIZONTAL);
|
||||
+}
|
||||
+
|
||||
+// flag bits (must match Rust sizer_flags):
|
||||
+// 1 = EXPAND, 2 = ALIGN_CENTRE_VERTICAL, 4 = wxALL, 8 = wxTOP,
|
||||
+// 16 = wxBOTTOM, 32 = wxLEFT, 64 = wxRIGHT
|
||||
@@ -169,6 +302,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) {
|
||||
@@ -267,65 +411,111 @@
|
||||
+ ((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) {
|
||||
+ return static_cast<AttrListStore*>(((wxDataViewCtrl*)win)->GetModel());
|
||||
+}
|
||||
+
|
||||
+void* wxbr_dvlc(void* parent) {
|
||||
+ // Multi-select (ctrl/shift-click) + row lines. Selection replaces the old
|
||||
+ // checkbox column.
|
||||
+ wxDataViewListCtrl* lc =
|
||||
+ new wxDataViewListCtrl((wxWindow*)parent, wxID_ANY, wxDefaultPosition,
|
||||
+ wxSize(-1, -1), wxDV_ROW_LINES | wxDV_MULTIPLE);
|
||||
+ lc->Bind(wxEVT_DATAVIEW_SELECTION_CHANGED, [](wxDataViewEvent&) {
|
||||
+ // checkbox column. A custom AttrListStore backs it so rows can be coloured by
|
||||
+ // 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);
|
||||
+ AttrListStore* store = new AttrListStore();
|
||||
+ dv->AssociateModel(store);
|
||||
+ store->DecRef(); // the control owns a reference now
|
||||
+ dv->Bind(wxEVT_DATAVIEW_SELECTION_CHANGED, [](wxDataViewEvent&) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_SELECTION_CHANGED, 0, 0);
|
||||
+ });
|
||||
+ lc->Bind(wxEVT_DATAVIEW_ITEM_CONTEXT_MENU, [](wxDataViewEvent&) {
|
||||
+ dv->Bind(wxEVT_DATAVIEW_ITEM_CONTEXT_MENU, [](wxDataViewEvent&) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_CONTEXT_MENU, 0, 0);
|
||||
+ });
|
||||
+ lc->Bind(wxEVT_DATAVIEW_ITEM_VALUE_CHANGED, [](wxDataViewEvent& e) {
|
||||
+ dv->Bind(wxEVT_DATAVIEW_ITEM_VALUE_CHANGED, [](wxDataViewEvent& e) {
|
||||
+ if (g_widget_event) {
|
||||
+ wxDataViewListCtrl* lc =
|
||||
+ dynamic_cast<wxDataViewListCtrl*>((wxWindow*)e.GetEventObject());
|
||||
+ if (!lc) return;
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
+ if (!dv) return;
|
||||
+ wxDataViewItem item = e.GetItem();
|
||||
+ if (!item.IsOk()) return;
|
||||
+ int row = lc->GetStore()->GetRow(item);
|
||||
+ int row = ((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
+ g_widget_event(WxEV_DVLC_VALUE_CHANGED, row, (long)e.GetColumn());
|
||||
+ }
|
||||
+ });
|
||||
+ lc->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_CLICK, [](wxDataViewEvent& e) {
|
||||
+ dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_CLICK, [](wxDataViewEvent& e) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_CLICK, (long)e.GetColumn(), 0);
|
||||
+ });
|
||||
+ lc->Bind(wxEVT_DATAVIEW_COLUMN_REORDERED, [](wxDataViewEvent&) {
|
||||
+ dv->Bind(wxEVT_DATAVIEW_COLUMN_REORDERED, [](wxDataViewEvent&) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DVLC_REORDERED, 0, 0);
|
||||
+ });
|
||||
+ // Row activation (double-click / Enter): report the row + column so the app
|
||||
+ // can, e.g., open the miner's IP in a browser.
|
||||
+ lc->Bind(wxEVT_DATAVIEW_ITEM_ACTIVATED, [](wxDataViewEvent& e) {
|
||||
+ dv->Bind(wxEVT_DATAVIEW_ITEM_ACTIVATED, [](wxDataViewEvent& e) {
|
||||
+ if (g_widget_event) {
|
||||
+ wxDataViewListCtrl* lc =
|
||||
+ dynamic_cast<wxDataViewListCtrl*>((wxWindow*)e.GetEventObject());
|
||||
+ if (!lc) return;
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
+ if (!dv) return;
|
||||
+ wxDataViewItem item = e.GetItem();
|
||||
+ if (!item.IsOk()) return;
|
||||
+ int row = lc->GetStore()->GetRow(item);
|
||||
+ int row = ((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
+ g_widget_event(WxEV_DVLC_ACTIVATED, row, (long)e.GetColumn());
|
||||
+ }
|
||||
+ });
|
||||
+ return (void*)lc;
|
||||
+ return (void*)dv;
|
||||
+}
|
||||
+
|
||||
+void wxbr_dvlc_append_text_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;
|
||||
+ ((wxDataViewListCtrl*)win)
|
||||
+ ->AppendTextColumn(wxString::FromUTF8(title), wxDATAVIEW_CELL_INERT,
|
||||
+ width, wxALIGN_NOT, flags);
|
||||
+ unsigned col = dv->GetColumnCount(); // next model column index
|
||||
+ dvlc_store(win)->AppendColumn("string");
|
||||
+ dv->AppendTextColumn(wxString::FromUTF8(title), col, wxDATAVIEW_CELL_INERT,
|
||||
+ 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) {
|
||||
+ ((wxDataViewListCtrl*)win)
|
||||
+ ->AppendToggleColumn(wxT(""), wxDATAVIEW_CELL_ACTIVATABLE, width,
|
||||
+ wxALIGN_CENTRE, 0);
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ unsigned col = dv->GetColumnCount();
|
||||
+ dvlc_store(win)->AppendColumn("bool");
|
||||
+ dv->AppendToggleColumn(wxT(""), col, wxDATAVIEW_CELL_ACTIVATABLE, width,
|
||||
+ wxALIGN_CENTRE, 0);
|
||||
+}
|
||||
+
|
||||
+void wxbr_dvlc_append_row(void* win, int nvals, const char** vals) {
|
||||
@@ -334,28 +524,45 @@
|
||||
+ for (int i = 0; i < nvals; i++) {
|
||||
+ values.push_back(wxVariant(vals[i] ? wxString::FromUTF8(vals[i]) : wxString()));
|
||||
+ }
|
||||
+ ((wxDataViewListCtrl*)win)->AppendItem(values);
|
||||
+ AttrListStore* store = dvlc_store(win);
|
||||
+ store->AppendItem(values);
|
||||
+ store->row_fg.push_back(wxColour()); // no per-row colour until set
|
||||
+}
|
||||
+
|
||||
+void wxbr_dvlc_delete_row(void* win, unsigned row) {
|
||||
+ ((wxDataViewListCtrl*)win)->DeleteItem(row);
|
||||
+ AttrListStore* store = dvlc_store(win);
|
||||
+ store->DeleteItem(row);
|
||||
+ if (row < store->row_fg.size()) store->row_fg.erase(store->row_fg.begin() + row);
|
||||
+}
|
||||
+
|
||||
+void wxbr_dvlc_clear(void* win) { ((wxDataViewListCtrl*)win)->DeleteAllItems(); }
|
||||
+void wxbr_dvlc_clear(void* win) {
|
||||
+ AttrListStore* store = dvlc_store(win);
|
||||
+ store->DeleteAllItems();
|
||||
+ store->row_fg.clear();
|
||||
+}
|
||||
+
|
||||
+// Set (or clear, when r<0) a row's text colour; used to paint rows by status.
|
||||
+void wxbr_dvlc_set_row_color(void* win, unsigned row, int r, int g, int b) {
|
||||
+ AttrListStore* store = dvlc_store(win);
|
||||
+ if (row >= store->row_fg.size()) return;
|
||||
+ store->row_fg[row] = (r < 0) ? wxColour() : wxColour(r, g, b);
|
||||
+ store->RowChanged(row);
|
||||
+}
|
||||
+
|
||||
+int wxbr_dvlc_row_count(void* win) {
|
||||
+ return (int)((wxDataViewListCtrl*)win)->GetStore()->GetItemCount();
|
||||
+ return (int)dvlc_store(win)->GetItemCount();
|
||||
+}
|
||||
+
|
||||
+void wxbr_dvlc_set_cell(void* win, unsigned row, unsigned col, const char* value) {
|
||||
+ ((wxDataViewListCtrl*)win)
|
||||
+ ->SetValue(wxVariant(wxString::FromUTF8(value)), row, col);
|
||||
+ AttrListStore* store = dvlc_store(win);
|
||||
+ store->SetValueByRow(wxVariant(wxString::FromUTF8(value)), row, col);
|
||||
+ store->RowValueChanged(row, col);
|
||||
+}
|
||||
+
|
||||
+int wxbr_dvlc_get_cell(void* win, unsigned row, unsigned col, char* buf, int cap) {
|
||||
+ wxDataViewListCtrl* lc = (wxDataViewListCtrl*)win;
|
||||
+ wxDataViewListStore* store = lc->GetStore();
|
||||
+ if (row >= store->GetItemCount() || col >= lc->GetColumnCount())
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ AttrListStore* store = dvlc_store(win);
|
||||
+ if (row >= store->GetItemCount() || (int)col >= (int)dv->GetColumnCount())
|
||||
+ return 0;
|
||||
+ wxVariant v;
|
||||
+ store->GetValueByRow(v, row, col);
|
||||
@@ -369,7 +576,7 @@
|
||||
+}
|
||||
+
|
||||
+int wxbr_dvlc_col_count(void* win) {
|
||||
+ return (int)((wxDataViewListCtrl*)win)->GetColumnCount();
|
||||
+ return (int)((wxDataViewCtrl*)win)->GetColumnCount();
|
||||
+}
|
||||
+
|
||||
+// Update a column's header text in place (creation index) without recreating
|
||||
@@ -409,58 +616,51 @@
|
||||
+}
|
||||
+
|
||||
+long wxbr_dvlc_selected_row(void* win) {
|
||||
+ return (long)((wxDataViewListCtrl*)win)->GetSelectedRow();
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ wxDataViewItem it = dv->GetSelection();
|
||||
+ if (!it.IsOk()) return -1;
|
||||
+ return (long)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(it);
|
||||
+}
|
||||
+
|
||||
+// Fill `buf` with the selected row indices (multi-select); returns the count.
|
||||
+int wxbr_dvlc_get_selections(void* win, int* buf, int cap) {
|
||||
+ wxDataViewListCtrl* lc = (wxDataViewListCtrl*)win;
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
+ wxDataViewItemArray items;
|
||||
+ int n = (int)lc->GetSelections(items);
|
||||
+ int n = (int)dv->GetSelections(items);
|
||||
+ int out = 0;
|
||||
+ for (int i = 0; i < n && out < cap; i++) {
|
||||
+ int row = lc->GetStore()->GetRow(items[i]);
|
||||
+ int row = m->GetRow(items[i]);
|
||||
+ if (row >= 0) buf[out++] = row;
|
||||
+ }
|
||||
+ return out;
|
||||
+}
|
||||
+
|
||||
+void wxbr_dvlc_select_rows(void* win, const int* rows, int n) {
|
||||
+ wxDataViewListCtrl* lc = (wxDataViewListCtrl*)win;
|
||||
+ lc->UnselectAll();
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
+ dv->UnselectAll();
|
||||
+ for (int i = 0; i < n; i++) {
|
||||
+ if (rows[i] >= 0) lc->SelectRow((unsigned)rows[i]);
|
||||
+ if (rows[i] >= 0) dv->Select(m->GetItem((unsigned)rows[i]));
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+// Retained for ABI; per-row colour is handled by the store (GetAttrByRow) and
|
||||
+// the native selection highlight, so these row-background hacks are no-ops now
|
||||
+// (they fought the selection highlight on GTK 3.3).
|
||||
+void wxbr_dvlc_set_alt_row_color(void* win, int r, int g, int b) {
|
||||
+ // No-op on GTK (native dataview lacks it); see wxbr_apply_zebra_css.
|
||||
+ ((wxDataViewListCtrl*)win)->SetAlternateRowColour(wxColour(r, g, b));
|
||||
+ (void)win; (void)r; (void)g; (void)b;
|
||||
+}
|
||||
+
|
||||
+// GTK's native dataview does not implement SetAlternateRowColour, so apply
|
||||
+// zebra striping app-wide via a CSS provider (GTK 3.20+ supports :nth-child on
|
||||
+// treeview rows). No-op off GTK.
|
||||
+void wxbr_apply_zebra_css(int r, int g, int b) {
|
||||
+#ifdef __WXGTK__
|
||||
+ GtkCssProvider* p = gtk_css_provider_new();
|
||||
+ char css[192];
|
||||
+ std::snprintf(css, sizeof(css),
|
||||
+ "treeview.view:nth-child(even){background-color:rgb(%d,%d,%d);}",
|
||||
+ r, g, b);
|
||||
+ gtk_css_provider_load_from_data(p, css, -1, NULL);
|
||||
+ gtk_style_context_add_provider_for_screen(
|
||||
+ gdk_screen_get_default(), GTK_STYLE_PROVIDER(p),
|
||||
+ GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
+ g_object_unref(p);
|
||||
+#else
|
||||
+ (void)r; (void)g; (void)b;
|
||||
+#endif
|
||||
+}
|
||||
+
|
||||
+void wxbr_dvlc_select_row(void* win, long row) {
|
||||
+ if (row < 0) return;
|
||||
+ ((wxDataViewListCtrl*)win)->SelectRow((unsigned)row);
|
||||
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
+ wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
+ dv->Select(m->GetItem((unsigned)row));
|
||||
+}
|
||||
+
|
||||
+// ---- timer -----------------------------------------------------------------
|
||||
@@ -594,8 +794,102 @@
|
||||
+ delete m;
|
||||
+}
|
||||
+
|
||||
+// ---- choice (dropdown) ------------------------------------------------------
|
||||
+
|
||||
+void* wxbr_choice(void* parent, int id) {
|
||||
+ wxChoice* c = new wxChoice((wxWindow*)parent, id);
|
||||
+ c->Bind(wxEVT_CHOICE, [id](wxCommandEvent& e) {
|
||||
+ if (g_widget_event)
|
||||
+ g_widget_event(WxEV_CHOICE_CHANGED, id, (long)e.GetSelection());
|
||||
+ });
|
||||
+ return (void*)c;
|
||||
+}
|
||||
+
|
||||
+void wxbr_choice_append(void* win, const char* label) {
|
||||
+ ((wxChoice*)win)->Append(wxString::FromUTF8(label));
|
||||
+}
|
||||
+
|
||||
+void wxbr_choice_clear(void* win) { ((wxChoice*)win)->Clear(); }
|
||||
+
|
||||
+int wxbr_choice_get_selection(void* win) {
|
||||
+ return ((wxChoice*)win)->GetSelection();
|
||||
+}
|
||||
+
|
||||
+void wxbr_choice_set_selection(void* win, int i) {
|
||||
+ ((wxChoice*)win)->SetSelection(i);
|
||||
+}
|
||||
+
|
||||
+// ---- media (icon) button: play / pause / stop -------------------------------
|
||||
+
|
||||
+// kind: 0=play (triangle), 1=pause (two bars), 2=stop (square). Drawn in the
|
||||
+// given colour on a transparent bitmap so it reads as a coloured glyph on the
|
||||
+// native button. Emits WxEV_BUTTON_CLICKED with `id`, like a normal button.
|
||||
+void* wxbr_media_button(void* parent, int id, int kind, int r, int g, int b) {
|
||||
+ const int sz = 20;
|
||||
+ wxImage img(sz, sz);
|
||||
+ img.InitAlpha();
|
||||
+ unsigned char* a = img.GetAlpha();
|
||||
+ if (a) memset(a, 0, (size_t)sz * sz); // fully transparent
|
||||
+ wxBitmap bmp(img);
|
||||
+ {
|
||||
+ wxMemoryDC mdc(bmp);
|
||||
+ wxGraphicsContext* gc = wxGraphicsContext::Create(mdc);
|
||||
+ if (gc) {
|
||||
+ gc->SetAntialiasMode(wxANTIALIAS_DEFAULT);
|
||||
+ wxColour col(r, g, b);
|
||||
+ gc->SetBrush(wxBrush(col));
|
||||
+ gc->SetPen(wxPen(col, 1.0));
|
||||
+ if (kind == 0) {
|
||||
+ wxGraphicsPath p = gc->CreatePath();
|
||||
+ p.MoveToPoint(5, 4);
|
||||
+ p.AddLineToPoint(16, 10);
|
||||
+ p.AddLineToPoint(5, 16);
|
||||
+ p.CloseSubpath();
|
||||
+ gc->FillPath(p);
|
||||
+ } else if (kind == 1) {
|
||||
+ gc->DrawRectangle(5, 4, 3.5, 12);
|
||||
+ gc->DrawRectangle(11.5, 4, 3.5, 12);
|
||||
+ } else {
|
||||
+ gc->DrawRectangle(5, 5, 10, 10);
|
||||
+ }
|
||||
+ delete gc;
|
||||
+ }
|
||||
+ }
|
||||
+ wxBitmapButton* btn = new wxBitmapButton((wxWindow*)parent, id, bmp);
|
||||
+ btn->Bind(wxEVT_BUTTON, [id](wxCommandEvent&) {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_BUTTON_CLICKED, id, 0);
|
||||
+ });
|
||||
+ return (void*)btn;
|
||||
+}
|
||||
+
|
||||
+// ---- live theme changes -----------------------------------------------------
|
||||
+
|
||||
+// Emit WxEV_SYS_COLOUR when the OS light/dark theme changes so the app can
|
||||
+// repaint custom-coloured widgets (KPI cards, table rows).
|
||||
+void wxbr_bind_sys_colour(void* win) {
|
||||
+ ((wxWindow*)win)->Bind(wxEVT_SYS_COLOUR_CHANGED, [](wxSysColourChangedEvent& e) {
|
||||
+ e.Skip();
|
||||
+ if (g_widget_event) g_widget_event(WxEV_SYS_COLOUR, 0, 0);
|
||||
+ });
|
||||
+}
|
||||
+
|
||||
+// Run a deferred action after the current event finishes unwinding: emits
|
||||
+// WxEV_DEFERRED with `id` from the main event loop. Used to rebuild a control
|
||||
+// from outside its own event handler (destroying a widget mid-event is unsafe).
|
||||
+void wxbr_call_after(int id) {
|
||||
+ if (wxTheApp) {
|
||||
+ wxTheApp->CallAfter([id]() {
|
||||
+ if (g_widget_event) g_widget_event(WxEV_DEFERRED, id, 0);
|
||||
+ });
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+// ---- deferred destroy (safe from event handlers) ----------------------------
|
||||
+
|
||||
+void wxbr_destroy(void* win) { ((wxWindow*)win)->Destroy(); }
|
||||
+
|
||||
+// Destroy a window's children immediately (used to rebuild a panel's dynamic
|
||||
+// contents in place, e.g. the filter dialog's per-column controls).
|
||||
+void wxbr_destroy_children(void* win) { ((wxWindow*)win)->DestroyChildren(); }
|
||||
+
|
||||
+} // extern "C"
|
||||
|
||||
+358
-64
@@ -20,10 +20,18 @@
|
||||
#include <wx/app.h>
|
||||
#include <wx/rearrangectrl.h>
|
||||
#include <wx/menu.h>
|
||||
#ifdef __WXGTK__
|
||||
#include <gtk/gtk.h>
|
||||
#endif
|
||||
#include <wx/choice.h>
|
||||
#include <wx/bmpbuttn.h>
|
||||
#include <wx/bitmap.h>
|
||||
#include <wx/image.h>
|
||||
#include <wx/dcmemory.h>
|
||||
#include <wx/dcgraph.h>
|
||||
#include <wx/graphics.h>
|
||||
#include <wx/wrapsizer.h>
|
||||
#include <wx/filedlg.h>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
|
||||
typedef void (*WxWidgetEventFn)(int kind, long p1, long p2);
|
||||
static WxWidgetEventFn g_widget_event = nullptr;
|
||||
@@ -40,6 +48,123 @@ enum WxWidgetEventKind {
|
||||
WxEV_DVLC_SELECTION_CHANGED = 9,
|
||||
WxEV_DVLC_CONTEXT_MENU = 10,
|
||||
WxEV_MENU_ITEM = 11,
|
||||
WxEV_CHOICE_CHANGED = 12,
|
||||
WxEV_SYS_COLOUR = 13,
|
||||
WxEV_DEFERRED = 14,
|
||||
};
|
||||
|
||||
// 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).
|
||||
class AttrListStore : public wxDataViewListStore {
|
||||
public:
|
||||
std::vector<wxColour> row_fg;
|
||||
bool GetAttrByRow(unsigned int row, unsigned int col,
|
||||
wxDataViewItemAttr& attr) const override {
|
||||
(void)col;
|
||||
if (row < row_fg.size() && row_fg[row].IsOk()) {
|
||||
attr.SetColour(row_fg[row]);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
// 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" {
|
||||
@@ -58,6 +183,14 @@ 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) {
|
||||
return (void*)new wxWrapSizer(vertical ? wxVERTICAL : wxHORIZONTAL);
|
||||
}
|
||||
|
||||
// flag bits (must match Rust sizer_flags):
|
||||
// 1 = EXPAND, 2 = ALIGN_CENTRE_VERTICAL, 4 = wxALL, 8 = wxTOP,
|
||||
// 16 = wxBOTTOM, 32 = wxLEFT, 64 = wxRIGHT
|
||||
@@ -166,6 +299,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) {
|
||||
@@ -264,65 +408,111 @@ 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) {
|
||||
return static_cast<AttrListStore*>(((wxDataViewCtrl*)win)->GetModel());
|
||||
}
|
||||
|
||||
void* wxbr_dvlc(void* parent) {
|
||||
// Multi-select (ctrl/shift-click) + row lines. Selection replaces the old
|
||||
// checkbox column.
|
||||
wxDataViewListCtrl* lc =
|
||||
new wxDataViewListCtrl((wxWindow*)parent, wxID_ANY, wxDefaultPosition,
|
||||
wxSize(-1, -1), wxDV_ROW_LINES | wxDV_MULTIPLE);
|
||||
lc->Bind(wxEVT_DATAVIEW_SELECTION_CHANGED, [](wxDataViewEvent&) {
|
||||
// checkbox column. A custom AttrListStore backs it so rows can be coloured by
|
||||
// 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);
|
||||
AttrListStore* store = new AttrListStore();
|
||||
dv->AssociateModel(store);
|
||||
store->DecRef(); // the control owns a reference now
|
||||
dv->Bind(wxEVT_DATAVIEW_SELECTION_CHANGED, [](wxDataViewEvent&) {
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_SELECTION_CHANGED, 0, 0);
|
||||
});
|
||||
lc->Bind(wxEVT_DATAVIEW_ITEM_CONTEXT_MENU, [](wxDataViewEvent&) {
|
||||
dv->Bind(wxEVT_DATAVIEW_ITEM_CONTEXT_MENU, [](wxDataViewEvent&) {
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_CONTEXT_MENU, 0, 0);
|
||||
});
|
||||
lc->Bind(wxEVT_DATAVIEW_ITEM_VALUE_CHANGED, [](wxDataViewEvent& e) {
|
||||
dv->Bind(wxEVT_DATAVIEW_ITEM_VALUE_CHANGED, [](wxDataViewEvent& e) {
|
||||
if (g_widget_event) {
|
||||
wxDataViewListCtrl* lc =
|
||||
dynamic_cast<wxDataViewListCtrl*>((wxWindow*)e.GetEventObject());
|
||||
if (!lc) return;
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
if (!dv) return;
|
||||
wxDataViewItem item = e.GetItem();
|
||||
if (!item.IsOk()) return;
|
||||
int row = lc->GetStore()->GetRow(item);
|
||||
int row = ((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
g_widget_event(WxEV_DVLC_VALUE_CHANGED, row, (long)e.GetColumn());
|
||||
}
|
||||
});
|
||||
lc->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_CLICK, [](wxDataViewEvent& e) {
|
||||
dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_CLICK, [](wxDataViewEvent& e) {
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_CLICK, (long)e.GetColumn(), 0);
|
||||
});
|
||||
lc->Bind(wxEVT_DATAVIEW_COLUMN_REORDERED, [](wxDataViewEvent&) {
|
||||
dv->Bind(wxEVT_DATAVIEW_COLUMN_REORDERED, [](wxDataViewEvent&) {
|
||||
if (g_widget_event) g_widget_event(WxEV_DVLC_REORDERED, 0, 0);
|
||||
});
|
||||
// Row activation (double-click / Enter): report the row + column so the app
|
||||
// can, e.g., open the miner's IP in a browser.
|
||||
lc->Bind(wxEVT_DATAVIEW_ITEM_ACTIVATED, [](wxDataViewEvent& e) {
|
||||
dv->Bind(wxEVT_DATAVIEW_ITEM_ACTIVATED, [](wxDataViewEvent& e) {
|
||||
if (g_widget_event) {
|
||||
wxDataViewListCtrl* lc =
|
||||
dynamic_cast<wxDataViewListCtrl*>((wxWindow*)e.GetEventObject());
|
||||
if (!lc) return;
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
|
||||
if (!dv) return;
|
||||
wxDataViewItem item = e.GetItem();
|
||||
if (!item.IsOk()) return;
|
||||
int row = lc->GetStore()->GetRow(item);
|
||||
int row = ((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
|
||||
g_widget_event(WxEV_DVLC_ACTIVATED, row, (long)e.GetColumn());
|
||||
}
|
||||
});
|
||||
return (void*)lc;
|
||||
return (void*)dv;
|
||||
}
|
||||
|
||||
void wxbr_dvlc_append_text_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;
|
||||
((wxDataViewListCtrl*)win)
|
||||
->AppendTextColumn(wxString::FromUTF8(title), wxDATAVIEW_CELL_INERT,
|
||||
width, wxALIGN_NOT, flags);
|
||||
unsigned col = dv->GetColumnCount(); // next model column index
|
||||
dvlc_store(win)->AppendColumn("string");
|
||||
dv->AppendTextColumn(wxString::FromUTF8(title), col, wxDATAVIEW_CELL_INERT,
|
||||
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) {
|
||||
((wxDataViewListCtrl*)win)
|
||||
->AppendToggleColumn(wxT(""), wxDATAVIEW_CELL_ACTIVATABLE, width,
|
||||
wxALIGN_CENTRE, 0);
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
unsigned col = dv->GetColumnCount();
|
||||
dvlc_store(win)->AppendColumn("bool");
|
||||
dv->AppendToggleColumn(wxT(""), col, wxDATAVIEW_CELL_ACTIVATABLE, width,
|
||||
wxALIGN_CENTRE, 0);
|
||||
}
|
||||
|
||||
void wxbr_dvlc_append_row(void* win, int nvals, const char** vals) {
|
||||
@@ -331,28 +521,45 @@ void wxbr_dvlc_append_row(void* win, int nvals, const char** vals) {
|
||||
for (int i = 0; i < nvals; i++) {
|
||||
values.push_back(wxVariant(vals[i] ? wxString::FromUTF8(vals[i]) : wxString()));
|
||||
}
|
||||
((wxDataViewListCtrl*)win)->AppendItem(values);
|
||||
AttrListStore* store = dvlc_store(win);
|
||||
store->AppendItem(values);
|
||||
store->row_fg.push_back(wxColour()); // no per-row colour until set
|
||||
}
|
||||
|
||||
void wxbr_dvlc_delete_row(void* win, unsigned row) {
|
||||
((wxDataViewListCtrl*)win)->DeleteItem(row);
|
||||
AttrListStore* store = dvlc_store(win);
|
||||
store->DeleteItem(row);
|
||||
if (row < store->row_fg.size()) store->row_fg.erase(store->row_fg.begin() + row);
|
||||
}
|
||||
|
||||
void wxbr_dvlc_clear(void* win) { ((wxDataViewListCtrl*)win)->DeleteAllItems(); }
|
||||
void wxbr_dvlc_clear(void* win) {
|
||||
AttrListStore* store = dvlc_store(win);
|
||||
store->DeleteAllItems();
|
||||
store->row_fg.clear();
|
||||
}
|
||||
|
||||
// Set (or clear, when r<0) a row's text colour; used to paint rows by status.
|
||||
void wxbr_dvlc_set_row_color(void* win, unsigned row, int r, int g, int b) {
|
||||
AttrListStore* store = dvlc_store(win);
|
||||
if (row >= store->row_fg.size()) return;
|
||||
store->row_fg[row] = (r < 0) ? wxColour() : wxColour(r, g, b);
|
||||
store->RowChanged(row);
|
||||
}
|
||||
|
||||
int wxbr_dvlc_row_count(void* win) {
|
||||
return (int)((wxDataViewListCtrl*)win)->GetStore()->GetItemCount();
|
||||
return (int)dvlc_store(win)->GetItemCount();
|
||||
}
|
||||
|
||||
void wxbr_dvlc_set_cell(void* win, unsigned row, unsigned col, const char* value) {
|
||||
((wxDataViewListCtrl*)win)
|
||||
->SetValue(wxVariant(wxString::FromUTF8(value)), row, col);
|
||||
AttrListStore* store = dvlc_store(win);
|
||||
store->SetValueByRow(wxVariant(wxString::FromUTF8(value)), row, col);
|
||||
store->RowValueChanged(row, col);
|
||||
}
|
||||
|
||||
int wxbr_dvlc_get_cell(void* win, unsigned row, unsigned col, char* buf, int cap) {
|
||||
wxDataViewListCtrl* lc = (wxDataViewListCtrl*)win;
|
||||
wxDataViewListStore* store = lc->GetStore();
|
||||
if (row >= store->GetItemCount() || col >= lc->GetColumnCount())
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
AttrListStore* store = dvlc_store(win);
|
||||
if (row >= store->GetItemCount() || (int)col >= (int)dv->GetColumnCount())
|
||||
return 0;
|
||||
wxVariant v;
|
||||
store->GetValueByRow(v, row, col);
|
||||
@@ -366,7 +573,7 @@ int wxbr_dvlc_get_cell(void* win, unsigned row, unsigned col, char* buf, int cap
|
||||
}
|
||||
|
||||
int wxbr_dvlc_col_count(void* win) {
|
||||
return (int)((wxDataViewListCtrl*)win)->GetColumnCount();
|
||||
return (int)((wxDataViewCtrl*)win)->GetColumnCount();
|
||||
}
|
||||
|
||||
// Update a column's header text in place (creation index) without recreating
|
||||
@@ -406,58 +613,51 @@ int wxbr_dvlc_col_at_pos(void* win, int pos) {
|
||||
}
|
||||
|
||||
long wxbr_dvlc_selected_row(void* win) {
|
||||
return (long)((wxDataViewListCtrl*)win)->GetSelectedRow();
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
wxDataViewItem it = dv->GetSelection();
|
||||
if (!it.IsOk()) return -1;
|
||||
return (long)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(it);
|
||||
}
|
||||
|
||||
// Fill `buf` with the selected row indices (multi-select); returns the count.
|
||||
int wxbr_dvlc_get_selections(void* win, int* buf, int cap) {
|
||||
wxDataViewListCtrl* lc = (wxDataViewListCtrl*)win;
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
wxDataViewItemArray items;
|
||||
int n = (int)lc->GetSelections(items);
|
||||
int n = (int)dv->GetSelections(items);
|
||||
int out = 0;
|
||||
for (int i = 0; i < n && out < cap; i++) {
|
||||
int row = lc->GetStore()->GetRow(items[i]);
|
||||
int row = m->GetRow(items[i]);
|
||||
if (row >= 0) buf[out++] = row;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
void wxbr_dvlc_select_rows(void* win, const int* rows, int n) {
|
||||
wxDataViewListCtrl* lc = (wxDataViewListCtrl*)win;
|
||||
lc->UnselectAll();
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
dv->UnselectAll();
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (rows[i] >= 0) lc->SelectRow((unsigned)rows[i]);
|
||||
if (rows[i] >= 0) dv->Select(m->GetItem((unsigned)rows[i]));
|
||||
}
|
||||
}
|
||||
|
||||
// Retained for ABI; per-row colour is handled by the store (GetAttrByRow) and
|
||||
// the native selection highlight, so these row-background hacks are no-ops now
|
||||
// (they fought the selection highlight on GTK 3.3).
|
||||
void wxbr_dvlc_set_alt_row_color(void* win, int r, int g, int b) {
|
||||
// No-op on GTK (native dataview lacks it); see wxbr_apply_zebra_css.
|
||||
((wxDataViewListCtrl*)win)->SetAlternateRowColour(wxColour(r, g, b));
|
||||
(void)win; (void)r; (void)g; (void)b;
|
||||
}
|
||||
|
||||
// GTK's native dataview does not implement SetAlternateRowColour, so apply
|
||||
// zebra striping app-wide via a CSS provider (GTK 3.20+ supports :nth-child on
|
||||
// treeview rows). No-op off GTK.
|
||||
void wxbr_apply_zebra_css(int r, int g, int b) {
|
||||
#ifdef __WXGTK__
|
||||
GtkCssProvider* p = gtk_css_provider_new();
|
||||
char css[192];
|
||||
std::snprintf(css, sizeof(css),
|
||||
"treeview.view:nth-child(even){background-color:rgb(%d,%d,%d);}",
|
||||
r, g, b);
|
||||
gtk_css_provider_load_from_data(p, css, -1, NULL);
|
||||
gtk_style_context_add_provider_for_screen(
|
||||
gdk_screen_get_default(), GTK_STYLE_PROVIDER(p),
|
||||
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
g_object_unref(p);
|
||||
#else
|
||||
(void)r; (void)g; (void)b;
|
||||
#endif
|
||||
}
|
||||
|
||||
void wxbr_dvlc_select_row(void* win, long row) {
|
||||
if (row < 0) return;
|
||||
((wxDataViewListCtrl*)win)->SelectRow((unsigned)row);
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
|
||||
dv->Select(m->GetItem((unsigned)row));
|
||||
}
|
||||
|
||||
// ---- timer -----------------------------------------------------------------
|
||||
@@ -591,8 +791,102 @@ void wxbr_popup_menu(void* win, void* menu) {
|
||||
delete m;
|
||||
}
|
||||
|
||||
// ---- choice (dropdown) ------------------------------------------------------
|
||||
|
||||
void* wxbr_choice(void* parent, int id) {
|
||||
wxChoice* c = new wxChoice((wxWindow*)parent, id);
|
||||
c->Bind(wxEVT_CHOICE, [id](wxCommandEvent& e) {
|
||||
if (g_widget_event)
|
||||
g_widget_event(WxEV_CHOICE_CHANGED, id, (long)e.GetSelection());
|
||||
});
|
||||
return (void*)c;
|
||||
}
|
||||
|
||||
void wxbr_choice_append(void* win, const char* label) {
|
||||
((wxChoice*)win)->Append(wxString::FromUTF8(label));
|
||||
}
|
||||
|
||||
void wxbr_choice_clear(void* win) { ((wxChoice*)win)->Clear(); }
|
||||
|
||||
int wxbr_choice_get_selection(void* win) {
|
||||
return ((wxChoice*)win)->GetSelection();
|
||||
}
|
||||
|
||||
void wxbr_choice_set_selection(void* win, int i) {
|
||||
((wxChoice*)win)->SetSelection(i);
|
||||
}
|
||||
|
||||
// ---- media (icon) button: play / pause / stop -------------------------------
|
||||
|
||||
// kind: 0=play (triangle), 1=pause (two bars), 2=stop (square). Drawn in the
|
||||
// given colour on a transparent bitmap so it reads as a coloured glyph on the
|
||||
// native button. Emits WxEV_BUTTON_CLICKED with `id`, like a normal button.
|
||||
void* wxbr_media_button(void* parent, int id, int kind, int r, int g, int b) {
|
||||
const int sz = 20;
|
||||
wxImage img(sz, sz);
|
||||
img.InitAlpha();
|
||||
unsigned char* a = img.GetAlpha();
|
||||
if (a) memset(a, 0, (size_t)sz * sz); // fully transparent
|
||||
wxBitmap bmp(img);
|
||||
{
|
||||
wxMemoryDC mdc(bmp);
|
||||
wxGraphicsContext* gc = wxGraphicsContext::Create(mdc);
|
||||
if (gc) {
|
||||
gc->SetAntialiasMode(wxANTIALIAS_DEFAULT);
|
||||
wxColour col(r, g, b);
|
||||
gc->SetBrush(wxBrush(col));
|
||||
gc->SetPen(wxPen(col, 1.0));
|
||||
if (kind == 0) {
|
||||
wxGraphicsPath p = gc->CreatePath();
|
||||
p.MoveToPoint(5, 4);
|
||||
p.AddLineToPoint(16, 10);
|
||||
p.AddLineToPoint(5, 16);
|
||||
p.CloseSubpath();
|
||||
gc->FillPath(p);
|
||||
} else if (kind == 1) {
|
||||
gc->DrawRectangle(5, 4, 3.5, 12);
|
||||
gc->DrawRectangle(11.5, 4, 3.5, 12);
|
||||
} else {
|
||||
gc->DrawRectangle(5, 5, 10, 10);
|
||||
}
|
||||
delete gc;
|
||||
}
|
||||
}
|
||||
wxBitmapButton* btn = new wxBitmapButton((wxWindow*)parent, id, bmp);
|
||||
btn->Bind(wxEVT_BUTTON, [id](wxCommandEvent&) {
|
||||
if (g_widget_event) g_widget_event(WxEV_BUTTON_CLICKED, id, 0);
|
||||
});
|
||||
return (void*)btn;
|
||||
}
|
||||
|
||||
// ---- live theme changes -----------------------------------------------------
|
||||
|
||||
// Emit WxEV_SYS_COLOUR when the OS light/dark theme changes so the app can
|
||||
// repaint custom-coloured widgets (KPI cards, table rows).
|
||||
void wxbr_bind_sys_colour(void* win) {
|
||||
((wxWindow*)win)->Bind(wxEVT_SYS_COLOUR_CHANGED, [](wxSysColourChangedEvent& e) {
|
||||
e.Skip();
|
||||
if (g_widget_event) g_widget_event(WxEV_SYS_COLOUR, 0, 0);
|
||||
});
|
||||
}
|
||||
|
||||
// Run a deferred action after the current event finishes unwinding: emits
|
||||
// WxEV_DEFERRED with `id` from the main event loop. Used to rebuild a control
|
||||
// from outside its own event handler (destroying a widget mid-event is unsafe).
|
||||
void wxbr_call_after(int id) {
|
||||
if (wxTheApp) {
|
||||
wxTheApp->CallAfter([id]() {
|
||||
if (g_widget_event) g_widget_event(WxEV_DEFERRED, id, 0);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// ---- deferred destroy (safe from event handlers) ----------------------------
|
||||
|
||||
void wxbr_destroy(void* win) { ((wxWindow*)win)->Destroy(); }
|
||||
|
||||
// Destroy a window's children immediately (used to rebuild a panel's dynamic
|
||||
// contents in place, e.g. the filter dialog's per-column controls).
|
||||
void wxbr_destroy_children(void* win) { ((wxWindow*)win)->DestroyChildren(); }
|
||||
|
||||
} // extern "C"
|
||||
|
||||
+127
@@ -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);
|
||||
@@ -64,6 +68,7 @@ mod notsafe {
|
||||
pub fn wxbr_dvlc_get_selections(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
|
||||
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_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;
|
||||
@@ -83,7 +88,16 @@ mod notsafe {
|
||||
pub fn wxbr_system_color(which: c_int, r: *mut u8, g: *mut u8, b: *mut u8);
|
||||
pub fn wxbr_set_bg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_set_fg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_choice(parent: *mut c_void, id: c_int) -> *mut c_void;
|
||||
pub fn wxbr_choice_append(win: *mut c_void, label: *const c_char);
|
||||
pub fn wxbr_choice_clear(win: *mut c_void);
|
||||
pub fn wxbr_choice_get_selection(win: *mut c_void) -> c_int;
|
||||
pub fn wxbr_choice_set_selection(win: *mut c_void, i: c_int);
|
||||
pub fn wxbr_media_button(parent: *mut c_void, id: c_int, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
|
||||
pub fn wxbr_bind_sys_colour(win: *mut c_void);
|
||||
pub fn wxbr_destroy(win: *mut c_void);
|
||||
pub fn wxbr_destroy_children(win: *mut c_void);
|
||||
pub fn wxbr_call_after(id: c_int);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -116,6 +130,9 @@ pub enum WxEventKind {
|
||||
DvlcSelectionChanged,
|
||||
DvlcContextMenu,
|
||||
MenuItem,
|
||||
ChoiceChanged,
|
||||
SysColour,
|
||||
Deferred,
|
||||
}
|
||||
|
||||
impl WxEventKind {
|
||||
@@ -131,6 +148,9 @@ impl WxEventKind {
|
||||
9 => WxEventKind::DvlcSelectionChanged,
|
||||
10 => WxEventKind::DvlcContextMenu,
|
||||
11 => WxEventKind::MenuItem,
|
||||
12 => WxEventKind::ChoiceChanged,
|
||||
13 => WxEventKind::SysColour,
|
||||
14 => WxEventKind::Deferred,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
@@ -141,6 +161,13 @@ pub fn apply_zebra_css(r: u8, g: u8, b: u8) {
|
||||
unsafe { notsafe::wxbr_apply_zebra_css(r as c_int, g as c_int, b as c_int) }
|
||||
}
|
||||
|
||||
/// Schedule a deferred action: a `Deferred` event carrying `id` is delivered
|
||||
/// from the event loop after the current event finishes. Use this to rebuild or
|
||||
/// destroy a control from outside its own event handler.
|
||||
pub fn call_after(id: i32) {
|
||||
unsafe { notsafe::wxbr_call_after(id as c_int) }
|
||||
}
|
||||
|
||||
/// Open a URL in the system default browser. Returns true on success.
|
||||
pub fn launch_browser(url: &str) -> bool {
|
||||
let c = CString::new(url).unwrap_or_default();
|
||||
@@ -216,6 +243,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) }
|
||||
}
|
||||
@@ -292,6 +327,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) })
|
||||
}
|
||||
@@ -371,6 +415,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 {
|
||||
@@ -382,6 +441,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) }
|
||||
}
|
||||
@@ -459,6 +526,15 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_dvlc_set_alt_row_color(self.0, r as c_int, g as c_int, b as c_int) }
|
||||
}
|
||||
|
||||
/// Set a row's text colour (e.g. by miner status). Pass `None` to clear it.
|
||||
pub fn dvlc_set_row_color(&self, row: usize, 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_row_color(self.0, row, r, g, b) }
|
||||
}
|
||||
|
||||
// ---- rearrangeable check-list ----
|
||||
|
||||
/// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
|
||||
@@ -553,9 +629,60 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_set_fg(self.0, r as c_int, g as c_int, b as c_int) }
|
||||
}
|
||||
|
||||
// ---- choice (dropdown) ----
|
||||
|
||||
/// Create a dropdown; selection changes emit `ChoiceChanged` with this id.
|
||||
pub fn choice(parent: Widget, id: i32) -> Widget {
|
||||
Widget(unsafe { notsafe::wxbr_choice(parent.0, id) })
|
||||
}
|
||||
|
||||
pub fn choice_append(&self, label: &str) {
|
||||
let c = CString::new(label).unwrap_or_default();
|
||||
unsafe { notsafe::wxbr_choice_append(self.0, c.as_ptr()) }
|
||||
}
|
||||
|
||||
pub fn choice_clear(&self) {
|
||||
unsafe { notsafe::wxbr_choice_clear(self.0) }
|
||||
}
|
||||
|
||||
pub fn choice_get_selection(&self) -> i32 {
|
||||
unsafe { notsafe::wxbr_choice_get_selection(self.0) }
|
||||
}
|
||||
|
||||
pub fn choice_set_selection(&self, i: i32) {
|
||||
unsafe { notsafe::wxbr_choice_set_selection(self.0, i) }
|
||||
}
|
||||
|
||||
// ---- media (icon) button ----
|
||||
|
||||
/// A coloured icon button: `kind` 0=play, 1=pause, 2=stop. Clicks emit
|
||||
/// `ButtonClicked` with `id`, like a normal button.
|
||||
pub fn media_button(parent: Widget, id: i32, kind: i32, color: (u8, u8, u8)) -> Widget {
|
||||
Widget(unsafe {
|
||||
notsafe::wxbr_media_button(
|
||||
parent.0,
|
||||
id,
|
||||
kind,
|
||||
color.0 as c_int,
|
||||
color.1 as c_int,
|
||||
color.2 as c_int,
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Listen for OS light/dark theme changes on this window (emits `SysColour`).
|
||||
pub fn bind_sys_colour(&self) {
|
||||
unsafe { notsafe::wxbr_bind_sys_colour(self.0) }
|
||||
}
|
||||
|
||||
/// Deferred destruction (safe from event handlers); used to rebuild
|
||||
/// the table when its column set changes.
|
||||
pub fn destroy(&self) {
|
||||
unsafe { notsafe::wxbr_destroy(self.0) }
|
||||
}
|
||||
|
||||
/// Destroy this window's children (to rebuild dynamic panel contents).
|
||||
pub fn destroy_children(&self) {
|
||||
unsafe { notsafe::wxbr_destroy_children(self.0) }
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user