mirror of
https://github.com/MarekZegare4/MeshCore-Solo.git
synced 2026-11-01 10:21:59 +00:00
JakubandClaude Opus 5.5
5932317d6b
- Every e-ink build: the nodes' names beside their dots, placed where they cover no other name, dot or mark; the trail dotted and the waypoints. - 4.2" and 4.26": the map on the left 3/5, beside it the selected node (distance and direction, type, last heard, path, a compass rose) and, with Flow on, a legend counting each kind over the last minute; the kinds are told apart by their dashes (gfx::Dash). - E-ink scale: a framed bar, half filled, ticks at the ends, the distance over its middle. The OLED map is unchanged. - The distance shows with the position set in Privacy too. - Sim: sim_trail() lays a trail and two waypoints. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1612 lines
74 KiB
C++
1612 lines
74 KiB
C++
#pragma once
|
|
#include "InfoKit.h"
|
|
#include "../Features.h"
|
|
#include "../GeoUtils.h"
|
|
#include "NavView.h"
|
|
#include "TabBar.h"
|
|
|
|
// ── Path (Nodes > a contact > Path) ───────────────────────────────────────────
|
|
// The repeaters between this node and a contact as a list: edit it, trace it
|
|
// out and back (each link's signal both ways), find where a route stops,
|
|
// save it as the contact's route. The list, the trace and the save are the UI
|
|
// Core's PathEditor (`core().route`); ui-lvgl's Route screen is a view over
|
|
// the same. Picking a repeater to add hands the Nodes list over for a moment
|
|
// (NearbyScreen: `_route_pick`).
|
|
class RouteView {
|
|
UITask* _task = nullptr;
|
|
bool _active = false;
|
|
bool _pick = false; // the Add row was chosen: NearbyScreen takes over the pick
|
|
int _sel = 0, _scroll = 0;
|
|
PopupMenu _menu; // one hop: up / down / remove
|
|
int _menu_hop = 0;
|
|
uint8_t _seen_state = PathEditor::IDLE; // a result's alert, once
|
|
uint8_t _sel_kind = 0xFF; // the action row under the cursor, kept as rows come and go
|
|
|
|
enum Row : uint8_t { R_HOP, R_NODE, R_ADD, R_TRACE, R_PROBE, R_TO_NODE, R_SAVE, R_KEEP };
|
|
|
|
PathEditor& R() { return _task->core().route; }
|
|
// The rows: the hops, the node, then the actions (Find break only after a
|
|
// trace with no reply).
|
|
int rows(Row* out) {
|
|
PathEditor& r = R();
|
|
int k = 0;
|
|
for (int i = 0; i < r.count(); i++) out[k++] = R_HOP;
|
|
out[k++] = R_NODE;
|
|
out[k++] = R_ADD;
|
|
out[k++] = R_TRACE;
|
|
if (r.canProbe()) out[k++] = R_PROBE;
|
|
if (r.count() > 0) out[k++] = R_TO_NODE; // with no repeaters the trace is to the node
|
|
out[k++] = R_SAVE;
|
|
out[k++] = R_KEEP;
|
|
return k;
|
|
}
|
|
static const int ROWS_MAX = PathEditor::MAX_HOPS + 7;
|
|
|
|
void openHopMenu(int i) {
|
|
_menu_hop = i;
|
|
_menu.begin("Hop", 3);
|
|
_menu.addItem("Move up");
|
|
_menu.addItem("Move down");
|
|
_menu.addItem("Remove");
|
|
}
|
|
|
|
// A link's signal, the weaker way rounded: "6/4" (out/back dB).
|
|
static void linkText(char* out, size_t n, int16_t o, int16_t b) {
|
|
snprintf(out, n, "%d/%d", (int)lroundf(o / 4.0f), (int)lroundf(b / 4.0f));
|
|
}
|
|
|
|
// What a result means, said once when it comes.
|
|
void announce() {
|
|
PathEditor& r = R();
|
|
if (r.state() == _seen_state) return;
|
|
_seen_state = r.state();
|
|
char t[48];
|
|
switch (r.state()) {
|
|
case PathEditor::DONE: {
|
|
int16_t w = 0;
|
|
if (r.worstX4(w)) snprintf(t, sizeof(t), "Weakest %d dB", (int)lroundf(w / 4.0f));
|
|
else return;
|
|
break;
|
|
}
|
|
case PathEditor::TIMEOUT:
|
|
snprintf(t, sizeof(t), "%s", r.count() ? "No reply: Find break" : "No reply");
|
|
break;
|
|
case PathEditor::PROBED:
|
|
if (r.reached() < r.count()) snprintf(t, sizeof(t), "Stops at %.14s", r.nodeName(r.reached() + 1));
|
|
else if (r.toNode()) snprintf(t, sizeof(t), "Node not repeating?");
|
|
else snprintf(t, sizeof(t), "All answered");
|
|
break;
|
|
case PathEditor::FAILED:
|
|
snprintf(t, sizeof(t), "%s", r.failure() == PathEditor::FAIL_NO_KEY ? "Repeater key unknown"
|
|
: r.failure() == PathEditor::FAIL_BUSY ? "Busy, try again"
|
|
: r.failure() == PathEditor::FAIL_EMPTY ? "Nothing to trace" : "Send failed");
|
|
break;
|
|
default: return;
|
|
}
|
|
_task->showAlert(t, 1500);
|
|
}
|
|
|
|
public:
|
|
bool active() const { return _active; }
|
|
bool takePick() { bool p = _pick; _pick = false; return p; }
|
|
|
|
bool open(UITask* task, const uint8_t* pub_key) {
|
|
_task = task;
|
|
if (!task->core().route.open(pub_key)) return false;
|
|
_active = true;
|
|
_pick = false;
|
|
_sel = _scroll = 0;
|
|
_menu.active = false;
|
|
_seen_state = PathEditor::IDLE;
|
|
_sel_kind = 0xFF;
|
|
return true;
|
|
}
|
|
// Back from picking a repeater: the cursor on Add, for the next one.
|
|
void show() {
|
|
_active = true;
|
|
_sel = R().count() + 1;
|
|
_sel_kind = R_ADD;
|
|
}
|
|
void close() {
|
|
if (_task) R().cancelTrace();
|
|
_active = false;
|
|
_menu.active = false;
|
|
}
|
|
|
|
int render(DisplayDriver& display) {
|
|
PathEditor& r = R();
|
|
r.poll();
|
|
announce();
|
|
const int n = r.count();
|
|
char title[32];
|
|
switch (r.state()) {
|
|
case PathEditor::RUNNING:
|
|
if (r.probing()) snprintf(title, sizeof(title), "Probe %d/%d", r.links() + 1, n);
|
|
else snprintf(title, sizeof(title), "Tracing...");
|
|
break;
|
|
case PathEditor::DONE: snprintf(title, sizeof(title), "OK %lums", (unsigned long)r.rttMs()); break;
|
|
case PathEditor::TIMEOUT: snprintf(title, sizeof(title), "No reply"); break;
|
|
case PathEditor::PROBED: snprintf(title, sizeof(title), "Reached %d/%d", r.reached(), n); break;
|
|
case PathEditor::FAILED: snprintf(title, sizeof(title), "Can't trace"); break;
|
|
default: snprintf(title, sizeof(title), "%s%s", r.edited() ? "*" : "", r.targetName());
|
|
}
|
|
drawScreenHeader(display, title, -1, 0, true, false);
|
|
Row kind[ROWS_MAX];
|
|
const int nrows = rows(kind);
|
|
followSelection(kind, nrows);
|
|
const int stop = r.state() == PathEditor::PROBED ? r.reached() + 1 : 0; // the node that didn't answer
|
|
drawList(display, nrows, _sel, _scroll, [&](int idx, int y, bool sel, int reserve) {
|
|
drawRowSelection(display, y, sel, reserve);
|
|
char left[40], right[16] = "";
|
|
int16_t o, b;
|
|
switch (kind[idx]) {
|
|
case R_HOP:
|
|
snprintf(left, sizeof(left), "%d %s", idx + 1, r.hop(idx).name);
|
|
if (r.linkSnrX4(idx + 1, o, b)) linkText(right, sizeof(right), o, b);
|
|
else if (idx + 1 == stop) snprintf(right, sizeof(right), "x");
|
|
else if (r.hop(idx).known < 4) snprintf(right, sizeof(right), "?");
|
|
break;
|
|
case R_NODE:
|
|
snprintf(left, sizeof(left), "> %s", r.targetName());
|
|
if (!r.toNode()) snprintf(right, sizeof(right), "-");
|
|
else if (r.linkSnrX4(n + 1, o, b)) linkText(right, sizeof(right), o, b);
|
|
else if (stop == n + 1) snprintf(right, sizeof(right), "x");
|
|
break;
|
|
case R_ADD: snprintf(left, sizeof(left), "+ Add repeater"); break;
|
|
case R_TRACE: snprintf(left, sizeof(left), "%s", r.state() == PathEditor::RUNNING ? "Stop" : "Trace"); break;
|
|
case R_PROBE: snprintf(left, sizeof(left), "Find break"); break;
|
|
case R_TO_NODE: snprintf(left, sizeof(left), "To node"); snprintf(right, sizeof(right), "%s", r.toNode() ? "ON" : "OFF"); break;
|
|
case R_SAVE: snprintf(left, sizeof(left), "%s", n ? "Save path" : "Save direct"); break;
|
|
case R_KEEP: snprintf(left, sizeof(left), "Keep path"); snprintf(right, sizeof(right), "%s", r.pinned() ? "ON" : "OFF"); break;
|
|
}
|
|
const int rw = right[0] ? display.getTextWidth(right) + display.getCharWidth() : 0;
|
|
display.drawTextEllipsized(2, y, display.width() - reserve - 4 - rw, left, sel);
|
|
if (right[0]) {
|
|
display.setColor(sel ? UIColor::window_bkg : UIColor::primary_txt);
|
|
display.drawTextRightAlign(display.width() - reserve - 2, y, right);
|
|
}
|
|
});
|
|
if (_menu.active) _menu.render(display);
|
|
return r.state() == PathEditor::RUNNING ? 100 : 2000;
|
|
}
|
|
|
|
// Returns true: the key was used (the view is modal).
|
|
bool handleInput(char c) {
|
|
PathEditor& r = R();
|
|
if (_menu.active) {
|
|
auto res = _menu.handleInput(c);
|
|
if (res == PopupMenu::SELECTED) {
|
|
int i = _menu.selectedIndex();
|
|
if (i == 0) { if (r.move(_menu_hop, -1)) _sel = _menu_hop - 1; }
|
|
else if (i == 1) { if (r.move(_menu_hop, +1)) _sel = _menu_hop + 1; }
|
|
else r.remove(_menu_hop);
|
|
_menu.active = false;
|
|
}
|
|
return true;
|
|
}
|
|
Row kind[ROWS_MAX];
|
|
const int nrows = rows(kind);
|
|
if (c == KEY_CANCEL) { close(); return true; }
|
|
if (c == KEY_UP) { _sel = _sel > 0 ? _sel - 1 : nrows - 1; _sel_kind = kind[_sel]; return true; }
|
|
if (c == KEY_DOWN) { _sel = _sel < nrows - 1 ? _sel + 1 : 0; _sel_kind = kind[_sel]; return true; }
|
|
if (_sel >= nrows) _sel = nrows - 1;
|
|
const Row k = kind[_sel];
|
|
if (keyIsPrev(c) || keyIsNext(c)) {
|
|
const int dir = keyIsNext(c) ? 1 : -1;
|
|
if (k == R_HOP) { if (r.move(_sel, dir)) _sel += dir; } // reorder in place
|
|
else if (k == R_TO_NODE) r.setToNode(!r.toNode());
|
|
else if (k == R_KEEP) toggleKeep();
|
|
return true;
|
|
}
|
|
if (c != KEY_ENTER && c != KEY_CONTEXT_MENU) return true;
|
|
switch (k) {
|
|
case R_HOP: openHopMenu(_sel); break;
|
|
case R_NODE: break;
|
|
case R_ADD:
|
|
if (r.full()) _task->showAlert("Path is full", 1000);
|
|
else { r.cancelTrace(); _pick = true; _active = false; }
|
|
break;
|
|
case R_TRACE:
|
|
if (r.state() == PathEditor::RUNNING) r.cancelTrace();
|
|
else { _seen_state = PathEditor::RUNNING; r.trace(); }
|
|
break;
|
|
case R_PROBE:
|
|
_seen_state = PathEditor::RUNNING;
|
|
r.probe();
|
|
break;
|
|
case R_TO_NODE: r.setToNode(!r.toNode()); break;
|
|
case R_SAVE:
|
|
if (!r.save()) _task->showAlert("Can't save", 1000);
|
|
else _task->showAlert(r.count() ? "Path saved" : "Saved: direct", 1000);
|
|
break;
|
|
case R_KEEP: toggleKeep(); break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
// The cursor stays on the action it was on when a row before it comes or
|
|
// goes (Find break after a trace with no reply); from Find break, once
|
|
// it's gone, to Trace.
|
|
void followSelection(const Row* kind, int nrows) {
|
|
if (_sel >= nrows) _sel = nrows - 1;
|
|
if (_sel_kind != 0xFF && _sel_kind > R_NODE && kind[_sel] != _sel_kind) {
|
|
int at = -1;
|
|
for (int i = 0; i < nrows && at < 0; i++) if (kind[i] == _sel_kind) at = i;
|
|
for (int i = 0; i < nrows && at < 0; i++) if (_sel_kind == R_PROBE && kind[i] == R_TRACE) at = i;
|
|
if (at >= 0) _sel = at;
|
|
}
|
|
_sel_kind = kind[_sel];
|
|
}
|
|
|
|
void toggleKeep() {
|
|
PathEditor& r = R();
|
|
bool now = r.setPinned(!r.pinned());
|
|
if (r.pinned() && !now) _task->showAlert("Kept once saved", 1000);
|
|
}
|
|
};
|
|
|
|
// ── Nearby Nodes ──────────────────────────────────────────────────────────────
|
|
// One list / detail / action-menu interaction path over two sources:
|
|
// SRC_STORED — contacts known to the mesh (distance / bearing / last-heard)
|
|
// SRC_SCAN — live NODE_DISCOVER_REQ results (RSSI / SNR / status)
|
|
// Filter (type) and sort are independent axes and combine freely. The action
|
|
// menu (Hold Enter) is identical everywhere; only the per-row column and the
|
|
// detail fields differ between sources.
|
|
class NearbyScreen : public UIScreen, protected NearbyModel {
|
|
UITask* _task;
|
|
|
|
// List data, filter / sort / source and the refresh logic live in
|
|
// ui-core/NearbyModel.h (shared with ui-lvgl); this class adds selection,
|
|
// detail / navigate views, scan timing and the action menu.
|
|
|
|
// ── action-menu actions (matched by id, not by row index) ────────────────────
|
|
enum Action : uint8_t { ACT_NAV, ACT_PING, ACT_WAYPOINT, ACT_LOCATOR,
|
|
ACT_ADD, ACT_DELETE, ACT_FAV, ACT_PIN, ACT_ADMIN, ACT_SORT, ACT_SCAN, ACT_MAP,
|
|
ACT_TELEM, ACT_RESET_PATH, ACT_SHARE, ACT_ROUTE, ACT_FLOW };
|
|
|
|
// Set by UITask::pickAdminTarget() (Tools > Admin, which is remote-only):
|
|
// while true, ENTER on an eligible row (a stored repeater/room contact) hands
|
|
// the node straight to Admin instead of opening the detail view -- everything
|
|
// else (filters, scan, ping, sort, the Hold-Enter menu) behaves identically to
|
|
// normal Nodes browsing, so picking a node for Admin looks exactly like using
|
|
// this screen for anything else. Mirrors MessagesScreen's
|
|
// startPickBotChannel()/startPickBotRoom() pick-mode idiom.
|
|
bool _pick_admin_target = false;
|
|
|
|
// Path view (RouteView above) and its repeater pick: Add hands the list over
|
|
// filtered to repeaters; Enter on one adds it, Back returns without.
|
|
RouteView _route;
|
|
bool _route_pick = false;
|
|
uint8_t _route_filter = F_ALL; // the filter to restore after the pick
|
|
uint8_t _route_key[PUB_KEY_SIZE];
|
|
|
|
int _sel;
|
|
int _scroll;
|
|
bool _detail;
|
|
bool _nav = false; // full-screen navigate-to-node view (over detail)
|
|
bool _map = false; // the nodes with a position on a map (under detail)
|
|
static const uint32_t FLOW_SHOW_MS = 60000; // packet flow lines stay this long
|
|
// and a ring here, for one placed nowhere else: on e-ink longer, each
|
|
// change being a refresh
|
|
static const uint32_t FLOW_HERE_MS = Features::IS_EINK ? 15000 : 3000;
|
|
uint32_t _flow_seen = 0;
|
|
int _map_zoom = 0; // 0: all of them in view; each step halves it, on the selected
|
|
navview::EtaTracker _nav_eta; // closing-speed/ETA for the navigate view
|
|
unsigned long _detail_refresh_ms;
|
|
unsigned long _list_refresh_ms = 0;
|
|
static const unsigned long DETAIL_REFRESH_MS = 10000UL;
|
|
static const unsigned long NAV_REFRESH_MS = 1000UL; // navigate view tracks a moving target
|
|
static const unsigned long TIME_LIST_REFRESH_MS = 3000UL;
|
|
|
|
// ── live-scan state ──────────────────────────────────────────────────────────
|
|
bool _scanning;
|
|
unsigned long _scan_started_ms;
|
|
static const unsigned long SCAN_DURATION_MS = 8000UL;
|
|
|
|
// ── popups ────────────────────────────────────────────────────────────────────
|
|
PopupMenu _menu; // unified action menu (Hold Enter), list + detail
|
|
PopupMenu _ping_menu; // ping (special: read-only result rows)
|
|
PopupMenu _confirm; // delete-contact confirmation (destructive → 2-step)
|
|
|
|
Action _menu_actions[16]; // parallel to _menu rows — stable action ids
|
|
int _menu_action_count;
|
|
char _sort_label[16]; // dynamic label for the Sort row
|
|
|
|
// ── ping state ───────────────────────────────────────────────────────────────
|
|
char _ping_time_str[24];
|
|
char _ping_snr_out_str[24];
|
|
char _ping_snr_back_str[24];
|
|
bool _pinging;
|
|
unsigned long _ping_started_ms;
|
|
|
|
// ── helpers ──────────────────────────────────────────────────────────────────
|
|
static void pubKeyToBase64(const uint8_t* key, char* out, int out_len) {
|
|
static const char T[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
int j = 0;
|
|
for (int i = 0; i < PUB_KEY_SIZE && j + 5 < out_len; i += 3) {
|
|
uint32_t b = ((uint32_t)key[i] << 16)
|
|
| (i+1 < PUB_KEY_SIZE ? (uint32_t)key[i+1] << 8 : 0)
|
|
| (i+2 < PUB_KEY_SIZE ? (uint32_t)key[i+2] : 0);
|
|
out[j++] = T[(b >> 18) & 63];
|
|
out[j++] = T[(b >> 12) & 63];
|
|
if (i+1 < PUB_KEY_SIZE) out[j++] = T[(b >> 6) & 63];
|
|
if (i+2 < PUB_KEY_SIZE) out[j++] = T[b & 63];
|
|
}
|
|
out[j] = '\0';
|
|
}
|
|
|
|
bool useImperial() const { return _task && _task->useImperial(); }
|
|
|
|
// Full "X ago" form for the detail view, built on the shared short-age tag
|
|
// so there's one bucket ladder (see geo::fmtAgeShort).
|
|
static void fmtAge(char* buf, int n, uint32_t lastmod) {
|
|
char s[8];
|
|
geo::fmtAgeShort(s, sizeof(s), rtc_clock.getCurrentTime(), lastmod);
|
|
if (!s[0]) { snprintf(buf, n, "unknown"); return; }
|
|
snprintf(buf, n, "%s ago", s);
|
|
}
|
|
|
|
// The selected entry, or nullptr when the list is empty.
|
|
const Entry* selected() const {
|
|
return (_count > 0 && _sel < _count) ? &_entries[_sel] : nullptr;
|
|
}
|
|
|
|
// ── data refresh (NearbyModel) + selection clamping ─────────────────────────
|
|
void refreshStored() { NearbyModel::refreshStored(); clampSelection(); }
|
|
void refreshScan() { NearbyModel::refreshScan(); clampSelection(); }
|
|
void refresh() { refreshModel(); clampSelection(); }
|
|
|
|
// Rebuild the stored list (re-merge live shares + re-sort) while keeping the
|
|
// currently highlighted node selected across the rebuild — by public key
|
|
// for a stored node, or by name for a non-contact live sender. Returns false
|
|
// if that node is no longer in the list (caller decides whether to drop the
|
|
// detail/nav view). Shared by the list, detail and navigate refresh paths.
|
|
bool refreshKeepingSelection() {
|
|
bool saved_contact = (_sel < _count) && _entries[_sel].contact_idx >= 0;
|
|
bool saved_live = (_sel < _count) && _entries[_sel].is_live && !saved_contact;
|
|
uint8_t saved_key[PUB_KEY_SIZE];
|
|
if (saved_contact) memcpy(saved_key, _entries[_sel].pub_key, PUB_KEY_SIZE);
|
|
char saved_name[sizeof(_entries[0].name)]; saved_name[0] = '\0';
|
|
if (_sel < _count) {
|
|
strncpy(saved_name, _entries[_sel].name, sizeof(saved_name) - 1);
|
|
saved_name[sizeof(saved_name) - 1] = '\0';
|
|
}
|
|
refreshStored();
|
|
int i = saved_contact ? findContact(saved_key)
|
|
: (saved_live && saved_name[0]) ? findLiveByName(saved_name) : -1;
|
|
if (i >= 0) { _sel = i; return true; }
|
|
return false;
|
|
}
|
|
|
|
void clampSelection() {
|
|
if (_count == 0) { _sel = _scroll = 0; }
|
|
else if (_sel >= _count) { _sel = _count - 1; if (_scroll > _sel) _scroll = _sel; }
|
|
}
|
|
|
|
// ── live scan ────────────────────────────────────────────────────────────────
|
|
void enterScan() {
|
|
_source = SRC_SCAN;
|
|
_detail = false;
|
|
_nav = false;
|
|
_scanning = true;
|
|
_scan_started_ms = millis();
|
|
_sel = _scroll = 0;
|
|
the_mesh.sendNodeDiscoverReq();
|
|
refreshScan();
|
|
}
|
|
|
|
void leaveScan() {
|
|
_source = SRC_STORED;
|
|
_detail = false;
|
|
_nav = false;
|
|
_sel = _scroll = 0;
|
|
refreshStored();
|
|
}
|
|
|
|
// Save the currently-selected entry as a waypoint (its name as label).
|
|
void saveSelectedWaypoint() {
|
|
const Entry* e = selected();
|
|
if (!e) return;
|
|
if (e->lat_e6 == 0 && e->lon_e6 == 0) { _task->showAlert("No node GPS", 1000); return; }
|
|
_task->addWaypoint(e->lat_e6, e->lon_e6, e->name); // WaypointStore truncates the label
|
|
}
|
|
|
|
// Toggle the given contact in the Favourites dial: unpin if already pinned, else
|
|
// pin to the first empty slot. Persisted immediately (same as the Messages picker).
|
|
// Unlike the Messages lists, this one doesn't ask which slot -- it takes the
|
|
// first free one. The menu here is already long, and the dial itself can
|
|
// rearrange afterwards.
|
|
void togglePinToDial(const uint8_t* pub_key) {
|
|
int slot = _task->findFavouriteSlot(pub_key);
|
|
if (slot >= 0) {
|
|
_task->clearFavouriteSlot(slot);
|
|
the_mesh.savePrefs();
|
|
char alert[24];
|
|
snprintf(alert, sizeof(alert), "Unpinned (slot %d)", slot + 1);
|
|
_task->showAlert(alert, 1000);
|
|
return;
|
|
}
|
|
for (int s = 0; s < NodePrefs::FAVOURITES_COUNT; s++) {
|
|
if (_task->isFavouriteSlotEmpty(s)) {
|
|
_task->setFavouriteSlot(s, pub_key);
|
|
the_mesh.savePrefs();
|
|
char alert[24];
|
|
snprintf(alert, sizeof(alert), "Pinned to slot %d", s + 1);
|
|
_task->showAlert(alert, 1000);
|
|
return;
|
|
}
|
|
}
|
|
_task->showAlert("Dial full", 1200);
|
|
}
|
|
|
|
// Deleting a contact is destructive → confirm first (default highlight = Cancel).
|
|
void startDeleteConfirm() {
|
|
const Entry* e = selected();
|
|
if (!e || !e->has_key || !entryIsContact(e)) return;
|
|
_confirm.beginConfirm("Delete contact?", "Delete");
|
|
}
|
|
|
|
void doDeleteSelected() {
|
|
const Entry* e = selected();
|
|
if (!e || !e->has_key || !entryIsContact(e)) return;
|
|
uint8_t key[PUB_KEY_SIZE];
|
|
memcpy(key, e->pub_key, PUB_KEY_SIZE);
|
|
if (the_mesh.deleteContactByKey(key)) {
|
|
_detail = false; // the node this detail/nav view showed is gone
|
|
_nav = false;
|
|
refresh();
|
|
clampSelection();
|
|
}
|
|
}
|
|
|
|
// ── ping ──────────────────────────────────────────────────────────────────────
|
|
void resetPingLines() {
|
|
_ping_time_str[0] = '\0';
|
|
_ping_snr_out_str[0] = '\0';
|
|
_ping_snr_back_str[0] = '\0';
|
|
}
|
|
|
|
int pingRowCount() const {
|
|
return 1 + (_ping_time_str[0] ? 1 : 0)
|
|
+ (_ping_snr_out_str[0] ? 1 : 0)
|
|
+ (_ping_snr_back_str[0] ? 1 : 0);
|
|
}
|
|
|
|
void rebuildPingMenu() {
|
|
int keep = _ping_menu.selectedIndex(); // preserve selection across a rebuild
|
|
_ping_menu.begin("Ping", 4);
|
|
_ping_menu.addItem("Send");
|
|
if (_ping_time_str[0]) _ping_menu.addItem(_ping_time_str);
|
|
if (_ping_snr_out_str[0]) _ping_menu.addItem(_ping_snr_out_str);
|
|
if (_ping_snr_back_str[0]) _ping_menu.addItem(_ping_snr_back_str);
|
|
_ping_menu.setSelected(keep);
|
|
}
|
|
|
|
void closePingMenu(bool clear_task = true) {
|
|
_ping_menu.active = false;
|
|
_pinging = false;
|
|
if (clear_task && _task) _task->clearPing();
|
|
resetPingLines();
|
|
}
|
|
|
|
void startPingForKey(const uint8_t* pub_key) {
|
|
resetPingLines();
|
|
snprintf(_ping_time_str, sizeof(_ping_time_str), "RTT: ...");
|
|
if (_task && _task->startPing(pub_key)) {
|
|
_pinging = true;
|
|
_ping_started_ms = millis();
|
|
} else {
|
|
snprintf(_ping_time_str, sizeof(_ping_time_str), "RTT: send fail");
|
|
}
|
|
if (_ping_menu.active) rebuildPingMenu(); // surface "RTT: ..." immediately
|
|
}
|
|
|
|
void updatePingMenuState() {
|
|
if (!_ping_menu.active || !_task || (!_pinging && !_task->isPingActive())) return;
|
|
|
|
int16_t snr_out = 0, snr_back = 0;
|
|
uint32_t rtt = 0;
|
|
_task->getPingResult(snr_out, snr_back, rtt);
|
|
|
|
if (_pinging && (snr_out != 0 || snr_back != 0 || rtt != 0)) {
|
|
if (rtt > 0 && rtt < 10000) {
|
|
snprintf(_ping_time_str, sizeof(_ping_time_str), "RTT: %lums", rtt);
|
|
} else {
|
|
snprintf(_ping_time_str, sizeof(_ping_time_str), "RTT: timeout");
|
|
}
|
|
if (snr_out != 0)
|
|
snprintf(_ping_snr_out_str, sizeof(_ping_snr_out_str), "SNR out: %.1f", snr_out / 4.0f);
|
|
if (snr_back != 0)
|
|
snprintf(_ping_snr_back_str, sizeof(_ping_snr_back_str), "SNR back: %.1f", snr_back / 4.0f);
|
|
_pinging = false;
|
|
} else if (_pinging && millis() - _ping_started_ms >= _task->pingTimeoutMs()) {
|
|
snprintf(_ping_time_str, sizeof(_ping_time_str), "RTT: timeout");
|
|
_ping_snr_out_str[0] = '\0';
|
|
_ping_snr_back_str[0] = '\0';
|
|
_pinging = false;
|
|
if (_task) _task->clearPing();
|
|
}
|
|
if (pingRowCount() != _ping_menu.count()) rebuildPingMenu();
|
|
}
|
|
|
|
// Ping popup input. Result rows are read-only, so UP/DOWN are swallowed to keep
|
|
// the highlight on "Send".
|
|
void handlePingMenuInput(char c) {
|
|
if (c == KEY_UP || c == KEY_DOWN) return;
|
|
auto res = _ping_menu.handleInput(c);
|
|
if (res == PopupMenu::SELECTED) {
|
|
const Entry* e = selected();
|
|
if (!_pinging && e && e->has_key) startPingForKey(e->pub_key);
|
|
_ping_menu.active = true; // stay open so Ping can be repeated
|
|
} else if (res == PopupMenu::CANCELLED) {
|
|
closePingMenu();
|
|
}
|
|
}
|
|
|
|
// ── action menu (Hold Enter) — same everywhere ──────────────────────────────
|
|
void buildSortLabel() {
|
|
snprintf(_sort_label, sizeof(_sort_label),
|
|
"Sort: %s", _sort == SORT_TIME ? "Recent" : "Dist");
|
|
}
|
|
|
|
// A row is already a contact when it carries a contacts[] index (stored source)
|
|
// or the live-scan flagged it known. Full 32-byte key required to add/delete.
|
|
bool entryIsContact(const Entry* e) const {
|
|
return e && ((e->contact_idx >= 0) || (_source == SRC_SCAN && e->is_known));
|
|
}
|
|
|
|
char _fav_label[12]; // "Fav: ON" / "Fav: OFF" -- rewritten in place by L/R
|
|
char _flow_label[12]; // "Flow: ON" / "Flow: OFF" -- the map's packet flow
|
|
char _pin_label[24]; // "Pin to dial" / "Unpin (slot N)" -- _menu stores the pointer
|
|
char _telem_label[20]; // "Telem: ..." -- rewritten in place by L/R
|
|
|
|
// What a contact may ask for, as one cycled value: status first, since
|
|
// location and sensors go unanswered without it (MyMesh::onContactRequest).
|
|
static uint8_t telemPerms(int step) {
|
|
static const uint8_t STEPS[5] = {
|
|
0, TELEM_PERM_BASE, TELEM_PERM_BASE | TELEM_PERM_LOCATION, TELEM_PERM_BASE | TELEM_PERM_ENVIRONMENT,
|
|
TELEM_PERM_BASE | TELEM_PERM_LOCATION | TELEM_PERM_ENVIRONMENT };
|
|
return STEPS[step];
|
|
}
|
|
static int telemStep(uint8_t perms) {
|
|
for (int i = 4; i > 0; i--) if (perms == telemPerms(i)) return i;
|
|
return 0;
|
|
}
|
|
void buildTelemLabel(uint8_t perms) {
|
|
static const char* const NAMES[5] = { "None", "Status", "Stat+loc", "Stat+sens", "All" };
|
|
snprintf(_telem_label, sizeof(_telem_label), "Telem: %s", NAMES[telemStep(perms)]);
|
|
}
|
|
|
|
void openActionMenu() {
|
|
const Entry* e = selected();
|
|
bool stored = (_source == SRC_STORED);
|
|
bool has_gps = e && stored && (e->lat_e6 != 0 || e->lon_e6 != 0);
|
|
bool has_key = e && e->has_key;
|
|
bool is_contact = entryIsContact(e);
|
|
bool can_add = e && has_key && !is_contact; // a new node we can save
|
|
bool is_pinned = e && has_key && _task->findFavouriteSlot(e->pub_key) >= 0;
|
|
// Admin needs a real saved contact (repeater/room), not a scan result or a
|
|
// name-only live-share row -- same gating as startPickAdminTarget()'s ENTER.
|
|
bool is_admin_target = e && stored && e->contact_idx >= 0
|
|
&& (e->type == ADV_TYPE_REPEATER || e->type == ADV_TYPE_ROOM);
|
|
|
|
buildSortLabel();
|
|
_menu_action_count = 0;
|
|
_menu.begin("Options", 10);
|
|
auto add = [&](const char* label, Action a) {
|
|
_menu.addItem(label);
|
|
_menu_actions[_menu_action_count++] = a;
|
|
};
|
|
auto addValue = [&](const char* label, Action a) {
|
|
_menu.addValueItem(label);
|
|
_menu_actions[_menu_action_count++] = a;
|
|
};
|
|
|
|
if (stored && !_map && positioned(0, 1) >= 0) add("Map", ACT_MAP);
|
|
if (_map) { // packet flow: what the radio hears, as lines (ui-core/PacketFlow.h)
|
|
buildFlowLabel();
|
|
addValue(_flow_label, ACT_FLOW);
|
|
}
|
|
if (has_gps) add("Navigate", ACT_NAV);
|
|
if (has_key) add("Ping", ACT_PING);
|
|
if (has_gps) add("Save waypoint", ACT_WAYPOINT);
|
|
// Only a position is needed: with an identity prefix this becomes a person
|
|
// target that follows them, without one a place target pinned where they were.
|
|
if (has_gps) add("Set as target", ACT_LOCATOR);
|
|
if (can_add) add("Add contact", ACT_ADD);
|
|
if (is_contact && has_key) {
|
|
snprintf(_fav_label, sizeof(_fav_label), e->fav ? "Fav: ON" : "Fav: OFF");
|
|
addValue(_fav_label, ACT_FAV);
|
|
}
|
|
if (is_contact && has_key) {
|
|
if (is_pinned) snprintf(_pin_label, sizeof(_pin_label), "Unpin (slot %d)",
|
|
_task->findFavouriteSlot(e->pub_key) + 1);
|
|
else snprintf(_pin_label, sizeof(_pin_label), "Pin to dial");
|
|
add(_pin_label, ACT_PIN);
|
|
}
|
|
// A saved contact (not a scan row): its telemetry permissions -- only where
|
|
// Privacy says "Allowed" do they count -- its path and its advert.
|
|
ContactInfo* ci = (is_contact && has_key) ? the_mesh.lookupContactByPubKey(e->pub_key, PUB_KEY_SIZE) : nullptr;
|
|
if (ci && contactctl::telemetryPerContact(_task->getNodePrefs())) {
|
|
buildTelemLabel(contactctl::telemetry(*ci));
|
|
addValue(_telem_label, ACT_TELEM);
|
|
}
|
|
if (ci) add("Path / trace", ACT_ROUTE);
|
|
if (ci && contactctl::hasPath(*ci)) add("Reset path", ACT_RESET_PATH);
|
|
if (ci) add("Share nearby", ACT_SHARE);
|
|
if (is_admin_target) add("Admin", ACT_ADMIN);
|
|
if (is_contact && has_key) add("Delete contact", ACT_DELETE);
|
|
if (stored) addValue(_sort_label, ACT_SORT); // sort is meaningless for live-scan rows
|
|
add(stored ? "Discover scan" : "Rescan", ACT_SCAN);
|
|
}
|
|
|
|
// Flip the selected contact's favourite flag and retitle the open menu row.
|
|
// The list re-sorts underneath (favourites first), but refreshKeepingSelection()
|
|
// re-finds this node, so the popup stays anchored to it.
|
|
void toggleFavSelected() {
|
|
const Entry* e = selected();
|
|
if (!e || !e->has_key) return;
|
|
bool now_fav = !e->fav;
|
|
if (!contactctl::setFavourite(e->pub_key, now_fav)) return;
|
|
snprintf(_fav_label, sizeof(_fav_label), now_fav ? "Fav: ON" : "Fav: OFF");
|
|
refreshKeepingSelection();
|
|
}
|
|
|
|
// Advance the value on the menu's value rows (Sort, Fav, Telem). Sort and Fav
|
|
// are two-state, so LEFT and RIGHT do the same there; Telem steps by `dir`.
|
|
void buildFlowLabel() {
|
|
NodePrefs* p = _task->getNodePrefs();
|
|
snprintf(_flow_label, sizeof(_flow_label), "Flow: %s", p && p->flow_show ? "ON" : "OFF");
|
|
}
|
|
|
|
void cycleMenuValue(int i, int dir = 1) {
|
|
if (i < 0 || i >= _menu_action_count) return;
|
|
if (_menu_actions[i] == ACT_SORT) {
|
|
_sort = (_sort == SORT_DIST) ? SORT_TIME : SORT_DIST;
|
|
buildSortLabel();
|
|
refresh();
|
|
} else if (_menu_actions[i] == ACT_FAV) {
|
|
toggleFavSelected();
|
|
} else if (_menu_actions[i] == ACT_FLOW) {
|
|
NodePrefs* p = _task->getNodePrefs();
|
|
if (!p) return;
|
|
p->flow_show = p->flow_show ? 0 : 1;
|
|
the_mesh.savePrefs();
|
|
if (!p->flow_show) _task->core().flow.clear();
|
|
buildFlowLabel();
|
|
} else if (_menu_actions[i] == ACT_TELEM) {
|
|
const Entry* e = selected();
|
|
ContactInfo* ci = e ? the_mesh.lookupContactByPubKey(e->pub_key, PUB_KEY_SIZE) : nullptr;
|
|
if (!ci) return;
|
|
uint8_t next = telemPerms((telemStep(contactctl::telemetry(*ci)) + dir + 5) % 5);
|
|
if (contactctl::setTelemetry(e->pub_key, next)) buildTelemLabel(next);
|
|
}
|
|
}
|
|
|
|
void runAction(Action a) {
|
|
switch (a) {
|
|
case ACT_NAV: {
|
|
const Entry* e = selected();
|
|
if (e && (e->lat_e6 != 0 || e->lon_e6 != 0)) { _nav = true; _nav_eta.reset(); }
|
|
else _task->showAlert("No node GPS", 1000);
|
|
break;
|
|
}
|
|
case ACT_PING: {
|
|
const Entry* e = selected();
|
|
rebuildPingMenu();
|
|
_ping_menu.active = true;
|
|
if (e && e->has_key) startPingForKey(e->pub_key);
|
|
break;
|
|
}
|
|
case ACT_WAYPOINT: saveSelectedWaypoint(); break;
|
|
case ACT_LOCATOR: {
|
|
const Entry* e = selected();
|
|
if (!e || (e->lat_e6 == 0 && e->lon_e6 == 0)) break;
|
|
// A prefix is enough to keep re-resolving someone who is moving; without
|
|
// one (a channel share, matched by name) the honest target is the place
|
|
// they were last seen, snapshotted like a waypoint.
|
|
if (e->has_prefix) _task->setTargetNow(1, e->pub_key, e->lat_e6, e->lon_e6, e->name);
|
|
else _task->setTargetNow(0, nullptr, e->lat_e6, e->lon_e6, e->name);
|
|
break;
|
|
}
|
|
case ACT_ADD: {
|
|
const Entry* e = selected();
|
|
if (e && e->has_key) {
|
|
if (the_mesh.addDiscoveredContact(e->pub_key, e->name, e->type)) {
|
|
refresh(); // now a known contact — re-sort / re-mark this pass
|
|
} else {
|
|
_task->showAlert("Contacts full", 1200);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case ACT_FAV: break; // value rows -- see cycleMenuValue()
|
|
case ACT_TELEM: break;
|
|
case ACT_RESET_PATH: {
|
|
const Entry* e = selected();
|
|
if (e && contactctl::resetPath(e->pub_key)) _task->showAlert("Path reset", 800);
|
|
break;
|
|
}
|
|
case ACT_ROUTE: {
|
|
const Entry* e = selected();
|
|
if (e && e->has_key && _route.open(_task, e->pub_key)) {
|
|
memcpy(_route_key, e->pub_key, PUB_KEY_SIZE);
|
|
_detail = true; // Back from the path lands on the node
|
|
}
|
|
break;
|
|
}
|
|
case ACT_SHARE: {
|
|
const Entry* e = selected();
|
|
_task->showAlert(e && contactctl::share(e->pub_key) ? "Shared nearby" : "No advert saved", 1000);
|
|
break;
|
|
}
|
|
case ACT_PIN: {
|
|
const Entry* e = selected();
|
|
if (e && e->has_key) togglePinToDial(e->pub_key);
|
|
break;
|
|
}
|
|
case ACT_DELETE: startDeleteConfirm(); break;
|
|
case ACT_ADMIN: {
|
|
const Entry* e = selected();
|
|
ContactInfo ci;
|
|
if (e && e->contact_idx >= 0 && the_mesh.getContactByIdx(e->contact_idx, ci))
|
|
_task->openAdminFor(ci, false); // direct from Nodes -- Cancel should return here, not to a pick-list
|
|
break;
|
|
}
|
|
case ACT_SORT: break; // value rows -- see cycleMenuValue()
|
|
case ACT_FLOW: break;
|
|
case ACT_SCAN: enterScan(); break;
|
|
case ACT_MAP: {
|
|
_map = true; _map_zoom = 0;
|
|
_detail_refresh_ms = millis();
|
|
const Entry* e = selected();
|
|
if (!e || (e->lat_e6 == 0 && e->lon_e6 == 0)) { int k = positioned(_sel, 1); if (k >= 0) _sel = k; }
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add on the Path view: the list, repeaters only, until one is picked.
|
|
void startRoutePick() {
|
|
_route_pick = true;
|
|
_route_filter = _filter;
|
|
_filter = F_RPT;
|
|
_detail = false;
|
|
_sel = _scroll = 0;
|
|
refresh();
|
|
}
|
|
void endRoutePick() {
|
|
_route_pick = false;
|
|
_filter = _route_filter;
|
|
refresh();
|
|
int i = findContact(_route_key); // the node whose path it is, selected again
|
|
if (i >= 0) _sel = i;
|
|
_detail = true;
|
|
_route.show();
|
|
}
|
|
|
|
// ── detail rendering ──────────────────────────────────────────────────────────
|
|
void renderStoredDetail(DisplayDriver& display) {
|
|
const Entry& e = _entries[_sel];
|
|
display.drawInvertedHeader(e.name, true, ctxMenuOpen());
|
|
drawStoredFields(display, e, 0, display.listStart(), display.width(), display.height());
|
|
}
|
|
|
|
// A stored node's position, distance, type, age and path, in the box from
|
|
// x0 / top, w wide down to bottom: the detail view's body, and on a wide
|
|
// screen the pane beside the list.
|
|
void drawStoredFields(DisplayDriver& display, const Entry& e, int x0, int top, int w, int bottom) {
|
|
const int tx = x0 + 2;
|
|
int step = display.lineStep();
|
|
if (step * 5 > bottom - top) step = (bottom - top) / 5;
|
|
char buf[32];
|
|
// Without a line to spare for the path (the OLED), the position takes one
|
|
// row, unlabelled: then there are five rows either way.
|
|
const bool one_pos = top + step * 5 + display.getLineHeight() > bottom;
|
|
if (one_pos) {
|
|
snprintf(buf, sizeof(buf), "%.5f,%.5f", e.lat_e6 / 1e6, e.lon_e6 / 1e6);
|
|
display.drawTextEllipsized(tx, top, w - 4, buf);
|
|
} else {
|
|
snprintf(buf, sizeof(buf), "Lat: %.5f", e.lat_e6 / 1e6);
|
|
display.setCursor(tx, top); display.print(buf);
|
|
snprintf(buf, sizeof(buf), "Lon: %.5f", e.lon_e6 / 1e6);
|
|
display.setCursor(tx, top + step); display.print(buf);
|
|
}
|
|
const int r0 = one_pos ? -1 : 0; // the rows under the position move up one
|
|
|
|
if (e.dist_km >= 0.0f) {
|
|
char dist[12];
|
|
geo::fmtDist(dist, sizeof(dist), e.dist_km, useImperial());
|
|
int az = geo::bearingDeg(_own_lat, _own_lon, e.lat_e6, e.lon_e6);
|
|
snprintf(buf, sizeof(buf), "Dist: %s %s", dist, geo::bearingCardinal(az));
|
|
} else {
|
|
snprintf(buf, sizeof(buf), "Dist: no GPS");
|
|
}
|
|
display.setCursor(tx, top + step * (2 + r0)); display.print(buf);
|
|
snprintf(buf, sizeof(buf), "Type: %s", typeName(e.type));
|
|
display.setCursor(tx, top + step * (3 + r0)); display.print(buf);
|
|
char age[16];
|
|
fmtAge(age, sizeof(age), e.lastmod);
|
|
// For a live [LOC] row, label the timestamp as a position share and note
|
|
// whether the sender's identity is verified (DM) or name-only (channel).
|
|
if (e.is_live) snprintf(buf, sizeof(buf), "Sharing pos: %s %s", age, e.live_verified ? "(DM)" : "(chan)");
|
|
else snprintf(buf, sizeof(buf), "Seen: %s", age);
|
|
display.drawTextEllipsized(tx, top + step * (4 + r0), w - 4, buf);
|
|
|
|
const int lh = display.getLineHeight();
|
|
int rows = 5 + r0;
|
|
// How a message gets there: a chain from you to it, a ring per repeater
|
|
// on the way.
|
|
ContactInfo ci;
|
|
if (top + step * rows + lh <= bottom && e.contact_idx >= 0 && the_mesh.getContactByIdx(e.contact_idx, ci)) {
|
|
const int y = top + step * rows;
|
|
display.setCursor(tx, y);
|
|
display.print("Path:");
|
|
int x = tx + display.getTextWidth("Path: ");
|
|
if (ci.out_path_len == 0xFF) {
|
|
display.print(" flood");
|
|
} else {
|
|
const int hops = ci.out_path_len & 63;
|
|
const int r = lh / 4 > 2 ? lh / 4 : 2, cy = y + lh / 2 - 1, gap = r + 3;
|
|
// up to 5 rings, as many as leave room for the count after them
|
|
const int fit = (x0 + w - 2 - x - display.getTextWidth("5 hops")) / (2 * r + 1 + gap) - 2;
|
|
const int cap = fit < 5 ? (fit < 1 ? 1 : fit) : 5, shown = hops > cap ? cap : hops;
|
|
for (int k = 0; k <= shown + 1; k++) { // you and it filled, the hops as rings
|
|
if (k) for (int dx = x - gap + 1; dx < x; dx += 2) display.fillRect(dx, cy, 1, 1);
|
|
info::circle(display, x + r, cy, r);
|
|
if (k == 0 || k == shown + 1) display.fillRect(x + 1, cy - r + 1, 2 * r - 1, 2 * r - 1);
|
|
x += 2 * r + 1 + gap;
|
|
}
|
|
if (hops == 0) snprintf(buf, sizeof(buf), "direct");
|
|
else snprintf(buf, sizeof(buf), "%d hop%s", hops, hops == 1 ? "" : "s");
|
|
display.setCursor(x, y);
|
|
display.print(buf);
|
|
}
|
|
rows++;
|
|
}
|
|
|
|
// Where it is, on a compass rose (north up), where the screen has the room
|
|
// (e-ink): beside the rows on a wide one, under them on a tall one.
|
|
if (!Features::IS_EINK || e.dist_km < 0.0f) return;
|
|
const int below = top + step * rows + lh;
|
|
int r, cx, cy;
|
|
if (bottom - below > w / 2) { r = (w < bottom - below ? w : bottom - below) / 2 - lh; cx = x0 + w / 2; cy = below + lh / 2 + r; }
|
|
else { r = (bottom - top) / 2 - lh / 2 - 1; cx = x0 + w - r - 3; cy = top + lh / 2 + r; }
|
|
const int text_r = tx + display.getTextWidth("Lon: -000.00000");
|
|
if (r < 2 * lh || (cy - r < below - lh && cx - r < text_r)) return;
|
|
info::rose(display, cx, cy, r, geo::bearingDeg(_own_lat, _own_lon, e.lat_e6, e.lon_e6));
|
|
}
|
|
|
|
// ── map view ────────────────────────────────────────────────────────────────
|
|
static bool hasPos(const Entry& e) { return e.lat_e6 != 0 || e.lon_e6 != 0; }
|
|
// The next entry with a position from `from` on in direction `dir` (from
|
|
// itself included), wrapping; -1 when none has one.
|
|
int positioned(int from, int dir) const {
|
|
for (int k = 0; k < _count; k++) {
|
|
int i = ((from + dir * k) % _count + _count) % _count;
|
|
if (hasPos(_entries[i])) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Every node with a position (and you) fitted in; zoomed in, centred on the
|
|
// selected one. Dots, the selected one boxed, live shares as diamonds;
|
|
// under the map its name and distance, "+n" for others under the same spot.
|
|
// E-ink has the room for more: the nodes' names beside their dots, your
|
|
// trail (dotted) and waypoints; a screen 40 characters wide (4.2", 4.26")
|
|
// keeps the map to the left and shows the selected node and the packet
|
|
// flow's legend beside it, the flow's kinds then told apart by their dashes.
|
|
void renderMap(DisplayDriver& d) {
|
|
const int W = d.width(), H = d.height(), lh = d.getLineHeight(), cw = d.getCharWidth(), s = miniIconScale(d);
|
|
const bool eink = Features::IS_EINK, wide = eink && W >= 40 * cw;
|
|
const int bar_y = H - lh - 1, mw = wide ? W * 3 / 5 : W; // the map's right edge
|
|
const int ax = 1, ay = 1, aw = mw - 2, ah = wide ? H - 2 : bar_y - 3;
|
|
d.setColor(UIColor::primary_txt);
|
|
int32_t tla = 0, tlo = 0;
|
|
const bool target = _task->activeTargetPos(tla, tlo);
|
|
int32_t mnla = 0, mxla = 0, mnlo = 0, mxlo = 0;
|
|
bool init = false;
|
|
auto fold = [&](int32_t la, int32_t lo) {
|
|
if (!init) { mnla = mxla = la; mnlo = mxlo = lo; init = true; return; }
|
|
if (la < mnla) mnla = la; if (la > mxla) mxla = la;
|
|
if (lo < mnlo) mnlo = lo; if (lo > mxlo) mxlo = lo;
|
|
};
|
|
// You: the GPS, else the position set in Privacy -- where the packet
|
|
// flow's lines end too.
|
|
int32_t mla = _own_lat, mlo = _own_lon;
|
|
const bool me = _own_gps || _task->core().fixedPosition(mla, mlo);
|
|
for (int i = 0; i < _count; i++) if (hasPos(_entries[i])) fold(_entries[i].lat_e6, _entries[i].lon_e6);
|
|
if (me) fold(mla, mlo);
|
|
if (!init || _sel >= _count || !hasPos(_entries[_sel])) {
|
|
d.drawTextCentered(W / 2, H / 2 - lh / 2, "No node positions");
|
|
return;
|
|
}
|
|
const Entry& sel = _entries[_sel];
|
|
float kx = cosf(((mnla + mxla) / 2.0e6f) * (float)M_PI / 180.0f);
|
|
if (kx < 0.05f) kx = 0.05f;
|
|
float span_la = (float)(mxla - mnla), span_lo = (float)(mxlo - mnlo) * kx;
|
|
if (span_la < 2000.0f) span_la = 2000.0f; // ~200 m: one node alone still has a scale
|
|
if (span_lo < 2000.0f) span_lo = 2000.0f;
|
|
// Fitted inside a margin clear of the north mark and the scale's label,
|
|
// and on e-ink of a name beside a dot at the edge.
|
|
const int mx = ICON_MAP_NORTH.w * s + 2 + (eink ? 2 * cw : 0), my = lh + 2 + (eink ? 2 * (lh / 3) + d.sepH() : 0);
|
|
const float fw = (float)(aw - 2 * mx), fh = (float)(ah - 2 * my);
|
|
float scale = fh / span_la < fw / span_lo ? fh / span_la : fw / span_lo;
|
|
float cla = (mnla + mxla) / 2.0f, clo = (mnlo + mxlo) / 2.0f;
|
|
if (_map_zoom > 0) { scale *= (float)(1 << _map_zoom); cla = sel.lat_e6; clo = sel.lon_e6; }
|
|
auto projectF = [&](int32_t la, int32_t lo, float& x, float& y) { // unrounded, for far ends
|
|
x = ax + aw / 2 + ((float)lo - clo) * kx * scale;
|
|
y = ay + ah / 2 - ((float)la - cla) * scale;
|
|
};
|
|
auto project = [&](int32_t la, int32_t lo, int& x, int& y) { // clamped far off the screen, never past an int
|
|
float fx, fy; projectF(la, lo, fx, fy);
|
|
x = (int)lroundf(fx < -30000 ? -30000 : fx > 30000 ? 30000 : fx); // rounded as the lines are
|
|
y = (int)lroundf(fy < -30000 ? -30000 : fy > 30000 ? 30000 : fy);
|
|
};
|
|
auto inside = [&](int x, int y) { return x >= ax && x < ax + aw && y >= ay && y < ay + ah; };
|
|
const int t = d.sepH();
|
|
|
|
// E-ink: your trail, dotted, and the waypoints, under everything else.
|
|
if (eink) {
|
|
const TrailStore& tr = _task->core().trail.store();
|
|
float x0 = 0, y0 = 0;
|
|
for (int i = 0; i < tr.count(); i++) {
|
|
float x1, y1; projectF(tr.at(i).lat_1e6, tr.at(i).lon_1e6, x1, y1);
|
|
if (i > 0 && !(tr.at(i).flags & TRAIL_FLAG_SEG_START)) gfx::drawLineClipped(d, x0, y0, x1, y1, ax, ay, aw, ah, trailDash());
|
|
x0 = x1; y0 = y1;
|
|
}
|
|
TrailPoint pend;
|
|
if (tr.count() > 0 && tr.pendingPoint(pend)) {
|
|
float x1, y1; projectF(pend.lat_1e6, pend.lon_1e6, x1, y1);
|
|
gfx::drawLineClipped(d, x0, y0, x1, y1, ax, ay, aw, ah, trailDash());
|
|
}
|
|
const WaypointStore& wps = _task->waypoints();
|
|
for (int i = 0; i < wps.count(); i++) {
|
|
int x, y; project(wps.at(i).lat_1e6, wps.at(i).lon_1e6, x, y);
|
|
if (inside(x, y)) miniIconDrawCentered(d, x, y, ICON_MAP_WAYPOINT);
|
|
}
|
|
}
|
|
|
|
int sx, sy, near = 0;
|
|
project(sel.lat_e6, sel.lon_e6, sx, sy);
|
|
for (int i = 0; i < _count; i++) {
|
|
if (!hasPos(_entries[i])) continue;
|
|
int x, y; project(_entries[i].lat_e6, _entries[i].lon_e6, x, y);
|
|
if (i != _sel && abs(x - sx) <= 2 * s && abs(y - sy) <= 2 * s) near++;
|
|
if (!inside(x, y)) continue;
|
|
miniIconDrawCentered(d, x, y, _entries[i].is_live ? ICON_MAP_CONTACT : ICON_MAP_DOT);
|
|
}
|
|
// Packet flow (ui-core/PacketFlow.h): the lines of the packets heard in
|
|
// the last minute, the newest two drawn three strokes wide, centred on
|
|
// the line; a ring for a packet sent, or heard on its way to a repeater.
|
|
// Its points are drawn where the contacts and you are now, not where they
|
|
// were when it was heard, so the lines meet on the marks.
|
|
const PacketFlow& fl = _task->core().flow;
|
|
for (int i = 0, lines = 0; fl.enabled() && i < fl.count(); i++) {
|
|
const PacketFlow::Flow& f = fl.at(i);
|
|
if (millis() - f.t_ms > FLOW_SHOW_MS) break; // newest first
|
|
float px[PacketFlow::MAX_PTS], py[PacketFlow::MAX_PTS];
|
|
for (int k = 0; k < f.n; k++) {
|
|
int32_t la = f.lat[k], lo = f.lon[k];
|
|
ContactInfo c;
|
|
if (f.node[k] >= 0) { // a contact: where its dot is now
|
|
if (the_mesh.getContactByIdx(f.node[k], c) && (c.gps_lat || c.gps_lon)) { la = c.gps_lat; lo = c.gps_lon; }
|
|
} else if (me && k == f.n - 1) { // the last point, no contact: here
|
|
la = mla; lo = mlo;
|
|
}
|
|
projectF(la, lo, px[k], py[k]);
|
|
}
|
|
if (f.n == 1) { // a packet nothing of which could be placed: a ring here, briefly
|
|
if (f.here && millis() - f.t_ms > FLOW_HERE_MS) continue;
|
|
if (fabsf(px[0]) < 30000 && fabsf(py[0]) < 30000)
|
|
gfx::drawCircleClipped(d, (int)lroundf(px[0]), (int)lroundf(py[0]), 6 * s, ax, ay, aw, ah);
|
|
continue;
|
|
}
|
|
const gfx::Dash dash = wide ? flowDash(f.kind) : gfx::DASH_SOLID;
|
|
const bool bold = lines++ < 2;
|
|
for (int k = 1; k < f.n; k++) {
|
|
gfx::drawLineClipped(d, px[k - 1], py[k - 1], px[k], py[k], ax, ay, aw, ah, dash);
|
|
if (!bold) continue;
|
|
// a stroke either side of the first, across the line's run
|
|
const bool flat = fabsf(px[k] - px[k - 1]) >= fabsf(py[k] - py[k - 1]);
|
|
const float ox = flat ? 0 : t, oy = flat ? t : 0;
|
|
gfx::drawLineClipped(d, px[k - 1] + ox, py[k - 1] + oy, px[k] + ox, py[k] + oy, ax, ay, aw, ah, dash);
|
|
gfx::drawLineClipped(d, px[k - 1] - ox, py[k - 1] - oy, px[k] - ox, py[k] - oy, ax, ay, aw, ah, dash);
|
|
}
|
|
}
|
|
if (me) { int x, y; project(mla, mlo, x, y); if (inside(x, y)) miniIconDrawCentered(d, x, y, ICON_MAP_CURRENT); }
|
|
if (target) { int x, y; project(tla, tlo, x, y); if (inside(x, y)) miniIconDrawCentered(d, x, y, ICON_MAP_TARGET); }
|
|
const int r = 4 * s;
|
|
d.drawRect(sx - r, sy - r, 2 * r + 1, 2 * r + 1);
|
|
|
|
// The north mark and the scale, on a background so they stay readable
|
|
// over the lines; their boxes are kept clear of the names below.
|
|
const int nw = ICON_MAP_NORTH.w * s + 2, nh = ICON_MAP_NORTH.h * s + 1;
|
|
d.setColor(UIColor::window_bkg);
|
|
d.fillRect(ax + aw - nw, ay, nw, nh);
|
|
d.setColor(UIColor::primary_txt);
|
|
miniIconDrawTop(d, ax + aw - ICON_MAP_NORTH.w * s - 1, ay, ICON_MAP_NORTH);
|
|
const float m_px = 0.111f / scale; // 1e-6 degree of latitude is 0.111 m
|
|
static const float STEPS[] = { 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000 };
|
|
float m = STEPS[0];
|
|
for (float st : STEPS) { m = st; if (st / m_px >= aw / 5) break; }
|
|
const int len = (int)(m / m_px);
|
|
char sc[12];
|
|
geo::fmtDist(sc, sizeof(sc), m / 1000.0f, useImperial());
|
|
const bool scale_on = len > 2 && len < aw;
|
|
const int ly = ay + ah - 2, lx = ax + aw - len - 1 - (wide ? 2 * t : 0), stw = d.getTextWidth(sc);
|
|
// On e-ink a map's scale bar: a framed bar, its left half filled, ticks
|
|
// up at the ends, the distance over its middle -- the OLED keeps a line.
|
|
const int bh = lh / 3 + t, tick = lh / 3; // e-ink: the bar's height, the ticks above it
|
|
if (scale_on && eink) {
|
|
const int by = ay + ah - bh - 1, ty = by - tick - lh;
|
|
int tx = lx + (len - stw) / 2;
|
|
if (tx + stw > ax + aw) tx = ax + aw - stw;
|
|
d.setColor(UIColor::window_bkg);
|
|
d.fillRect(tx - 2, ty - 1, stw + 4, lh + 1);
|
|
d.fillRect(lx - t - 1, by - tick - 1, len + 2 * t + 2, bh + tick + 2);
|
|
d.setColor(UIColor::primary_txt);
|
|
for (int k = 0; k < t; k++) d.drawRect(lx + k, by + k, len - 2 * k, bh - 2 * k);
|
|
d.fillRect(lx, by, len / 2, bh);
|
|
d.fillRect(lx, by - tick, t, tick);
|
|
d.fillRect(lx + len - t, by - tick, t, tick);
|
|
d.setCursor(tx, ty);
|
|
d.print(sc);
|
|
} else if (scale_on) {
|
|
d.setColor(UIColor::window_bkg);
|
|
d.fillRect(lx + len - stw - 1, ly - lh - 1, stw + 2, lh + 1);
|
|
d.fillRect(lx - 1, ly - 1, len + 2, s + 2);
|
|
d.setColor(UIColor::primary_txt);
|
|
d.fillRect(lx, ly, len, s);
|
|
d.setCursor(lx + len - stw, ly - lh);
|
|
d.print(sc);
|
|
}
|
|
|
|
// E-ink: names beside the dots, the selected one first, then the others in
|
|
// the list's order, each where it covers no other name, dot or the marks
|
|
// (right of the dot, else left); one that fits nowhere is left out.
|
|
if (eink) {
|
|
struct Box { int16_t x, y, w, h; };
|
|
Box taken[NEARBY_MAX * 2 + 4]; // ~0.5 KB of stack, only while drawing
|
|
int nt = 0;
|
|
auto hit = [&](const Box& b) {
|
|
if (b.x < ax || b.y < ay || b.x + b.w > ax + aw || b.y + b.h > ay + ah) return true;
|
|
for (int k = 0; k < nt; k++)
|
|
if (b.x < taken[k].x + taken[k].w && taken[k].x < b.x + b.w && b.y < taken[k].y + taken[k].h && taken[k].y < b.y + b.h) return true;
|
|
return false;
|
|
};
|
|
const int half = ICON_MAP_DOT.w * s / 2 + 1;
|
|
auto box = [](int x, int y, int w, int h) { return Box{ (int16_t)x, (int16_t)y, (int16_t)w, (int16_t)h }; };
|
|
taken[nt++] = box(ax + aw - nw, ay, nw, nh);
|
|
if (scale_on) taken[nt++] = box(lx - t - 1, ay + ah - bh - tick - lh - 2, len + 2 * t + 2, bh + tick + lh + 3);
|
|
for (int i = 0; i < _count && nt < NEARBY_MAX + 2; i++) {
|
|
if (!hasPos(_entries[i])) continue;
|
|
int x, y; project(_entries[i].lat_e6, _entries[i].lon_e6, x, y);
|
|
if (inside(x, y)) taken[nt++] = box(x - half, y - half, 2 * half + 1, 2 * half + 1);
|
|
}
|
|
const int maxw = (wide ? 12 : 8) * cw;
|
|
for (int n = 0; n < _count && nt < (int)(sizeof(taken) / sizeof(taken[0])); n++) {
|
|
const int i = n == 0 ? _sel : (n <= _sel ? n - 1 : n); // the selected one first
|
|
const Entry& e = _entries[i];
|
|
if (!hasPos(e) || !e.name[0]) continue;
|
|
int x, y; project(e.lat_e6, e.lon_e6, x, y);
|
|
if (!inside(x, y)) continue;
|
|
int tw = d.getTextWidth(e.name);
|
|
if (tw > maxw) tw = maxw;
|
|
const int off = i == _sel ? r + 2 : half + 1;
|
|
Box b = box(x + off, y - lh / 2, tw + 2, lh);
|
|
if (hit(b)) { b.x = (int16_t)(x - off - tw - 2); if (hit(b)) continue; }
|
|
taken[nt++] = b;
|
|
d.setColor(UIColor::window_bkg);
|
|
d.fillRect(b.x, b.y, b.w, b.h);
|
|
d.setColor(UIColor::primary_txt);
|
|
d.drawTextEllipsized(b.x + 1, b.y, tw, e.name);
|
|
}
|
|
}
|
|
|
|
// The selected node: in a pane beside the map (wide), else on a bar under it.
|
|
char dist[16] = "";
|
|
float dkm = sel.dist_km;
|
|
if (dkm < 0.0f && me) dkm = geo::haversineKm(mla, mlo, sel.lat_e6, sel.lon_e6);
|
|
if (dkm >= 0.0f) geo::fmtDist(dist, sizeof(dist), dkm, useImperial(), true);
|
|
char name[40];
|
|
if (near > 0) snprintf(name, sizeof(name), "%s +%d", sel.name, near);
|
|
else snprintf(name, sizeof(name), "%s", sel.name);
|
|
if (wide) {
|
|
renderMapPane(d, sel, name, dist, me ? geo::bearingDeg(mla, mlo, sel.lat_e6, sel.lon_e6) : -1, mw);
|
|
return;
|
|
}
|
|
d.fillRect(0, bar_y - 1, W, d.sepH());
|
|
const int rw = dist[0] ? d.getTextWidth(dist) + d.getCharWidth() : 0;
|
|
d.drawTextEllipsized(1, bar_y + 1, W - 2 - rw, name);
|
|
if (dist[0]) { d.setCursor(W - 1 - d.getTextWidth(dist), bar_y + 1); d.print(dist); }
|
|
}
|
|
|
|
// The map's dashes (wide e-ink): each kind of packet its own, the trail dotted.
|
|
static gfx::Dash trailDash() { return { 0x1, 3 }; }
|
|
static gfx::Dash flowDash(uint8_t kind) {
|
|
switch (kind) {
|
|
case PacketFlow::K_ADVERT: return gfx::DASH_SOLID;
|
|
case PacketFlow::K_MSG: return { 0x3F, 9 }; // long dashes
|
|
case PacketFlow::K_GROUP: return { 0x07, 6 }; // short dashes
|
|
default: return { 0x5F, 9 }; // dash and dot: requests, acks, the rest
|
|
}
|
|
}
|
|
|
|
// Beside the map on a wide screen: the selected node (name, distance and
|
|
// bearing, type, last heard, path) and, with the packet flow on, its legend:
|
|
// a sample of each kind's dashes and how many were heard in the last minute.
|
|
void renderMapPane(DisplayDriver& d, const Entry& e, const char* name, const char* dist, int deg, int mw) {
|
|
const int W = d.width(), H = d.height(), lh = d.getLineHeight(), cw = d.getCharWidth(), t = d.sepH();
|
|
const int px = mw + t + 3, pw = W - px - 2, step = d.lineStep();
|
|
d.setColor(UIColor::primary_txt);
|
|
d.fillRect(mw, 0, t, H);
|
|
int y = 1;
|
|
d.drawTextEllipsized(px, y, pw, name);
|
|
y += lh + 1;
|
|
d.fillRect(px, y, pw, t);
|
|
y += t + 2;
|
|
char buf[32];
|
|
if (dist[0]) {
|
|
if (deg >= 0) snprintf(buf, sizeof(buf), "%s %s", dist, geo::bearingCardinal(deg));
|
|
else snprintf(buf, sizeof(buf), "%s", dist);
|
|
d.drawTextEllipsized(px, y, pw, buf); y += step;
|
|
}
|
|
snprintf(buf, sizeof(buf), "%s", typeName(e.type));
|
|
d.drawTextEllipsized(px, y, pw, buf); y += step;
|
|
char age[16];
|
|
fmtAge(age, sizeof(age), e.lastmod);
|
|
snprintf(buf, sizeof(buf), "%s %s", e.is_live ? "Sharing" : "Seen", age);
|
|
d.drawTextEllipsized(px, y, pw, buf); y += step;
|
|
ContactInfo ci;
|
|
if (e.contact_idx >= 0 && the_mesh.getContactByIdx(e.contact_idx, ci)) {
|
|
if (ci.out_path_len == 0xFF) snprintf(buf, sizeof(buf), "Path: flood");
|
|
else if ((ci.out_path_len & 63) == 0) snprintf(buf, sizeof(buf), "Path: direct");
|
|
else snprintf(buf, sizeof(buf), "Path: %d hop%s", ci.out_path_len & 63, (ci.out_path_len & 63) == 1 ? "" : "s");
|
|
d.drawTextEllipsized(px, y, pw, buf); y += step;
|
|
}
|
|
|
|
// The legend, from the bottom up as far as it fits; between it and the
|
|
// node, a compass rose pointing at the node when there is the room.
|
|
const PacketFlow& fl = _task->core().flow;
|
|
const bool trail = _task->core().trail.store().count() > 1;
|
|
struct Row { const char* label; int n; gfx::Dash dash; bool ring; };
|
|
Row rows[7];
|
|
int nr = 0;
|
|
if (fl.enabled()) {
|
|
rows[nr++] = { "Advert", fl.count(PacketFlow::K_ADVERT), flowDash(PacketFlow::K_ADVERT), false };
|
|
rows[nr++] = { "DM", fl.count(PacketFlow::K_MSG), flowDash(PacketFlow::K_MSG), false };
|
|
rows[nr++] = { "Channel", fl.count(PacketFlow::K_GROUP), flowDash(PacketFlow::K_GROUP), false };
|
|
rows[nr++] = { "Other", fl.count(PacketFlow::K_REQ) + fl.count(PacketFlow::K_ACK) + fl.count(PacketFlow::K_OTHER),
|
|
flowDash(PacketFlow::K_OTHER), false };
|
|
rows[nr++] = { "Sent", fl.count(PacketFlow::K_SENT), gfx::DASH_SOLID, true };
|
|
}
|
|
if (trail) rows[nr++] = { "Trail", -1, trailDash(), false };
|
|
const int head = fl.enabled() ? 1 : 0;
|
|
int top = nr ? H - (nr + head) * step - 1 : H;
|
|
if (top < y + step / 2) { top = H; nr = 0; } // no room for it under the node
|
|
const int room = top - y - lh / 2, size = room < pw ? room : pw;
|
|
if (deg >= 0 && size >= 5 * lh) info::rose(d, px + pw / 2, y + room / 2, size / 2 - lh, deg);
|
|
if (!nr) return;
|
|
int ry = top;
|
|
if (head) { d.setCursor(px, ry); d.print("Last minute"); ry += step; }
|
|
const int sw = 3 * cw; // the sample line
|
|
for (int i = 0; i < nr; i++, ry += step) {
|
|
const int cy = ry + lh / 2;
|
|
if (rows[i].ring) gfx::drawCircleClipped(d, px + sw / 2, cy, lh / 3, px, ry, sw, lh);
|
|
else gfx::drawLine(d, px, cy, px + sw - 1, cy, rows[i].dash);
|
|
d.setCursor(px + sw + cw, ry);
|
|
d.print(rows[i].label);
|
|
if (rows[i].n >= 0) {
|
|
snprintf(buf, sizeof(buf), "%d", rows[i].n);
|
|
d.setCursor(px + pw - d.getTextWidth(buf), ry);
|
|
d.print(buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
void renderScanDetail(DisplayDriver& display) {
|
|
const Entry& e = _entries[_sel];
|
|
const int hdr = display.listStart(); // content top (gap below the header separator)
|
|
|
|
char label[32];
|
|
if (e.name[0]) { strncpy(label, e.name, 31); label[31] = '\0'; }
|
|
else { snprintf(label, sizeof(label), "[%s]", typeName(e.type)); }
|
|
display.drawInvertedHeader(label, true, ctxMenuOpen());
|
|
|
|
char b64[48];
|
|
pubKeyToBase64(e.pub_key, b64, sizeof(b64));
|
|
int max_chars = (display.width() - 4) / display.getCharWidth();
|
|
char b64_line[48];
|
|
if (max_chars < 4) {
|
|
b64_line[0] = '\0';
|
|
} else if ((int)strlen(b64) > max_chars) {
|
|
strncpy(b64_line, b64, max_chars - 3);
|
|
b64_line[max_chars - 3] = '\0';
|
|
strcat(b64_line, "...");
|
|
} else {
|
|
strncpy(b64_line, b64, sizeof(b64_line) - 1);
|
|
b64_line[sizeof(b64_line) - 1] = '\0';
|
|
}
|
|
if (b64_line[0]) { display.setCursor(2, hdr); display.print(b64_line); }
|
|
|
|
int step = display.lineStep();
|
|
if (step * 5 > display.height() - hdr) step = (display.height() - hdr) / 5;
|
|
char buf[32];
|
|
snprintf(buf, sizeof(buf), "RSSI: %d dBm", (int)e.rssi);
|
|
display.setCursor(2, hdr + step); display.print(buf);
|
|
snprintf(buf, sizeof(buf), "SNR: %.1f dB", e.snr_x4 / 4.0f);
|
|
display.setCursor(2, hdr + step * 2); display.print(buf);
|
|
drawSignalBars(display, display.width() - 2, hdr + step * 2, e.snr_x4); // how we hear them
|
|
snprintf(buf, sizeof(buf), "Rem: %.1f dB", e.remote_snr_x4 / 4.0f);
|
|
display.setCursor(2, hdr + step * 3); display.print(buf);
|
|
drawSignalBars(display, display.width() - 2, hdr + step * 3, e.remote_snr_x4); // how they hear us
|
|
display.setCursor(2, hdr + step * 4);
|
|
display.print(e.is_known ? "Status: known" : "Status: new");
|
|
}
|
|
|
|
// Any Hold-Enter popup on screen → highlight the ≡ hint so it reads as the
|
|
// source of the open menu.
|
|
bool ctxMenuOpen() const { return _menu.active || _confirm.active || _ping_menu.active; }
|
|
|
|
// Draw whichever popup is active over the current view. Returns true if one was.
|
|
bool renderActivePopup(DisplayDriver& display) {
|
|
updatePingMenuState();
|
|
if (_ping_menu.active) { _ping_menu.render(display); return true; }
|
|
if (_confirm.active) { _confirm.render(display); return true; }
|
|
if (_menu.active) { _menu.render(display); return true; }
|
|
return false;
|
|
}
|
|
|
|
// Header as a circular filter tab bar (shared geometry — see TabBar.h): the
|
|
// active filter sits centred as a filled pill, neighbours fan out either
|
|
// side and wrap around (the tab before "All" is "Snsr", and vice-versa),
|
|
// matching the wrap-around LEFT/RIGHT cycle.
|
|
void drawFilterTabs(DisplayDriver& display) {
|
|
tabbar::draw(display, filterLabels(), F_COUNT, _filter, display.menuHintWidth());
|
|
display.drawContextMenuHint(UIColor::primary_txt, ctxMenuOpen()); // Nodes list has a Hold-Enter menu
|
|
}
|
|
|
|
public:
|
|
NearbyScreen(UITask* task)
|
|
: _task(task), _sel(0), _scroll(0), _detail(false),
|
|
_detail_refresh_ms(0), _scanning(false), _scan_started_ms(0),
|
|
_menu_action_count(0), _pinging(false), _ping_started_ms(0) {
|
|
bindModel(&task->core(), task->getNodePrefs());
|
|
resetPingLines();
|
|
_sort_label[0] = '\0';
|
|
}
|
|
|
|
// Whether the full-screen navigate-to-node view is up -- used by UITask's
|
|
// GPS duty-cycle "is anything live using GPS right now" check, since this
|
|
// view needs an unbroken stream of fixes for bearing/ETA, not a stale one.
|
|
bool isNavigating() const { return _nav; }
|
|
|
|
void onShow() override {
|
|
_sel = _scroll = 0;
|
|
_detail = false;
|
|
_nav = false;
|
|
_map = false;
|
|
_source = SRC_STORED;
|
|
// _filter / _sort persist across enter() — set once in the constructor
|
|
_scanning = false;
|
|
_menu.active = false;
|
|
_ping_menu.active = false;
|
|
_confirm.active = false;
|
|
_pinging = false;
|
|
_pick_admin_target = false; // stale pick-mode from a previous visit shouldn't linger
|
|
_route.close();
|
|
_route_pick = false;
|
|
resetPingLines();
|
|
_task->clearPing();
|
|
refreshStored();
|
|
}
|
|
|
|
// Entered via UITask::pickAdminTarget() right after setCurrScreen(this) has
|
|
// already run onShow()'s reset above -- just arms the pick-mode flag.
|
|
void startPickAdminTarget() { _pick_admin_target = true; }
|
|
|
|
int render(DisplayDriver& display) override {
|
|
display.setTextSize(1);
|
|
int mq_delay = 0; // >0 while the selected row's name is marquee-scrolling
|
|
|
|
// Periodic refresh of the selected entry while in detail or navigate view,
|
|
// preserving the selection across the list rebuild. Navigate refreshes
|
|
// faster so a moving live target (a contact sharing [LOC]) tracks smoothly.
|
|
// Re-selection keys on contact index for stored nodes, and on name for a
|
|
// non-contact live sender — without the latter, navigating to someone who
|
|
// only shares on a channel would drop out on the first refresh.
|
|
unsigned long refresh_due = _nav ? NAV_REFRESH_MS : DETAIL_REFRESH_MS;
|
|
if ((_detail || _nav) && _source == SRC_STORED &&
|
|
millis() - _detail_refresh_ms >= refresh_due) {
|
|
if (!refreshKeepingSelection()) { _detail = false; _nav = false; } // node/share gone
|
|
_detail_refresh_ms = millis();
|
|
}
|
|
|
|
// ── path view (over the detail) ──────────────────────────────────────────
|
|
if (_route.active()) return _route.render(display);
|
|
|
|
// ── navigate-to-node view ────────────────────────────────────────────────
|
|
if (_nav && _sel < _count) {
|
|
const Entry& e = _entries[_sel];
|
|
int cog; bool cogv = _task->currentCourse(cog);
|
|
navview::draw(display, _own_gps, _own_lat, _own_lon,
|
|
e.lat_e6, e.lon_e6, e.name, cogv, cog, useImperial(), &_nav_eta);
|
|
return 1000;
|
|
}
|
|
|
|
// ── detail view ──────────────────────────────────────────────────────────
|
|
if (_detail && _sel < _count) {
|
|
if (_source == SRC_SCAN) renderScanDetail(display);
|
|
else renderStoredDetail(display);
|
|
renderActivePopup(display);
|
|
return _ping_menu.active ? 50 : 2000;
|
|
}
|
|
|
|
// ── map view ─────────────────────────────────────────────────────────────
|
|
if (_map) {
|
|
if (millis() - _detail_refresh_ms >= DETAIL_REFRESH_MS) {
|
|
refreshKeepingSelection();
|
|
_detail_refresh_ms = millis();
|
|
}
|
|
renderMap(display);
|
|
if (renderActivePopup(display)) return 50;
|
|
const PacketFlow& fl = _task->core().flow; // new lines show within a second
|
|
return fl.enabled() && (fl.seq() != _flow_seen || fl.active(FLOW_SHOW_MS)) ? (_flow_seen = fl.seq(), 1000) : 2000;
|
|
}
|
|
|
|
// ── list view ────────────────────────────────────────────────────────────
|
|
if (_source == SRC_SCAN) {
|
|
refreshScan();
|
|
if (_scanning && millis() - _scan_started_ms >= SCAN_DURATION_MS) _scanning = false;
|
|
} else if (millis() - _list_refresh_ms >= TIME_LIST_REFRESH_MS) {
|
|
// Re-merge + re-sort periodically so newly-heard contacts and fresh live
|
|
// [LOC] shares bubble to the right spot under either sort (distances move
|
|
// as you and they do, not just recency). Keep the highlighted node put.
|
|
refreshKeepingSelection();
|
|
_list_refresh_ms = millis();
|
|
}
|
|
|
|
// A screen 40 characters wide (the 4.2" e-ink) keeps the list to the left
|
|
// and shows the highlighted node's detail beside it.
|
|
const bool split = _source == SRC_STORED && _count > 0 && display.width() >= 40 * display.getCharWidth();
|
|
const int lw = split ? display.width() * 11 / 20 : display.width(); // the list's right edge
|
|
// An arrow towards the node before its distance: one more cell.
|
|
const bool arrows = _source == SRC_STORED && _sort != SORT_TIME;
|
|
int dist_col = lw - display.getCharWidth() * (arrows ? 9 : 7);
|
|
|
|
display.setColor(UIColor::primary_txt);
|
|
const char* flt = (_filter != F_ALL) ? filterLabel(_filter) : nullptr;
|
|
if (_source == SRC_SCAN) {
|
|
char title[28];
|
|
const char* base = _scanning ? "Scanning" : "Scan";
|
|
if (flt) {
|
|
if (!_scanning && _count == 0) snprintf(title, sizeof(title), "Scan %s: none", flt);
|
|
else snprintf(title, sizeof(title), "%s %s (%d)", base, flt, _count);
|
|
} else if (_scanning) snprintf(title, sizeof(title), "Scanning (%d)", _count);
|
|
else if (_count == 0) snprintf(title, sizeof(title), "Scan: none");
|
|
else snprintf(title, sizeof(title), "Scan (%d)", _count);
|
|
drawScreenHeader(display, title, -1, 0, true, ctxMenuOpen());
|
|
} else {
|
|
// Stored list: the filter is a visible tab strip (LEFT/RIGHT switches tabs).
|
|
drawFilterTabs(display);
|
|
}
|
|
|
|
if (_count == 0) {
|
|
char empty[24];
|
|
if (_source == SRC_SCAN) {
|
|
const char* msg;
|
|
if (_scanning) { // the header already says Scanning: just show it's listening
|
|
display.drawTextCentered(display.width() / 2, display.height() / 2 - display.lineStep() / 2, "No replies yet");
|
|
int r = drawLoadingDots(display, display.width() / 2, display.height() / 2 + display.lineStep() + 2);
|
|
if (mq_delay <= 0 || r < mq_delay) mq_delay = r;
|
|
msg = nullptr;
|
|
}
|
|
else if (flt) { snprintf(empty, sizeof(empty), "No %s nodes", flt); msg = empty; }
|
|
else msg = "No nodes found";
|
|
if (msg) display.drawTextCentered(display.width() / 2, display.height() / 2, msg);
|
|
} else {
|
|
const char* hint;
|
|
if (_pick_admin_target && !flt) { snprintf(empty, sizeof(empty), "Nothing to admin"); hint = "Repeaters & rooms"; }
|
|
else if (flt) { snprintf(empty, sizeof(empty), "No %s contacts", flt); hint = "Left/Right: filter"; }
|
|
else { snprintf(empty, sizeof(empty), "No contacts found"); hint = "Enter: discover";}
|
|
display.drawTextCentered(display.width() / 2, display.height() / 2 - display.lineStep() / 2, empty);
|
|
display.drawTextCentered(display.width() / 2, display.height() / 2 + display.lineStep() / 2, hint);
|
|
}
|
|
} else {
|
|
drawList(display, _count, _sel, _scroll, [&](int idx, int y, bool sel, int reserve) {
|
|
const Entry& e = _entries[idx];
|
|
|
|
drawRowSelection(display, y, sel, reserve, lw);
|
|
|
|
char filt[32];
|
|
int tx = 2;
|
|
if (e.is_live) {
|
|
// Diamond marker = this node is broadcasting its position ([LOC]),
|
|
// the same marker the map uses for a live-tracked contact. DM-verified
|
|
// vs channel-only is spelled out in the detail view.
|
|
int iw = ICON_MAP_CONTACT.w * miniIconScale(display);
|
|
miniIconDrawCentered(display, tx + iw / 2, y + display.getLineHeight() / 2 - 1, ICON_MAP_CONTACT);
|
|
tx += iw + 2;
|
|
}
|
|
// Star = favourite, the same marker every other list uses. Shown next to
|
|
// any live diamond so both states read at once.
|
|
if (e.fav) {
|
|
int iw = ICON_PG_STAR.w * miniIconScale(display);
|
|
miniIconDrawCentered(display, tx + iw / 2, y + display.getLineHeight() / 2 - 1, ICON_PG_STAR);
|
|
tx += iw + 2;
|
|
}
|
|
display.translateUTF8ToBlocks(filt, e.name, sizeof(filt));
|
|
if (_source == SRC_SCAN && !e.name[0]) { // unknown node → "[Type]"
|
|
snprintf(filt, sizeof(filt), "[%s]", typeName(e.type));
|
|
}
|
|
int mqr = display.drawTextEllipsized(tx, y, dist_col - tx - 2, filt, sel);
|
|
if (sel && mqr > 0) mq_delay = mqr;
|
|
|
|
display.setColor(sel ? UIColor::window_bkg : UIColor::primary_txt);
|
|
char right[10];
|
|
if (_source == SRC_SCAN) { // live scan: how well we hear it, as bars
|
|
drawSignalBars(display, lw - reserve - 2, y, e.snr_x4);
|
|
right[0] = '\0';
|
|
} else if (_sort == SORT_TIME) {
|
|
geo::fmtAgeShort(right, sizeof(right), rtc_clock.getCurrentTime(), e.lastmod);
|
|
if (!right[0]) snprintf(right, sizeof(right), "?"); // unknown / RTC not synced
|
|
} else {
|
|
if (e.dist_km >= 0.0f) geo::fmtDist(right, sizeof(right), e.dist_km, useImperial());
|
|
else strcpy(right, "-"); // no fix of ours or theirs
|
|
}
|
|
if (right[0]) display.drawTextRightAlign(lw - reserve - 2, y, right);
|
|
if (arrows && e.dist_km >= 0.0f) {
|
|
const int deg = geo::bearingDeg(_own_lat, _own_lon, e.lat_e6, e.lon_e6);
|
|
const MiniIcon& ic = *ICON_ARROWS[((deg + 22) % 360) / 45];
|
|
miniIconDraw(display, lw - reserve - 2 - display.getTextWidth(right) - 3
|
|
- ic.w * miniIconScale(display), y, ic);
|
|
}
|
|
}, lw);
|
|
if (split && _sel < _count) {
|
|
const int top = display.listStart();
|
|
display.setColor(UIColor::primary_txt);
|
|
display.fillRect(lw + 2, top, display.sepH(), display.height() - top);
|
|
drawStoredFields(display, _entries[_sel], lw + 2 + display.sepH() + 2, top,
|
|
display.width() - lw - 4 - display.sepH(), display.height());
|
|
}
|
|
}
|
|
|
|
if (renderActivePopup(display)) return 50;
|
|
int ret;
|
|
if (_source == SRC_SCAN) ret = _scanning ? 200 : 2000;
|
|
else ret = _count == 0 ? 3000 : 2000;
|
|
return (mq_delay > 0 && mq_delay < ret) ? mq_delay : ret;
|
|
}
|
|
|
|
// The nodes map, from outside the list (the sim harness).
|
|
bool openMap() {
|
|
int i = positioned(0, 1);
|
|
if (i < 0) return false;
|
|
_sel = i;
|
|
_detail = false; // the map is drawn from the list
|
|
_map = true; _map_zoom = 0;
|
|
_detail_refresh_ms = millis();
|
|
return true;
|
|
}
|
|
|
|
// Path / trace for a contact, from outside the list (the sim harness).
|
|
bool openRoute(const uint8_t* pub_key) {
|
|
int i = findContact(pub_key);
|
|
if (i < 0 || !_route.open(_task, pub_key)) return false;
|
|
_sel = i;
|
|
_detail = true;
|
|
memcpy(_route_key, pub_key, PUB_KEY_SIZE);
|
|
return true;
|
|
}
|
|
|
|
bool handleInput(char c) override {
|
|
// ── path view: modal; Add hands the Nodes list over for one repeater ──────
|
|
if (_route.active()) {
|
|
_route.handleInput(c);
|
|
if (_route.takePick()) startRoutePick();
|
|
return true;
|
|
}
|
|
|
|
// ── navigate-to-node view — any nav key returns to detail ─────────────────
|
|
if (_nav) {
|
|
if (c == KEY_CANCEL) _nav = false; // only Back leaves a navigate view
|
|
return true;
|
|
}
|
|
|
|
// ── popups (same handling in list and detail) ─────────────────────────────
|
|
if (_confirm.active) {
|
|
auto res = _confirm.handleInput(c);
|
|
if (res == PopupMenu::SELECTED) {
|
|
if (_confirm.selectedIndex() == 0) doDeleteSelected();
|
|
_confirm.active = false;
|
|
} else if (res == PopupMenu::CANCELLED) {
|
|
_confirm.active = false;
|
|
}
|
|
return true;
|
|
}
|
|
if (_ping_menu.active) { handlePingMenuInput(c); return true; }
|
|
if (_menu.active) {
|
|
// LEFT/RIGHT -- and Enter, which PopupMenu reports as VALUE_NEXT on a
|
|
// value row -- cycle Sort, Fav and Telem in place; the popup stays open so
|
|
// the user can keep tapping, and only Back closes it. Other rows swallow L/R.
|
|
if (keyIsPrev(c) || keyIsNext(c)) {
|
|
cycleMenuValue(_menu.selectedIndex(), keyIsNext(c) ? 1 : -1);
|
|
return true;
|
|
}
|
|
auto res = _menu.handleInput(c);
|
|
if (res == PopupMenu::VALUE_NEXT) {
|
|
cycleMenuValue(_menu.selectedIndex());
|
|
} else if (res == PopupMenu::SELECTED) {
|
|
int i = _menu.selectedIndex();
|
|
if (i >= 0 && i < _menu_action_count) runAction(_menu_actions[i]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ── detail view ───────────────────────────────────────────────────────────
|
|
if (_detail) {
|
|
if (c == KEY_CANCEL) { _detail = false; closePingMenu(); return true; }
|
|
if (c == KEY_CONTEXT_MENU) { openActionMenu(); return true; }
|
|
return true;
|
|
}
|
|
|
|
// ── map view: Left / Right a node, Up / Down zoom, Enter its detail ──────
|
|
if (_map) {
|
|
if (c == KEY_CANCEL) { _map = false; return true; }
|
|
if (c == KEY_CONTEXT_MENU) { openActionMenu(); return true; }
|
|
if (_count == 0) return true;
|
|
if (keyIsPrev(c)) { int k = positioned(_sel - 1, -1); if (k >= 0) _sel = k; return true; }
|
|
if (keyIsNext(c)) { int k = positioned(_sel + 1, 1); if (k >= 0) _sel = k; return true; }
|
|
if (c == KEY_UP) { if (_map_zoom < 8) _map_zoom++; return true; }
|
|
if (c == KEY_DOWN) { if (_map_zoom > 0) _map_zoom--; return true; }
|
|
if (c == KEY_ENTER) { _detail = true; _detail_refresh_ms = millis(); return true; }
|
|
return true;
|
|
}
|
|
|
|
// ── list view ───────────────────────────────────────────────────────────
|
|
if (c == KEY_CANCEL) {
|
|
if (_route_pick) { endRoutePick(); return true; }
|
|
if (_pick_admin_target) { _pick_admin_target = false; _task->leaveTool(); return true; }
|
|
if (_source == SRC_SCAN) leaveScan();
|
|
else _task->leaveTool();
|
|
return true;
|
|
}
|
|
if (c == KEY_CONTEXT_MENU) { if (!_route_pick) openActionMenu(); return true; }
|
|
// drawList() reclamps _scroll from _sel every render.
|
|
if (c == KEY_UP && _count > 0) { _sel = (_sel > 0) ? _sel - 1 : _count - 1; return true; }
|
|
if (c == KEY_DOWN && _count > 0) { _sel = (_sel < _count - 1) ? _sel + 1 : 0; return true; }
|
|
if (c == KEY_ENTER) {
|
|
if (_route_pick) { // a repeater into the path
|
|
const Entry* e = selected();
|
|
if (e && e->has_key && e->type == ADV_TYPE_REPEATER) {
|
|
if (!_task->core().route.addRepeater(e->pub_key)) _task->showAlert("Already the last hop", 1000);
|
|
endRoutePick();
|
|
}
|
|
return true;
|
|
}
|
|
if (_pick_admin_target) {
|
|
const Entry* e = selected();
|
|
ContactInfo ci;
|
|
if (e && e->contact_idx >= 0 && (e->type == ADV_TYPE_REPEATER || e->type == ADV_TYPE_ROOM)
|
|
&& the_mesh.getContactByIdx(e->contact_idx, ci)) {
|
|
_pick_admin_target = false;
|
|
_task->openAdminFor(ci, true); // via the picker -- Cancel should return here
|
|
}
|
|
// else: row isn't an eligible admin target -- ignore, stay on the picker.
|
|
return true;
|
|
}
|
|
if (_count == 0) { if (_source == SRC_STORED) enterScan(); return true; }
|
|
_detail = true;
|
|
_detail_refresh_ms = millis();
|
|
return true;
|
|
}
|
|
if (_route_pick) return true; // the filter stays on repeaters
|
|
if (keyIsPrev(c)) { tabbar::turn(_task->getDisplay(), filterLabels(), _filter, -1); _filter = (_filter + F_COUNT - 1) % F_COUNT; refresh(); return true; }
|
|
if (keyIsNext(c)) { tabbar::turn(_task->getDisplay(), filterLabels(), _filter, +1); _filter = (_filter + 1) % F_COUNT; refresh(); return true; }
|
|
return false;
|
|
}
|
|
};
|
|
|