#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. void renderMap(DisplayDriver& d) { const int W = d.width(), H = d.height(), lh = d.getLineHeight(), s = miniIconScale(d); const int bar_y = H - lh - 1, ax = 1, ay = 1, aw = W - 2, ah = 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. const int mx = ICON_MAP_NORTH.w * s + 2, my = lh + 2; 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; }; 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; const int t = d.sepH(); 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 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); 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); gfx::drawLineClipped(d, px[k - 1] - ox, py[k - 1] - oy, px[k] - ox, py[k] - oy, ax, ay, aw, ah); } } 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 stay readable over the lines. d.setColor(UIColor::window_bkg); d.fillRect(ax + aw - ICON_MAP_NORTH.w * s - 2, ay, ICON_MAP_NORTH.w * s + 2, ICON_MAP_NORTH.h * s + 1); d.setColor(UIColor::primary_txt); miniIconDrawTop(d, ax + aw - ICON_MAP_NORTH.w * s - 1, ay, ICON_MAP_NORTH); // The scale: a round distance about a quarter of the width, bottom right. 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()); if (len > 2 && len < aw) { const int ly = ay + ah - 2, lx = ax + aw - len - 1, tw = d.getTextWidth(sc); d.setColor(UIColor::window_bkg); d.fillRect(lx + len - tw - 1, ly - lh - 1, tw + 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 - d.getTextWidth(sc), ly - lh); d.print(sc); } d.fillRect(0, bar_y - 1, W, d.sepH()); char right[16] = ""; if (sel.dist_km >= 0.0f) geo::fmtDist(right, sizeof(right), sel.dist_km, 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); const int rw = right[0] ? d.getTextWidth(right) + d.getCharWidth() : 0; d.drawTextEllipsized(1, bar_y + 1, W - 2 - rw, name); if (right[0]) { d.setCursor(W - 1 - d.getTextWidth(right), bar_y + 1); d.print(right); } } 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; } };