mirror of
https://github.com/MarekZegare4/MeshCore-Solo.git
synced 2026-11-02 10:51:57 +00:00
Claude
997da95ecf
- GPS: stop() resets the sky state so the 'Searching' timer does not run while the receiver is off; the status page shows it only when GPS is on. - L2 keyboard: put the FOCUSED state back after typing a key or picking a variant, so the cursor is drawn again after characters like a-ogonek. - Quick panel: drop the full-screen dim (a blend per frame), so the screen below stays interactive; tiles are one sideways-scrolling, snapping row; the brightness slider no longer animates and only updates the backlight when the value changes. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VeBrxKyHHxWsmttVkUdBrj
427 lines
18 KiB
C++
427 lines
18 KiB
C++
#pragma once
|
||
#include <helpers/ui/DisplayDriver.h>
|
||
#include <helpers/ui/UIScreen.h>
|
||
#include <Arduino.h>
|
||
#include "icons.h"
|
||
#include "InfoKit.h"
|
||
#include "PopupMenu.h"
|
||
#include "TabBar.h"
|
||
#include "../MyMesh.h"
|
||
#include "../ui-core/Diagnostics.h"
|
||
#include "../ui-core/Battery.h"
|
||
#if ENV_INCLUDE_GPS == 1 && defined(GPS_SKYVIEW)
|
||
#include "SkyView.h"
|
||
#define STATUS_HAS_SKY 1
|
||
#elif ENV_INCLUDE_GPS == 1
|
||
#include <helpers/sensors/GpsSky.h> // the type only: no receiver data without GPS_SKYVIEW
|
||
#endif
|
||
|
||
extern MyMesh the_mesh;
|
||
|
||
// Home › Status (Enter on the Status page): what the device can tell about
|
||
// itself, one tab per subject. LEFT/RIGHT switches tabs, UP/DOWN scrolls a
|
||
// tab by whole blocks.
|
||
// Radio -- frequency, SF / BW / CR, TX power, the noise floor with its
|
||
// last half hour, the last packet's signal.
|
||
// GPS -- on / off (Enter toggles), fix, satellites, position, altitude,
|
||
// speed, precision, time to first fix.
|
||
// Sky -- the sky plot or the signal bars (SkyView.h); Enter swaps them.
|
||
// Power -- battery level, voltage, source, its trend, then any sensors.
|
||
// Mesh -- packet counts with a traffic line, nodes heard, contacts.
|
||
// Hold Enter resets the counters.
|
||
// System -- uptime, firmware, device, memory, queue, errors, a font card.
|
||
// Replaces Tools › Diagnostics and Tools › Satellites. Drawn with InfoKit.h.
|
||
class StatusScreen : public UIScreen {
|
||
public:
|
||
enum Tab : uint8_t { TAB_RADIO, TAB_GPS, TAB_SKY, TAB_POWER, TAB_MESH, TAB_SYSTEM, TAB_ALL };
|
||
|
||
private:
|
||
UITask* _task;
|
||
uint8_t _tabs[TAB_ALL]; // the tabs this board has, in order
|
||
const char* _labels[TAB_ALL];
|
||
uint8_t _count = 0;
|
||
uint8_t _cur = 0; // index into _tabs
|
||
int _scroll = 0; // blocks scrolled off the top
|
||
bool _more = false; // the last frame cut blocks off at the bottom
|
||
bool _signal = false; // Sky: the bars instead of the plot
|
||
PopupMenu _reset_menu; // Mesh, Hold Enter -> confirm
|
||
CayenneLPP _lpp;
|
||
unsigned long _lpp_at = 0;
|
||
|
||
// History lines (ui-core/StatusHistory.h), one sample a minute (32 min).
|
||
// E-ink draws them as charts (chartBlock()) over a longer span: a sample
|
||
// every 5 minutes, 8 hours. Its Radio chart also has the SNR of the last
|
||
// 32 packets.
|
||
static const int HIST_N = Features::IS_EINK ? 96 : 32;
|
||
static constexpr const char* HIST_SPAN = Features::IS_EINK ? "8 h ago" : "32 min";
|
||
uicore::StatusHistory<HIST_N, Features::IS_EINK ? 300000UL : 60000UL> _hist;
|
||
|
||
// A chart as a block (e-ink): `title` with the value now on its line, the
|
||
// chart under it.
|
||
template <int N>
|
||
void chartBlock(DisplayDriver& d, info::Flow& f, int rsv, const char* title, const char* now,
|
||
const info::History<N>& hs, int min_span, bool bars, const char* span) {
|
||
const int lh = d.getLineHeight(), ch = 3 * lh;
|
||
if (!f.place(d.lineStep() + info::chartH(d, ch) + 2)) return;
|
||
info::valueRow(d, f.at, title, now, false, rsv, 1);
|
||
info::chart(d, 1, f.at + d.lineStep(), d.width() - rsv - 3, ch, hs, min_span, bars, span, "now");
|
||
}
|
||
|
||
void addTab(uint8_t t, const char* label) { _tabs[_count] = t; _labels[_count] = label; _count++; }
|
||
uint8_t tab() const { return _tabs[_cur]; }
|
||
|
||
static uint32_t totalRx() {
|
||
uint32_t n = 0;
|
||
for (uint8_t t = 0; t < 16; t++) n += the_mesh.getNumRecvByType(t);
|
||
return n;
|
||
}
|
||
static uint32_t totalTx() {
|
||
uint32_t n = 0;
|
||
for (uint8_t t = 0; t < 16; t++) n += the_mesh.getNumSentByType(t);
|
||
return n;
|
||
}
|
||
|
||
int battMv() const { return _task->getBattMilliVolts(); }
|
||
int battPct() const {
|
||
NodePrefs* p = the_mesh.getNodePrefs();
|
||
return battery::percent(battMv(), p ? (int)p->low_batt_mv : 0);
|
||
}
|
||
bool imperial() const {
|
||
NodePrefs* p = the_mesh.getNodePrefs();
|
||
return p && p->units_imperial;
|
||
}
|
||
|
||
// One label/value row as a block.
|
||
// A long value takes the line under its label (no cursor here to scroll it).
|
||
void row(DisplayDriver& d, info::Flow& f, int reserve, const char* label, const char* value) {
|
||
if (f.place(info::rowH(d, label, value, reserve))) info::rowWrapped(d, f.at, label, value, reserve);
|
||
}
|
||
void section(DisplayDriver& d, info::Flow& f, int reserve, const char* label) {
|
||
if (f.place(d.lineStep())) info::section(d, f.at, label, reserve);
|
||
}
|
||
|
||
// ── tabs ──────────────────────────────────────────────────────────────
|
||
void tabRadio(DisplayDriver& d, info::Flow& f, int rsv) {
|
||
NodePrefs* p = the_mesh.getNodePrefs();
|
||
char a[24], b[24];
|
||
const int lh = d.getLineHeight();
|
||
if (f.place(info::bigH(d) + 2)) {
|
||
snprintf(a, sizeof(a), "%.3f", p ? p->freq : 0.0f);
|
||
info::big(d, 1, f.at, a, "MHz");
|
||
}
|
||
if (f.place(lh + 5)) {
|
||
int x = 1;
|
||
snprintf(a, sizeof(a), "SF%u", p ? (unsigned)p->sf : 0); x = info::chip(d, x, f.at, a);
|
||
snprintf(a, sizeof(a), "BW%g", p ? p->bw : 0.0f); x = info::chip(d, x, f.at, a);
|
||
snprintf(a, sizeof(a), "CR%u", p ? (unsigned)p->cr : 0); info::chip(d, x, f.at, a);
|
||
}
|
||
snprintf(a, sizeof(a), "%d dBm", (int)radio_driver.getTxPower());
|
||
row(d, f, rsv, "TX power", a);
|
||
const int nf = (int)radio_driver.getNoiseFloor();
|
||
if (nf) snprintf(a, sizeof(a), "%d dBm", nf); else strcpy(a, "-");
|
||
if (Features::IS_EINK) {
|
||
chartBlock(d, f, rsv, "Noise", a, _hist.noise, 6, false, HIST_SPAN);
|
||
} else if (f.place(d.lineStep())) { // label, the last half hour, the value now
|
||
info::valueRow(d, f.at, "Noise", a, false, rsv, 1);
|
||
const int x0 = 1 + d.getTextWidth("Noise") + 6;
|
||
const int x1 = d.width() - rsv - 2 - d.getTextWidth(a) - 6;
|
||
if (x1 - x0 > 12) info::spark(d, x0, f.at, x1 - x0, lh - 1, _hist.noise);
|
||
}
|
||
if (f.place(d.lineStep())) {
|
||
const float snr = radio_driver.getLastSNR();
|
||
snprintf(b, sizeof(b), "%d dBm", (int)radio_driver.getLastRSSI());
|
||
info::valueRow(d, f.at, "Last RX", b, false, rsv, 1);
|
||
drawSignalBars(d, d.width() - rsv - 2 - d.getTextWidth(b) - 5, f.at, (int)(snr * 4));
|
||
}
|
||
snprintf(b, sizeof(b), "%.1f dB", radio_driver.getLastSNR());
|
||
if (Features::IS_EINK) chartBlock(d, f, rsv, "SNR", b, _hist.snr, 20, false, "32 pkts");
|
||
else row(d, f, rsv, "Last SNR", b);
|
||
}
|
||
|
||
#if ENV_INCLUDE_GPS == 1
|
||
void tabGps(DisplayDriver& d, info::Flow& f, int rsv) {
|
||
char a[24];
|
||
const int lh = d.getLineHeight();
|
||
const bool on = _task->getGPSState();
|
||
if (f.place(d.lineStep())) {
|
||
info::valueRow(d, f.at, "GPS", nullptr, false, rsv, 1);
|
||
info::toggle(d, d.width() - rsv - 2, f.at, on);
|
||
}
|
||
LocationProvider* loc = sensors.getLocationProvider();
|
||
#ifdef STATUS_HAS_SKY
|
||
GpsSky* g = skyview::sky();
|
||
#else
|
||
GpsSky* g = nullptr;
|
||
#endif
|
||
if (!loc) { row(d, f, rsv, "Receiver", "none"); return; }
|
||
const bool fix = loc->isValid();
|
||
if (f.place(lh + 5)) { // the fix as a chip, satellites used / in view
|
||
const char* st = !on ? "OFF" : !fix ? "NO FIX" : (g && g->fix_mode == 2) ? "2D FIX" : "3D FIX";
|
||
info::chip(d, 1, f.at, st, on && fix);
|
||
#ifdef STATUS_HAS_SKY
|
||
if (g) snprintf(a, sizeof(a), "%d/%d sats", skyview::usedCount(*g), g->count);
|
||
else
|
||
#endif
|
||
snprintf(a, sizeof(a), "%ld sats", loc->satellitesCount());
|
||
d.drawTextRightAlign(d.width() - rsv - 2, f.at + 1, a);
|
||
}
|
||
const long lat = loc->getLatitude(), lon = loc->getLongitude();
|
||
// The driver reports 999 deg before a first fix (0,0 in the simulator).
|
||
const bool known = labs(lat) <= 90000000L && (lat || lon);
|
||
if (known) snprintf(a, sizeof(a), "%.5f\xc2\xb0%c", labs(lat) / 1e6, lat < 0 ? 'S' : 'N'); else strcpy(a, "-");
|
||
row(d, f, rsv, fix ? "Lat" : "Lat (last)", a);
|
||
if (known) snprintf(a, sizeof(a), "%.5f\xc2\xb0%c", labs(lon) / 1e6, lon < 0 ? 'W' : 'E'); else strcpy(a, "-");
|
||
row(d, f, rsv, fix ? "Lon" : "Lon (last)", a);
|
||
if (fix) {
|
||
telemetry::altText(loc->getAltitude() / 1000.0f, imperial(), L1_INFO, a, sizeof(a));
|
||
row(d, f, rsv, "Altitude", a);
|
||
}
|
||
if (g && fix) {
|
||
if (imperial()) snprintf(a, sizeof(a), "%.0f mph", g->speed_kmh * 0.621371f);
|
||
else snprintf(a, sizeof(a), "%.0f km/h", g->speed_kmh);
|
||
row(d, f, rsv, "Speed", a);
|
||
}
|
||
if (g) {
|
||
if (g->hdop > 0 && g->hdop < 99) snprintf(a, sizeof(a), "%.1f", g->hdop); else strcpy(a, "-");
|
||
row(d, f, rsv, "HDOP", a);
|
||
if (g->ttff_ms) snprintf(a, sizeof(a), "%lu s", (unsigned long)(g->ttff_ms / 1000));
|
||
else if (on && g->start_ms) {
|
||
const unsigned long s = (millis() - g->start_ms) / 1000;
|
||
if (!Features::IS_EINK) snprintf(a, sizeof(a), "%lu s", s);
|
||
else if (s < 60) strcpy(a, "<1 min"); // seconds would refresh the panel every second
|
||
else snprintf(a, sizeof(a), "%lu min", s / 60);
|
||
}
|
||
else strcpy(a, "-");
|
||
row(d, f, rsv, g->ttff_ms ? "First fix" : "Searching", a);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
void tabPower(DisplayDriver& d, info::Flow& f, int rsv) {
|
||
char a[24];
|
||
const int mv = battMv(), pct = battPct();
|
||
if (f.place(info::bigH(d) + 2)) {
|
||
snprintf(a, sizeof(a), "%d", pct);
|
||
const int w = info::big(d, 1, f.at, a, "%");
|
||
const int mx = 1 + w + 8, mh = d.getLineHeight() + 2;
|
||
info::meter(d, mx, f.at + info::bigH(d) - mh - 1, d.width() - rsv - 2 - mx, mh, pct / 100.0f);
|
||
}
|
||
snprintf(a, sizeof(a), "%d.%02d V", mv / 1000, (mv % 1000) / 10);
|
||
row(d, f, rsv, "Battery", a);
|
||
row(d, f, rsv, "Source", board.isExternalPowered() ? "USB" : "Battery");
|
||
if (Features::IS_EINK) {
|
||
chartBlock(d, f, rsv, "Trend", nullptr, _hist.batt, 20, false, HIST_SPAN);
|
||
} else if (f.place(d.lineStep())) {
|
||
d.setCursor(1, f.at);
|
||
d.print("Trend");
|
||
const int x0 = 1 + d.getTextWidth("Trend") + 6;
|
||
info::spark(d, x0, f.at, d.width() - rsv - 2 - x0, d.getLineHeight() - 1, _hist.batt, 20);
|
||
}
|
||
|
||
// Sensors: every reading but the battery (above) and the position (GPS).
|
||
if (!_lpp_at || millis() - _lpp_at > 5000) { // both passes (measure, draw) read one query
|
||
_lpp.reset();
|
||
sensors.querySensors(0xFF, _lpp);
|
||
_lpp_at = millis() | 1;
|
||
}
|
||
static const struct { uint8_t type; const char* name; } NAMES[] = {
|
||
{ LPP_TEMPERATURE, "Temperature" }, { LPP_RELATIVE_HUMIDITY, "Humidity" },
|
||
{ LPP_BAROMETRIC_PRESSURE, "Pressure" }, { LPP_ALTITUDE, "Altitude" },
|
||
{ LPP_CURRENT, "Current" }, { LPP_POWER, "Power" }, { LPP_LUMINOSITY, "Light" },
|
||
{ LPP_PERCENTAGE, "Moisture" }, { LPP_DISTANCE, "Distance" }, { LPP_CONCENTRATION, "CO2" },
|
||
};
|
||
bool titled = false;
|
||
LPPReader r(_lpp.getBuffer(), _lpp.getSize());
|
||
uint8_t ch, type;
|
||
while (r.readHeader(ch, type)) {
|
||
const char* name = nullptr;
|
||
for (auto& n : NAMES) if (n.type == type) { name = n.name; break; }
|
||
if (!name) { r.skipData(type); continue; }
|
||
telemetry::lppText(r, type, imperial(), L1_INFO, a, sizeof(a));
|
||
if (!titled) { section(d, f, rsv, "Sensors"); titled = true; }
|
||
row(d, f, rsv, name, a);
|
||
}
|
||
}
|
||
|
||
void tabMesh(DisplayDriver& d, info::Flow& f, int rsv) {
|
||
char a[24];
|
||
const int lh = d.getLineHeight();
|
||
if (f.place(d.lineStep())) {
|
||
snprintf(a, sizeof(a), "RX %lu", (unsigned long)totalRx());
|
||
d.setCursor(1, f.at); d.print(a);
|
||
snprintf(a, sizeof(a), "TX %lu", (unsigned long)totalTx());
|
||
d.drawTextRightAlign(d.width() - rsv - 2, f.at, a);
|
||
}
|
||
if (Features::IS_EINK) { // packets per 5 minutes, as bars
|
||
const int ch = 3 * lh;
|
||
if (f.place(info::chartH(d, ch) + 2))
|
||
info::chart(d, 1, f.at, d.width() - rsv - 3, ch, _hist.traffic, 4, true, HIST_SPAN, "now");
|
||
} else if (f.place(lh + 6)) {
|
||
info::spark(d, 1, f.at, d.width() - rsv - 3, lh + 3, _hist.traffic, 4);
|
||
}
|
||
|
||
static const uint8_t MSG[] = { PAYLOAD_TYPE_TXT_MSG, PAYLOAD_TYPE_GRP_TXT };
|
||
static const uint8_t ADVERT[] = { PAYLOAD_TYPE_ADVERT };
|
||
static const uint8_t ROUTE[] = { PAYLOAD_TYPE_ACK, PAYLOAD_TYPE_PATH, PAYLOAD_TYPE_TRACE };
|
||
snprintf(a, sizeof(a), "%lu / %lu", (unsigned long)diag::sumByTypes(true, MSG, 2), (unsigned long)diag::sumByTypes(false, MSG, 2));
|
||
row(d, f, rsv, "Messages", a);
|
||
snprintf(a, sizeof(a), "%lu / %lu", (unsigned long)diag::sumByTypes(true, ADVERT, 1), (unsigned long)diag::sumByTypes(false, ADVERT, 1));
|
||
row(d, f, rsv, "Adverts", a);
|
||
snprintf(a, sizeof(a), "%lu / %lu", (unsigned long)diag::sumByTypes(true, ROUTE, 3), (unsigned long)diag::sumByTypes(false, ROUTE, 3));
|
||
row(d, f, rsv, "Acks, paths", a);
|
||
snprintf(a, sizeof(a), "%lu", (unsigned long)the_mesh.getNumForwarded());
|
||
row(d, f, rsv, "Forwarded", a);
|
||
snprintf(a, sizeof(a), "%d", heardLastHour());
|
||
row(d, f, rsv, "Heard in 1 h", a);
|
||
snprintf(a, sizeof(a), "%d", the_mesh.getNumContacts());
|
||
row(d, f, rsv, "Contacts", a);
|
||
}
|
||
|
||
void tabSystem(DisplayDriver& d, info::Flow& f, int rsv) {
|
||
char a[32];
|
||
uint32_t up = millis() / 1000;
|
||
unsigned long dd = up / 86400, h = (up % 86400) / 3600, m = (up % 3600) / 60;
|
||
if (dd) snprintf(a, sizeof(a), "%lud %luh %lum", dd, h, m);
|
||
else snprintf(a, sizeof(a), "%luh %lum", h, m);
|
||
row(d, f, rsv, "Uptime", a);
|
||
diag::shortVersion(a, sizeof(a));
|
||
row(d, f, rsv, "Firmware", a);
|
||
row(d, f, rsv, "Built", FIRMWARE_BUILD_DATE);
|
||
row(d, f, rsv, "Device", board.getManufacturerName());
|
||
uint32_t heap_free, heap_total;
|
||
DeviceDiag::getHeapStats(heap_free, heap_total);
|
||
if (heap_total) snprintf(a, sizeof(a), "%lu of %lu KB", (unsigned long)(heap_free / 1024), (unsigned long)(heap_total / 1024));
|
||
else strcpy(a, "-");
|
||
row(d, f, rsv, "Free heap", a);
|
||
snprintf(a, sizeof(a), "%lu B", (unsigned long)DeviceDiag::getStackFreeBytes());
|
||
row(d, f, rsv, "Free stack", a);
|
||
snprintf(a, sizeof(a), "%d", the_mesh.getPoolFreeCount());
|
||
row(d, f, rsv, "Packet pool", a);
|
||
snprintf(a, sizeof(a), "%d", the_mesh.getOutboundQueueLen());
|
||
row(d, f, rsv, "Send queue", a);
|
||
const uint16_t err = the_mesh.getErrFlags();
|
||
if (!err) strcpy(a, "none");
|
||
else snprintf(a, sizeof(a), "%s%s%s", (err & ERR_EVENT_FULL) ? "full " : "",
|
||
(err & ERR_EVENT_CAD_TIMEOUT) ? "CAD " : "", (err & ERR_EVENT_STARTRX_TIMEOUT) ? "RX" : "");
|
||
row(d, f, rsv, "Errors", a);
|
||
section(d, f, rsv, "Font");
|
||
diag::Line lines[diag::MAX_LINES];
|
||
const int n = diag::fontLines(lines);
|
||
for (int i = 0; i < n; i++)
|
||
if (f.place(d.lineStep())) d.drawTextEllipsized(1, f.at, d.width() - rsv - 3, lines[i]);
|
||
}
|
||
|
||
// All of a tab's blocks, drawn (or, through a measuring Flow, only counted).
|
||
void layout(DisplayDriver& d, info::Flow& f, int rsv) {
|
||
switch (tab()) {
|
||
case TAB_RADIO: tabRadio(d, f, rsv); break;
|
||
#if ENV_INCLUDE_GPS == 1
|
||
case TAB_GPS: tabGps(d, f, rsv); break;
|
||
#endif
|
||
case TAB_POWER: tabPower(d, f, rsv); break;
|
||
case TAB_MESH: tabMesh(d, f, rsv); break;
|
||
case TAB_SYSTEM: tabSystem(d, f, rsv); break;
|
||
default: break;
|
||
}
|
||
}
|
||
|
||
public:
|
||
StatusScreen(UITask* task) : _task(task), _lpp(160) {
|
||
addTab(TAB_RADIO, "Radio");
|
||
#if ENV_INCLUDE_GPS == 1
|
||
addTab(TAB_GPS, "GPS");
|
||
#endif
|
||
#ifdef STATUS_HAS_SKY
|
||
addTab(TAB_SKY, "Sky");
|
||
#endif
|
||
addTab(TAB_POWER, "Power");
|
||
addTab(TAB_MESH, "Mesh");
|
||
addTab(TAB_SYSTEM, "System");
|
||
}
|
||
|
||
// Open on a given tab (Status page: Radio; the GPS shortcuts: GPS / Sky).
|
||
void showTab(uint8_t t) {
|
||
for (uint8_t i = 0; i < _count; i++) if (_tabs[i] == t) { _cur = i; _scroll = 0; }
|
||
}
|
||
// GPS stays awake while its live tabs are on screen.
|
||
bool wantsLiveGps() const { return tab() == TAB_GPS || tab() == TAB_SKY; }
|
||
|
||
// Called from the UI loop on every pass; the history keeps its own pace.
|
||
void sample() {
|
||
_hist.tick(millis(), (int)radio_driver.getNoiseFloor(), battMv(), totalRx(), radio_driver.getLastSNR());
|
||
}
|
||
|
||
const info::History<HIST_N>& battHistory() const { return _hist.batt; }
|
||
|
||
// Contacts heard from in the last hour (cached for 10 s: it walks them all).
|
||
static int heardLastHour() {
|
||
static unsigned long at = 0;
|
||
static int n = 0;
|
||
if (at && millis() - at < 10000) return n;
|
||
at = millis() | 1;
|
||
n = 0;
|
||
const uint32_t now = rtc_clock.getCurrentTime();
|
||
const int nc = the_mesh.getNumContacts();
|
||
for (int i = 0; i < nc; i++) {
|
||
ContactInfo ci;
|
||
if (!the_mesh.getContactByIdx(i + MAX_ANON_CONTACTS, ci)) continue;
|
||
if (ci.lastmod && ci.lastmod + 3600 >= now) n++;
|
||
}
|
||
return n;
|
||
}
|
||
|
||
int render(DisplayDriver& display) override {
|
||
display.setTextSize(1);
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
tabbar::draw(display, _labels, _count, _cur);
|
||
const int top = display.listStart(), bottom = display.height();
|
||
int next = 1000;
|
||
|
||
#ifdef STATUS_HAS_SKY
|
||
if (tab() == TAB_SKY) {
|
||
next = skyview::render(display, top, _signal, _task->getGPSState());
|
||
} else
|
||
#endif
|
||
{
|
||
// Measure first, so a tab taller than the screen gets its scroll column.
|
||
info::Flow m = info::Flow::measure();
|
||
layout(display, m, 0);
|
||
const long view = bottom - top;
|
||
const int rsv = m.total_px > view ? scrollIndicatorColWidth(display) : 0;
|
||
info::Flow f(top, bottom, _scroll);
|
||
layout(display, f, rsv);
|
||
_more = f.more;
|
||
if (rsv) drawScrollIndicatorPx(display, top, view, f.total_px, view, f.skipped_px);
|
||
}
|
||
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
if (_reset_menu.active) { _reset_menu.render(display); return 50; }
|
||
return next;
|
||
}
|
||
|
||
bool handleInput(char c) override {
|
||
if (_reset_menu.active) {
|
||
auto res = _reset_menu.handleInput(c);
|
||
if (res == PopupMenu::SELECTED && _reset_menu.selectedIndex() == 0) {
|
||
diag::resetCounters();
|
||
_hist.countersReset();
|
||
}
|
||
return true;
|
||
}
|
||
if (keyIsPrev(c)) { _cur = (_cur + _count - 1) % _count; _scroll = 0; return true; }
|
||
if (keyIsNext(c)) { _cur = (_cur + 1) % _count; _scroll = 0; return true; }
|
||
if (c == KEY_UP) { if (_scroll > 0) _scroll--; return true; }
|
||
if (c == KEY_DOWN) { if (_more) _scroll++; return true; }
|
||
#if ENV_INCLUDE_GPS == 1
|
||
if (c == KEY_ENTER && tab() == TAB_GPS) { _task->toggleGPS(); return true; }
|
||
#endif
|
||
if (c == KEY_ENTER && tab() == TAB_SKY) { _signal = !_signal; return true; }
|
||
if (c == KEY_CONTEXT_MENU && tab() == TAB_MESH) {
|
||
_reset_menu.beginConfirm("Reset counters?", "Reset");
|
||
return true;
|
||
}
|
||
if (c == KEY_CANCEL) { _task->gotoHomeScreen(); return true; }
|
||
return false;
|
||
}
|
||
};
|