Compare commits

...
16 Commits
Author SHA1 Message Date
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 5564 additions and 365 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);
}
}
+87 -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,100 @@ 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 columns (synthetic, so the columns
// show variety offline).
control_board: if self.model.contains("S17") {
"Xilinx".to_string()
} else if self.model.contains("S19j") || self.model.contains("S19k") {
"AMLogic".to_string()
} else if self.model.contains("S19") {
"BeagleBone Black".to_string()
} else if self.model.contains("S21") {
"CVITek".to_string()
} else {
String::new()
},
pic_present: if self.model.contains("S21") {
Some(false) // noPIC example
} else if self.model.starts_with("Antminer") {
Some(true)
} else {
None // WhatsMiner: unknown over the network
},
// Access: idle/view-only units (no worker) shown locked; the rest
// unlocked. (Live rows infer this from control capabilities.)
write_locked: Some(self.worker.is_empty()),
errors: if self.model.contains("S21 Pro") {
vec![
"[Warning] hashrate 70% below expected".to_string(),
"[Warning] chip temperature high (HashBoard 2)".to_string(),
]
} else {
Vec::new()
},
..Default::default()
}
}
}
/// The 9 bench boards. Two are idle (S17 stock, WardenOS dev), one is slow
/// (S21 Pro aml stock at ~30% of expected); the other six hash normally.
/// The 9 bench boards (9 rows total). One is idle/not-hashing (S17 stock,
/// .112); one is paused (WardenOS dev, .115 - deliberately rebucketed from idle
/// so the "paused" status/KPI bucket is exercisable offline); one is slow (S21
/// Pro aml stock at ~30% of expected); the other six hash normally.
///
/// Derived totals (used by the workflow tests):
/// total = 9, hashing = 6, slow = 1, not hashing = 2,
/// total = 9, hashing = 6, slow = 1, not hashing = 1, paused = 1,
/// total hashrate = 685.0 TH/s, total power = 21300 W.
pub fn bench_fleet() -> Vec<MinerRow> {
let boards = [
Board { ip: "10.255.1.112", model: "Antminer S17", firmware: "Stock",
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
worker: "", mining: false },
worker: "", mining: false, paused: false },
Board { ip: "10.255.1.166", model: "Antminer S19", firmware: "[removed] 1.2",
hashrate: 95.0, expected: 96.0, power: 3250.0, temp: 65.0, fan: 4200.0,
worker: "blueflare.s19", mining: true },
worker: "blueflare.s19", mining: true, paused: false },
Board { ip: "10.255.1.152", model: "Antminer S19j Pro", firmware: "[removed] 1.2",
hashrate: 100.0, expected: 104.0, power: 3100.0, temp: 62.0, fan: 3900.0,
worker: "blueflare.s19jpro", mining: true },
worker: "blueflare.s19jpro", mining: true, paused: false },
Board { ip: "10.255.1.167", model: "Antminer S19k Pro", firmware: "[removed] 1.2",
hashrate: 120.0, expected: 128.0, power: 3300.0, temp: 68.0, fan: 4500.0,
worker: "blueflare.s19kpro", mining: true },
worker: "blueflare.s19kpro", mining: true, paused: false },
Board { ip: "10.255.1.149", model: "Antminer S21 Pro", firmware: "Stock",
hashrate: 60.0, expected: 200.0, power: 1500.0, temp: 55.0, fan: 3000.0,
worker: "blueflare.s21pro", mining: true }, // slow: 60/200 = 30%
worker: "blueflare.s21pro", mining: true, paused: false }, // slow: 60/200 = 30%
Board { ip: "10.255.1.126", model: "WhatsMiner M30S", firmware: "WMOS H3",
hashrate: 92.0, expected: 96.0, power: 3400.0, temp: 70.0, fan: 4800.0,
worker: "blueflare.h3", mining: true },
worker: "blueflare.h3", mining: true, paused: false },
Board { ip: "10.255.1.131", model: "WhatsMiner M30S+", firmware: "WMOS H616",
hashrate: 100.0, expected: 100.0, power: 3450.0, temp: 71.0, fan: 4900.0,
worker: "blueflare.h616", mining: true },
worker: "blueflare.h616", mining: true, paused: false },
Board { ip: "10.255.1.148", model: "WhatsMiner M50", firmware: "WMOS CB4",
hashrate: 118.0, expected: 122.0, power: 3300.0, temp: 66.0, fan: 4600.0,
worker: "blueflare.m50", mining: true },
worker: "blueflare.m50", mining: true, paused: false },
// Rebucketed from idle/not-hashing to paused so the "paused"
// status/KPI bucket is exercisable in the fake-scan/offline demo.
Board { ip: "10.255.1.115", model: "Antminer S19", firmware: "WardenOS dev",
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
worker: "", mining: false },
worker: "", mining: false, paused: true },
];
boards.into_iter().map(Board::into_row).collect()
}
+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());
}
}
+761 -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()
@@ -419,9 +500,34 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
.fold(0.0f64, f64::max);
let is_mining = data.is_mining;
let slow = crate::model::is_slow(is_mining, hashrate_ths, expected_ths);
let operating_state = data.operating_state.as_ref().map(|s| s.to_string()).unwrap_or_default();
let paused = crate::model::is_paused(&operating_state, is_mining);
// Probe what this miner supports being told to do (sync, no extra I/O).
let caps = MinerCaps {
fault_light: miner.supports_set_fault_light(),
restart: miner.supports_restart(),
pause: miner.supports_pause(),
resume: miner.supports_resume(),
power_limit: miner.supports_set_power_limit(),
tuning: miner.supports_set_tuning_percent(),
firmware_flash: miner.supports_upgrade_firmware(),
};
// PIC vs noPIC is not reported over the network by asic-rs; best-effort
// heuristic from the model string, else unknown (true detection needs an
// on-board SSH/I2C probe -- a separate feature).
let pic_present = if model.to_lowercase().contains("nopic") { Some(false) } else { None };
// Access: locked/view-only when the miner exposes no writable control at
// all, otherwise unlocked. Inferred from capabilities (asic-rs has no direct
// lock-state field).
let write_locked = Some(!caps.any_control());
let errors = summarize_messages(&data.messages);
MinerRow {
ip: data.ip.to_string(),
selected: false,
caps,
pic_present,
write_locked,
errors,
model,
mac: data.mac.map(|m| m.to_string()).unwrap_or_default(),
hostname: data.hostname.clone().unwrap_or_default(),
@@ -437,7 +543,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
chip_temp_c,
fluid_temp_c,
outlet_temp_c,
fan_rpm,
fan_rpms,
psu_fan_rpm,
fan_count: (!data.fans.is_empty()).then_some(data.fans.len() as u32),
expected_fans: data.expected_fans.map(|v| v as u32),
@@ -452,13 +558,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 +1099,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 +1325,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);
}
}
+1975 -124
View File
File diff suppressed because it is too large Load Diff
+168 -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,728 @@
+// 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,16 @@
+ pub fn wxbr_system_color(which: c_int, r: *mut u8, g: *mut u8, b: *mut u8);
+ pub fn wxbr_set_bg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_set_fg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_choice(parent: *mut c_void, id: c_int) -> *mut c_void;
+ pub fn wxbr_choice_append(win: *mut c_void, label: *const c_char);
+ pub fn wxbr_choice_clear(win: *mut c_void);
+ pub fn wxbr_choice_get_selection(win: *mut c_void) -> c_int;
+ pub fn wxbr_choice_set_selection(win: *mut c_void, i: c_int);
+ pub fn wxbr_media_button(parent: *mut c_void, id: c_int, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
+ pub fn wxbr_bind_sys_colour(win: *mut c_void);
+ pub fn wxbr_destroy(win: *mut c_void);
+ pub fn wxbr_destroy_children(win: *mut c_void);
+ pub fn wxbr_call_after(id: c_int);
+ }
+}
+
@@ -129,6 +148,10 @@
+ DvlcSelectionChanged,
+ DvlcContextMenu,
+ MenuItem,
+ ChoiceChanged,
+ SysColour,
+ Deferred,
+ DvlcHeaderRightClick,
+}
+
+impl WxEventKind {
@@ -144,6 +167,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 +181,13 @@
+ unsafe { notsafe::wxbr_apply_zebra_css(r as c_int, g as c_int, b as c_int) }
+}
+
+/// Schedule a deferred action: a `Deferred` event carrying `id` is delivered
+/// from the event loop after the current event finishes. Use this to rebuild or
+/// destroy a control from outside its own event handler.
+pub fn call_after(id: i32) {
+ unsafe { notsafe::wxbr_call_after(id as c_int) }
+}
+
+/// Open a URL in the system default browser. Returns true on success.
+pub fn launch_browser(url: &str) -> bool {
+ let c = CString::new(url).unwrap_or_default();
@@ -229,6 +263,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 +347,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 +435,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 +461,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 +496,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 +519,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 +558,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 +682,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) }
+ }
+}
+529 -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,1064 @@
+// 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,35 @@
+#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 <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 +64,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 +211,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 +331,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 +440,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 +648,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 +737,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
@@ -409,58 +785,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 +966,102 @@
+ delete m;
+}
+
+// ---- choice (dropdown) ------------------------------------------------------
+
+void* wxbr_choice(void* parent, int id) {
+ wxChoice* c = new wxChoice((wxWindow*)parent, id);
+ c->Bind(wxEVT_CHOICE, [id](wxCommandEvent& e) {
+ if (g_widget_event)
+ g_widget_event(WxEV_CHOICE_CHANGED, id, (long)e.GetSelection());
+ });
+ return (void*)c;
+}
+
+void wxbr_choice_append(void* win, const char* label) {
+ ((wxChoice*)win)->Append(wxString::FromUTF8(label));
+}
+
+void wxbr_choice_clear(void* win) { ((wxChoice*)win)->Clear(); }
+
+int wxbr_choice_get_selection(void* win) {
+ return ((wxChoice*)win)->GetSelection();
+}
+
+void wxbr_choice_set_selection(void* win, int i) {
+ ((wxChoice*)win)->SetSelection(i);
+}
+
+// ---- media (icon) button: play / pause / stop -------------------------------
+
+// kind: 0=play (triangle), 1=pause (two bars), 2=stop (square). Drawn in the
+// given colour on a transparent bitmap so it reads as a coloured glyph on the
+// native button. Emits WxEV_BUTTON_CLICKED with `id`, like a normal button.
+void* wxbr_media_button(void* parent, int id, int kind, int r, int g, int b) {
+ const int sz = 20;
+ wxImage img(sz, sz);
+ img.InitAlpha();
+ unsigned char* a = img.GetAlpha();
+ if (a) memset(a, 0, (size_t)sz * sz); // fully transparent
+ wxBitmap bmp(img);
+ {
+ wxMemoryDC mdc(bmp);
+ wxGraphicsContext* gc = wxGraphicsContext::Create(mdc);
+ if (gc) {
+ gc->SetAntialiasMode(wxANTIALIAS_DEFAULT);
+ wxColour col(r, g, b);
+ gc->SetBrush(wxBrush(col));
+ gc->SetPen(wxPen(col, 1.0));
+ if (kind == 0) {
+ wxGraphicsPath p = gc->CreatePath();
+ p.MoveToPoint(5, 4);
+ p.AddLineToPoint(16, 10);
+ p.AddLineToPoint(5, 16);
+ p.CloseSubpath();
+ gc->FillPath(p);
+ } else if (kind == 1) {
+ gc->DrawRectangle(5, 4, 3.5, 12);
+ gc->DrawRectangle(11.5, 4, 3.5, 12);
+ } else {
+ gc->DrawRectangle(5, 5, 10, 10);
+ }
+ delete gc;
+ }
+ }
+ wxBitmapButton* btn = new wxBitmapButton((wxWindow*)parent, id, bmp);
+ btn->Bind(wxEVT_BUTTON, [id](wxCommandEvent&) {
+ if (g_widget_event) g_widget_event(WxEV_BUTTON_CLICKED, id, 0);
+ });
+ return (void*)btn;
+}
+
+// ---- live theme changes -----------------------------------------------------
+
+// Emit WxEV_SYS_COLOUR when the OS light/dark theme changes so the app can
+// repaint custom-coloured widgets (KPI cards, table rows).
+void wxbr_bind_sys_colour(void* win) {
+ ((wxWindow*)win)->Bind(wxEVT_SYS_COLOUR_CHANGED, [](wxSysColourChangedEvent& e) {
+ e.Skip();
+ if (g_widget_event) g_widget_event(WxEV_SYS_COLOUR, 0, 0);
+ });
+}
+
+// Run a deferred action after the current event finishes unwinding: emits
+// WxEV_DEFERRED with `id` from the main event loop. Used to rebuild a control
+// from outside its own event handler (destroying a widget mid-event is unsafe).
+void wxbr_call_after(int id) {
+ if (wxTheApp) {
+ wxTheApp->CallAfter([id]() {
+ if (g_widget_event) g_widget_event(WxEV_DEFERRED, id, 0);
+ });
+ }
+}
+
+// ---- deferred destroy (safe from event handlers) ----------------------------
+
+void wxbr_destroy(void* win) { ((wxWindow*)win)->Destroy(); }
+
+// Destroy a window's children immediately (used to rebuild a panel's dynamic
+// contents in place, e.g. the filter dialog's per-column controls).
+void wxbr_destroy_children(void* win) { ((wxWindow*)win)->DestroyChildren(); }
+
+} // extern "C"
@@ -20,14 +20,35 @@
#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 <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 +61,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 +208,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 +328,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 +437,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 +645,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 +734,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
@@ -406,58 +782,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 +963,102 @@ void wxbr_popup_menu(void* win, void* menu) {
delete m;
}
// ---- choice (dropdown) ------------------------------------------------------
void* wxbr_choice(void* parent, int id) {
wxChoice* c = new wxChoice((wxWindow*)parent, id);
c->Bind(wxEVT_CHOICE, [id](wxCommandEvent& e) {
if (g_widget_event)
g_widget_event(WxEV_CHOICE_CHANGED, id, (long)e.GetSelection());
});
return (void*)c;
}
void wxbr_choice_append(void* win, const char* label) {
((wxChoice*)win)->Append(wxString::FromUTF8(label));
}
void wxbr_choice_clear(void* win) { ((wxChoice*)win)->Clear(); }
int wxbr_choice_get_selection(void* win) {
return ((wxChoice*)win)->GetSelection();
}
void wxbr_choice_set_selection(void* win, int i) {
((wxChoice*)win)->SetSelection(i);
}
// ---- media (icon) button: play / pause / stop -------------------------------
// kind: 0=play (triangle), 1=pause (two bars), 2=stop (square). Drawn in the
// given colour on a transparent bitmap so it reads as a coloured glyph on the
// native button. Emits WxEV_BUTTON_CLICKED with `id`, like a normal button.
void* wxbr_media_button(void* parent, int id, int kind, int r, int g, int b) {
const int sz = 20;
wxImage img(sz, sz);
img.InitAlpha();
unsigned char* a = img.GetAlpha();
if (a) memset(a, 0, (size_t)sz * sz); // fully transparent
wxBitmap bmp(img);
{
wxMemoryDC mdc(bmp);
wxGraphicsContext* gc = wxGraphicsContext::Create(mdc);
if (gc) {
gc->SetAntialiasMode(wxANTIALIAS_DEFAULT);
wxColour col(r, g, b);
gc->SetBrush(wxBrush(col));
gc->SetPen(wxPen(col, 1.0));
if (kind == 0) {
wxGraphicsPath p = gc->CreatePath();
p.MoveToPoint(5, 4);
p.AddLineToPoint(16, 10);
p.AddLineToPoint(5, 16);
p.CloseSubpath();
gc->FillPath(p);
} else if (kind == 1) {
gc->DrawRectangle(5, 4, 3.5, 12);
gc->DrawRectangle(11.5, 4, 3.5, 12);
} else {
gc->DrawRectangle(5, 5, 10, 10);
}
delete gc;
}
}
wxBitmapButton* btn = new wxBitmapButton((wxWindow*)parent, id, bmp);
btn->Bind(wxEVT_BUTTON, [id](wxCommandEvent&) {
if (g_widget_event) g_widget_event(WxEV_BUTTON_CLICKED, id, 0);
});
return (void*)btn;
}
// ---- live theme changes -----------------------------------------------------
// Emit WxEV_SYS_COLOUR when the OS light/dark theme changes so the app can
// repaint custom-coloured widgets (KPI cards, table rows).
void wxbr_bind_sys_colour(void* win) {
((wxWindow*)win)->Bind(wxEVT_SYS_COLOUR_CHANGED, [](wxSysColourChangedEvent& e) {
e.Skip();
if (g_widget_event) g_widget_event(WxEV_SYS_COLOUR, 0, 0);
});
}
// Run a deferred action after the current event finishes unwinding: emits
// WxEV_DEFERRED with `id` from the main event loop. Used to rebuild a control
// from outside its own event handler (destroying a widget mid-event is unsafe).
void wxbr_call_after(int id) {
if (wxTheApp) {
wxTheApp->CallAfter([id]() {
if (g_widget_event) g_widget_event(WxEV_DEFERRED, id, 0);
});
}
}
// ---- deferred destroy (safe from event handlers) ----------------------------
void wxbr_destroy(void* win) { ((wxWindow*)win)->Destroy(); }
// Destroy a window's children immediately (used to rebuild a panel's dynamic
// contents in place, e.g. the filter dialog's per-column controls).
void wxbr_destroy_children(void* win) { ((wxWindow*)win)->DestroyChildren(); }
} // extern "C"
+167
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,16 @@ mod notsafe {
pub fn wxbr_system_color(which: c_int, r: *mut u8, g: *mut u8, b: *mut u8);
pub fn wxbr_set_bg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
pub fn wxbr_set_fg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
pub fn wxbr_choice(parent: *mut c_void, id: c_int) -> *mut c_void;
pub fn wxbr_choice_append(win: *mut c_void, label: *const c_char);
pub fn wxbr_choice_clear(win: *mut c_void);
pub fn wxbr_choice_get_selection(win: *mut c_void) -> c_int;
pub fn wxbr_choice_set_selection(win: *mut c_void, i: c_int);
pub fn wxbr_media_button(parent: *mut c_void, id: c_int, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
pub fn wxbr_bind_sys_colour(win: *mut c_void);
pub fn wxbr_destroy(win: *mut c_void);
pub fn wxbr_destroy_children(win: *mut c_void);
pub fn wxbr_call_after(id: c_int);
}
}
@@ -116,6 +135,10 @@ pub enum WxEventKind {
DvlcSelectionChanged,
DvlcContextMenu,
MenuItem,
ChoiceChanged,
SysColour,
Deferred,
DvlcHeaderRightClick,
}
impl WxEventKind {
@@ -131,6 +154,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 +168,13 @@ pub fn apply_zebra_css(r: u8, g: u8, b: u8) {
unsafe { notsafe::wxbr_apply_zebra_css(r as c_int, g as c_int, b as c_int) }
}
/// Schedule a deferred action: a `Deferred` event carrying `id` is delivered
/// from the event loop after the current event finishes. Use this to rebuild or
/// destroy a control from outside its own event handler.
pub fn call_after(id: i32) {
unsafe { notsafe::wxbr_call_after(id as c_int) }
}
/// Open a URL in the system default browser. Returns true on success.
pub fn launch_browser(url: &str) -> bool {
let c = CString::new(url).unwrap_or_default();
@@ -216,6 +250,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 +334,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 +422,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 +448,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 +483,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 +506,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 +545,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 +669,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) }
}
}