Compare commits

...
18 Commits
Author SHA1 Message Date
noahandClaude Opus 4.8 9b5d811b1e GUI round 9 (batch 2): KPI box layout, bottom-right error indicator, algorithm filter + hashrate cycling
Round-9 UI items #5, #6, #7 and the #9 algorithm-cycle follow-on.

#6 KPI boxes: switch the header from a wrap sizer to a horizontal box
sizer with every card at proportion 1 + EXPAND, so the cards are always
equal width and grow to span the full window; a per-card min size
(116x62) floors them at their largest content. Fix the filter-alignment
drift by re-running each card's sizer in refresh_kpis after set_label
(the centring spacers now recompute around the new value width). The
active-filter highlight now paints the card panel and both its texts, so
the whole box tints instead of only the strip behind the text. Bind the
card click on the value and label static texts too (a click on the number
or caption registers the quick-filter, not just the card gap).

#5 error indicator: add a second, colour-tinted status-bar field pinned
to the bottom-right corner (wxbr_status_indicator_init/set in the widget
bridge; a wxStaticText repositioned into the right field on resize). Scan
and apply outcomes route here without overwriting the left scan-status
text: a total apply failure and a scan failure show red, a partial apply
failure amber, full success clears it; a new scan/action clears any stale
message.

#7 algorithm filter: the Filter dialog now offers every column (via a new
ViewState::filter_columns) rather than only the visible ones, so Algorithm
-- and any other hidden metric -- can be filtered without first un-hiding
its column. Filters already match on the plain model cell, independent of
visibility.

#9 hashrate cycling: compute per-algorithm hashrate totals in compute_kpis
(Kpis::hashrate_by_algo, ordered by total). The hashrate KPI card shows
the selected algorithm's total under a "<Algo> Hashrate" caption and
cycles through the running algorithms when clicked (a no-op with a single
algorithm). SHA256 renders as "SHA-256".

Bridge provenance patches 0002/0003 regenerated to match the -patched tree.
Compile-checked (release + tests); 74 offline tests pass; headless
self-test PASS; screenshot-verified equal-width cards, full-box highlight,
click-through-text, and centred values after filtering.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 11:09:50 -06:00
noahandClaude Opus 4.8 77399bdd06 GUI round 9 (batch 1): column-reorder persistence, post-action refresh, algorithm column, hashrate KPI label
- #1 Column reorder now persists (incl. after sorting a moved column). On wxGTK,
  GetColumnPosition() does not reflect a native GtkTreeView column drag, so the
  reorder was read as a no-op and the rebuild snapped columns back. dvlc_col_at_pos
  now reads the real display order from the GtkTreeView (gtk_tree_view_get_columns
  + GTKColumnToWX) on __WXGTK__, falling back to GetColumnPosition elsewhere.
- #2 A right-click config action (e.g. Flash lights) now re-probes the miners it
  targeted when it finishes, so the change shows in the table (skipped after a
  flash, since the unit is rebooting). New App.action_targets.
- #7 New Algorithm column (from asic-rs hashrate.algo: SHA256/Scrypt/Equihash/...),
  categorical so it is filterable via the value checklist.
- #9 SHA-256 Hashrate KPI: card relabelled "SHA-256 Hashrate" and the value drops
  the "/s" ("685 TH", "1.2 PH"). (Per-algorithm click-cycling deferred.)

Note on #8 (Z15 shows T not k): our formatting already derives the SI prefix from
the base value (si_mantissa), so a wrong 'T' means asic-rs reports the wrong unit
for that Equihash model -- an asic-rs backend fix that needs a live Z15 to verify.

cargo check --release --tests clean; patch 0003 regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:41:21 -06:00
noahandClaude Opus 4.8 408b7d12b4 GUI: real access/lock-state detection via credentialed digest probe
asic-rs has no lock-state signal (a wrong-password miner just silently returns
fewer fields, because the collector drops the 401). This builds the real check
ON TOP of asic-rs:

- access_probe.rs: a NON-mutating, digest-authenticated GET to a privileged
  endpoint (Antminer get_miner_conf.cgi, read-only). The HTTP status is decisive
  -- 200 = credentials authenticate (writable -> unlocked), 401/403 = rejected
  (view-only -> locked); anything else -> indeterminate. Pure classifier +
  unit tests; shells out to curl --digest (no HTTP crate) so the offline build
  is unaffected.
- Right-click "Check access (auth)" on the selected miners runs start_access_probe
  on a background thread using the saved scan (web) credentials (default root/root),
  updating write_locked in the rows as results arrive. Fake-scan mode returns
  deterministic demo results. Guarded against a flash / concurrent probe.

Replaces the previous capability-based inference for the miners the user
explicitly checks. cargo check --release --tests clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:32:44 -06:00
noahandClaude Opus 4.8 50cd463bee GUI fix: guard out-of-range dvlc GetItem (crash selecting rows after refresh)
Round-9 #10: selecting miners could trip
`datavcmn.cpp: assert "row < m_hash.GetCount()" failed in GetItem(): invalid
index` and crash. wxDataViewIndexListModel::GetItem() asserts on an out-of-range
row, and three bridge helpers called it with an index that can go stale when the
row set shrinks (a filter, or a scan that returns fewer rows): wxbr_dvlc_
ensure_visible (the round-8 scroll-hold, unguarded), wxbr_dvlc_select_rows and
wxbr_dvlc_select_row (only lower-bounded). All three now bound the row against
the store's item count before calling GetItem, so a stale/empty index is a
no-op instead of a crash.

Local wx-rs bridge compile clean; patch 0003 regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:29:14 -06:00
noahandClaude Opus 4.8 d73299166e GUI: real PIC detection via on-board SSH + i2c probe (right-click action)
asic-rs and the miner's network API cannot report PIC-vs-noPIC (only one legacy
SKU, ANTMINER S19J88NOPIC, carries it in the model string; the authoritative
signal lives on the control board's I2C bus). So this builds the real detector
ON TOP of asic-rs as an opt-in SSH probe, per the project wiki
(30-power-thermal-and-board-identity/hashboard-eeprom-pic.md):

- pic_probe.rs: SSH to the control board and run i2cdump -y <bus> 0x48 b, then
  discriminate by the register period -- a PIC/MCU board exposes an 8-byte
  register file that WRAPS every 8 bytes ("17 00 4b 50 7f 00 00 00 ..."), while
  a noPIC board has a 4-register LM75 temp sensor (4-byte wrap). The classifier
  is pure + unit-tested against the wiki's example dumps and is conservative
  (indeterminate -> None, never a guess). The I2C bus is chosen from the
  control-board family (AMLogic->1, BeagleBone->0, else try both). We shell out
  to ssh/sshpass (no SSH crate) so the offline/vendored build is unaffected.
- Right-click "Detect PIC (SSH)..." on the selected miners: a dialog collects
  SSH login (prefilled from a new 0600 ssh-credentials.txt, default user root),
  then start_pic_probe runs one miner at a time on a background thread (each is a
  slow SSH round trip; never part of the fast network scan) and upserts
  pic_present into the rows as results arrive. Fake-scan mode returns
  deterministic demo results. Guarded against a firmware flash / concurrent probe.

The classifier is unit-tested; the live SSH round-trip needs a reachable bench
miner with SSH + i2c-tools to verify end-to-end. cargo check --release --tests
clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:25:15 -06:00
noahandClaude Opus 4.8 a81fef3c7d GUI round 8: Errors column hover tooltip (full message list)
Item 12 (tooltip half): hovering an Errors cell now shows the full list of the
miner's error/event messages ("[Severity] text (component)", most severe first)
as a tooltip; the cell itself keeps the compact red summary.

wxDataViewCtrl has no per-cell tooltip API, and wx mouse-motion events are not
delivered to wx handlers on the native GTK control, so this uses GtkTreeView's
native "query-tooltip" signal directly (guarded by __WXGTK__): a per-cell
tooltip map (row, model column) -> text on the AttrListStore, populated from
Rust via a new dvlc_set_cell_tooltip bridge fn, and looked up by the signal
handler using dv->GTKColumnToWX(gcol)->GetModelColumn(). The map is populated on
every platform (a no-op where nothing reads it) so the non-GTK platform round
can wire its own tooltip surface later.

Local wx-rs bridge compile + full cargo check clean; patches 0002/0003
regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:37:18 -06:00
noahandClaude Opus 4.8 365732b5d4 GUI round 8b.2 fix: rubber-band drag-select uses native GtkTreeView on GTK
The wx-mouse-event rubber-band approach (LEFT_DOWN/MOTION/LEFT_UP) does not work
on the native GTK wxDataViewCtrl: the underlying GtkTreeView grabs the pointer
during a button drag, so wx never delivers the MOTION events, and only the
initial click row was selected (verified against the shipped binary).

Fix: on GTK, enable the GtkTreeView's own native rubber-band selection via
dv->GtkGetTreeView() + gtk_tree_view_set_rubber_banding(TRUE), guarded by
__WXGTK__ (gtk/gtk.h included only there). The wx-mouse-event approach is kept
as the non-GTK fallback for the future Windows/macOS builds, where it will be
verified in the platform round. The column-header right-click menu (native wx
dataview event) already worked and is unchanged.

Local wx-rs bridge compile clean; patch 0003 regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:27:16 -06:00
noahandClaude Opus 4.8 98603077e3 GUI round 8: view presets (save/load column arrangement, filters, sort)
Item 11: a "Presets" button (top-right) opens a dialog to save the current
table view -- column arrangement + visibility, sort, and all active filters --
as a named profile, load a saved one, or delete it. The built-in "Default"
profile is always the first preset and shows IP, Model, Hashrate, Power, Chip
temp, Firmware, Control board, PIC and Status; the app now boots with it.

- New presets.rs: a serde-serialized PresetView snapshot of ViewState (Vec-based
  so the JSON has no enum map keys), Preset { name, view }, and load/save to
  ~/.config/alkane-toolkit/presets.json. "Default" is re-seeded on load and not
  written, so it can't be lost or deleted. A loaded preset missing newer columns
  still covers every column (they're appended hidden).
- serde/serde_json added to alkane-gui (already vendored + locked via asic-rs);
  Column/ColFilter/TextOp/NumOp derive Serialize/Deserialize and ViewState is
  now Clone.
- ui.rs: build_presets_dialog + apply_preset_load/save/delete, wired to the new
  Presets button.

Unit tests: default-preset round-trips through ViewState and JSON.
cargo check --release --tests is clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:21:49 -06:00
noahandClaude Opus 4.8 bc9f847689 GUI round 8b.2: column-header menu + rubber-band drag-select
Bridge + UI (local wx-rs bridge compile + full cargo check clean).

- Column-header right-click menu (#5): right-clicking a column header opens an
  Excel-style menu -- Sort ascending / descending, Auto-size this column, Hide
  <column> (not offered for the fixed IP column), and Columns... (the full
  show/hide picker). New wx event WxEV_DVLC_HEADER_RIGHT_CLICK bound from the
  native wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, plus a wxbr_dvlc_autosize_col
  bridge fn (wxCOL_WIDTH_AUTOSIZE). (Sticky/frozen columns are the separate 8c
  dual-control piece.)
- Rubber-band (click-drag) range selection (#10): wxDataViewCtrl has no native
  drag-to-extend selection (only ctrl/shift-click), so it is tracked in the
  bridge -- LEFT_DOWN records the anchor row (and lets the native handler select
  it), dragging with the button down selects the inclusive row range under the
  cursor, LEFT_UP clears the anchor; modifier-clicks are left to the native
  multi-select. Reuses the existing Select/UnselectAll primitives and emits
  SELECTION_CHANGED so the model's selected-IP set stays in sync.
- KPI cards widened to 150px so "685 TH/s" / "21.3 kW" are no longer clipped.

wx-rs patches 0002/0003 regenerated + round-trip validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:13:27 -06:00
noahandClaude Opus 4.8 71cdf2d988 GUI round 8b.1: scroll-hold, zebra striping + vertical gridlines, default-colour text
Bridge + rendering rework (validated with a local wx-rs bridge compile + full
cargo check; CI is the build oracle).

- Scroll position hold (#2): the table no longer jumps to the top as new rows
  stream in during a scan. fill_rows captures the top visible row before the
  clear+refill and restores it after (new wx-rs bridge fns dvlc_get_top_row /
  dvlc_ensure_visible, wrapping wxDataViewCtrl::GetTopItem / EnsureVisible).
- Default-colour text (#3b): rows are no longer tinted wholesale by status. Every
  cell is now the default text colour (black in light mode, white in dark -- the
  SegmentRenderer falls back to wxSYS_COLOUR_WINDOWTEXT for any run with no
  explicit colour), so IP addresses, slashes, expected/target values and all
  non-conditional cells read in the default colour. Only the conditionally-
  formatted columns carry colour: Hashrate/Boards/Chips actual (ratio scale),
  Chip temp (blue-red), fans (grey-blue), Access (red/green), Errors (red), and
  the Status column keeps its own status colour on its own cell.
- Zebra striping (#8): odd rows get a subtle theme-aware background via the
  AttrListStore (a per-row BACKGROUND attr, so it does not disturb the
  default-foreground fallback and the native selection highlight still shows
  through). This replaces the status row-tint as the row separator. (The earlier
  abandoned attempt used SetAlternateRowColour / GTK CSS against the status
  foreground tint; removing that tint is what makes the background approach
  clean now.)
- Vertical gridlines (#8): wxDV_VERT_RULES added to the table style (row lines
  were already on), so columns have borders.
- KPI cards: wxWrapSizer now drops wxEXTEND_LAST_ON_EACH_LINE, so the last card
  on a line is no longer stretched -- the uniform-size KPI boxes stay uniform.

wx-rs patches 0002/0003 regenerated and round-trip-validated against the source.
cargo check --release --tests is clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 16:55:27 -06:00
noahandClaude Opus 4.8 4fea3becf6 GUI round 8a.2: PIC, Access (locked), and Errors columns
Adds the round-8 columns that asic-rs either already exposes or that we infer.
Control board type (#9) and identify-light state (#4b) were already scannable
columns; this adds the three new ones:

- PIC (#9): asic-rs does not report PIC-vs-noPIC over the network (it needs an
  on-board SSH/I2C probe -- a separate feature), so this is a best-effort
  inference from the model string ("NoPIC" variants), showing "?" when unknown.
  New MinerRow.pic_present.
- Access (#13): locked (view-only) vs unlocked (writable), inferred from whether
  the miner exposes any writable control capability (asic-rs has no direct
  lock-state field). Red = locked, green = unlocked. New MinerRow.write_locked
  and MinerCaps::any_control().
- Errors (#12): wires asic-rs's structured MinerData.messages (previously
  dropped) into MinerRow.errors as "[Severity] text (component)" lines, most
  severe first. The column shows a summary (blank / the single message / "N
  errors") in red when non-empty; the full list becomes a hover tooltip once the
  tooltip bridge support lands in 8b.

The identify-light column header is relabelled "Light" (from "Fault light") to
match the round-8 terminology. Fixtures populated with demo values so all new
columns render offline. Unit tests for the three cell renderers + any_control.

cargo check --release --tests is clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 16:37:21 -06:00
noahandClaude Opus 4.8 7781ff71d3 GUI round 8a: no phantom-offline rows, hashrate/temp conditional formatting, multi-range parse, uniform KPI cards
First slice of the round-8 batch (Linux; Windows/macOS builds deferred to a
dedicated platform round per the design discussion). Feature/format changes
with no C++ bridge dependency; the bridge-dependent items (scroll-hold, zebra +
default-colour rework, header menu, rubber-band select, tooltips, presets,
frozen columns, plus the new asic-rs columns) follow in 8b/8c.

- Offline recognition (reverses the round-6 interpretation): the scanner no
  longer fabricates a row for an address with no miner. Only miners that
  actually respond become rows; a responding non-mining miner is "not hashing".
  Removed the MinerRow.offline field, MinerRow::offline(), the "offline" status,
  and the synthetic fixture/fake-scan offline rows. The bench fleet is now 9
  rows (was 10); KPI not-hashing is 1.
- Hashrate conditional format: the scale now bottoms out at 50% (full red at
  <=50% of expected, amber at 75%, green at 100%+), matching "green = 100%,
  red = 50% or lower".
- Hashrate cell format: prefix-only unit, no space, no spaces around the slash
  (e.g. "60.0T/200T", "80.5T/95.0T") instead of "60.0 TH/s / 200 TH/s". The
  combined-cell encoder now builds from formatted parts rather than re-splitting
  a joined string on " / ", so hashrate ("/") and count columns (" / ") each
  keep their own separator.
- Chip temperature: new blue-to-red conditional scale (cool blue at/below 40 C
  to hot red at/above 90 C); the Chip temp column is now a coloured cell.
- Multi-range scan input: each octet may be a range, so "10.1-9.1.1-255" expands
  to the 9 /24s (cartesian per-octet parse). CIDR / full-range / short-range
  forms are preserved.
- KPI header: every card is now a uniform size with its value + label centred.
- Right-click menu: "Fault light on/off" relabelled to "Flash lights on/off"
  (the underlying asic-rs set_fault_light call is unchanged).

Tests updated for the new formats/counts; new unit tests for the 50%-100% ratio
scale, the blue-to-red temp scale, the parts-based combined encoder, and the
per-octet range parser. cargo check --release --tests is clean; CI runs the
release build + tests + headless self-test.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 16:26:19 -06:00
noahandClaude Opus 4.8 86e4761316 GUI round 7: code-review remediation (flash safety, unknown-actual colour, credentials, coverage)
Fixes the Critical/High findings from the round-6 review (6 parallel dimension
reviewers + adversarial verify), plus the cheap high-value non-blocking ones.
Full write-up in code-review-report.md.

Firmware-flash safety (the one irreversible, hardware-destroying action):
- Critical: re-triggering an action no longer races the previous one. A flash
  now takes an exclusive lock (new App.flashing): it will not start while any
  scan / refresh / config action is running, and none of those (nor another
  flash) start while it runs. begin_scan, start_action, start_refresh and
  apply_flash_confirm all gate on it, and the context menu offers only the
  read-only "Open in browser" while flashing. This removes the two overlapping-
  network-operation paths that could interrupt/corrupt an upload and brick a
  miner (old.stop() never joined the in-flight upload).
- High: the flash confirm dialog now lists every target IP + model and warns
  loudly when the batch spans more than one model (a single image is rarely
  valid for all), instead of showing only a bare count.

Correctness:
- High: combined columns no longer paint the "-" placeholder solid red when the
  actual is unknown but the expected is known (an idle/paused/booting miner of a
  recognised model looked like a 0% catastrophic failure). fill_rows now gates
  the ratio on the actual being known; unknown-actual falls to the plain,
  uncoloured segment. Was masked by the all-zero-expected fixtures.
- compute_kpis buckets by status() instead of re-deriving the precedence from
  raw flags (KPI header can no longer disagree with a row's status; offline
  folds into not_hashing).

Security:
- credentials file is created at 0600 up front (OpenOptions::mode) and
  re-tightened while still empty, so the plaintext password is never on disk
  under a looser mode (was create-0644 then chmod-0600).
- the "Set scan credentials" dialog no longer pre-fills the saved password in
  plaintext; a blank Password field keeps the stored one.

Robustness / API:
- the fake-scan branches of the config-action / refresh / flash background
  threads now honour the cancel flag (were ignored, so stop() was a no-op).
- MinerRow.online -> offline (default false = online), removing the footgun
  where a struct-update literal that forgot `online: true` read back offline.

Tests (the review's primary focus -- these paths had zero coverage):
- scan.rs fake_mode_background_actions: start_scan offline-row emission,
  start_refresh (Row/Failed/Done), start_firmware_flash_action, and that a
  cancelled run still terminates with Done rather than hanging.
- model.rs: flash_confirmed (exact/case/prefix/whitespace), compute_kpis vs
  status() consistency, Default-is-online.
- new ui::tests: ratio_color/fan_color/tint_toward stops+clamping+blends, and
  the combined-cell unknown-actual and cooling-cell encodings.
- credentials.rs: configured_factory smoke (both branches) + pre-existing-0644
  re-tighten.
- self-test: offline row (.199) spot-check, KPI quick-filter toggle on/off, and
  a numeric (not lexical) IP-sort assertion via model::ip_to_u32.

Deferred (non-blocking, tracked in code-review-report.md): start_* boilerplate
extraction; per-model firmware image-compatibility check; scoping saved
credentials to a chosen backend; a masked password field (needs a wx-rs
TE_PASSWORD binding); flash-specific status text; a segment-encode microbench.

Verified: cargo check --release --tests is clean; unit tests + benches + the
headless self-test run in CI (local release link is OOM-blocked on this
desktop).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 14:06:03 -06:00
noahandClaude Opus 4.8 c1234f6df7 GUI round 6 self-test fix: decode combined-column cells in spot-checks
The round-6 combined columns (Hashrate/Hashboards/TotalChips/Cooling) now
store colour-segment-encoded strings in the data view, so the headless
self-test's per-IP spot-checks read raw encoded bytes instead of plain text.
Two checks failed in CI as a result:
- S21 Pro (.149) hashrate read "B95E18<US>60.0 TH/s / 200 TH/s" (colour hex
  prefix + encoded combined text) rather than the plain value.
- S17 (.112) blank-hashrate read an encoded empty cell (invisible control
  chars), so is_empty() was false.

Fix: the spot-check `cell` closure now runs dvlc_get_cell output through
decode_segments_plain (a no-op for plain cells), and the S21 hashrate check
expects the combined "60.0 TH/s / 200 TH/s" form. The "every cell matches the
model" loop already decoded, so it was unaffected.

Verified: cargo check --release --tests is clean; the self-test itself is a
CI gate (local release link is OOM-blocked on this desktop).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 13:27:54 -06:00
noahandClaude Opus 4.8 b6afe08a5f GUI round 6: offline detection, combined columns, per-cell colours, paused status, credentials, refresh, firmware flash
Large round implemented via a research workflow (6 parallel readers) then a
file-partitioned implementation workflow (model/scan/bridge/ui/fixtures), all to
one shared contract.

Table / model:
- Offline recognition fix: the scan loop now emits a row for EVERY probed IP -
  non-responders become an "offline" row (new MinerRow.online flag +
  MinerRow::offline()), so unreachable miners show up (offline, red) instead of
  vanishing. Previously only responders got a row.
- Not-hashing rows are now RED (were grey); offline also red.
- New "paused" status (operating_state contains "pause" while not mining):
  its own blue row colour, a blue "Paused" KPI card, and a Kpis.paused count.
- Combined actual/expected columns: Hashrate, Hashboards and TotalChips fold
  their separate Expected* columns into one "actual / expected" cell; the actual
  is drawn on a smooth red->amber->green scale by ratio (100% = green), the
  expected in plain text, the slash black. num_value is carved out so a numeric
  filter never matches a row that only has an expected value.
- Fan column shows every fan's RPM as "rpm/rpm/rpm" (max 3 sig digits, SI-style),
  each fan coloured on its own grey->blue speed scale, slashes black.
- These four columns render via a new wxDataViewCustomRenderer (SegmentRenderer)
  that draws colour runs from a \x1f/\x1e-encoded value; every other column keeps
  the stock renderer and per-row status colour.

Interaction:
- KPI quick-filter: clicking the Hashing / Slow / Not hashing / Paused card
  filters the table to that status (composed with any column filters) and
  highlights the active card; clicking again clears it.
- Removed "Select all" / "Clear selection" from the right-click menu.
- Right-click "Refresh": re-polls the selected miners (asic-rs scan_miner) on a
  background thread and upserts the rows, without a full network scan.
- "Set scan credentials..." button (top-right): stores a username/password
  (~/.config/alkane-toolkit/scan-credentials.txt, 0600) that is fanned out to
  every asic-rs firmware backend via with_firmware_discovery_auth, so scans and
  all right-click actions authenticate. Applied through a new
  credentials::configured_factory() used everywhere MinerFactory::new() was.
- "Flash firmware..." (right-click): asic-rs UpgradeFirmware for the backends
  that support it (stock Antminer + EPIC; every other backend declines and is
  reported as unsupported). File picker (new wxFileDialog binding) + a typed
  "FLASH" confirmation; one miner at a time; cancel only between miners.
- Responsive layout: the KPI and controls rows use wxWrapSizer so they reflow
  when narrow; the min window size drops from 1200x720 to 640x480.

Bridge (wx-rs): SegmentRenderer + dvlc_append_colored_col, wrap_sizer,
bind_click (clickable KPI cards), file_dialog; dropped a vestigial gtk.h include.
Patches 0002/0003 regenerated + round-trip validated.

Portability note: every widget is a stock, natively-backed wxWidgets control
(ports to wxMSW/wxOSX); wxDataViewCtrl is native on Linux/macOS and wx's own
generic (still-correct) drawing on Windows.

Verified: cargo check --release --tests is clean; the release build + tests +
headless self-test run in CI. (Local release link is OOM-blocked on this
desktop; CI is the authoritative build.)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 13:09:16 -06:00
noahandClaude Opus 4.8 eb08a9ef97 GUI: per-miner capabilities + live config write path (right-click actions)
Completes the right-click config menu (round-2 item 11): the menu now offers
real actions computed from the intersection of what every selected miner
supports, and applies them to the fleet over the network.

- Capability detection: to_row probes each miner's asic-rs supports_* methods
  (fault light, restart, pause, resume, power limit, tuning) at scan time and
  stores them in MinerRow.caps -- no extra network round-trip.
- Intersection: MinerCaps::intersect_all yields the actions common to the whole
  selection; the context menu offers only those (a mixed mining + idle selection
  shows just fault light + restart; an all-mining selection shows everything).
- Write path: scan::start_config_action runs on a background thread -- it
  re-discovers each selected miner with asic-rs scan_miner(ip), applies the
  setter, and reports per-IP results that drain into the status bar (running
  progress while applying, a pass/fail summary when done). Cancellable, and a
  new action cancels any in-flight one so two never overlap. In fake-scan mode
  it simulates success so the flow is exercisable offline.
- Actions: fault light on/off, pause, resume, restart apply immediately; set
  power limit and set tuning % open a small value-prompt dialog first. Factory
  reset, change password, and firmware upgrade are deliberately not exposed in a
  casual right-click.

Adds the `measurements` dependency (already in the lock, transitive via asic-rs)
for Power::from_watts.

Review fixes (one review pass):
- Restart / pause / resume now require a confirmation dialog (naming the count)
  so a misclick can't stop a producing fleet; fault light stays instant, and
  power/tuning are confirmed by their value entry.
- The action result is held on the status bar for a few ticks so a fleet
  action's outcome (including failures) isn't clobbered by the next timer tick.
- The action loop uses a current-thread tokio runtime (it applies to one miner
  at a time; a worker pool was wasted).
- The value prompt validates before closing: a bad value keeps the dialog and
  the captured selection so it can be corrected.
- The menu's "(N)" counts use the rows-backed selection, matching what is
  actually acted on.

Verified off-screen: capability intersection (mixed vs all-mining selections),
the value-prompt and confirmation nested modals (menu -> dialog) with no crash,
the end-to-end apply flow, 46 unit tests (incl. a caps-intersection test), and
the headless self-test.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 11:05:15 -06:00
noahandClaude Opus 4.8 297e21a519 GUI round 3: Excel-style filters, status row colours, icon controls, context menu, live theme
Addresses the round-3 feedback batch:

- Right-click now works: a context menu (open selected in browser, select all,
  clear) pops up from the table. It was never wired before. (The live-config
  intersection over the selection remains a follow-up; no dead menu items.)
- Selection is readable again in both themes: the alt-row/zebra CSS hack (which
  painted row backgrounds over the native highlight, leaving white-on-white) is
  gone; the native selection highlight shows through.
- Row text is coloured by status (green = hashing, amber = slow, grey = not
  hashing), which also separates rows without fragile GTK zebra striping.
- Dark mode: KPI cards and rows follow the system theme (no more white boxes in
  dark mode); a system-colour-changed event repaints them live if the OS toggles
  light/dark while the app is open.
- Play / Pause / Stop are coloured media icons (green triangle / amber bars /
  red square) instead of text buttons.
- Filter panel redesigned Excel-style: a column dropdown at the top selects the
  column; controls adapt to its type. Text columns: a value checklist ("is any
  of") or a predicate (contains / does not contain / begins with / ends with /
  equals). Numeric columns: between / = / != / > / >= / < / <=. Filters AND
  across columns; edits held in a working copy, committed on Apply.
- Auto-rescan label shortened to "Rescan (s):" so the value field has room.

Table: replaced wxDataViewListCtrl with a raw wxDataViewCtrl + a custom
AttrListStore (per-row foreground via GetAttrByRow), which keeps in-table column
drag while enabling status row colours. New wx-rs bridge primitives: wxChoice
dropdown, coloured media buttons (drawn on a transparent bitmap via
wxGraphicsContext), a wxEVT_SYS_COLOUR_CHANGED event, destroy_children, and
call_after (deferred rebuilds). Patches 0002/0003 regenerated + round-trip
validated.

Model: ColFilter { Values, Text{op}, Num{op} } with TextOp/NumOp and
passes_filters -> ColFilter::matches; Column::num_value for numeric filtering.

Review fixes (one review pass):
- Deferred the two rebuilds that destroyed a control from inside its own event
  (filter op-dropdown change; column drag-reorder) via call_after, avoiding a
  use-after-free.
- num_value returns None for a blank-displaying value-type cell (Hashrate,
  Power, ChipTemp, ...), so "ChipTemp <= 50" no longer matches a miner with no
  temperature reading.
- Value checklist maps a checked entry back to its real value by index, so a
  literal "(blank)" value is not confused with an empty cell.

Verified off-screen: 45 unit tests, headless self-test (14 checks), and
interaction screenshots of selection, right-click, the text/numeric filter, the
comparator swap, and dark mode.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 09:19:38 -06:00
noahandClaude Opus 4.8 7fac0ce726 CI: make the headless UI self-test a hard gate
The self-test was continue-on-error while the container display path was
unproven. Run 529 confirmed it launches and passes (SELFTEST PASS) once xauth
was installed, so remove continue-on-error: a future regression that breaks GUI
init now fails the build instead of releasing silently.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-16 19:30:17 -06:00
16 changed files with 5918 additions and 367 deletions
-1
View File
@@ -75,7 +75,6 @@ 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 xauth dbus-x11 fonts-dejavu-core >/dev/null
Generated
+3
View File
@@ -80,6 +80,9 @@ dependencies = [
"alkane-discovery",
"asic-rs",
"futures-util",
"measurements",
"serde",
"serde_json",
"tokio",
"wx-rs",
]
+3
View File
@@ -14,5 +14,8 @@ 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"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
+115
View File
@@ -0,0 +1,115 @@
//! Real access / lock-state detection: whether this miner accepts privileged
//! (credentialed) command writes, or is view-only.
//!
//! asic-rs has no lock-state signal (a wrong-password miner just silently
//! returns fewer fields, because the collector drops the 401). We build the real
//! check ON TOP of asic-rs: a NON-mutating, digest-authenticated GET to a
//! privileged endpoint. On Antminer every `/cgi-bin/*.cgi` requires digest auth,
//! so the HTTP status is decisive -- 200 means our credentials authenticate
//! (we can write -> unlocked), 401/403 means they are rejected (view-only ->
//! locked). We probe `get_miner_conf.cgi`, which is read-only (never the
//! mutating `set_miner_conf.cgi`).
//!
//! We shell out to `curl --digest` (already present, supports digest auth)
//! rather than add an HTTP+digest crate, so the offline/vendored build is
//! unaffected. `Some(true)` = locked, `Some(false)` = unlocked, `None` =
//! indeterminate (unreachable, or an endpoint/vendor this probe doesn't cover).
use std::process::Command;
use std::time::Duration;
/// Classify a miner's access state from an HTTP status code string (curl's
/// `%{http_code}` output). Conservative: anything other than a clear
/// authenticated/unauthorized answer is `None`.
pub fn classify_http_code(code: &str) -> Option<bool> {
match code.trim() {
"200" | "204" => Some(false), // authenticated -> unlocked/writable
"401" | "403" => Some(true), // rejected -> locked/view-only
_ => None, // 000 (no connect), 404, 5xx, ... -> unknown
}
}
/// The privileged, read-only endpoint we probe per firmware family. Antminer
/// stock/aftermarket all gate `get_miner_conf.cgi` behind digest auth.
fn endpoint(_firmware: &str) -> &'static str {
"/cgi-bin/get_miner_conf.cgi"
}
/// Probe one miner's access state over its web API with the given credentials.
/// Returns `Ok(Some(true/false))` on a decisive lock/unlock answer, `Ok(None)`
/// if reachable-but-indeterminate or a vendor this probe doesn't cover, or
/// `Err` only on a failure to run curl at all.
pub fn probe_access(ip: &str, firmware: &str, user: &str, pass: &str) -> Result<Option<bool>, String> {
let url = format!("http://{ip}{}", endpoint(firmware));
let userpass = format!("{user}:{pass}");
let mut cmd = Command::new("curl");
cmd.args([
"-s",
"-o",
"/dev/null",
"-w",
"%{http_code}",
"--digest",
"-u",
&userpass,
"--connect-timeout",
"5",
"--max-time",
"9",
&url,
]);
let out = wait_with_timeout(cmd, Duration::from_secs(12))?;
// curl prints the status code to stdout regardless of exit status (000 on a
// connection failure), so classify the code rather than the exit status.
let code = String::from_utf8_lossy(&out.stdout);
Ok(classify_http_code(&code))
}
/// Run a command with a wall-clock timeout (curl can hang past --max-time on a
/// black-holed host).
fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process::Output, String> {
use std::io::Read;
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
let start = std::time::Instant::now();
loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(status) => {
let mut stdout = Vec::new();
let mut stderr = Vec::new();
if let Some(mut o) = child.stdout.take() {
let _ = o.read_to_end(&mut stdout);
}
if let Some(mut e) = child.stderr.take() {
let _ = e.read_to_end(&mut stderr);
}
return Ok(std::process::Output { status, stdout, stderr });
}
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
return Err("curl timed out".into());
}
std::thread::sleep(Duration::from_millis(100));
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classify_codes() {
assert_eq!(classify_http_code("200"), Some(false), "authenticated -> unlocked");
assert_eq!(classify_http_code("204"), Some(false));
assert_eq!(classify_http_code("401"), Some(true), "unauthorized -> locked");
assert_eq!(classify_http_code("403"), Some(true));
assert_eq!(classify_http_code("000"), None, "no connection -> unknown");
assert_eq!(classify_http_code("404"), None, "endpoint absent -> unknown");
assert_eq!(classify_http_code("500"), None);
assert_eq!(classify_http_code(" 200 "), Some(false), "whitespace tolerated");
assert_eq!(classify_http_code(""), None);
}
}
+158
View File
@@ -0,0 +1,158 @@
//! 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";
/// SSH login for the control board (used by the PIC probe; distinct from the
/// web/API scan credentials above -- miners' SSH root login is usually not the
/// same account as the web digest-auth login).
pub const SSH_CREDENTIALS_FILE: &str = "ssh-credentials.txt";
/// Load a saved username/password pair from `file`, if present.
fn load_creds_file(file: &str) -> Option<(String, String)> {
let s = std::fs::read_to_string(config_path(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 a username/password pair to `file`, restricting it to owner read/write
/// (credentials are plaintext on disk, so the mode matters).
fn save_creds_file(file: &str, user: &str, pass: &str) -> std::io::Result<()> {
let p = config_path(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(())
}
fn clear_creds_file(file: &str) -> std::io::Result<()> {
match std::fs::remove_file(config_path(file)) {
Ok(()) => Ok(()),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
Err(e) => Err(e),
}
}
/// Load the saved miner web/API username/password, if any were saved.
pub fn load_credentials() -> Option<(String, String)> {
load_creds_file(CREDENTIALS_FILE)
}
/// Save the miner web/API username/password (0600).
pub fn save_credentials(user: &str, pass: &str) -> std::io::Result<()> {
save_creds_file(CREDENTIALS_FILE, user, pass)
}
/// Load the saved SSH username/password for the PIC probe, if any.
pub fn load_ssh_credentials() -> Option<(String, String)> {
load_creds_file(SSH_CREDENTIALS_FILE)
}
/// Save the SSH username/password for the PIC probe (0600).
pub fn save_ssh_credentials(user: &str, pass: &str) -> std::io::Result<()> {
save_creds_file(SSH_CREDENTIALS_FILE, user, pass)
}
/// Remove the saved web/API credentials, if any. Not an error if none were saved.
pub fn clear_credentials() -> std::io::Result<()> {
match clear_creds_file(CREDENTIALS_FILE) {
Ok(()) => 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);
}
}
+88 -15
View File
@@ -2,7 +2,8 @@
//! 10.255.1.0/24 (see ../../../HANDOFF.md section 7 and the parent project's
//! [removed]). These are the reference values the workflow tests compare
//! the application's actual output against, and the rows the offline
//! `ALKANE_FAKE_SCAN` demo mode renders.
//! `ALKANE_FAKE_SCAN` demo mode renders. Only miners that respond become rows,
//! so there is no synthetic "offline" fixture.
//!
//! Hashrate/power/temp are representative per-model figures (the bench boards
//! are not always energised); the point of the fixtures is a fixed, known input
@@ -24,6 +25,10 @@ struct Board {
fan: f64,
worker: &'static str,
mining: bool,
/// True for the bench board deliberately rebucketed into the "paused"
/// status/KPI bucket (not-mining but operator-paused, distinct from a
/// unit that is simply idle/not-hashing).
paused: bool,
}
impl Board {
@@ -37,6 +42,18 @@ impl Board {
} else {
(None, None, 0.0)
};
let fan_rpms = if self.mining {
vec![self.fan, self.fan * 0.95, self.fan * 1.02]
} else {
vec![]
};
// Firmware-flash capability is modeled on the real Bitmain/Antminer
// upgrade path (S17/S19/S21 family); WhatsMiner boards in this fleet
// don't advertise it, so both true and false show up and the
// firmware menu item is testable.
let firmware_flash = self.model == "Antminer S17"
|| self.model.starts_with("Antminer S19")
|| self.model.starts_with("Antminer S21");
MinerRow {
ip: self.ip.to_string(),
selected: false,
@@ -47,10 +64,12 @@ impl Board {
efficiency,
power_w: self.power,
chip_temp_c: self.temp,
fan_rpm: self.fan,
fan_rpms,
worker: self.worker.to_string(),
is_mining: self.mining,
slow,
paused: self.paused,
// offline defaults to false (online); these bench rows are reachable.
mac: format!("AA:BB:CC:00:{:02X}:{last_octet:02X}", last_octet.wrapping_mul(3)),
hostname: format!("miner-{last_octet}"),
hashboards: boards,
@@ -68,47 +87,101 @@ 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,
},
// Demo values for the round-8/9 columns (synthetic, so the columns
// show variety offline).
algorithm: "SHA256".to_string(),
control_board: if self.model.contains("S17") {
"Xilinx".to_string()
} else if self.model.contains("S19j") || self.model.contains("S19k") {
"AMLogic".to_string()
} else if self.model.contains("S19") {
"BeagleBone Black".to_string()
} else if self.model.contains("S21") {
"CVITek".to_string()
} else {
String::new()
},
pic_present: if self.model.contains("S21") {
Some(false) // noPIC example
} else if self.model.starts_with("Antminer") {
Some(true)
} else {
None // WhatsMiner: unknown over the network
},
// Access: idle/view-only units (no worker) shown locked; the rest
// unlocked. (Live rows infer this from control capabilities.)
write_locked: Some(self.worker.is_empty()),
errors: if self.model.contains("S21 Pro") {
vec![
"[Warning] hashrate 70% below expected".to_string(),
"[Warning] chip temperature high (HashBoard 2)".to_string(),
]
} else {
Vec::new()
},
..Default::default()
}
}
}
/// The 9 bench boards. Two are idle (S17 stock, WardenOS dev), one is slow
/// (S21 Pro aml stock at ~30% of expected); the other six hash normally.
/// The 9 bench boards (9 rows total). One is idle/not-hashing (S17 stock,
/// .112); one is paused (WardenOS dev, .115 - deliberately rebucketed from idle
/// so the "paused" status/KPI bucket is exercisable offline); one is slow (S21
/// Pro aml stock at ~30% of expected); the other six hash normally.
///
/// Derived totals (used by the workflow tests):
/// total = 9, hashing = 6, slow = 1, not hashing = 2,
/// total = 9, hashing = 6, slow = 1, not hashing = 1, paused = 1,
/// total hashrate = 685.0 TH/s, total power = 21300 W.
pub fn bench_fleet() -> Vec<MinerRow> {
let boards = [
Board { ip: "10.255.1.112", model: "Antminer S17", firmware: "Stock",
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
worker: "", mining: false },
worker: "", mining: false, paused: false },
Board { ip: "10.255.1.166", model: "Antminer S19", firmware: "[removed] 1.2",
hashrate: 95.0, expected: 96.0, power: 3250.0, temp: 65.0, fan: 4200.0,
worker: "blueflare.s19", mining: true },
worker: "blueflare.s19", mining: true, paused: false },
Board { ip: "10.255.1.152", model: "Antminer S19j Pro", firmware: "[removed] 1.2",
hashrate: 100.0, expected: 104.0, power: 3100.0, temp: 62.0, fan: 3900.0,
worker: "blueflare.s19jpro", mining: true },
worker: "blueflare.s19jpro", mining: true, paused: false },
Board { ip: "10.255.1.167", model: "Antminer S19k Pro", firmware: "[removed] 1.2",
hashrate: 120.0, expected: 128.0, power: 3300.0, temp: 68.0, fan: 4500.0,
worker: "blueflare.s19kpro", mining: true },
worker: "blueflare.s19kpro", mining: true, paused: false },
Board { ip: "10.255.1.149", model: "Antminer S21 Pro", firmware: "Stock",
hashrate: 60.0, expected: 200.0, power: 1500.0, temp: 55.0, fan: 3000.0,
worker: "blueflare.s21pro", mining: true }, // slow: 60/200 = 30%
worker: "blueflare.s21pro", mining: true, paused: false }, // slow: 60/200 = 30%
Board { ip: "10.255.1.126", model: "WhatsMiner M30S", firmware: "WMOS H3",
hashrate: 92.0, expected: 96.0, power: 3400.0, temp: 70.0, fan: 4800.0,
worker: "blueflare.h3", mining: true },
worker: "blueflare.h3", mining: true, paused: false },
Board { ip: "10.255.1.131", model: "WhatsMiner M30S+", firmware: "WMOS H616",
hashrate: 100.0, expected: 100.0, power: 3450.0, temp: 71.0, fan: 4900.0,
worker: "blueflare.h616", mining: true },
worker: "blueflare.h616", mining: true, paused: false },
Board { ip: "10.255.1.148", model: "WhatsMiner M50", firmware: "WMOS CB4",
hashrate: 118.0, expected: 122.0, power: 3300.0, temp: 66.0, fan: 4600.0,
worker: "blueflare.m50", mining: true },
worker: "blueflare.m50", mining: true, paused: false },
// Rebucketed from idle/not-hashing to paused so the "paused"
// status/KPI bucket is exercisable in the fake-scan/offline demo.
Board { ip: "10.255.1.115", model: "Antminer S19", firmware: "WardenOS dev",
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
worker: "", mining: false },
worker: "", mining: false, paused: true },
];
boards.into_iter().map(Board::into_row).collect()
}
+4
View File
@@ -1,8 +1,12 @@
//! alkane-toolkit — primary view (docs/UI-SPEC.md).
//! Pure-Rust wxWidgets app on the vendored, patched wx-rs.
mod access_probe;
mod credentials;
mod fixtures;
mod model;
mod pic_probe;
mod presets;
mod scan;
mod ui;
File diff suppressed because it is too large Load Diff
+223
View File
@@ -0,0 +1,223 @@
//! Real PIC-vs-noPIC detection for Antminer control boards, over SSH + i2c-tools.
//!
//! asic-rs and the miner's network API cannot report PIC presence (see the
//! project wiki, 30-power-thermal-and-board-identity/hashboard-eeprom-pic.md);
//! the authoritative tell lives on the control board's I2C bus. On a
//! PIC/MCU-equipped board, I2C 0x48 is a hashboard MCU exposing an 8-byte
//! register file that WRAPS every 8 bytes (e.g. `17 00 4b 50 7f 00 00 00 ...`);
//! on a noPIC board, 0x48 is a plain LM75 temperature sensor with a 4-register
//! layout that wraps every 4 bytes. We read 0x48 with `i2cdump` over SSH and
//! discriminate by that period.
//!
//! This is a slow, credentialed, opt-in probe (an SSH handshake + shell command
//! per miner), never part of the fast network scan. We shell out to `ssh`
//! (via `sshpass` for password auth) rather than pull in an SSH crate, so the
//! offline/vendored build is unaffected.
use std::process::Command;
use std::time::Duration;
/// SSH login for the miner's control board (distinct from the web/API creds).
#[derive(Debug, Clone)]
pub struct SshCreds {
pub user: String,
/// Empty means key-based auth (BatchMode); otherwise `sshpass` is used.
pub pass: String,
}
/// Which I2C bus to probe, chosen from the control-board family. AMLogic uses
/// i2c-1, BeagleBone uses i2c-0; for anything else (Xilinx/CVITek/unknown) we
/// try both. The wiki confirms the AML/BB buses; Zynx/CVITek are unconfirmed.
pub fn bus_candidates(control_board: &str) -> Vec<u8> {
let cb = control_board.to_lowercase();
if cb.contains("amlogic") || cb.contains("aml") {
vec![1]
} else if cb.contains("beaglebone") || cb.contains("bb") {
vec![0]
} else {
vec![1, 0]
}
}
/// Classify an `i2cdump -y <bus> 0x48 b` dump: `Some(true)` = PIC (8-byte MCU
/// register file), `Some(false)` = noPIC (4-register LM75), `None` = couldn't
/// tell (address unresponsive, no periodicity, or unparseable). Conservative:
/// anything ambiguous is `None`, never a guess.
pub fn classify_i2cdump(stdout: &str) -> Option<bool> {
let bytes = parse_dump_offset0(stdout)?;
// An LM75's 4 registers repeat every 4 bytes; check that first because a
// period-4 sequence is trivially also period-8.
let period4 = (0..12).all(|i| bytes[i] == bytes[i + 4]);
if period4 {
return Some(false); // LM75 -> noPIC
}
let period8 = (0..8).all(|i| bytes[i] == bytes[i + 8]);
if period8 {
return Some(true); // 8-byte MCU register file -> PIC
}
None
}
/// Parse the 16 bytes of the `00:` row of an `i2cdump ... b` output. Returns
/// `None` if the row is missing or any cell is unreadable ("XX").
fn parse_dump_offset0(stdout: &str) -> Option<[u8; 16]> {
let line = stdout.lines().find_map(|l| {
let l = l.trim();
l.strip_prefix("00:").map(str::trim_start)
})?;
// The row is "<16 hex/XX cells> <ascii gutter>"; take the first 16 cells.
let mut out = [0u8; 16];
let mut n = 0;
for tok in line.split_whitespace() {
if n == 16 {
break;
}
if tok.len() != 2 {
break; // reached the ascii gutter
}
match u8::from_str_radix(tok, 16) {
Ok(b) => {
out[n] = b;
n += 1;
}
Err(_) => return None, // "XX" = no response -> indeterminate
}
}
(n == 16).then_some(out)
}
/// Build the ssh argv for one `i2cdump` on `bus`. Uses `sshpass -p <pass>` when
/// a password is set, else relies on key auth (BatchMode).
fn ssh_command(ip: &str, bus: u8, creds: &SshCreds) -> Command {
let remote = format!("i2cdump -y {bus} 0x48 b");
let target = format!("{}@{ip}", creds.user);
let ssh_opts = [
"-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"-o", "ConnectTimeout=6",
"-o", "NumberOfPasswordPrompts=1",
];
if creds.pass.is_empty() {
let mut c = Command::new("ssh");
c.arg("-o").arg("BatchMode=yes");
c.args(ssh_opts).arg(&target).arg(&remote);
c
} else {
// sshpass reads the password from the env var named after -e's default,
// but we use -p for simplicity; the password never reaches the argv of
// a child that logs it (sshpass scrubs its own argv).
let mut c = Command::new("sshpass");
c.arg("-p").arg(&creds.pass).arg("ssh");
c.args(ssh_opts).arg(&target).arg(&remote);
c
}
}
/// Probe one miner's PIC state over SSH. Returns `Ok(Some(true/false))` on a
/// confident PIC/noPIC read, `Ok(None)` if reachable but indeterminate, or
/// `Err` on an SSH/connection/auth failure.
pub fn probe_pic(ip: &str, control_board: &str, creds: &SshCreds) -> Result<Option<bool>, String> {
let mut last_err = String::from("no i2c bus responded");
for bus in bus_candidates(control_board) {
match run_probe(ip, bus, creds) {
Ok(Some(v)) => return Ok(Some(v)),
Ok(None) => last_err = format!("i2c-0x48 on bus {bus} was indeterminate"),
Err(e) => return Err(e), // an auth/connection error won't improve on another bus
}
}
// Reachable but couldn't classify on any candidate bus.
let _ = last_err;
Ok(None)
}
fn run_probe(ip: &str, bus: u8, creds: &SshCreds) -> Result<Option<bool>, String> {
let out = wait_with_timeout(ssh_command(ip, bus, creds), Duration::from_secs(12))?;
if !out.status.success() {
let err = String::from_utf8_lossy(&out.stderr);
// A failed i2cdump on this bus (e.g. bus doesn't exist) is not fatal --
// let the caller try the next bus. But an SSH/auth failure is fatal.
let e = err.trim().to_string();
if e.to_lowercase().contains("permission denied")
|| e.to_lowercase().contains("connection")
|| e.to_lowercase().contains("timed out")
|| e.to_lowercase().contains("no route")
|| e.to_lowercase().contains("host key")
{
return Err(if e.is_empty() { "ssh failed".into() } else { e });
}
return Ok(None);
}
Ok(classify_i2cdump(&String::from_utf8_lossy(&out.stdout)))
}
/// Run a command with a wall-clock timeout (SSH can hang on a dead host).
fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process::Output, String> {
use std::io::Read;
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
let mut child = cmd.spawn().map_err(|e| format!("spawn ssh: {e}"))?;
let start = std::time::Instant::now();
loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(status) => {
let mut stdout = Vec::new();
let mut stderr = Vec::new();
if let Some(mut o) = child.stdout.take() {
let _ = o.read_to_end(&mut stdout);
}
if let Some(mut e) = child.stderr.take() {
let _ = e.read_to_end(&mut stderr);
}
return Ok(std::process::Output { status, stdout, stderr });
}
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
return Err("ssh timed out".into());
}
std::thread::sleep(Duration::from_millis(100));
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classify_pic_from_wiki_dump() {
// The wiki's PIC/MCU board dump: 8-byte register file that wraps.
let dump = "\
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 17 00 4b 50 7f 00 00 00 17 00 4b 50 7f 00 00 00 ................
10: 17 00 4b 50 7f 00 00 00 17 00 4b 50 7f 00 00 00 ................";
assert_eq!(classify_i2cdump(dump), Some(true), "8-byte wrap -> PIC");
}
#[test]
fn classify_nopic_from_lm75() {
// An LM75 has 4 registers (temp/config/Thyst/Tos) that wrap every 4.
let dump = "\
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 19 00 4b 50 19 00 4b 50 19 00 4b 50 19 00 4b 50 ................";
assert_eq!(classify_i2cdump(dump), Some(false), "4-register LM75 -> noPIC");
}
#[test]
fn classify_indeterminate() {
// No response (XX) or no periodicity -> None (never a guess).
let xx = "00: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX";
assert_eq!(classify_i2cdump(xx), None);
let noisy = "00: 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10";
assert_eq!(classify_i2cdump(noisy), None);
assert_eq!(classify_i2cdump("no offset row here"), None);
}
#[test]
fn bus_from_control_board() {
assert_eq!(bus_candidates("AMLogic"), vec![1]);
assert_eq!(bus_candidates("BeagleBone Black"), vec![0]);
assert_eq!(bus_candidates("Xilinx"), vec![1, 0]);
assert_eq!(bus_candidates(""), vec![1, 0]);
}
}
+146
View File
@@ -0,0 +1,146 @@
//! Saved view presets: named snapshots of the table's column arrangement,
//! visibility, sort, and filters. Persisted as JSON in the config dir. The
//! first preset is always a built-in "Default" profile.
use std::collections::{HashMap, HashSet};
use serde::{Deserialize, Serialize};
use crate::model::{ColFilter, Column, ViewState, ALL_COLUMNS};
use crate::scan::config_path;
pub const PRESETS_FILE: &str = "presets.json";
/// The built-in default profile's visible columns, in display order (Ip first).
const DEFAULT_PROFILE: [Column; 9] = [
Column::Ip,
Column::Model,
Column::Hashrate,
Column::Power,
Column::ChipTemp,
Column::Firmware,
Column::ControlBoard,
Column::Pic,
Column::Status,
];
/// A serializable snapshot of a `ViewState` (Vec-based so JSON has no map keys
/// that are enums, and column order within `visible` is preserved).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresetView {
pub order: Vec<Column>,
pub visible: Vec<Column>,
pub sort: Option<(Column, bool)>,
pub filters: Vec<(Column, ColFilter)>,
}
impl PresetView {
pub fn from_view(v: &ViewState) -> PresetView {
PresetView {
order: v.order.clone(),
// keep the visible columns in display order for stability
visible: v.order.iter().copied().filter(|c| v.visible.contains(c)).collect(),
sort: v.sort,
filters: v.filters.iter().map(|(k, f)| (*k, f.clone())).collect(),
}
}
/// Rebuild a `ViewState` from this snapshot. Any column missing from a
/// loaded (possibly older) preset is appended to `order` and left hidden, so
/// the result always covers every `Column`.
pub fn to_view(&self) -> ViewState {
let mut order = self.order.clone();
for c in ALL_COLUMNS {
if !order.contains(&c) {
order.push(c);
}
}
let mut visible: HashSet<Column> = self.visible.iter().copied().collect();
visible.insert(Column::Ip); // IP is always shown
let filters: HashMap<Column, ColFilter> = self.filters.iter().cloned().collect();
ViewState { order, visible, sort: self.sort, filters }
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Preset {
pub name: String,
pub view: PresetView,
}
/// The built-in default profile (always present as the first preset).
pub fn default_preset() -> Preset {
let mut order: Vec<Column> = DEFAULT_PROFILE.to_vec();
for c in ALL_COLUMNS {
if !order.contains(&c) {
order.push(c);
}
}
Preset {
name: "Default".to_string(),
view: PresetView {
order,
visible: DEFAULT_PROFILE.to_vec(),
sort: None,
filters: Vec::new(),
},
}
}
/// Load saved presets, always with the built-in "Default" first. A missing or
/// unreadable file yields just the default.
pub fn load_presets() -> Vec<Preset> {
let mut presets = std::fs::read_to_string(config_path(PRESETS_FILE))
.ok()
.and_then(|s| serde_json::from_str::<Vec<Preset>>(&s).ok())
.unwrap_or_default();
// The default profile is always present and always first.
presets.retain(|p| p.name != "Default");
presets.insert(0, default_preset());
presets
}
/// Persist presets (the built-in "Default" is not written; it is re-seeded on
/// load). Best-effort: errors are returned for the caller to surface.
pub fn save_presets(presets: &[Preset]) -> std::io::Result<()> {
let p = config_path(PRESETS_FILE);
if let Some(dir) = p.parent() {
std::fs::create_dir_all(dir)?;
}
let user: Vec<&Preset> = presets.iter().filter(|p| p.name != "Default").collect();
let json = serde_json::to_string_pretty(&user)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
std::fs::write(p, json)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_preset_round_trips_through_view() {
let p = default_preset();
let view = p.view.to_view();
// IP first + the requested default columns visible.
assert!(view.visible.contains(&Column::Ip));
assert!(view.visible.contains(&Column::ControlBoard));
assert!(view.visible.contains(&Column::Pic));
assert!(view.visible.contains(&Column::Status));
assert!(!view.visible.contains(&Column::Cooling), "not in the default profile");
// to_view covers every column in `order`.
assert_eq!(view.order.len(), ALL_COLUMNS.len());
// Round-trip a snapshot back out.
let snap = PresetView::from_view(&view);
assert_eq!(snap.visible.first(), Some(&Column::Ip));
}
#[test]
fn preset_json_round_trip() {
let p = default_preset();
let json = serde_json::to_string(&vec![&p]).unwrap();
let back: Vec<Preset> = serde_json::from_str(&json).unwrap();
assert_eq!(back.len(), 1);
assert_eq!(back[0].name, "Default");
assert_eq!(back[0].view.visible, DEFAULT_PROFILE.to_vec());
}
}
+763 -10
View File
@@ -1,10 +1,11 @@
//! 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;
@@ -119,6 +120,32 @@ pub fn parse_line(line: &str) -> Result<Vec<Ipv4Addr>, String> {
}
return Ok((0..count).map(|i| Ipv4Addr::from(base + i as u32)).collect());
}
// Per-octet ranges: each of the four octets may be a single number or an
// inclusive `a-b` range, e.g. "10.1-9.1.1-255" scans the cartesian product
// (the 9 /24s: 10.1.1.x .. 10.9.1.x). This also subsumes a plain single
// address and a bare last-octet range like "10.253.1.3-234".
let parts: Vec<&str> = line.split('.').collect();
if parts.len() == 4 && parts.iter().all(|p| is_octet_spec(p)) {
let r: Vec<(u8, u8)> =
parts.iter().map(|p| parse_octet_spec(p)).collect::<Result<_, String>>()?;
let count: u64 = r.iter().map(|(lo, hi)| (*hi as u64 - *lo as u64 + 1)).product();
if count > MAX_ADDRS {
return Err(format!("range too large (> {MAX_ADDRS} addresses): {line}"));
}
let mut out = Vec::with_capacity(count as usize);
for a in r[0].0..=r[0].1 {
for b in r[1].0..=r[1].1 {
for c in r[2].0..=r[2].1 {
for d in r[3].0..=r[3].1 {
out.push(Ipv4Addr::new(a, b, c, d));
}
}
}
}
return Ok(out);
}
// Full A-B range across two dotted addresses (e.g. "10.0.0.1-10.7.255.254"),
// which the per-octet form above cannot express.
if let Some((start_s, end_s)) = line.split_once('-') {
let start: Ipv4Addr = start_s
.trim()
@@ -147,6 +174,27 @@ pub fn parse_line(line: &str) -> Result<Vec<Ipv4Addr>, String> {
Ok(vec![addr])
}
/// Parse one octet spec: `"n"` -> `(n, n)`, or `"a-b"` -> `(a, b)` inclusive
/// (rejecting `a > b`). Used by the per-octet range form in `parse_line`.
fn parse_octet_spec(s: &str) -> Result<(u8, u8), String> {
let s = s.trim();
if let Some((lo, hi)) = s.split_once('-') {
let lo: u8 = lo.trim().parse().map_err(|_| format!("bad octet range: {s}"))?;
let hi: u8 = hi.trim().parse().map_err(|_| format!("bad octet range: {s}"))?;
if lo > hi {
return Err(format!("octet range start after end: {s}"));
}
Ok((lo, hi))
} else {
let n: u8 = s.parse().map_err(|_| format!("bad octet: {s}"))?;
Ok((n, n))
}
}
fn is_octet_spec(s: &str) -> bool {
parse_octet_spec(s).is_ok()
}
fn prefix_mask(prefix: u8) -> u32 {
if prefix == 0 {
0
@@ -305,7 +353,7 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
}
};
rt.block_on(async move {
let mut factory = MinerFactory::new();
let mut factory = crate::credentials::configured_factory();
for (ip, prefix) in &cidrs {
factory = match factory.with_subnet(&format!("{ip}/{prefix}")) {
Ok(f) => f,
@@ -325,8 +373,13 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
return; // Stop / re-scan requested
}
done += 1;
if let Some(miner) = miner {
let row = to_row(&*miner).await;
// Only surface a row for an address that actually has a miner
// behind it. A non-responding address is not shown -- we never
// fabricate a phantom "offline" row for an empty IP; a miner is
// reported as "not hashing" only when it responds and we can see
// it is not mining.
if let Some(m) = miner {
let row = to_row(&*m).await;
if tx.send(ScanMsg::Row(row)).is_err() {
return; // UI gone
}
@@ -344,6 +397,34 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
ScanHandle { rx, cancel }
}
/// Flatten a miner's structured messages into display lines, most severe first
/// ("[Error] text (component)"), for the Errors column + hover tooltip.
fn summarize_messages(messages: &[asic_rs::core::data::message::MinerMessage]) -> Vec<String> {
use asic_rs::core::data::message::MessageSeverity;
let rank = |s: &MessageSeverity| match s {
MessageSeverity::Error => 0u8,
MessageSeverity::Warning => 1,
MessageSeverity::Info => 2,
};
let mut ranked: Vec<(u8, String)> = messages
.iter()
.map(|m| {
let sev = match m.severity {
MessageSeverity::Error => "Error",
MessageSeverity::Warning => "Warning",
MessageSeverity::Info => "Info",
};
let line = match &m.component {
Some(c) => format!("[{sev}] {} ({c})", m.message),
None => format!("[{sev}] {}", m.message),
};
(rank(&m.severity), line)
})
.collect();
ranked.sort_by_key(|(r, _)| *r);
ranked.into_iter().map(|(_, s)| s).collect()
}
async fn to_row(miner: &dyn Miner) -> MinerRow {
let data = miner.get_data().await;
let hashrate_ths = data
@@ -362,11 +443,11 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
.as_ref()
.map(|t| t.as_celsius())
.unwrap_or(0.0);
let fan_rpm = data
let fan_rpms: Vec<f64> = data
.fans
.iter()
.filter_map(|f| f.rpm.as_ref().map(|r| r.as_rpm()))
.fold(0.0f64, f64::max);
.map(|f| f.rpm.as_ref().map(|r| r.as_rpm()).unwrap_or(0.0))
.collect();
let worker = data
.pools
.iter()
@@ -417,11 +498,38 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
.iter()
.filter_map(|f| f.rpm.as_ref().map(|r| r.as_rpm()))
.fold(0.0f64, f64::max);
let algorithm = data.hashrate.as_ref().map(|h| h.algo.to_string()).unwrap_or_default();
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(),
};
// PIC vs noPIC is not reported over the network by asic-rs; best-effort
// heuristic from the model string, else unknown (true detection needs an
// on-board SSH/I2C probe -- a separate feature).
let pic_present = if model.to_lowercase().contains("nopic") { Some(false) } else { None };
// Access: locked/view-only when the miner exposes no writable control at
// all, otherwise unlocked. Inferred from capabilities (asic-rs has no direct
// lock-state field).
let write_locked = Some(!caps.any_control());
let errors = summarize_messages(&data.messages);
MinerRow {
ip: data.ip.to_string(),
selected: false,
caps,
algorithm,
pic_present,
write_locked,
errors,
model,
mac: data.mac.map(|m| m.to_string()).unwrap_or_default(),
hostname: data.hostname.clone().unwrap_or_default(),
@@ -437,7 +545,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),
@@ -452,13 +560,513 @@ 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) => "flash lights on".into(),
ConfigAction::FaultLight(false) => "flash lights 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 }
}
/// Progress/results from a background SSH PIC probe of specific miners.
pub enum PicProbeMsg {
Started { total: usize },
/// One miner's PIC result: `pic` = Some(true/false)/None (indeterminate),
/// or `error` set on an SSH/connection failure.
Result { ip: String, pic: Option<bool>, error: Option<String> },
Done { total: usize },
}
/// A running PIC probe; `stop` cancels the remaining miners.
pub struct PicProbeHandle {
pub rx: Receiver<PicProbeMsg>,
cancel: Arc<AtomicBool>,
}
impl PicProbeHandle {
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
}
/// Probe the PIC state of `targets` (ip + control-board string) over SSH on a
/// background thread, one miner at a time (each is a slow SSH round trip). In
/// fake-scan mode it reports simulated results without touching the network.
pub fn start_pic_probe(
targets: Vec<(String, String)>,
creds: crate::pic_probe::SshCreds,
) -> PicProbeHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
let total = targets.len();
let _ = tx.send(PicProbeMsg::Started { total });
if fake_scan_enabled() {
let err_tx = tx.clone();
let thread_cancel = cancel.clone();
let res = std::thread::Builder::new().name("fake-pic-probe".into()).spawn(move || {
for (ip, cb) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
// Deterministic demo: Antminer S21 (CVITek) noPIC, other
// Antminers PIC, WhatsMiner indeterminate.
let pic = if cb.to_lowercase().contains("cvitek") {
Some(false)
} else if !cb.is_empty() {
Some(true)
} else {
None
};
let _ = tx.send(PicProbeMsg::Result { ip, pic, error: None });
}
let _ = tx.send(PicProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(PicProbeMsg::Done { total });
}
return PicProbeHandle { rx, cancel };
}
let thread_cancel = cancel.clone();
let err_tx = tx.clone();
let res = std::thread::Builder::new().name("pic-probe".into()).spawn(move || {
for (ip, cb) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let (pic, error) = match crate::pic_probe::probe_pic(&ip, &cb, &creds) {
Ok(v) => (v, None),
Err(e) => (None, Some(e)),
};
if tx.send(PicProbeMsg::Result { ip, pic, error }).is_err() {
return; // UI gone
}
}
let _ = tx.send(PicProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(PicProbeMsg::Done { total });
}
PicProbeHandle { rx, cancel }
}
/// Progress/results from a background access (lock-state) probe.
pub enum AccessProbeMsg {
Started { total: usize },
/// `locked` = Some(true) locked/view-only, Some(false) unlocked/writable,
/// None indeterminate; `error` set only when the probe couldn't run.
Result { ip: String, locked: Option<bool>, error: Option<String> },
Done { total: usize },
}
/// A running access probe; `stop` cancels the remaining miners.
pub struct AccessProbeHandle {
pub rx: Receiver<AccessProbeMsg>,
cancel: Arc<AtomicBool>,
}
impl AccessProbeHandle {
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
}
/// Probe the access/lock state of `targets` (ip + firmware string) over the web
/// API with `creds` (user, pass), on a background thread. A digest-auth GET is
/// fast, but we still run one miner at a time with cancel-between. Fake-scan mode
/// returns deterministic demo results.
pub fn start_access_probe(
targets: Vec<(String, String)>,
creds: (String, String),
) -> AccessProbeHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
let total = targets.len();
let _ = tx.send(AccessProbeMsg::Started { total });
let (user, pass) = creds;
if fake_scan_enabled() {
let err_tx = tx.clone();
let thread_cancel = cancel.clone();
let res = std::thread::Builder::new().name("fake-access-probe".into()).spawn(move || {
for (ip, _fw) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
// Demo: the WardenOS-dev unit (.115) is locked, others unlocked.
let locked = Some(ip.ends_with(".115"));
let _ = tx.send(AccessProbeMsg::Result { ip, locked, error: None });
}
let _ = tx.send(AccessProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(AccessProbeMsg::Done { total });
}
return AccessProbeHandle { rx, cancel };
}
let thread_cancel = cancel.clone();
let err_tx = tx.clone();
let res = std::thread::Builder::new().name("access-probe".into()).spawn(move || {
for (ip, fw) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let (locked, error) = match crate::access_probe::probe_access(&ip, &fw, &user, &pass) {
Ok(v) => (v, None),
Err(e) => (None, Some(e)),
};
if tx.send(AccessProbeMsg::Result { ip, locked, error }).is_err() {
return; // UI gone
}
}
let _ = tx.send(AccessProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(AccessProbeMsg::Done { total });
}
AccessProbeHandle { rx, cancel }
}
#[cfg(test)]
mod tests {
@@ -493,6 +1101,31 @@ mod tests {
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(10, 253, 1, 234));
}
#[test]
fn parse_per_octet_ranges() {
// The user's example: 9 /24s (octet2 1..9), each with .1.1-255.
let ips = parse_line("10.1-9.1.1-255").unwrap();
assert_eq!(ips.len(), 9 * 255, "9 /24 ranges of 255 addresses each");
assert_eq!(ips[0], Ipv4Addr::new(10, 1, 1, 1), "ascending, first combo");
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(10, 9, 1, 255));
// Ordered by octet: the second address is .1.1.2, the 256th is .2.1.1.
assert_eq!(ips[1], Ipv4Addr::new(10, 1, 1, 2));
assert_eq!(ips[255], Ipv4Addr::new(10, 2, 1, 1));
// Ranges in more than one octet.
let ips = parse_line("192.168.0-1.10-12").unwrap();
assert_eq!(ips.len(), 2 * 3);
assert_eq!(ips[0], Ipv4Addr::new(192, 168, 0, 10));
assert_eq!(*ips.last().unwrap(), Ipv4Addr::new(192, 168, 1, 12));
// A single address still works through the per-octet path.
assert_eq!(parse_line("10.0.0.5").unwrap(), vec![Ipv4Addr::new(10, 0, 0, 5)]);
// Reversed octet range is an error.
assert!(parse_line("10.9-1.1.1").is_err());
// Out-of-range octet falls through and is reported.
assert!(parse_line("10.1.1.999").is_err());
}
#[test]
fn parse_cross_octet_range() {
let ips = parse_line("10.253.1.250-10.253.2.5").unwrap();
@@ -694,4 +1327,124 @@ mod tests {
println!("bench_targets_to_cidrs_large_range: {} addrs -> {sink} cidrs, {:?}/op", ips.len(), per);
assert!(per.as_millis() < 200, "targets_to_cidrs regressed: {per:?}/op");
}
/// Exercise the round-6 background actions through their fake-scan branch:
/// offline-row emission (start_scan), per-IP refresh (start_refresh),
/// firmware flash (start_firmware_flash_action), and that a cancelled run
/// still terminates. ALKANE_FAKE_SCAN is process-global, but no other test
/// calls these functions, so setting it here only affects this one
/// (sequential) test; all fake-mode assertions live in a single #[test] so
/// they never race each other over the env var.
#[test]
fn fake_mode_background_actions() {
use std::sync::mpsc::RecvTimeoutError;
use std::time::Duration;
let deadline = Duration::from_secs(5);
std::env::set_var(FAKE_SCAN_ENV, "1");
// start_scan (fake): streams exactly the bench-fleet fixtures, one Row
// per fixture, and no fabricated rows for empty addresses.
{
let h = start_scan(vec!["10.255.1.0/30".into()]);
let mut rows = Vec::new();
let mut total = 0usize;
loop {
match h.rx.recv_timeout(deadline) {
Ok(ScanMsg::Started { total: t, .. }) => total = t,
Ok(ScanMsg::Row(r)) => rows.push(r),
Ok(ScanMsg::Done(_)) => break,
Ok(_) => {}
Err(RecvTimeoutError::Timeout) => panic!("fake start_scan hung"),
Err(RecvTimeoutError::Disconnected) => break,
}
}
let fleet = crate::fixtures::bench_fleet();
assert_eq!(rows.len(), fleet.len(), "one Row per fixture, no phantom offline rows");
assert_eq!(total, fleet.len());
assert!(rows.iter().all(|r| r.status() != "offline"), "no 'offline' status exists");
}
// start_refresh: a known fixture IP re-reads as a Row, an unknown IP is
// reported Failed{offline}, and the run ends with Done{ok:1,total:2}.
{
let known = "10.255.1.112".to_string(); // an S17 in bench_fleet
let unknown = "10.0.0.250".to_string();
let h = start_refresh(vec![known.clone(), unknown.clone()]);
let (mut rows, mut failed, mut done) = (0usize, 0usize, None);
loop {
match h.rx.recv_timeout(deadline) {
Ok(RefreshMsg::Started { .. }) => {}
Ok(RefreshMsg::Row(r)) => {
assert_eq!(r.ip, known);
rows += 1;
}
Ok(RefreshMsg::Failed { ip, detail }) => {
assert_eq!(ip, unknown);
assert_eq!(detail, "offline");
failed += 1;
}
Ok(RefreshMsg::Done { ok, total }) => {
done = Some((ok, total));
break;
}
Err(RecvTimeoutError::Timeout) => panic!("fake start_refresh hung"),
Err(RecvTimeoutError::Disconnected) => break,
}
}
assert_eq!(rows, 1);
assert_eq!(failed, 1);
assert_eq!(done, Some((1, 2)));
}
// start_firmware_flash_action: fake mode reports one simulated success
// per IP and a matching Done summary.
{
let image = FirmwareImage::new("fw.bin".to_string(), vec![0u8; 8]);
let h = start_firmware_flash_action(
vec!["10.255.1.166".into(), "10.255.1.149".into()],
image,
);
let (mut results, mut done) = (0usize, None);
loop {
match h.rx.recv_timeout(deadline) {
Ok(ActionMsg::Started { .. }) => {}
Ok(ActionMsg::Result { ok, detail, .. }) => {
assert!(ok);
assert_eq!(detail, "simulated");
results += 1;
}
Ok(ActionMsg::Done { ok, total }) => {
done = Some((ok, total));
break;
}
Err(RecvTimeoutError::Timeout) => panic!("fake flash hung"),
Err(RecvTimeoutError::Disconnected) => break,
}
}
assert_eq!(results, 2);
assert_eq!(done, Some((2, 2)));
}
// Cancellation contract: stopping a run still delivers a terminal Done
// rather than hanging (the fake branches now honour the cancel flag).
{
let big: Vec<String> = (0..200).map(|i| format!("10.9.0.{}", i % 256)).collect();
let h = start_refresh(big);
h.stop();
let mut saw_done = false;
loop {
match h.rx.recv_timeout(deadline) {
Ok(RefreshMsg::Done { .. }) => {
saw_done = true;
break;
}
Ok(_) => {}
Err(_) => break,
}
}
assert!(saw_done, "a cancelled fake refresh must still emit Done, not hang");
}
std::env::remove_var(FAKE_SCAN_ENV);
}
}
+2115 -125
View File
File diff suppressed because it is too large Load Diff
+185 -1
View File
@@ -10,7 +10,7 @@
+pub use widgets::*;
--- a/src/widgets.rs
+++ b/src/widgets.rs
@@ -0,0 +1,561 @@
@@ -0,0 +1,745 @@
+// 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,16 +61,20 @@
+ 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);
+ pub fn wxbr_dvlc_clear(win: *mut c_void);
+ pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
+ pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *const c_char);
+ pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
+ pub fn wxbr_dvlc_set_col_title(win: *mut c_void, col: c_int, title: *const c_char);
+ pub fn wxbr_dvlc_set_sort_indicator(win: *mut c_void, col: c_int, active: c_int, ascending: c_int);
+ pub fn wxbr_dvlc_col_at_pos(win: *mut c_void, pos: c_int) -> c_int;
@@ -77,6 +83,10 @@
+ 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_dvlc_set_zebra(win: *mut c_void, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_dvlc_get_top_row(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_ensure_visible(win: *mut c_void, row: usize);
+ pub fn wxbr_apply_zebra_css(r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_rearrange_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
+ pub fn wxbr_rearrange_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
@@ -96,7 +106,18 @@
+ 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);
+ pub fn wxbr_status_indicator_init(frame: *mut c_void);
+ pub fn wxbr_status_indicator_set(text: *const c_char, r: c_int, g: c_int, b: c_int);
+ }
+}
+
@@ -129,6 +150,10 @@
+ DvlcSelectionChanged,
+ DvlcContextMenu,
+ MenuItem,
+ ChoiceChanged,
+ SysColour,
+ Deferred,
+ DvlcHeaderRightClick,
+}
+
+impl WxEventKind {
@@ -144,6 +169,10 @@
+ 9 => WxEventKind::DvlcSelectionChanged,
+ 10 => WxEventKind::DvlcContextMenu,
+ 11 => WxEventKind::MenuItem,
+ 12 => WxEventKind::ChoiceChanged,
+ 13 => WxEventKind::SysColour,
+ 14 => WxEventKind::Deferred,
+ 15 => WxEventKind::DvlcHeaderRightClick,
+ _ => return None,
+ })
+ }
@@ -154,6 +183,28 @@
+ 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) }
+}
+
+/// Reconfigure the frame's status bar to two fields and attach a colour-tinted
+/// label pinned to the right-hand field (bottom-right corner). Call once after
+/// `create_status_bar()`. The main scan status keeps using the left field via
+/// the upstream `set_status_text` path.
+pub fn status_indicator_init(frame: Widget) {
+ unsafe { notsafe::wxbr_status_indicator_init(frame.0) }
+}
+
+/// Set the bottom-right status indicator's text and colour (an empty string
+/// clears it). Used for scan/apply errors (red) and warnings (amber).
+pub fn status_indicator_set(text: &str, r: u8, g: u8, b: u8) {
+ let c = CString::new(text).unwrap_or_default();
+ unsafe { notsafe::wxbr_status_indicator_set(c.as_ptr(), r as c_int, g as c_int, b 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 +280,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 +364,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 +452,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 +478,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) }
+ }
@@ -422,6 +513,13 @@
+ unsafe { notsafe::wxbr_dvlc_set_cell(self.0, row, col, c.as_ptr()) }
+ }
+
+ /// Set the hover tooltip for one cell (empty clears it). GTK only; a no-op
+ /// on other platforms until they gain per-cell tooltip support.
+ pub fn dvlc_set_cell_tooltip(&self, row: usize, col: usize, text: &str) {
+ let c = CString::new(text).unwrap_or_default();
+ unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
+ }
+
+ pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
+ let mut buf = vec![0i8; 4096];
+ let n = unsafe {
@@ -438,6 +536,11 @@
+ unsafe { notsafe::wxbr_dvlc_col_count(self.0).max(0) as usize }
+ }
+
+ /// Auto-size the column at display position `pos` to fit its content.
+ pub fn dvlc_autosize_col(&self, pos: usize) {
+ unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
+ }
+
+ /// Model column index shown at display position `pos` (after drag reorder).
+ pub fn dvlc_col_at_pos(&self, pos: usize) -> Option<usize> {
+ let v = unsafe { notsafe::wxbr_dvlc_col_at_pos(self.0, pos as c_int) };
@@ -472,6 +575,36 @@
+ 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) }
+ }
+
+ /// Set the alternating-row (zebra) background colour applied to odd rows.
+ /// Pass `None` to turn zebra striping off.
+ pub fn dvlc_set_zebra(&self, color: Option<(u8, u8, u8)>) {
+ let (r, g, b) = match color {
+ Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
+ None => (-1, -1, -1),
+ };
+ unsafe { notsafe::wxbr_dvlc_set_zebra(self.0, r, g, b) }
+ }
+
+ /// The model-row index of the top (first visible) row, or `None` if empty.
+ pub fn dvlc_get_top_row(&self) -> Option<usize> {
+ let r = unsafe { notsafe::wxbr_dvlc_get_top_row(self.0) };
+ (r >= 0).then_some(r as usize)
+ }
+
+ /// Scroll so `row` is visible (used to restore scroll position after a refill).
+ pub fn dvlc_ensure_visible(&self, row: usize) {
+ unsafe { notsafe::wxbr_dvlc_ensure_visible(self.0, row) }
+ }
+
+ // ---- rearrangeable check-list ----
+
+ /// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
@@ -566,9 +699,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) }
+ }
+}
+598 -63
View File
@@ -1,6 +1,6 @@
--- a/cpp_src/widgets_bridge.cpp
+++ b/cpp_src/widgets_bridge.cpp
@@ -0,0 +1,598 @@
@@ -0,0 +1,1133 @@
+// 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,14 +23,36 @@
+#include <wx/app.h>
+#include <wx/rearrangectrl.h>
+#include <wx/menu.h>
+#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 <wx/statusbr.h>
+#include <cstring>
+#include <cstdio>
+#include <map>
+#include <vector>
+#ifdef __WXGTK__
+// For native GtkTreeView rubber-band (click-drag) selection, which wx does not
+// enable and which cannot be done via wx mouse events on GTK (the native widget
+// grabs the pointer during a drag). Guarded so non-GTK builds are unaffected.
+#include <gtk/gtk.h>
+#endif
+#include <cstdio>
+
+typedef void (*WxWidgetEventFn)(int kind, long p1, long p2);
+static WxWidgetEventFn g_widget_event = nullptr;
+
+#ifndef __WXGTK__
+// Anchor row per data-view control for the wx-mouse-event rubber-band fallback
+// (non-GTK platforms; GTK uses native GtkTreeView rubber-banding instead).
+static std::map<wxDataViewCtrl*, int> g_drag_anchor;
+#endif
+
+// Event kinds (must match Rust WxEventKind in src/widgets.rs)
+enum WxWidgetEventKind {
+ WxEV_BUTTON_CLICKED = 1,
@@ -43,6 +65,135 @@
+ 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,
+ WxEV_DVLC_HEADER_RIGHT_CLICK = 15,
+};
+
+// A list store that carries an optional per-row foreground colour plus an
+// alternating-row (zebra) background, surfaced to the native control via
+// GetAttrByRow. The zebra background is set on odd rows only; because it is a
+// BACKGROUND attr (not a foreground one), it does not affect the SegmentRenderer
+// "no explicit colour -> default text colour" path, and the native selection
+// highlight still paints over it for selected rows.
+class AttrListStore : public wxDataViewListStore {
+ public:
+ std::vector<wxColour> row_fg;
+ wxColour zebra; // odd-row background; unset (=off) unless the app sets it
+ // Per-cell hover tooltip text, keyed by (row, model column). Used for the
+ // Errors column's full-message tooltip (see the GTK query-tooltip handler).
+ std::map<std::pair<unsigned, unsigned>, wxString> cell_tip;
+ bool GetAttrByRow(unsigned int row, unsigned int col,
+ wxDataViewItemAttr& attr) const override {
+ (void)col;
+ bool set = false;
+ if (row < row_fg.size() && row_fg[row].IsOk()) {
+ attr.SetColour(row_fg[row]);
+ set = true;
+ }
+ if (zebra.IsOk() && (row % 2 == 1)) {
+ attr.SetBackgroundColour(zebra);
+ set = true;
+ }
+ return set;
+ }
+};
+
+// A wxDataViewCustomRenderer that draws a cell value made of coloured text
+// runs. The encoding matches alkane_gui::model::encode_segments: segments are
+// joined by U+001F (ASCII unit separator); each segment is an optional
+// 6-hex-digit RRGGBB colour followed by U+001E (ASCII record separator) and
+// then its plain text. A value containing no U+001E at all -- e.g. any
+// ordinary string -- is drawn as a single run in the default text colour, so
+// this renderer is safe to use in place of a plain text column.
+namespace {
+
+struct ColorSegment {
+ bool has_colour = false;
+ wxColour colour;
+ wxString text;
+};
+
+std::vector<ColorSegment> ParseColorSegments(const wxString& value) {
+ std::vector<ColorSegment> segs;
+ if (value.Find(wxUniChar(0x1e)) == wxNOT_FOUND) {
+ ColorSegment s;
+ s.text = value;
+ segs.push_back(s);
+ return segs;
+ }
+ wxString rest = value;
+ for (;;) {
+ int sep = rest.Find(wxUniChar(0x1f));
+ wxString piece = (sep == wxNOT_FOUND) ? rest : rest.Left(sep);
+ ColorSegment s;
+ int csep = piece.Find(wxUniChar(0x1e));
+ if (csep == wxNOT_FOUND) {
+ s.text = piece;
+ } else {
+ wxString hex = piece.Left(csep);
+ s.text = piece.Mid(csep + 1);
+ unsigned long v;
+ if (hex.length() == 6 && hex.ToULong(&v, 16)) {
+ s.colour = wxColour((unsigned char)((v >> 16) & 0xff),
+ (unsigned char)((v >> 8) & 0xff),
+ (unsigned char)(v & 0xff));
+ s.has_colour = true;
+ }
+ }
+ segs.push_back(s);
+ if (sep == wxNOT_FOUND) break;
+ rest = rest.Mid(sep + 1);
+ }
+ return segs;
+}
+
+} // namespace
+
+class SegmentRenderer : public wxDataViewCustomRenderer {
+ public:
+ SegmentRenderer()
+ : wxDataViewCustomRenderer(wxASCII_STR("string"), wxDATAVIEW_CELL_INERT) {}
+
+ bool SetValue(const wxVariant& value) override {
+ m_value = value.GetString();
+ return true;
+ }
+
+ bool GetValue(wxVariant& value) const override {
+ value = m_value;
+ return true;
+ }
+
+ bool Render(wxRect cell, wxDC* dc, int state) override {
+ bool selected = (state & wxDATAVIEW_CELL_SELECTED) != 0;
+ wxColour highlight = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
+ wxColour plain = GetAttr().HasColour()
+ ? GetAttr().GetColour()
+ : wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
+ wxCoord x = cell.x;
+ for (const ColorSegment& seg : ParseColorSegments(m_value)) {
+ if (seg.text.IsEmpty()) continue;
+ dc->SetTextForeground(selected ? highlight : (seg.has_colour ? seg.colour : plain));
+ wxSize extent = dc->GetTextExtent(seg.text);
+ wxCoord y = cell.y + (cell.height - extent.GetHeight()) / 2;
+ dc->DrawText(seg.text, x, y);
+ x += extent.GetWidth();
+ }
+ return true;
+ }
+
+ wxSize GetSize() const override {
+ wxString plain;
+ for (const ColorSegment& seg : ParseColorSegments(m_value)) plain += seg.text;
+ wxSize sz = GetTextExtent(plain);
+ if (sz.GetWidth() < 1) sz.SetWidth(1);
+ return sz;
+ }
+
+ private:
+ wxString m_value;
+};
+
+extern "C" {
@@ -61,6 +212,18 @@
+ return (void*)new wxBoxSizer(vertical ? wxVERTICAL : wxHORIZONTAL);
+}
+
+// A box sizer that wraps its items onto additional lines instead of shrinking
+// them when the available space runs out. wxWrapSizer is a wxBoxSizer
+// subclass, so it accepts the same add/add_sizer/add_spacer/add_stretch and
+// set_sizer_on calls as wxbr_box_sizer's result.
+void* wxbr_wrap_sizer(int vertical) {
+ // wxREMOVE_LEADING_SPACES only: drop the default wxEXTEND_LAST_ON_EACH_LINE so
+ // the last item on a line is NOT stretched to fill the row (keeps fixed-size
+ // items -- e.g. the uniform KPI cards -- the same size).
+ return (void*)new wxWrapSizer(vertical ? wxVERTICAL : wxHORIZONTAL,
+ wxREMOVE_LEADING_SPACES);
+}
+
+// flag bits (must match Rust sizer_flags):
+// 1 = EXPAND, 2 = ALIGN_CENTRE_VERTICAL, 4 = wxALL, 8 = wxTOP,
+// 16 = wxBOTTOM, 32 = wxLEFT, 64 = wxRIGHT
@@ -169,6 +332,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 +441,206 @@
+ ((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());
+}
+
+#ifdef __WXGTK__
+// GtkTreeView "query-tooltip" handler: show the per-cell tooltip stored for the
+// (row, model column) under the pointer (used by the Errors column). wx does
+// not surface per-cell tooltips on wxDataViewCtrl, and mouse-motion events are
+// not delivered to wx handlers on the native GTK control, so this hooks the
+// native signal directly.
+static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keyboard,
+ GtkTooltip* tooltip, gpointer user_data) {
+ (void)keyboard;
+ wxDataViewCtrl* dv = static_cast<wxDataViewCtrl*>(user_data);
+ gint bx = 0, by = 0;
+ gtk_tree_view_convert_widget_to_bin_window_coords(GTK_TREE_VIEW(tv), x, y, &bx, &by);
+ GtkTreePath* path = nullptr;
+ GtkTreeViewColumn* gcol = nullptr;
+ if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tv), bx, by, &path, &gcol, nullptr, nullptr))
+ return FALSE;
+ gint* idx = gtk_tree_path_get_indices(path);
+ int row = idx ? idx[0] : -1;
+ gtk_tree_path_free(path);
+ if (row < 0 || !gcol) return FALSE;
+ wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
+ if (!wxcol) return FALSE;
+ AttrListStore* store = static_cast<AttrListStore*>(dv->GetModel());
+ auto it = store->cell_tip.find({(unsigned)row, wxcol->GetModelColumn()});
+ if (it == store->cell_tip.end() || it->second.IsEmpty()) return FALSE;
+ gtk_tooltip_set_text(tooltip, it->second.utf8_str());
+ return TRUE;
+}
+#endif
+
+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_VERT_RULES | 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&) {
+ // Right-click on a column header: Excel-style per-column menu (hide/sort/...).
+ dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, [](wxDataViewEvent& e) {
+ if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_RIGHT_CLICK, (long)e.GetColumn(), 0);
+ });
+ dv->Bind(wxEVT_DATAVIEW_COLUMN_REORDERED, [](wxDataViewEvent&) {
+ if (g_widget_event) g_widget_event(WxEV_DVLC_REORDERED, 0, 0);
+ });
+ // Rubber-band (click-drag) range selection. wxDataViewCtrl has none natively.
+#ifdef __WXGTK__
+ // On GTK the control wraps a GtkTreeView, which supports native rubber-band
+ // selection -- just not enabled by wx. Enable it directly. (wx delivers no
+ // MOTION events during the native drag, so the mouse-event fallback below is
+ // inapplicable on GTK.)
+ {
+ GtkWidget* tv = dv->GtkGetTreeView();
+ if (tv) {
+ gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tv), TRUE);
+ // Per-cell hover tooltips (Errors column) via the native signal.
+ gtk_widget_set_has_tooltip(tv, TRUE);
+ g_signal_connect(tv, "query-tooltip", G_CALLBACK(dvlc_query_tooltip), dv);
+ }
+ }
+#else
+ // Non-GTK fallback: track a drag anchor and extend the selection to the row
+ // under the cursor. LEFT_DOWN records the anchor (and lets the native handler
+ // select it); dragging with the button down selects the inclusive range.
+ dv->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent& e) {
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
+ if (!dv) { e.Skip(); return; }
+ // Leave modifier-clicks to the native ctrl/shift multi-select behaviour.
+ if (e.ControlDown() || e.ShiftDown()) { g_drag_anchor.erase(dv); e.Skip(); return; }
+ wxDataViewItem item;
+ wxDataViewColumn* col = nullptr;
+ dv->HitTest(e.GetPosition(), item, col);
+ if (item.IsOk()) {
+ g_drag_anchor[dv] =
+ (int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
+ } else {
+ g_drag_anchor.erase(dv);
+ }
+ e.Skip(); // let the native handler select the anchor row
+ });
+ dv->Bind(wxEVT_MOTION, [](wxMouseEvent& e) {
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
+ if (!dv || !e.LeftIsDown()) { e.Skip(); return; }
+ auto it = g_drag_anchor.find(dv);
+ if (it == g_drag_anchor.end()) { e.Skip(); return; }
+ wxDataViewItem item;
+ wxDataViewColumn* col = nullptr;
+ dv->HitTest(e.GetPosition(), item, col);
+ if (!item.IsOk()) { e.Skip(); return; }
+ wxDataViewIndexListModel* model = (wxDataViewIndexListModel*)dv->GetModel();
+ int cur = (int)model->GetRow(item);
+ int lo = it->second < cur ? it->second : cur;
+ int hi = it->second < cur ? cur : it->second;
+ dv->UnselectAll();
+ for (int r = lo; r <= hi; ++r) dv->Select(model->GetItem((unsigned)r));
+ // Selecting programmatically does not emit SELECTION_CHANGED, so notify.
+ if (g_widget_event) g_widget_event(WxEV_DVLC_SELECTION_CHANGED, 0, 0);
+ e.Skip();
+ });
+ dv->Bind(wxEVT_LEFT_UP, [](wxMouseEvent& e) {
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
+ if (dv) g_drag_anchor.erase(dv);
+ e.Skip();
+ });
+#endif
+ // 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 +649,82 @@
+ 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();
+ store->cell_tip.clear();
+}
+
+// Set (or clear, with an empty string) the hover tooltip for one cell,
+// addressed by (row, model column). Used for the Errors column's full text.
+void wxbr_dvlc_set_cell_tooltip(void* win, unsigned row, unsigned col, const char* text) {
+ AttrListStore* store = dvlc_store(win);
+ if (text && text[0]) {
+ store->cell_tip[{row, col}] = wxString::FromUTF8(text);
+ } else {
+ store->cell_tip.erase({row, col});
+ }
+}
+
+// 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);
+}
+
+// Set (or clear, when r<0) the alternating-row (zebra) background colour. The
+// app passes a theme-aware colour; odd rows get it (see AttrListStore).
+void wxbr_dvlc_set_zebra(void* win, int r, int g, int b) {
+ dvlc_store(win)->zebra = (r < 0) ? wxColour() : wxColour(r, g, b);
+}
+
+// The model-row index of the first (top) visible row, or -1 if none. Used to
+// hold the scroll position across a full clear+refill during a live scan.
+int wxbr_dvlc_get_top_row(void* win) {
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
+ wxDataViewItem item = dv->GetTopItem();
+ if (!item.IsOk()) return -1;
+ return (int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
+}
+
+// Scroll so `row` is visible (used with wxbr_dvlc_get_top_row to restore the
+// scroll position after a refill). Out-of-range rows are ignored -- GetItem()
+// itself asserts on row >= count, so the bound MUST be checked before calling.
+void wxbr_dvlc_ensure_visible(void* win, unsigned row) {
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
+ if (row >= (unsigned)dvlc_store(win)->GetItemCount()) return;
+ wxDataViewItem item = ((wxDataViewIndexListModel*)dv->GetModel())->GetItem(row);
+ if (item.IsOk()) dv->EnsureVisible(item);
+}
+
+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 +738,15 @@
+}
+
+int wxbr_dvlc_col_count(void* win) {
+ return (int)((wxDataViewListCtrl*)win)->GetColumnCount();
+ return (int)((wxDataViewCtrl*)win)->GetColumnCount();
+}
+
+// Auto-size a column (by display position) to fit its content + header.
+void wxbr_dvlc_autosize_col(void* win, int pos) {
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
+ if (pos < 0 || (unsigned)pos >= dv->GetColumnCount()) return;
+ wxDataViewColumn* c = dv->GetColumn((unsigned)pos);
+ if (c) c->SetWidth(wxCOL_WIDTH_AUTOSIZE);
+}
+
+// Update a column's header text in place (creation index) without recreating
@@ -401,6 +778,25 @@
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
+ unsigned n = dv->GetColumnCount();
+ if (pos < 0 || (unsigned)pos >= n) return -1;
+#ifdef __WXGTK__
+ // wxGTK's GetColumnPosition() does NOT reflect a native GtkTreeView column
+ // drag, so after the user reorders columns it reports the creation order and
+ // the reorder is silently lost. Read the real display order from the
+ // GtkTreeView instead, then map the column back to its wx creation index.
+ GtkWidget* tvw = dv->GtkGetTreeView();
+ if (tvw) {
+ GList* cols = gtk_tree_view_get_columns(GTK_TREE_VIEW(tvw)); // display order
+ GtkTreeViewColumn* gcol = (GtkTreeViewColumn*)g_list_nth_data(cols, (guint)pos);
+ g_list_free(cols);
+ if (gcol) {
+ wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
+ for (unsigned i = 0; i < n; i++) {
+ if (dv->GetColumn(i) == wxcol) return (int)i;
+ }
+ }
+ return -1;
+ }
+#endif
+ for (unsigned i = 0; i < n; i++) {
+ wxDataViewColumn* c = dv->GetColumn(i);
+ if (c && dv->GetColumnPosition(c) == (unsigned)pos) return (int)i;
@@ -409,58 +805,54 @@
+}
+
+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();
+ int count = (int)dvlc_store(win)->GetItemCount();
+ dv->UnselectAll();
+ for (int i = 0; i < n; i++) {
+ if (rows[i] >= 0) lc->SelectRow((unsigned)rows[i]);
+ // GetItem() asserts on an out-of-range row, so bound both ends.
+ if (rows[i] >= 0 && rows[i] < count) 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();
+ if (row >= (long)dvlc_store(win)->GetItemCount()) return;
+ dv->Select(m->GetItem((unsigned)row));
+}
+
+// ---- timer -----------------------------------------------------------------
@@ -594,8 +986,151 @@
+ 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);
+ });
+ }
+}
+
+// ---- status-bar error/warning indicator -------------------------------------
+// A colour-tinted static text pinned to the RIGHT-hand field of the frame's
+// status bar, so scan/apply errors surface in the bottom-right corner without
+// overwriting the main (left) scan-status text. The status bar is reconfigured
+// to two fields: field 0 (stretch) carries the scan status set via the upstream
+// SetStatusText path; field 1 (fixed) hosts this coloured label, which we
+// reposition into that field's rect whenever the bar is resized.
+static wxStaticText* g_status_indicator = nullptr;
+
+static void reposition_status_indicator() {
+ if (!g_status_indicator) return;
+ wxStatusBar* sb = wxDynamicCast(g_status_indicator->GetParent(), wxStatusBar);
+ if (!sb) return;
+ wxRect r;
+ if (!sb->GetFieldRect(1, r)) return;
+ wxSize best = g_status_indicator->GetBestSize();
+ int h = best.GetHeight();
+ int y = r.y + (r.height - h) / 2;
+ g_status_indicator->SetSize(r.x + 4, y, r.width - 8, h);
+}
+
+void wxbr_status_indicator_init(void* frame_ptr) {
+ wxFrame* frame = (wxFrame*)frame_ptr;
+ wxStatusBar* sb = frame->GetStatusBar();
+ if (!sb) sb = frame->CreateStatusBar();
+ int widths[2] = { -1, 340 };
+ sb->SetFieldsCount(2);
+ sb->SetStatusWidths(2, widths);
+ if (!g_status_indicator) {
+ g_status_indicator = new wxStaticText(sb, wxID_ANY, wxEmptyString,
+ wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT | wxST_NO_AUTORESIZE);
+ sb->Bind(wxEVT_SIZE, [](wxSizeEvent& ev) {
+ reposition_status_indicator();
+ ev.Skip();
+ });
+ }
+ reposition_status_indicator();
+}
+
+// Set the bottom-right indicator text and its colour. An empty string clears it.
+void wxbr_status_indicator_set(const char* text, int r, int g, int b) {
+ if (!g_status_indicator) return;
+ g_status_indicator->SetLabel(wxString::FromUTF8(text ? text : ""));
+ g_status_indicator->SetForegroundColour(
+ wxColour((unsigned char)r, (unsigned char)g, (unsigned char)b));
+ reposition_status_indicator();
+ g_status_indicator->Refresh();
+}
+
+// ---- 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"
@@ -20,14 +20,36 @@
#include <wx/app.h>
#include <wx/rearrangectrl.h>
#include <wx/menu.h>
#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 <wx/statusbr.h>
#include <cstring>
#include <cstdio>
#include <map>
#include <vector>
#ifdef __WXGTK__
// For native GtkTreeView rubber-band (click-drag) selection, which wx does not
// enable and which cannot be done via wx mouse events on GTK (the native widget
// grabs the pointer during a drag). Guarded so non-GTK builds are unaffected.
#include <gtk/gtk.h>
#endif
#include <cstdio>
typedef void (*WxWidgetEventFn)(int kind, long p1, long p2);
static WxWidgetEventFn g_widget_event = nullptr;
#ifndef __WXGTK__
// Anchor row per data-view control for the wx-mouse-event rubber-band fallback
// (non-GTK platforms; GTK uses native GtkTreeView rubber-banding instead).
static std::map<wxDataViewCtrl*, int> g_drag_anchor;
#endif
// Event kinds (must match Rust WxEventKind in src/widgets.rs)
enum WxWidgetEventKind {
WxEV_BUTTON_CLICKED = 1,
@@ -40,6 +62,135 @@ 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,
WxEV_DVLC_HEADER_RIGHT_CLICK = 15,
};
// A list store that carries an optional per-row foreground colour plus an
// alternating-row (zebra) background, surfaced to the native control via
// GetAttrByRow. The zebra background is set on odd rows only; because it is a
// BACKGROUND attr (not a foreground one), it does not affect the SegmentRenderer
// "no explicit colour -> default text colour" path, and the native selection
// highlight still paints over it for selected rows.
class AttrListStore : public wxDataViewListStore {
public:
std::vector<wxColour> row_fg;
wxColour zebra; // odd-row background; unset (=off) unless the app sets it
// Per-cell hover tooltip text, keyed by (row, model column). Used for the
// Errors column's full-message tooltip (see the GTK query-tooltip handler).
std::map<std::pair<unsigned, unsigned>, wxString> cell_tip;
bool GetAttrByRow(unsigned int row, unsigned int col,
wxDataViewItemAttr& attr) const override {
(void)col;
bool set = false;
if (row < row_fg.size() && row_fg[row].IsOk()) {
attr.SetColour(row_fg[row]);
set = true;
}
if (zebra.IsOk() && (row % 2 == 1)) {
attr.SetBackgroundColour(zebra);
set = true;
}
return set;
}
};
// A wxDataViewCustomRenderer that draws a cell value made of coloured text
// runs. The encoding matches alkane_gui::model::encode_segments: segments are
// joined by U+001F (ASCII unit separator); each segment is an optional
// 6-hex-digit RRGGBB colour followed by U+001E (ASCII record separator) and
// then its plain text. A value containing no U+001E at all -- e.g. any
// ordinary string -- is drawn as a single run in the default text colour, so
// this renderer is safe to use in place of a plain text column.
namespace {
struct ColorSegment {
bool has_colour = false;
wxColour colour;
wxString text;
};
std::vector<ColorSegment> ParseColorSegments(const wxString& value) {
std::vector<ColorSegment> segs;
if (value.Find(wxUniChar(0x1e)) == wxNOT_FOUND) {
ColorSegment s;
s.text = value;
segs.push_back(s);
return segs;
}
wxString rest = value;
for (;;) {
int sep = rest.Find(wxUniChar(0x1f));
wxString piece = (sep == wxNOT_FOUND) ? rest : rest.Left(sep);
ColorSegment s;
int csep = piece.Find(wxUniChar(0x1e));
if (csep == wxNOT_FOUND) {
s.text = piece;
} else {
wxString hex = piece.Left(csep);
s.text = piece.Mid(csep + 1);
unsigned long v;
if (hex.length() == 6 && hex.ToULong(&v, 16)) {
s.colour = wxColour((unsigned char)((v >> 16) & 0xff),
(unsigned char)((v >> 8) & 0xff),
(unsigned char)(v & 0xff));
s.has_colour = true;
}
}
segs.push_back(s);
if (sep == wxNOT_FOUND) break;
rest = rest.Mid(sep + 1);
}
return segs;
}
} // namespace
class SegmentRenderer : public wxDataViewCustomRenderer {
public:
SegmentRenderer()
: wxDataViewCustomRenderer(wxASCII_STR("string"), wxDATAVIEW_CELL_INERT) {}
bool SetValue(const wxVariant& value) override {
m_value = value.GetString();
return true;
}
bool GetValue(wxVariant& value) const override {
value = m_value;
return true;
}
bool Render(wxRect cell, wxDC* dc, int state) override {
bool selected = (state & wxDATAVIEW_CELL_SELECTED) != 0;
wxColour highlight = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
wxColour plain = GetAttr().HasColour()
? GetAttr().GetColour()
: wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
wxCoord x = cell.x;
for (const ColorSegment& seg : ParseColorSegments(m_value)) {
if (seg.text.IsEmpty()) continue;
dc->SetTextForeground(selected ? highlight : (seg.has_colour ? seg.colour : plain));
wxSize extent = dc->GetTextExtent(seg.text);
wxCoord y = cell.y + (cell.height - extent.GetHeight()) / 2;
dc->DrawText(seg.text, x, y);
x += extent.GetWidth();
}
return true;
}
wxSize GetSize() const override {
wxString plain;
for (const ColorSegment& seg : ParseColorSegments(m_value)) plain += seg.text;
wxSize sz = GetTextExtent(plain);
if (sz.GetWidth() < 1) sz.SetWidth(1);
return sz;
}
private:
wxString m_value;
};
extern "C" {
@@ -58,6 +209,18 @@ void* wxbr_box_sizer(int vertical) {
return (void*)new wxBoxSizer(vertical ? wxVERTICAL : wxHORIZONTAL);
}
// A box sizer that wraps its items onto additional lines instead of shrinking
// them when the available space runs out. wxWrapSizer is a wxBoxSizer
// subclass, so it accepts the same add/add_sizer/add_spacer/add_stretch and
// set_sizer_on calls as wxbr_box_sizer's result.
void* wxbr_wrap_sizer(int vertical) {
// wxREMOVE_LEADING_SPACES only: drop the default wxEXTEND_LAST_ON_EACH_LINE so
// the last item on a line is NOT stretched to fill the row (keeps fixed-size
// items -- e.g. the uniform KPI cards -- the same size).
return (void*)new wxWrapSizer(vertical ? wxVERTICAL : wxHORIZONTAL,
wxREMOVE_LEADING_SPACES);
}
// flag bits (must match Rust sizer_flags):
// 1 = EXPAND, 2 = ALIGN_CENTRE_VERTICAL, 4 = wxALL, 8 = wxTOP,
// 16 = wxBOTTOM, 32 = wxLEFT, 64 = wxRIGHT
@@ -166,6 +329,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 +438,206 @@ 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());
}
#ifdef __WXGTK__
// GtkTreeView "query-tooltip" handler: show the per-cell tooltip stored for the
// (row, model column) under the pointer (used by the Errors column). wx does
// not surface per-cell tooltips on wxDataViewCtrl, and mouse-motion events are
// not delivered to wx handlers on the native GTK control, so this hooks the
// native signal directly.
static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keyboard,
GtkTooltip* tooltip, gpointer user_data) {
(void)keyboard;
wxDataViewCtrl* dv = static_cast<wxDataViewCtrl*>(user_data);
gint bx = 0, by = 0;
gtk_tree_view_convert_widget_to_bin_window_coords(GTK_TREE_VIEW(tv), x, y, &bx, &by);
GtkTreePath* path = nullptr;
GtkTreeViewColumn* gcol = nullptr;
if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tv), bx, by, &path, &gcol, nullptr, nullptr))
return FALSE;
gint* idx = gtk_tree_path_get_indices(path);
int row = idx ? idx[0] : -1;
gtk_tree_path_free(path);
if (row < 0 || !gcol) return FALSE;
wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
if (!wxcol) return FALSE;
AttrListStore* store = static_cast<AttrListStore*>(dv->GetModel());
auto it = store->cell_tip.find({(unsigned)row, wxcol->GetModelColumn()});
if (it == store->cell_tip.end() || it->second.IsEmpty()) return FALSE;
gtk_tooltip_set_text(tooltip, it->second.utf8_str());
return TRUE;
}
#endif
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_VERT_RULES | 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&) {
// Right-click on a column header: Excel-style per-column menu (hide/sort/...).
dv->Bind(wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, [](wxDataViewEvent& e) {
if (g_widget_event) g_widget_event(WxEV_DVLC_HEADER_RIGHT_CLICK, (long)e.GetColumn(), 0);
});
dv->Bind(wxEVT_DATAVIEW_COLUMN_REORDERED, [](wxDataViewEvent&) {
if (g_widget_event) g_widget_event(WxEV_DVLC_REORDERED, 0, 0);
});
// Rubber-band (click-drag) range selection. wxDataViewCtrl has none natively.
#ifdef __WXGTK__
// On GTK the control wraps a GtkTreeView, which supports native rubber-band
// selection -- just not enabled by wx. Enable it directly. (wx delivers no
// MOTION events during the native drag, so the mouse-event fallback below is
// inapplicable on GTK.)
{
GtkWidget* tv = dv->GtkGetTreeView();
if (tv) {
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tv), TRUE);
// Per-cell hover tooltips (Errors column) via the native signal.
gtk_widget_set_has_tooltip(tv, TRUE);
g_signal_connect(tv, "query-tooltip", G_CALLBACK(dvlc_query_tooltip), dv);
}
}
#else
// Non-GTK fallback: track a drag anchor and extend the selection to the row
// under the cursor. LEFT_DOWN records the anchor (and lets the native handler
// select it); dragging with the button down selects the inclusive range.
dv->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent& e) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
if (!dv) { e.Skip(); return; }
// Leave modifier-clicks to the native ctrl/shift multi-select behaviour.
if (e.ControlDown() || e.ShiftDown()) { g_drag_anchor.erase(dv); e.Skip(); return; }
wxDataViewItem item;
wxDataViewColumn* col = nullptr;
dv->HitTest(e.GetPosition(), item, col);
if (item.IsOk()) {
g_drag_anchor[dv] =
(int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
} else {
g_drag_anchor.erase(dv);
}
e.Skip(); // let the native handler select the anchor row
});
dv->Bind(wxEVT_MOTION, [](wxMouseEvent& e) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
if (!dv || !e.LeftIsDown()) { e.Skip(); return; }
auto it = g_drag_anchor.find(dv);
if (it == g_drag_anchor.end()) { e.Skip(); return; }
wxDataViewItem item;
wxDataViewColumn* col = nullptr;
dv->HitTest(e.GetPosition(), item, col);
if (!item.IsOk()) { e.Skip(); return; }
wxDataViewIndexListModel* model = (wxDataViewIndexListModel*)dv->GetModel();
int cur = (int)model->GetRow(item);
int lo = it->second < cur ? it->second : cur;
int hi = it->second < cur ? cur : it->second;
dv->UnselectAll();
for (int r = lo; r <= hi; ++r) dv->Select(model->GetItem((unsigned)r));
// Selecting programmatically does not emit SELECTION_CHANGED, so notify.
if (g_widget_event) g_widget_event(WxEV_DVLC_SELECTION_CHANGED, 0, 0);
e.Skip();
});
dv->Bind(wxEVT_LEFT_UP, [](wxMouseEvent& e) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)e.GetEventObject();
if (dv) g_drag_anchor.erase(dv);
e.Skip();
});
#endif
// 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 +646,82 @@ 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();
store->cell_tip.clear();
}
// Set (or clear, with an empty string) the hover tooltip for one cell,
// addressed by (row, model column). Used for the Errors column's full text.
void wxbr_dvlc_set_cell_tooltip(void* win, unsigned row, unsigned col, const char* text) {
AttrListStore* store = dvlc_store(win);
if (text && text[0]) {
store->cell_tip[{row, col}] = wxString::FromUTF8(text);
} else {
store->cell_tip.erase({row, col});
}
}
// 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);
}
// Set (or clear, when r<0) the alternating-row (zebra) background colour. The
// app passes a theme-aware colour; odd rows get it (see AttrListStore).
void wxbr_dvlc_set_zebra(void* win, int r, int g, int b) {
dvlc_store(win)->zebra = (r < 0) ? wxColour() : wxColour(r, g, b);
}
// The model-row index of the first (top) visible row, or -1 if none. Used to
// hold the scroll position across a full clear+refill during a live scan.
int wxbr_dvlc_get_top_row(void* win) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
wxDataViewItem item = dv->GetTopItem();
if (!item.IsOk()) return -1;
return (int)((wxDataViewIndexListModel*)dv->GetModel())->GetRow(item);
}
// Scroll so `row` is visible (used with wxbr_dvlc_get_top_row to restore the
// scroll position after a refill). Out-of-range rows are ignored -- GetItem()
// itself asserts on row >= count, so the bound MUST be checked before calling.
void wxbr_dvlc_ensure_visible(void* win, unsigned row) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
if (row >= (unsigned)dvlc_store(win)->GetItemCount()) return;
wxDataViewItem item = ((wxDataViewIndexListModel*)dv->GetModel())->GetItem(row);
if (item.IsOk()) dv->EnsureVisible(item);
}
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 +735,15 @@ 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();
}
// Auto-size a column (by display position) to fit its content + header.
void wxbr_dvlc_autosize_col(void* win, int pos) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
if (pos < 0 || (unsigned)pos >= dv->GetColumnCount()) return;
wxDataViewColumn* c = dv->GetColumn((unsigned)pos);
if (c) c->SetWidth(wxCOL_WIDTH_AUTOSIZE);
}
// Update a column's header text in place (creation index) without recreating
@@ -398,6 +775,25 @@ int wxbr_dvlc_col_at_pos(void* win, int pos) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
unsigned n = dv->GetColumnCount();
if (pos < 0 || (unsigned)pos >= n) return -1;
#ifdef __WXGTK__
// wxGTK's GetColumnPosition() does NOT reflect a native GtkTreeView column
// drag, so after the user reorders columns it reports the creation order and
// the reorder is silently lost. Read the real display order from the
// GtkTreeView instead, then map the column back to its wx creation index.
GtkWidget* tvw = dv->GtkGetTreeView();
if (tvw) {
GList* cols = gtk_tree_view_get_columns(GTK_TREE_VIEW(tvw)); // display order
GtkTreeViewColumn* gcol = (GtkTreeViewColumn*)g_list_nth_data(cols, (guint)pos);
g_list_free(cols);
if (gcol) {
wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
for (unsigned i = 0; i < n; i++) {
if (dv->GetColumn(i) == wxcol) return (int)i;
}
}
return -1;
}
#endif
for (unsigned i = 0; i < n; i++) {
wxDataViewColumn* c = dv->GetColumn(i);
if (c && dv->GetColumnPosition(c) == (unsigned)pos) return (int)i;
@@ -406,58 +802,54 @@ 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();
int count = (int)dvlc_store(win)->GetItemCount();
dv->UnselectAll();
for (int i = 0; i < n; i++) {
if (rows[i] >= 0) lc->SelectRow((unsigned)rows[i]);
// GetItem() asserts on an out-of-range row, so bound both ends.
if (rows[i] >= 0 && rows[i] < count) 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();
if (row >= (long)dvlc_store(win)->GetItemCount()) return;
dv->Select(m->GetItem((unsigned)row));
}
// ---- timer -----------------------------------------------------------------
@@ -591,8 +983,151 @@ 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);
});
}
}
// ---- status-bar error/warning indicator -------------------------------------
// A colour-tinted static text pinned to the RIGHT-hand field of the frame's
// status bar, so scan/apply errors surface in the bottom-right corner without
// overwriting the main (left) scan-status text. The status bar is reconfigured
// to two fields: field 0 (stretch) carries the scan status set via the upstream
// SetStatusText path; field 1 (fixed) hosts this coloured label, which we
// reposition into that field's rect whenever the bar is resized.
static wxStaticText* g_status_indicator = nullptr;
static void reposition_status_indicator() {
if (!g_status_indicator) return;
wxStatusBar* sb = wxDynamicCast(g_status_indicator->GetParent(), wxStatusBar);
if (!sb) return;
wxRect r;
if (!sb->GetFieldRect(1, r)) return;
wxSize best = g_status_indicator->GetBestSize();
int h = best.GetHeight();
int y = r.y + (r.height - h) / 2;
g_status_indicator->SetSize(r.x + 4, y, r.width - 8, h);
}
void wxbr_status_indicator_init(void* frame_ptr) {
wxFrame* frame = (wxFrame*)frame_ptr;
wxStatusBar* sb = frame->GetStatusBar();
if (!sb) sb = frame->CreateStatusBar();
int widths[2] = { -1, 340 };
sb->SetFieldsCount(2);
sb->SetStatusWidths(2, widths);
if (!g_status_indicator) {
g_status_indicator = new wxStaticText(sb, wxID_ANY, wxEmptyString,
wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT | wxST_NO_AUTORESIZE);
sb->Bind(wxEVT_SIZE, [](wxSizeEvent& ev) {
reposition_status_indicator();
ev.Skip();
});
}
reposition_status_indicator();
}
// Set the bottom-right indicator text and its colour. An empty string clears it.
void wxbr_status_indicator_set(const char* text, int r, int g, int b) {
if (!g_status_indicator) return;
g_status_indicator->SetLabel(wxString::FromUTF8(text ? text : ""));
g_status_indicator->SetForegroundColour(
wxColour((unsigned char)r, (unsigned char)g, (unsigned char)b));
reposition_status_indicator();
g_status_indicator->Refresh();
}
// ---- 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"
+184
View File
@@ -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,16 +48,20 @@ 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);
pub fn wxbr_dvlc_clear(win: *mut c_void);
pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *const c_char);
pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
pub fn wxbr_dvlc_set_col_title(win: *mut c_void, col: c_int, title: *const c_char);
pub fn wxbr_dvlc_set_sort_indicator(win: *mut c_void, col: c_int, active: c_int, ascending: c_int);
pub fn wxbr_dvlc_col_at_pos(win: *mut c_void, pos: c_int) -> c_int;
@@ -64,6 +70,10 @@ 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_dvlc_set_zebra(win: *mut c_void, r: c_int, g: c_int, b: c_int);
pub fn wxbr_dvlc_get_top_row(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_ensure_visible(win: *mut c_void, row: usize);
pub fn wxbr_apply_zebra_css(r: c_int, g: c_int, b: c_int);
pub fn wxbr_rearrange_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
pub fn wxbr_rearrange_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
@@ -83,7 +93,18 @@ 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);
pub fn wxbr_status_indicator_init(frame: *mut c_void);
pub fn wxbr_status_indicator_set(text: *const c_char, r: c_int, g: c_int, b: c_int);
}
}
@@ -116,6 +137,10 @@ pub enum WxEventKind {
DvlcSelectionChanged,
DvlcContextMenu,
MenuItem,
ChoiceChanged,
SysColour,
Deferred,
DvlcHeaderRightClick,
}
impl WxEventKind {
@@ -131,6 +156,10 @@ impl WxEventKind {
9 => WxEventKind::DvlcSelectionChanged,
10 => WxEventKind::DvlcContextMenu,
11 => WxEventKind::MenuItem,
12 => WxEventKind::ChoiceChanged,
13 => WxEventKind::SysColour,
14 => WxEventKind::Deferred,
15 => WxEventKind::DvlcHeaderRightClick,
_ => return None,
})
}
@@ -141,6 +170,28 @@ 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) }
}
/// Reconfigure the frame's status bar to two fields and attach a colour-tinted
/// label pinned to the right-hand field (bottom-right corner). Call once after
/// `create_status_bar()`. The main scan status keeps using the left field via
/// the upstream `set_status_text` path.
pub fn status_indicator_init(frame: Widget) {
unsafe { notsafe::wxbr_status_indicator_init(frame.0) }
}
/// Set the bottom-right status indicator's text and colour (an empty string
/// clears it). Used for scan/apply errors (red) and warnings (amber).
pub fn status_indicator_set(text: &str, r: u8, g: u8, b: u8) {
let c = CString::new(text).unwrap_or_default();
unsafe { notsafe::wxbr_status_indicator_set(c.as_ptr(), r as c_int, g as c_int, b 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 +267,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 +351,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 +439,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 +465,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) }
}
@@ -409,6 +500,13 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_set_cell(self.0, row, col, c.as_ptr()) }
}
/// Set the hover tooltip for one cell (empty clears it). GTK only; a no-op
/// on other platforms until they gain per-cell tooltip support.
pub fn dvlc_set_cell_tooltip(&self, row: usize, col: usize, text: &str) {
let c = CString::new(text).unwrap_or_default();
unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
}
pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
let mut buf = vec![0i8; 4096];
let n = unsafe {
@@ -425,6 +523,11 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_col_count(self.0).max(0) as usize }
}
/// Auto-size the column at display position `pos` to fit its content.
pub fn dvlc_autosize_col(&self, pos: usize) {
unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
}
/// Model column index shown at display position `pos` (after drag reorder).
pub fn dvlc_col_at_pos(&self, pos: usize) -> Option<usize> {
let v = unsafe { notsafe::wxbr_dvlc_col_at_pos(self.0, pos as c_int) };
@@ -459,6 +562,36 @@ 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) }
}
/// Set the alternating-row (zebra) background colour applied to odd rows.
/// Pass `None` to turn zebra striping off.
pub fn dvlc_set_zebra(&self, color: Option<(u8, u8, u8)>) {
let (r, g, b) = match color {
Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
None => (-1, -1, -1),
};
unsafe { notsafe::wxbr_dvlc_set_zebra(self.0, r, g, b) }
}
/// The model-row index of the top (first visible) row, or `None` if empty.
pub fn dvlc_get_top_row(&self) -> Option<usize> {
let r = unsafe { notsafe::wxbr_dvlc_get_top_row(self.0) };
(r >= 0).then_some(r as usize)
}
/// Scroll so `row` is visible (used to restore scroll position after a refill).
pub fn dvlc_ensure_visible(&self, row: usize) {
unsafe { notsafe::wxbr_dvlc_ensure_visible(self.0, row) }
}
// ---- rearrangeable check-list ----
/// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
@@ -553,9 +686,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) }
}
}