{

return QStringLiteral(

"QLabel#statusBarCompactLabel { color: %1; font-size: 12px; background: transparent; }")

.arg(color);

{

if (!label) {

return;

}

label->setObjectName(kStatusBarCompactLabelObjectName);

AetherSDR::ThemeManager::instance().applyStyleSheet(label, statusBarCompactLabelStyle(color));

{

if (!label) {

return;

}

label->setText(text);

label->ensurePolished();

label->setMinimumWidth(label->sizeHint().width() + 2);

{

const long long hz = static_cast<long long>(std::round(mhz * 1e6));

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

.arg(static_cast<int>(hz / 1000000))

.arg(static_cast<int>((hz / 1000) % 1000), 3, 10, QChar('0'))

.arg(static_cast<int>(hz % 1000), 3, 10, QChar('0'));

{

#ifdef Q_OS_LINUX

// PipeWire/pulse-shim churns these constantly (monitor sources, per-app

// loopbacks, fallback auto-null sink, echo-cancel/combine virtuals).

// They are never useful as a PC mic or local speaker target; treating

// them as "new devices" is what re-fires the dialog in #2864.

if (id.contains(".monitor")) return true;

if (id.startsWith("pulse_input_loopback")) return true;

if (id.contains("auto_null")) return true;

if (id.contains("echo-cancel")) return true;

if (id.contains("combined")) return true;

#else

Q_UNUSED(id);

#endif

return false;

{

QList<QByteArray> ids;

ids.reserve(devices.size());

for (const QAudioDevice& device : devices) {

if (isTransientAudioDeviceId(device.id()))

continue;

ids.append(device.id());

}

return ids;

{

return std::any_of(ids.cbegin(), ids.cend(),

[&id](const QByteArray& candidate) {

return candidate == id;

});

const QList<QByteArray>& knownIds)

{

QList<QByteArray> added;

for (const QAudioDevice& device : devices) {

if (isTransientAudioDeviceId(device.id()))

continue;

if (!containsAudioDeviceId(knownIds, device.id()))

added.append(device.id());

}

return added;

const QList<QByteArray>& currentIds)

{

QList<QByteArray> removed;

for (const QByteArray& id : knownIds) {

if (!containsAudioDeviceId(currentIds, id))

removed.append(id);

}

return removed;

const QAudioDevice& target)

{

if (target.isNull())

return true;

return std::any_of(devices.cbegin(), devices.cend(),

[&target](const QAudioDevice& device) {

return device.id() == target.id();

});

{

if (lhs.isNull() && rhs.isNull())

return true;

if (lhs.isNull() || rhs.isNull())

return false;

return lhs.id() == rhs.id();

{

return AppSettings::instance()

.value("FramelessWindow", "True").toString() == "True";

{

const UINT dpi = GetDpiForWindow(hwnd);

return GetSystemMetricsForDpi(SM_CXSIZEFRAME, dpi)

+ GetSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi);

const SliceModel* other)

{

if (!slice || !other || slice == other

|| !slice->diversity() || !other->diversity()) {

return false;

}

const bool parentChildPair =

(slice->isDiversityParent() && other->isDiversityChild())

|| (slice->isDiversityChild() && other->isDiversityParent());

if (parentChildPair) {

return true;

}

return !slice->panId().isEmpty() && slice->panId() == other->panId();

QList<quint32>* disconnectHandles)

{

if (disconnectHandles)

disconnectHandles->clear();

const auto clients = buildDisconnectClients(info);

// When multiFLEX is disabled, any connected client blocks us — show the

// Connected Stations dialog so the user can disconnect them first.

if (!info.multiFlexEnabled && !clients.isEmpty()) {

ConnectedStationsDialog::RadioMeta meta;

meta.model = info.model;

meta.nickname = info.nickname;

meta.callsign = info.callsign;

QList<ConnectedStationsDialog::Client> sdClients;

for (const auto& c : clients) {

ConnectedStationsDialog::Client sc;

sc.handle = c.handle;

sc.program = c.program;

sc.station = c.station;

sdClients.append(sc);

}

ConnectedStationsDialog dialog(meta, sdClients, this);

if (dialog.exec() != QDialog::Accepted)

return false;

const quint32 handle = dialog.selectedHandle();

if (handle == 0)

return false;

if (disconnectHandles)

*disconnectHandles = {handle};

return true;

}

const int maxSlices = RadioModel::maxSlicesForModel(info.model);

if (clients.isEmpty() || clients.size() < maxSlices)

return true;

ClientDisconnectDialog dialog(clients, maxSlices, this);

if (dialog.exec() != QDialog::Accepted)

return false;

if (disconnectHandles)

*disconnectHandles = dialog.selectedHandles();

return !dialog.selectedHandles().isEmpty();

QList<quint32>* disconnectHandles)

{

if (disconnectHandles)

disconnectHandles->clear();

const auto clients = buildDisconnectClients(info);

// licensedClients == 1 means the radio's multiFLEX license allows only one

// simultaneous client — effectively mf_enable=0 from the SmartLink perspective.

// WanRadioInfo defaults to 1 when licensed_clients is absent from the SmartLink

// response (older firmware, partial parse), so this gate is fail-safe: it blocks

// rather than allows. Log when we hit the default so field reports are diagnosable.

if (info.licensedClients <= 1 && !clients.isEmpty()) {

if (info.licensedClients == 1)

qCWarning(lcGui) << "MainWindow: WAN licensedClients=1 (may be default) — "

"showing conflict dialog as a precaution";

ConnectedStationsDialog::RadioMeta meta;

meta.model = info.model;

meta.nickname = info.nickname;

meta.callsign = info.callsign;

QList<ConnectedStationsDialog::Client> sdClients;

for (const auto& c : clients) {

ConnectedStationsDialog::Client sc;

sc.handle = c.handle;

sc.program = c.program;

sc.station = c.station;

sdClients.append(sc);

}

ConnectedStationsDialog dialog(meta, sdClients, this);

if (dialog.exec() != QDialog::Accepted)

return false;

const quint32 handle = dialog.selectedHandle();

if (handle == 0)

return false;

if (disconnectHandles)

*disconnectHandles = {handle};

return true;

}

const int maxSlices = RadioModel::maxSlicesForModel(info.model);

if (clients.isEmpty() || clients.size() < maxSlices)

return true;

ClientDisconnectDialog dialog(clients, maxSlices, this);

if (dialog.exec() != QDialog::Accepted)

return false;

if (disconnectHandles)

*disconnectHandles = dialog.selectedHandles();

return !dialog.selectedHandles().isEmpty();

const QList<quint32>& handles)

{

if (!m_smartLink.isConnected()) {

m_connPanel->setStatusText("SmartLink is not connected");

statusBar()->showMessage("SmartLink is not connected.", 4000);

return false;

}

if (serial.trimmed().isEmpty()) {

m_connPanel->setStatusText("SmartLink radio serial unavailable");

return false;

}

if (handles.isEmpty()) {

m_connPanel->setStatusText("No remote clients to disconnect");

return false;

}

m_smartLink.disconnectRadioClients(serial, handles);

return true;

{

const auto clients = buildDisconnectClients(info);

if (clients.isEmpty()) {

m_connPanel->setStatusText("No remote clients to disconnect");

statusBar()->showMessage("No remote clients are currently reported for that radio.", 4000);

return;

}

ClientDisconnectDialog dialog(clients,

RadioModel::maxSlicesForModel(info.model),

this,

ClientDisconnectDialog::Mode::RemoteClientDisconnect);

if (dialog.exec() != QDialog::Accepted)

return;

const QList<quint32> handles = dialog.selectedHandles();

if (handles.isEmpty())

return;

if (sendWanRadioClientDisconnects(info.serial, handles)) {

m_connPanel->setStatusText("Disconnect request sent");

statusBar()->showMessage("Remote client disconnect request sent through SmartLink.", 4000);

}

{

MultiFlexDialog dlg(&m_radioModel, this);

connect(&dlg, &MultiFlexDialog::disconnectClientRequested,

this, &MainWindow::handleMultiFlexClientDisconnect);

dlg.exec();

{

if (handle == 0 || handle == m_radioModel.ourClientHandle())

return;

QString name = cleanClientDisplayText(displayName);

if (name.isEmpty())

name = QString("client 0x%1").arg(handle, 8, 16, QChar('0')).toUpper();

if (m_radioModel.isWan()) {

const QString serial = !m_pendingWanRadio.serial.isEmpty()

? m_pendingWanRadio.serial

: m_radioModel.serial();

if (sendWanRadioClientDisconnects(serial, {handle})) {

m_connPanel->setStatusText("Disconnect request sent");

statusBar()->showMessage(

QString("SmartLink disconnect request sent for %1.").arg(name), 4000);

}

return;

}

if (m_radioModel.disconnectClient(handle))

statusBar()->showMessage(QString("Disconnect request sent for %1.").arg(name), 4000);

{

QList<quint32> disconnectHandles;

if (promptForClientSlots && !confirmClientSlotAvailability(info, &disconnectHandles)) {

m_connPanel->setStatusText("Connection canceled");

setPanadapterConnectionAnimation(false);

return;

}

m_userDisconnected = false;

m_radioModel.setKnownGuiClients(splitClientField(info.guiClientHandles),

splitClientField(info.guiClientPrograms),

splitClientField(info.guiClientStations),

splitClientField(info.guiClientIps),

splitClientField(info.guiClientHosts));

m_radioModel.setPendingClientDisconnects(disconnectHandles);

m_connPanel->setStatusText("Requesting SmartLink connection…");

setPanadapterConnectionAnimation(true, "Connecting to remote radio…");

// Store WAN radio info for when connect_ready arrives

m_pendingWanRadio = info;

// Pre-bind UDP socket for VITA-49 reception BEFORE requesting

// connection, so we can pass our port to the SmartLink server.

// The server tells the radio our public IP:port for UDP streaming.

quint16 udpPort = m_radioModel.panStream()->localPort();

if (udpPort == 0) {

// Not yet bound — start WAN early to get a port

const quint16 radioUdpPort = static_cast<quint16>(

info.publicUdpPort > 0 ? info.publicUdpPort : 4993);

auto* ps = m_radioModel.panStream();

QMetaObject::invokeMethod(ps, [ps, info, radioUdpPort]() {

ps->startWan(QHostAddress(info.publicIp), radioUdpPort);

}, Qt::BlockingQueuedConnection);

udpPort = ps->localPort();

}

qDebug() << "MainWindow: pre-bound UDP port" << udpPort << "for WAN hole punch";

auto requestSmartLinkConnect = [this, serial = info.serial, udpPort] {

if (serial != m_pendingWanRadio.serial)

return;

m_smartLink.requestConnect(serial, udpPort);

};

if (!disconnectHandles.isEmpty()) {

sendWanRadioClientDisconnects(info.serial, disconnectHandles);

QTimer::singleShot(350, this, requestSmartLinkConnect);

} else {

requestSmartLinkConnect();

}

{

if (m_userDisconnected || m_radioModel.isConnected()

|| m_pendingWanRadio.serial.isEmpty()) {

m_wanReconnectTimer.stop();

m_wanReconnectAttemptInProgress = false;

return;

}

if (m_wanReconnectAttemptInProgress) {

m_wanReconnectTimer.start();

return;

}

m_connPanel->setStatusText("Reconnecting via SmartLink…");

setPanadapterConnectionAnimation(true, "Reconnecting to remote radio…");

m_wanReconnectAttemptInProgress = true;

if (!m_smartLink.isConnected()) {

m_smartLink.reconnect();

m_wanReconnectTimer.start();

return;

}

startWanRadioConnect(m_pendingWanRadio, false);

m_wanReconnectTimer.start();

const RadioInfo& radioInfo,

const WanRadioInfo& wanInfo)

{

if (m_reconnectDlg) {

QDialog* reconnectDialog = m_reconnectDlg;

m_reconnectDlg = nullptr;

reconnectDialog->close();

reconnectDialog->deleteLater();

}

auto* dialog = new QDialog(this);

m_reconnectDlg = dialog;

dialog->setWindowTitle(tr("Radio Disconnected"));

dialog->setModal(true);

dialog->setWindowModality(Qt::ApplicationModal);

dialog->setWindowFlags(dialog->windowFlags() & ~Qt::WindowContextHelpButtonHint);

dialog->setFixedWidth(460);

AetherSDR::ThemeManager::instance().applyStyleSheet(dialog, "QDialog { background: {{color.background.0}}; }"

"QFrame#forcedDisconnectHeader {"

" background: qlineargradient(x1:0, y1:0, x2:1, y2:0,"

" stop:0 #103626, stop:1 #10283a);"

" border-bottom: 1px solid {{color.accent}};"

"}"

"QLabel { color: {{color.text.primary}}; background: transparent; }"

"QLabel#eyebrow { color: #40ff80; background: transparent; font-weight: bold; }"

"QLabel#title { color: {{color.text.primary}}; background: transparent; font-size: 18px; font-weight: bold; }"

"QLabel#body { color: {{color.text.primary}}; background: transparent; }"

"QPushButton {"

" background: {{color.background.1}};"

" border: 1px solid {{color.background.2}};"

" border-radius: 3px;"

" color: {{color.text.primary}};"

" padding: 7px 16px;"

"}"

"QPushButton:hover { background: {{color.background.1}}; border-color: {{color.accent}}; }"

"QPushButton#primaryButton {"

" background: {{color.accent}};"

" border-color: {{color.accent.bright}};"

" color: {{color.background.0}};"

" font-weight: bold;"

"}"

"QPushButton#primaryButton:hover { background: {{color.accent.bright}}; }");

auto* outer = new QVBoxLayout(dialog);

outer->setContentsMargins(0, 0, 0, 0);

outer->setSpacing(0);

auto* header = new QFrame(dialog);

header->setObjectName("forcedDisconnectHeader");

auto* headerLayout = new QVBoxLayout(header);

headerLayout->setContentsMargins(18, 14, 18, 14);

headerLayout->setSpacing(4);

auto* eyebrow = new QLabel(tr("CONNECTION ENDED"), header);

eyebrow->setObjectName("eyebrow");

headerLayout->addWidget(eyebrow);

auto* title = new QLabel(tr("Disconnected by another client"), header);

title->setObjectName("title");

headerLayout->addWidget(title);

outer->addWidget(header);

auto* content = new QWidget(dialog);

auto* layout = new QVBoxLayout(content);

layout->setContentsMargins(18, 16, 18, 18);

layout->setSpacing(14);

auto* body = new QLabel(

tr("Another client requested this AetherSDR session to disconnect. "

"Automatic reconnect has been paused so the other operator can use the radio safely."),

content);

body->setObjectName("body");

body->setWordWrap(true);

layout->addWidget(body);

auto* buttons = new QHBoxLayout;

buttons->setSpacing(10);

auto* quit = new QPushButton(tr("Quit"), content);

quit->setCursor(Qt::PointingHandCursor);

quit->setMinimumHeight(34);

buttons->addWidget(quit);

auto* reconnect = new QPushButton(tr("Reconnect"), content);

reconnect->setObjectName("primaryButton");

reconnect->setCursor(Qt::PointingHandCursor);

reconnect->setMinimumHeight(34);

buttons->addWidget(reconnect);

layout->addLayout(buttons);

outer->addWidget(content);

connect(dialog, &QObject::destroyed, this, [this, dialog] {

if (m_reconnectDlg == dialog)

m_reconnectDlg = nullptr;

});

connect(quit, &QPushButton::clicked, this, [this, dialog] {

m_userDisconnected = true;

if (m_reconnectDlg == dialog)

m_reconnectDlg = nullptr;

dialog->close();

dialog->deleteLater();

QApplication::quit();

});

connect(reconnect, &QPushButton::clicked, this, [this, dialog, wasWan, radioInfo, wanInfo] {

if (m_reconnectDlg == dialog)

m_reconnectDlg = nullptr;

dialog->close();

dialog->deleteLater();

m_userDisconnected = false;

m_connPanel->setStatusText("Reconnecting…");

setPanadapterConnectionAnimation(true, "Reconnecting to radio…");

QTimer::singleShot(300, this, [this, wasWan, radioInfo, wanInfo] {

if (wasWan && !wanInfo.serial.isEmpty()) {

startWanRadioConnect(wanInfo);

return;

}

if (radioInfo.address.isNull()) {

setPanadapterConnectionAnimation(false);

m_connPanel->setStatusText("Select a radio to reconnect");

m_connPanel->show();

return;

}

QList<quint32> disconnectHandles;

if (!confirmClientSlotAvailability(radioInfo, &disconnectHandles)) {

m_userDisconnected = true;

m_connPanel->setStatusText("Connection canceled");

setPanadapterConnectionAnimation(false);

return;

}

m_radioModel.setPendingClientDisconnects(disconnectHandles);

m_radioModel.connectToRadio(radioInfo);

});

});

dialog->adjustSize();

if (QScreen* screen = windowHandle() ? windowHandle()->screen() : QApplication::primaryScreen()) {

const QRect area = screen->availableGeometry();

dialog->move(area.center() - dialog->rect().center());

}

dialog->show();

dialog->raise();

dialog->activateWindow();

{

std::vector<std::unique_ptr<RadioSession>> sessions;

sessions.push_back(std::make_unique<RadioSession>());

sessions.front()->setSessionId(0);

return sessions;

: QMainWindow(parent)

, m_sessions(makeInitialSessions())

, m_session(m_sessions.front().get())

, m_radioModel(m_session->radioModel())

{

// Status bar is the only top-level shell besides the spectrum / applet

// rail / titlebar that the operator can directly retheme. Declare its

// container here — statusBar() lazy-creates the QStatusBar on first

// call, so this is also the construction point.

theme::setContainer(statusBar(), QStringLiteral("statusbar"));

setWindowTitle(QString("AetherSDR v%1").arg(QCoreApplication::applicationVersion()));

setWindowIcon(QIcon(":/icon.png"));

setMinimumSize(1024, 400);

resize(1400, 800);

// Apply frameless flag before first show() so the window is created

// without chrome from the start — avoids the flash + re-create that

// setWindowFlags() after show would cause (#framleess via View menu).

// Default ON: TitleBar provides drag, double-click-maximize, and the

// min/max/close trio at the far right. View → Frameless Window can

// still toggle it off as an escape hatch.

{

auto& s = AppSettings::instance();

// One-shot migration: existing installs have FramelessWindow=False

// saved from when frameless was opt-in. Force ON for the

// transition so users see the new chrome by default; the View

// menu toggle still lets them flip it off afterwards.

if (!s.contains("FramelessMigratedV0823")) {

s.setValue("FramelessWindow", "True");

s.setValue("FramelessMigratedV0823", "True");

s.save();

}

if (s.value("FramelessWindow", "True").toString() == "True") {

#ifndef Q_OS_WIN

setWindowFlags(windowFlags() | Qt::FramelessWindowHint);

#endif

}

// Theming layer-0 backdrop (Phase 5 PR 3 — "fade to desktop"

// experiment). Disabling the default opaque window background

// lets MainWindow::paintEvent() honour color.background.app's

// alpha. Today's installs see no visual change because the

// bundled themes ship the token fully opaque (#0f0f1a / #f5f5f8) —

// the architectural hook just lets operators dial alpha down

// through the Theme Editor to A/B test which applets/docks still

// need their own opaque backgrounds.

setAttribute(Qt::WA_TranslucentBackground, true);

setAutoFillBackground(false);

connect(&ThemeManager::instance(), &ThemeManager::themeChanged,

this, qOverload<>(&QWidget::update));

// 8-axis edge resize for frameless mode — same install pattern

// as the floating dialogs (SpotHub, RadioSetup, MemoryDialog).

// Filter sits on the native QWindow so it doesn't compete with

// the TitleBar's drag-to-move handler (the 6 px resize margin

// is well clear of the 18+ px title-bar height). Stays

// installed across frameless toggles — when the system frame is

// back on, the platform owns resize and our filter no-ops.

FramelessResizer::install(this);

// One-shot migration: collapse the legacy "CwDecodeOverlay" flat

// key into the nested AppSettings["CwDecoder"] blob (#2417). The

// legacy key only encoded RX-side decode; the new blob also holds

// the independent TX-side toggle.

CwDecodeSettings::migrateLegacy();

// One-shot migration: remove persisted per-slice audio mute state.

// The radio does not persist audio_mute, so restoring it from

// AppSettings caused Slice A to start muted on every reconnect.

if (!s.contains("SliceAudioMutedMigratedV0999")) {

// Cover A-H for FLEX-6700/M owners — the now-removed setter

// computed QChar('A' + sliceId) for sliceId 0..7, so 8-slice

// radios could have left up to eight orphan keys behind.

for (const QChar letter : {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'})

s.remove(QString("SliceAudioMuted_%1").arg(letter));

s.setValue("SliceAudioMutedMigratedV0999", "True");

s.save();

}

}

applyDarkTheme();

m_perfHeartbeatTimer.setInterval(50);

connect(&m_perfHeartbeatTimer, &QTimer::timeout, this, [] {

PerfTelemetry::instance().recordUiHeartbeat();

});

m_perfHeartbeatTimer.start();

// Audio worker thread (#502) — AudioEngine runs on its own thread so

// audio processing never competes with paintEvent for main thread CPU.

m_audioThread = new QThread(this);

// Lean render mode (#3283): read persisted state early so panadapters

// created during startup seed their Lean button/widget correctly, then

// apply once after construction to cover VFOs + the WAVE applet.

// Persistence is the nested "Display" blob (Principle V); the legacy

// flat "LeanMode" key is migrated into it on first read.

DisplaySettings::migrateLegacy();

m_leanMode = DisplaySettings::leanMode();