int sliceId;

int x;

VfoWidget* w;

int splitPartner;

const SpectrumWidget::SliceOverlay* overlay;

const SpectrumWidget::SliceOverlay& overlay,

VfoWidget* widget,

int markerX,

int spectrumWidth)

{

if (overlay.mode == "RTTY" || overlay.mode == "DIGL") {

return VfoWidget::ForceRight;

}

const bool defaultOnLeft = VfoWidget::defaultFlagOnLeftForMode(overlay.mode);

const bool previousOnLeft = widget ? widget->onLeft() : defaultOnLeft;

return VfoWidget::autoDirectionForSingleFlag(

markerX, widget ? widget->width() : 0, spectrumWidth,

defaultOnLeft, previousOnLeft);

const QVector<VfoPos>& vfos, int index, int panelWidth, int spectrumWidth)

{

const int previousMarkerX = index > 0 ? vfos[index - 1].x : 0;

const int nextMarkerX = index + 1 < vfos.size() ? vfos[index + 1].x : 0;

const bool previousOnLeft = vfos[index].w ? vfos[index].w->onLeft() : true;

return VfoWidget::autoDirectionForDeconflictedFlag(

index, vfos.size(), vfos[index].x, previousMarkerX, nextMarkerX,

panelWidth, spectrumWidth, previousOnLeft);

const SpectrumWidget::SliceOverlay& overlay)

{

if (!active || active->sliceId == overlay.sliceId

|| !active->diversity || !overlay.diversity) {

return false;

}

const bool parentChildPair =

(active->diversityParent && overlay.diversityChild)

|| (active->diversityChild && overlay.diversityParent);

if (parentChildPair) {

return true;

}

if (active->diversityIndex >= 0 && overlay.diversityIndex >= 0) {

return active->diversityIndex != overlay.diversityIndex;

}

return true;

{

if (!vfo.overlay) {

return 1000 + std::max(vfo.sliceId, 0);

}

return VfoWidget::diversityPairOrderKey(

vfo.overlay->diversityParent,

vfo.overlay->diversityChild,

vfo.overlay->diversityIndex,

vfo.sliceId);

QMap<int, VfoWidget::FlagDir>& dirMap)

{

for (int i = 0; i < vfos.size(); ++i) {

if (vfos[i].splitPartner < 0) {

continue;

}

if (dirMap.contains(vfos[i].sliceId)) {

continue;

}

int partnerIndex = -1;

for (int j = 0; j < vfos.size(); ++j) {

if (vfos[j].sliceId == vfos[i].splitPartner) {

partnerIndex = j;

break;

}

}

if (partnerIndex < 0) {

continue;

}

if (dirMap.contains(vfos[partnerIndex].sliceId)) {

continue;

}

// Split partners stay locked to opposite sides regardless of edge

// proximity (#2663). Flipping a partner near an edge collapses both

// panels onto the same side and makes the RX/TX pair overlap.

const int leftIndex = (vfos[i].x <= vfos[partnerIndex].x) ? i : partnerIndex;

const int rightIndex = (leftIndex == i) ? partnerIndex : i;

dirMap[vfos[leftIndex].sliceId] = VfoWidget::LockLeft;

dirMap[vfos[rightIndex].sliceId] = VfoWidget::LockRight;

}

QMap<int, VfoWidget::FlagDir>& dirMap)

{

QVector<int> diversityIndices;

for (int i = 0; i < vfos.size(); ++i) {

if (!vfos[i].overlay || dirMap.contains(vfos[i].sliceId)) {

continue;

}

if (!overlayIsDiversityPairCandidate(*vfos[i].overlay)) {

continue;

}

diversityIndices.append(i);

}

if (diversityIndices.size() != 2) {

return;

}

std::sort(diversityIndices.begin(), diversityIndices.end(),

[&vfos](int lhs, int rhs) {

const int lhsKey = diversityOrderKeyForVfo(vfos[lhs]);

const int rhsKey = diversityOrderKeyForVfo(vfos[rhs]);

if (lhsKey != rhsKey) {

return lhsKey < rhsKey;

}

return vfos[lhs].sliceId < vfos[rhs].sliceId;

});

dirMap[vfos[diversityIndices[0]].sliceId] = VfoWidget::LockLeft;

dirMap[vfos[diversityIndices[1]].sliceId] = VfoWidget::LockRight;

QMap<int, VfoWidget::FlagDir>& dirMap)

{

for (const SpectrumWidget::SliceOverlay& overlay : overlays) {

if (overlay.mode == "RTTY" || overlay.mode == "DIGL") {

dirMap[overlay.sliceId] = VfoWidget::ForceRight;

}

}

{

if (!std::isfinite(bottomDbm)) {

return kMinDisplayDbm;

}

return std::clamp(bottomDbm,

kMinDisplayDbm,

kMaxDisplayDbm - kMinDisplayRangeDb);

{

bottomDbm = clampDbmBottom(bottomDbm);

if (!std::isfinite(rangeDb)) {

rangeDb = kMinDisplayRangeDb;

}

const float maxRangeForBottom =

std::min(kMaxDisplayRangeDb, kMaxDisplayDbm - bottomDbm);

return std::clamp(rangeDb,

kMinDisplayRangeDb,

std::max(kMinDisplayRangeDb, maxRangeForBottom));

{

if (!std::isfinite(rangeDb)) {

rangeDb = kMinDisplayRangeDb;

}

rangeDb = std::clamp(rangeDb, kMinDisplayRangeDb, kMaxDisplayRangeDb);

if (!std::isfinite(refDbm)) {

return kMinDisplayDbm + rangeDb;

}

return std::clamp(refDbm,

kMinDisplayDbm + rangeDb,

kMaxDisplayDbm);

{

if (!std::isfinite(minDbm) || !std::isfinite(maxDbm)) {

return false;

}

minDbm = std::max(minDbm, kMinDisplayDbm);

maxDbm = std::min(maxDbm, kMaxDisplayDbm);

if (maxDbm - minDbm > kMaxDisplayRangeDb) {

minDbm = maxDbm - kMaxDisplayRangeDb;

}

if (maxDbm - minDbm < kMinDisplayRangeDb) {

maxDbm = std::min(kMaxDisplayDbm, minDbm + kMinDisplayRangeDb);

minDbm = std::min(minDbm, maxDbm - kMinDisplayRangeDb);

minDbm = std::max(minDbm, kMinDisplayDbm);

}

return true;

{

#ifdef Q_OS_MAC

switch (shape) {

case Qt::SplitVCursor:

return Qt::SizeVerCursor;

case Qt::SizeAllCursor:

return Qt::OpenHandCursor;

default:

break;

}

#endif

return shape;

{

if (!widget) {

return;

}

if (!widget->property(kSliceCursorOverrideActiveProperty).toBool()) {

widget->setProperty(kSliceCursorOverrideHadCursorProperty,

widget->testAttribute(Qt::WA_SetCursor));

widget->setProperty(kSliceCursorOverrideShapeProperty,

static_cast<int>(widget->cursor().shape()));

widget->setProperty(kSliceCursorOverrideActiveProperty, true);

}

widget->setCursor(normalizedSpectrumCursorShape(shape));

{

if (!widget

|| !widget->property(kSliceCursorOverrideActiveProperty).toBool()) {

return;

}

const bool hadCursor =

widget->property(kSliceCursorOverrideHadCursorProperty).toBool();

const Qt::CursorShape previousShape = static_cast<Qt::CursorShape>(

widget->property(kSliceCursorOverrideShapeProperty).toInt());

widget->setProperty(kSliceCursorOverrideActiveProperty, false);

widget->setProperty(kSliceCursorOverrideHadCursorProperty, QVariant());

widget->setProperty(kSliceCursorOverrideShapeProperty, QVariant());

if (hadCursor) {

widget->setCursor(previousShape);

} else {

widget->unsetCursor();

}

{

const int widthPx = std::abs(hiX - loX);

if (widthPx <= kFilterPassbandMinBodyPx) {

return 0;

}

return std::min(grabPx, (widthPx - kFilterPassbandMinBodyPx - 1) / 2);

{

const int left = std::min(loX, hiX);

const int right = std::max(loX, hiX);

const bool insidePassband = mx >= left && mx <= right;

if (insidePassband && right - left <= kFilterPassbandMinBodyPx) {

return 0;

}

const int insideGrabPx = filterInteriorGrabPx(loX, hiX, grabPx);

const bool lowIsLeft = loX <= hiX;

const bool lowHit = lowIsLeft

? (mx >= loX - grabPx && mx <= loX + insideGrabPx)

: (mx >= loX - insideGrabPx && mx <= loX + grabPx);

const bool highHit = lowIsLeft

? (mx >= hiX - insideGrabPx && mx <= hiX + grabPx)

: (mx >= hiX - grabPx && mx <= hiX + insideGrabPx);

if (lowHit && highHit) {

return (std::abs(mx - loX) <= std::abs(mx - hiX)) ? -1 : 1;

}

if (lowHit) {

return -1;

}

if (highHit) {

return 1;

}

return 0;

{

const int left = std::min(loX, hiX);

const int right = std::max(loX, hiX);

return mx >= left && mx <= right

&& filterEdgeHitAtPixel(mx, loX, hiX, grabPx) == 0;

{

return std::clamp(lineDurationMs,

kWaterfallLineDurationMinMs,

kWaterfallLineDurationMaxMs);

{

// See SpectrumOverlayMenu.cpp: the rate control value is intentionally sent

// directly as line_duration. The tested behavior is 1 slowest, 100 fastest.

return std::clamp(ratePercent,

kWaterfallRatePercentMin,

kWaterfallRatePercentMax);

{

const float t2 = t * t;

const float t3 = t2 * t;

const float value = 0.5f * ((2.0f * p1)

+ (-p0 + p2) * t

+ (2.0f * p0 - 5.0f * p1 + 4.0f * p2 - p3) * t2

+ (-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t3);

const float lo = std::min(p1, p2);

const float hi = std::max(p1, p2);

return std::clamp(value, lo, hi);

{

const int clamped = std::clamp(lineDurationMs,

kWaterfallLineDurationMinMs,

kWaterfallLineDurationMaxMs);

struct RateCalibration {

int ratePercent;

float msPerRow;

};

static constexpr RateCalibration kMeasuredRateCurve[] = {

{1, 6000.0f},

{8, 4000.9f},

{50, 677.2f},

{56, 473.2f},

{67, 223.0f},

{69, 192.1f},

{71, 163.9f},

{75, 120.7f},

{77, 102.0f},

{78, 90.5f},

{79, 88.8f},

{80, 81.2f},

{83, 64.2f},

{90, 46.3f},

{93, 42.0f},

{100, 42.0f},

};

if (clamped <= kMeasuredRateCurve[0].ratePercent) {

return kMeasuredRateCurve[0].msPerRow;

}

constexpr int kMeasuredRateCurveSize =

static_cast<int>(sizeof(kMeasuredRateCurve) / sizeof(kMeasuredRateCurve[0]));

for (int i = 1; i < kMeasuredRateCurveSize; ++i) {

const RateCalibration& lower = kMeasuredRateCurve[i - 1];

const RateCalibration& upper = kMeasuredRateCurve[i];

if (clamped <= upper.ratePercent) {

const float fraction = static_cast<float>(clamped - lower.ratePercent)

/ static_cast<float>(upper.ratePercent - lower.ratePercent);

const float lowerLog = std::log(lower.msPerRow);

const float upperLog = std::log(upper.msPerRow);

return std::exp(lowerLog + (upperLog - lowerLog) * fraction);

}

}

return kMeasuredRateCurve[kMeasuredRateCurveSize - 1].msPerRow;

const QVector<SpectrumWidget::SpotMarker>& rhs)

{

constexpr double kFrequencyEpsilonMhz = 1.0e-6;

if (lhs.size() != rhs.size()) {

return false;

}

for (qsizetype i = 0; i < lhs.size(); ++i) {

const SpectrumWidget::SpotMarker& a = lhs.at(i);

const SpectrumWidget::SpotMarker& b = rhs.at(i);

if (a.callsign != b.callsign

|| std::abs(a.freqMhz - b.freqMhz) > kFrequencyEpsilonMhz

|| a.color != b.color

|| a.backgroundColor != b.backgroundColor

|| a.dxccColor != b.dxccColor

|| a.source != b.source) {

return false;

}

}

return true;

explicit PerfInputScope(const char* kind)

: m_kind(kind),

m_enabled(PerfTelemetry::instance().enabled()),

m_startNs(m_enabled ? PerfTelemetry::nowNs() : 0)

{

}

~PerfInputScope()

{

if (!m_enabled)

return;

PerfTelemetry::instance().recordInputEvent(

m_kind,

static_cast<double>(PerfTelemetry::nowNs() - m_startNs) / 1000000.0);

}

const char* m_kind;

bool m_enabled;

qint64 m_startNs;

enum class Kind {

Panadapter,

Waterfall

};

explicit PerfUpdateScope(Kind kind)

: m_kind(kind),

m_enabled(PerfTelemetry::instance().enabled()),

m_startNs(m_enabled ? PerfTelemetry::nowNs() : 0)

{

}

~PerfUpdateScope()

{

if (!m_enabled)

return;

const double durationMs = static_cast<double>(PerfTelemetry::nowNs() - m_startNs) / 1000000.0;

if (m_kind == Kind::Waterfall)

PerfTelemetry::instance().recordWaterfallUpdate(durationMs);

else

PerfTelemetry::instance().recordPanUpdate(durationMs);

}

Kind m_kind;

bool m_enabled;

qint64 m_startNs;

explicit ScopeExit(F&& fn)

: m_fn(std::forward<F>(fn))

{

}

~ScopeExit()

{

m_fn();

}

ScopeExit(const ScopeExit&) = delete;

ScopeExit& operator=(const ScopeExit&) = delete;

F m_fn;

{

const long long hz = static_cast<long long>(std::llround(freqMhz * 1.0e6));

const int mhzPart = static_cast<int>(hz / 1000000);

const int khzPart = static_cast<int>((hz / 1000) % 1000);

const int hzPart = static_cast<int>(hz % 1000);

return QString("%1.%2.%3")

.arg(mhzPart)

.arg(khzPart, 3, 10, QChar('0'))

.arg(hzPart, 3, 10, QChar('0'));

{

QString label = QString::number(freqMhz, 'f', decimals);

const qsizetype dot = label.indexOf(QLatin1Char('.'));

if (dot < 0) {

return label;

}

const qsizetype minDecimals = std::min(decimals, 3);

const qsizetype minLength = dot + 1 + minDecimals;

while (label.size() > minLength && label.endsWith(QLatin1Char('0'))) {

label.chop(1);

}

return label;

{

auto& c = wfStopsCache();

auto& tm = ThemeManager::instance();

for (int i = 0; i < static_cast<int>(WfColorScheme::Count); ++i) {

const QBrush br = tm.brush(QString::fromLatin1(

wfSchemeToken(static_cast<WfColorScheme>(i))));

std::vector<WfGradientStop> v;

if (br.gradient()) {

for (const auto& gs : br.gradient()->stops()) {

WfGradientStop s;

s.pos = static_cast<float>(gs.first);

s.r = gs.second.red();

s.g = gs.second.green();

s.b = gs.second.blue();

v.push_back(s);

}

}

// Fallback so a missing/malformed token still produces a usable

// black→white ramp instead of a divide-by-zero on the first paint.

if (v.size() < 2)

v = { {0.0f, 0, 0, 0}, {1.0f, 255, 255, 255} };

c.stops[i] = std::move(v);

}

c.initialized = true;

{

int i = 0;

while (i < n - 2 && stops[i + 1].pos < t) ++i;

const float seg = (t - stops[i].pos) / (stops[i + 1].pos - stops[i].pos);

const int r = static_cast<int>(stops[i].r + seg * (stops[i + 1].r - stops[i].r));

const int g = static_cast<int>(stops[i].g + seg * (stops[i + 1].g - stops[i].g));

const int b = static_cast<int>(stops[i].b + seg * (stops[i + 1].b - stops[i].b));

return qRgb(qBound(0, r, 255), qBound(0, g, 255), qBound(0, b, 255));

{

return qEnvironmentVariableIsSet("AETHER_NO_GPU")

|| qEnvironmentVariable("QT_OPENGL").compare(

QStringLiteral("software"), Qt::CaseInsensitive) == 0;

{

const QString lower = deviceName.toLower();

return lower.contains(QStringLiteral("llvmpipe"))

|| lower.contains(QStringLiteral("softpipe"))

|| lower.contains(QStringLiteral("swiftshader"))

|| lower.contains(QStringLiteral("software"))

|| lower.contains(QStringLiteral("warp"))

|| lower.contains(QStringLiteral("microsoft basic render"));

{

#ifdef AETHER_GPU_SPECTRUM

QRhi* currentRhi = rhi();

if (!currentRhi) {

return QStringLiteral("QRhi initializing");

}

const QString backendName = QString::fromLatin1(currentRhi->backendName());

const QRhiDriverInfo driverInfo = currentRhi->driverInfo();

const QString deviceName = QString::fromUtf8(driverInfo.deviceName).trimmed();

const bool softwareOpenGl = currentRhi->backend() == QRhi::OpenGLES2

&& qtSoftwareOpenGlRequested();

const bool cpuDevice = driverInfo.deviceType == QRhiDriverInfo::CpuDevice

|| softwareOpenGl

|| qrhiDeviceNameLooksSoftware(deviceName);

QStringList details;

details << backendName;

if (!deviceName.isEmpty()) {

details << deviceName;

}

if (softwareOpenGl) {

details << QStringLiteral("software OpenGL");

}

return QStringLiteral("%1 QRhi (%2)")

.arg(cpuDevice ? QStringLiteral("CPU") : QStringLiteral("GPU"),

details.join(QStringLiteral("; ")));

#else

return QStringLiteral("CPU QPainter");

#endif

{

const double secs = std::max(0.001, m_panStats.sinceMs() / 1000.0);

const auto msPerSec = [secs](quint64 us) { return (us / 1000.0) / secs; };

QVariantMap m;

m[QStringLiteral("panIndex")] = m_panIndex;

m[QStringLiteral("name")] = objectName();

m[QStringLiteral("visible")] = isVisible();

m[QStringLiteral("widthPx")] = width();

m[QStringLiteral("heightPx")] = height();

m[QStringLiteral("dpr")] = devicePixelRatioF();

m[QStringLiteral("renderMode")] =

m_spectrumRenderMode == SpectrumRenderMode::Mode3D

? QStringLiteral("3D") : QStringLiteral("2D");

m[QStringLiteral("renderer")] = rendererDescription();

m[QStringLiteral("leanMode")] = m_leanMode;

m[QStringLiteral("sinceMs")] = static_cast<qlonglong>(m_panStats.sinceMs());

m[QStringLiteral("fftFramesPerSec")] = m_panStats.updateSpectrumCalls / secs;

m[QStringLiteral("ingestMsPerSec")] = msPerSec(m_panStats.updateSpectrumUs);

m[QStringLiteral("gpuFramesPerSec")] = m_panStats.gpuFrames / secs;

// Main-thread budget consumed preparing + encoding GPU frames, in

// "ms per wall second" — the single number to compare before/after.

m[QStringLiteral("gpuFrameMsPerSec")] = msPerSec(m_panStats.gpuFrameUs);

m[QStringLiteral("avgGpuFrameUs")] = m_panStats.gpuFrames

? static_cast<double>(m_panStats.gpuFrameUs) / m_panStats.gpuFrames : 0.0;

m[QStringLiteral("fftBuildMsPerSec")] = msPerSec(m_panStats.fftBuildUs);

m[QStringLiteral("fftVboBytesPerSec")] =

static_cast<double>(m_panStats.fftVboBytes) / secs;

m[QStringLiteral("overlayRebuildsPerSec")] = m_panStats.overlayRebuilds / secs;

m[QStringLiteral("overlayRebuildMsPerSec")] = msPerSec(m_panStats.overlayRebuildUs);

m[QStringLiteral("overlayUploadBytesPerSec")] =

static_cast<double>(m_panStats.overlayUploadBytes) / secs;

m[QStringLiteral("wfUploadBytesPerSec")] =

static_cast<double>(m_panStats.wfUploadBytes) / secs;

m[QStringLiteral("paintsPerSec")] = m_panStats.paintEvents / secs;

m[QStringLiteral("paintMsPerSec")] = msPerSec(m_panStats.paintUs);

QVariantMap causes;

for (auto it = m_panStats.dirtyCauses.cbegin();

it != m_panStats.dirtyCauses.cend(); ++it)

causes[QString::fromLatin1(it.key())] = static_cast<qulonglong>(it.value());

m[QStringLiteral("overlayDirtyCauses")] = causes;

if (reset)

m_panStats.reset();

return m;

: SPECTRUM_BASE_CLASS(parent)

{

// Container declaration — every token lookup made by this widget or

// any of its children (without their own declaration) resolves

// through the "spectrum" scope chain. Token migration into this

// scope happens in step 4 of the refactor.

theme::setContainer(this, QStringLiteral("spectrum"));

m_panStats.clock.start(); // panstats rates are meaningless without an epoch

setMinimumHeight(100);

setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

setAutoFillBackground(false);

setAccessibleName(tr("Panadapter spectrum display"));

#ifdef AETHER_GPU_SPECTRUM

// Explicitly request Metal on macOS.

# ifdef Q_OS_MAC

setApi(QRhiWidget::Api::Metal);

// WA_NativeWindow forces Qt to create a dedicated native NSView for this widget.

// Without it, QRhiWidget embedded in a QWidget hierarchy (especially one whose

// backing store was created before this widget was added) fails to obtain a QRhi

// context because the parent window's surface type is RasterSurface, not MetalSurface

// (#714, Qt 6.6 era). The native view is expensive, though: every present forces

// a raster flushSubWindow blend of the pan region on the GUI thread.

// AETHER_PAN_NO_NATIVE_WINDOW=1 skips it to validate the composited path on

// newer Qt, where the whole window flushes through one rhi swapchain.

if (nativeWindowPreferred()) {

setAttribute(Qt::WA_NativeWindow);

}

# else

// AETHER_NO_GPU / QT_OPENGL=software: force the OpenGL QRhi backend so the

// software OpenGL rasterizer requested in main.cpp actually takes effect.

// Without this, QRhiWidget defaults to D3D11 on Windows and ignores

// QT_OPENGL entirely, making the flag a silent no-op there (#3597). On Linux

// the default backend is already OpenGL, so this is a harmless explicit

// restatement that keeps the two platforms on the same code path.

if (qtSoftwareOpenGlRequested()) {

setApi(QRhiWidget::Api::OpenGL);

qInfo() << "SpectrumWidget: AETHER_NO_GPU/QT_OPENGL=software — forcing "

"OpenGL QRhi backend (software rasterizer) instead of D3D11";

}

// Warn if running under XWayland — GLX context switching between the main

// window and child dialogs (e.g. Radio Setup) can trigger BadAccess (#1233).

// main.cpp normally forces native Wayland, but log it if we ended up here.

if (QGuiApplication::platformName() == QLatin1String("xcb")

&& qEnvironmentVariable("XDG_SESSION_TYPE") == QLatin1String("wayland")) {

qWarning() << "SpectrumWidget: running under XWayland with OpenGL — "

"GLX context issues may occur. Set QT_QPA_PLATFORM=wayland "

"or AETHER_NO_GPU=1 to work around (#1233)";

}

# endif

#else

setAttribute(Qt::WA_OpaquePaintEvent);

#endif

setSpectrumCursor(Qt::CrossCursor);

setMouseTracking(true);

// Floating overlay menu (child widget, stays on top)

m_overlayMenu = new SpectrumOverlayMenu(this);

m_overlayMenu->raise();

m_tnfHoverPopup = new QLabel(this);

m_tnfHoverPopup->setAttribute(Qt::WA_TransparentForMouseEvents);

m_tnfHoverPopup->setMargin(6);

m_tnfHoverPopup->hide();

m_tnfHoverPopup->raise();

m_panadapterMessageOverlay = new PanadapterMessageOverlay(this);

m_panadapterMessageOverlay->hide();

// Tune guide auto-hide timer (2-second inactivity timeout)

m_tuneGuideTimer = new QTimer(this);

m_tuneGuideTimer->setSingleShot(true);

m_tuneGuideTimer->setInterval(4000);

connect(m_tuneGuideTimer, &QTimer::timeout, this, [this]() {

m_tuneGuideVisible = false;

markOverlayDirty();

});

// SQL threshold line auto-hide (manual SQL only — see setSquelchLine).

// Shows for 3 s on enable or slider movement; slider re-adjust resets it.

// Auto SQL pins the line at the tracked level so the timer is skipped.

m_squelchLineHideTimer = new QTimer(this);

m_squelchLineHideTimer->setSingleShot(true);

m_squelchLineHideTimer->setInterval(3000);

connect(m_squelchLineHideTimer, &QTimer::timeout, this, [this]() {

if (m_kiwiSdrWaterfallActive && m_kiwiSdrSquelchLineVisible) {

m_kiwiSdrSquelchLineVisible = false;

} else {

m_flexSquelchLineVisible = false;

}

markOverlayDirty();

});

m_connectionAnimationTimer = new QTimer(this);

m_connectionAnimationTimer->setInterval(40);

connect(m_connectionAnimationTimer, &QTimer::timeout, this, [this]() {

if (m_connectionAnimationVisible)

markOverlayDirty();

});

m_fpsMeterTimer = new QTimer(this);

m_fpsMeterTimer->setInterval(1000);

connect(m_fpsMeterTimer, &QTimer::timeout, this, [this]() {

updateFpsMeterValues();

});

createFpsMeterLabels();

// Continuous edge auto-pan while dragging a slice (user-reported). While the

// cursor sits in the edge zone this timer drives a real pan velocity (see

// edgePanVelocityStep) so the band keeps scrolling without further

// mouse-move events. Velocity knobs are env-tunable so the feel can be

// swept without rebuilding; AETHER_NO_DRAG_EDGEPAN=1 disables the whole

// thing (restores the legacy reveal-only behaviour for A/B testing).

m_vfoDragEdgePanDisabled = qEnvironmentVariableIntValue("AETHER_NO_DRAG_EDGEPAN") != 0;

if (int v = qEnvironmentVariableIntValue("AETHER_DRAG_EDGEPAN_VMAX"); v > 0) {

m_edgePanVmaxPctBw = v;

}

if (int v = qEnvironmentVariableIntValue("AETHER_DRAG_EDGEPAN_RAMP"); v > 0) {

m_edgePanRampMs = v;

}

if (int v = qEnvironmentVariableIntValue("AETHER_DRAG_EDGEPAN_INTERVAL"); v > 0) {

m_edgePanIntervalMs = v;

}

m_vfoDragEdgePanTimer = new QTimer(this);

m_vfoDragEdgePanTimer->setInterval(m_edgePanIntervalMs);

connect(m_vfoDragEdgePanTimer, &QTimer::timeout, this, [this]() {

if (m_draggingVfo) {

edgePanVelocityStep();

} else {

m_vfoDragEdgePanTimer->stop();