400 lines
21 KiB
C++
400 lines
21 KiB
C++
#include <QCoreApplication>
|
||
#include "radiosettingspage.h"
|
||
#include "ptt_hotkey_manager.h"
|
||
#include "radio_audio_engine.h"
|
||
#include "../db/db_manager.h"
|
||
#include "../../lib/debug_config.h"
|
||
|
||
#include <QApplication>
|
||
#include <QVBoxLayout>
|
||
#include <QHBoxLayout>
|
||
#include <QLabel>
|
||
#include <QPushButton>
|
||
#include <QHideEvent>
|
||
#include <QShowEvent>
|
||
#include <QFormLayout>
|
||
#include <QSpinBox>
|
||
#include <QCheckBox>
|
||
#include <QButtonGroup>
|
||
#include <QPainter>
|
||
#include <algorithm>
|
||
#include <QKeyEvent>
|
||
#ifdef Q_OS_WIN
|
||
#include <qt_windows.h>
|
||
#endif
|
||
|
||
/* Шкала показывает именно RMS детектора; отметки соответствуют редактируемым порогам. */
|
||
class RadioLevelMeter : public QWidget {
|
||
public:
|
||
explicit RadioLevelMeter(QWidget* parent) : QWidget(parent) { setMinimumSize(200, 34); }
|
||
float level = -120;
|
||
int on = -35, off = -45;
|
||
bool valid = false, vad = false;
|
||
protected:
|
||
void paintEvent(QPaintEvent*) override {
|
||
QPainter painter(this);
|
||
QRect bar(1, 1, width() - 2, 16);
|
||
painter.fillRect(bar, palette().color(QPalette::Mid));
|
||
auto x = [&](float value) { return bar.left() + int(std::clamp(vad ? value / 100 : (value + 90) / 90, 0.0f, 1.0f) * bar.width()); };
|
||
if (valid) painter.fillRect(QRect(bar.left(), bar.top(), x(level) - bar.left(), bar.height()), QColor("#27ae60"));
|
||
painter.setPen(palette().color(QPalette::Text));
|
||
painter.drawText(QRect(0, 18, width(), 16), Qt::AlignLeft, vad ? QStringLiteral("0%") : QStringLiteral("−90 dBFS"));
|
||
painter.drawText(QRect(0, 18, width(), 16), Qt::AlignRight, vad ? QStringLiteral("100%") : QStringLiteral("0"));
|
||
for (int threshold : {off, on}) {
|
||
if (vad && threshold == off) continue;
|
||
painter.setPen(QPen(threshold == on ? QColor("#e67e22") : QColor("#3390ec"), 2));
|
||
painter.drawLine(x(threshold), 0, x(threshold), 18);
|
||
}
|
||
}
|
||
};
|
||
|
||
RadioActivationSettings::RadioActivationSettings(bool compact, QWidget* parent) : QWidget(parent), m_compact(compact) {
|
||
auto* form = new QFormLayout(this);
|
||
form->setContentsMargins(0, 0, 0, 8);
|
||
form->setRowWrapPolicy(QFormLayout::WrapLongRows);
|
||
form->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
|
||
auto add = [&](const QString& label, const char* name, int min, int max, const QString& suffix) {
|
||
auto* spin = new QSpinBox(this);
|
||
spin->setObjectName(QLatin1String(name)); spin->setRange(min, max); spin->setSuffix(suffix);
|
||
auto* text = new QLabel(label, this); text->setWordWrap(true);
|
||
form->addRow(text, spin);
|
||
connect(spin, QOverload<int>::of(&QSpinBox::valueChanged), this, &RadioActivationSettings::updateControls);
|
||
return spin;
|
||
};
|
||
auto label = [&](const char* name) {
|
||
auto* text = new QLabel(this); text->setObjectName(QLatin1String(name)); text->setWordWrap(true);
|
||
form->addRow(text); return text;
|
||
};
|
||
auto* modes = new QWidget(this);
|
||
auto* row = new QHBoxLayout(modes); row->setContentsMargins(0, 0, 0, 0); row->setSpacing(0);
|
||
m_mode = new QButtonGroup(this);
|
||
for (int mode : {1, 2}) {
|
||
auto* button = new QPushButton(mode == 1 ? QStringLiteral("VAD") : QCoreApplication::translate("ChatGui", "By signal level"), modes);
|
||
button->setObjectName(mode == 1 ? QStringLiteral("radioModeVad") : QStringLiteral("radioModeLevel"));
|
||
button->setCheckable(true); button->setMinimumHeight(36);
|
||
button->setStyleSheet("QPushButton:checked { background: #3390EC; color: white; }");
|
||
m_mode->addButton(button, mode); row->addWidget(button, 1);
|
||
connect(button, &QPushButton::clicked, this, [this, mode]() {
|
||
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "Radio settings: select mode=%d compact=%d (pending Apply)", mode, m_compact);
|
||
updateControls();
|
||
});
|
||
}
|
||
m_mode->button(1)->setChecked(true);
|
||
form->addRow(QCoreApplication::translate("ChatGui", "Automatic transmission:"), modes);
|
||
m_levelText = label("radioLevelText");
|
||
m_levelMeter = new RadioLevelMeter(this); m_levelMeter->setObjectName(QStringLiteral("radioLevelMeter"));
|
||
form->addRow(m_levelMeter);
|
||
m_levelOn = add(QCoreApplication::translate("ChatGui", "Start threshold (orange):"), "radioLevelOn", -90, 0, QStringLiteral(" dBFS"));
|
||
m_levelOff = add(QCoreApplication::translate("ChatGui", "Stop threshold (blue):"), "radioLevelOff", -90, 0, QStringLiteral(" dBFS"));
|
||
m_vadText = label("radioVadText");
|
||
m_vadMeter = new RadioLevelMeter(this); m_vadMeter->vad = true; m_vadMeter->setObjectName(QStringLiteral("radioVadMeter"));
|
||
form->addRow(m_vadMeter);
|
||
m_threshold = add(QCoreApplication::translate("ChatGui", "VAD speech threshold:"), "radioVadThreshold", 10, 95, QStringLiteral(" %"));
|
||
m_threshold->setToolTip(QCoreApplication::translate("ChatGui",
|
||
"Speech probability threshold: lower is more sensitive. This is not a volume threshold."));
|
||
m_gainText = label("radioVadGainText");
|
||
m_vadGain = add(QCoreApplication::translate("ChatGui", "VAD max gain:"), "radioVadGain", 1, 60, QCoreApplication::translate("ChatGui", " dB"));
|
||
m_hangover = add(QCoreApplication::translate("ChatGui", "Silence before ending transmission:"), "radioHangover", 50, 2000,
|
||
QCoreApplication::translate("ChatGui", " ms"));
|
||
if (!compact) {
|
||
m_compressor = new QCheckBox(QCoreApplication::translate("ChatGui", "Transmission and VAD compressor"), this);
|
||
form->addRow(m_compressor);
|
||
connect(m_compressor, &QCheckBox::toggled, this, &RadioActivationSettings::updateControls);
|
||
m_txGain = add(QCoreApplication::translate("ChatGui", "Transmission max gain:"), "radioTxGain", 1, 60,
|
||
QCoreApplication::translate("ChatGui", " dB"));
|
||
label("radioActivationHint")->setText(QCoreApplication::translate("ChatGui",
|
||
"Enable automatic transmission using the radio panel button. Both modes include 0.6 s of prebuffer. "
|
||
"Signal level is measured after echo cancellation, before compression. Start requires 40 ms above the start threshold; "
|
||
"transmission ends after the configured silence below the stop threshold. The VAD compressor has a separate maximum gain."));
|
||
}
|
||
m_error = label("radioActivationError"); m_error->setStyleSheet(QStringLiteral("color: #e74c3c;"));
|
||
auto* engine = RadioAudioEngine::instance();
|
||
connect(engine, &RadioAudioEngine::stateChanged, this, [this, engine]() {
|
||
setEnabled(engine->settingsReady() && !engine->settingsBusy());
|
||
if (!m_loaded && engine->settingsReady()) loadSettings();
|
||
else updateControls();
|
||
});
|
||
connect(engine, &RadioAudioEngine::inputLevelChanged, this, &RadioActivationSettings::updateMeters);
|
||
loadSettings();
|
||
}
|
||
|
||
QMap<QString, int> RadioActivationSettings::values() const {
|
||
QMap<QString, int> result{{"radio_auto_mode", m_mode->checkedId()}, {"radio_level_on_dbfs", m_levelOn->value()},
|
||
{"radio_level_off_dbfs", m_levelOff->value()}, {"radio_vad_threshold", m_threshold->value()},
|
||
{"radio_auto_hangover_ms", m_hangover->value()}, {"radio_vad_compressor_max_gain_db", m_vadGain->value()}};
|
||
if (!m_compact) {
|
||
result.insert(QStringLiteral("radio_compressor_enabled"), m_compressor->isChecked() ? 1 : 0);
|
||
result.insert(QStringLiteral("radio_compressor_max_gain_db"), m_txGain->value());
|
||
}
|
||
return result;
|
||
}
|
||
|
||
bool RadioActivationSettings::canApply() const {
|
||
auto* engine = RadioAudioEngine::instance();
|
||
if (!m_loaded || !engine->settingsReady() || engine->settingsBusy() || m_levelOff->value() >= m_levelOn->value()) return false;
|
||
const auto draft = values();
|
||
for (auto it = draft.cbegin(); it != draft.cend(); ++it) if (engine->setting(it.key()) != it.value()) return true;
|
||
return false;
|
||
}
|
||
|
||
bool RadioActivationSettings::apply() {
|
||
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "Radio settings: apply compact=%d mode=%d on=%d off=%d vad=%d gain=%d hangover=%d",
|
||
m_compact, m_mode->checkedId(), m_levelOn->value(), m_levelOff->value(), m_threshold->value(),
|
||
m_vadGain->value(), m_hangover->value());
|
||
return RadioAudioEngine::instance()->applySettings(values());
|
||
}
|
||
|
||
void RadioActivationSettings::loadSettings() {
|
||
auto* engine = RadioAudioEngine::instance();
|
||
setEnabled(engine->settingsReady() && !engine->settingsBusy());
|
||
if (!engine->settingsReady()) return;
|
||
m_loaded = false;
|
||
m_mode->button(engine->autoMode())->setChecked(true);
|
||
m_levelOn->setValue(engine->setting(QStringLiteral("radio_level_on_dbfs")));
|
||
m_levelOff->setValue(engine->setting(QStringLiteral("radio_level_off_dbfs")));
|
||
m_threshold->setValue(engine->setting(QStringLiteral("radio_vad_threshold")));
|
||
m_hangover->setValue(engine->setting(QStringLiteral("radio_auto_hangover_ms")));
|
||
m_vadGain->setValue(engine->setting(QStringLiteral("radio_vad_compressor_max_gain_db")));
|
||
if (!m_compact) {
|
||
m_compressor->setChecked(engine->setting(QStringLiteral("radio_compressor_enabled")) != 0);
|
||
m_txGain->setValue(engine->setting(QStringLiteral("radio_compressor_max_gain_db")));
|
||
}
|
||
m_loaded = true;
|
||
updateControls();
|
||
}
|
||
|
||
void RadioActivationSettings::updateControls() {
|
||
if (!m_loaded) return;
|
||
QString error = m_levelOff->value() >= m_levelOn->value()
|
||
? QCoreApplication::translate("ChatGui", "The stop threshold must be lower than the start threshold")
|
||
: RadioAudioEngine::instance()->settingsError();
|
||
m_error->setText(error); m_error->setVisible(!error.isEmpty());
|
||
m_levelMeter->on = m_levelOn->value(); m_levelMeter->off = m_levelOff->value();
|
||
m_vadMeter->on = m_threshold->value();
|
||
updateMeters();
|
||
emit changed();
|
||
}
|
||
|
||
void RadioActivationSettings::updateMeters() {
|
||
auto* engine = RadioAudioEngine::instance();
|
||
m_levelMeter->valid = engine->inputLevelValid(); m_levelMeter->level = engine->inputLevel(); m_levelMeter->update();
|
||
QString text;
|
||
if (!engine->isActive()) text = QCoreApplication::translate("ChatGui", "Enable radio to measure the microphone level");
|
||
else if (!engine->inputLevelValid()) text = QCoreApplication::translate("ChatGui", "Microphone level unavailable");
|
||
else text = QCoreApplication::translate("ChatGui", "Current level: %1 dBFS").arg(engine->inputLevel(), 0, 'f', 1);
|
||
m_levelText->setText(text); m_levelMeter->setAccessibleName(text);
|
||
m_vadMeter->valid = engine->vadValid(); m_vadMeter->level = engine->vadProbability() * 100; m_vadMeter->update();
|
||
if (engine->vadValid()) text = QCoreApplication::translate("ChatGui", "VAD speech probability: %1%").arg(engine->vadProbability() * 100, 0, 'f', 1);
|
||
else if (!engine->autoEnabled() || engine->autoMode() != 1)
|
||
text = QCoreApplication::translate("ChatGui", "Enable automatic transmission in VAD mode to see speech probability");
|
||
else if (engine->autoBlocked()) text = QCoreApplication::translate("ChatGui", "VAD measurement paused: channel busy");
|
||
else text = QCoreApplication::translate("ChatGui", "VAD speech probability unavailable");
|
||
m_vadText->setText(text); m_vadMeter->setAccessibleName(text);
|
||
if (!engine->vadValid()) text = QCoreApplication::translate("ChatGui", "Current VAD compressor gain: —");
|
||
else if (!engine->vadCompressorEnabled()) text = QCoreApplication::translate("ChatGui", "VAD compressor off (0 dB)");
|
||
else text = QCoreApplication::translate("ChatGui", "Current VAD compressor gain: %1 dB")
|
||
.arg((engine->vadGain() >= 0 ? QStringLiteral("+") : QString()) + QString::number(engine->vadGain(), 'f', 1));
|
||
m_gainText->setText(text);
|
||
}
|
||
|
||
RadioSettingsPage::RadioSettingsPage(DbManager* db, QWidget* parent) : QWidget(parent), m_db(db) {
|
||
auto* layout = new QVBoxLayout(this);
|
||
auto* title = new QLabel(QCoreApplication::translate("ChatGui", "Radio (PTT)"), this);
|
||
title->setStyleSheet("font-weight: bold; font-size: 13px;");
|
||
layout->addWidget(title);
|
||
m_activation = new RadioActivationSettings(false, this);
|
||
layout->addWidget(m_activation);
|
||
if (PttHotkeyManager::usesPortal()) {
|
||
auto* hint = new QLabel(QCoreApplication::translate("ChatGui",
|
||
"Global shortcuts work from any application. Assign a regular key with Ctrl, Shift, Alt or "
|
||
"Win in the system dialog. Changes are saved by the system immediately. Keyboard "
|
||
"transmission is disabled during setup."), this);
|
||
hint->setWordWrap(true);
|
||
layout->addWidget(hint);
|
||
auto* button = new QPushButton(QCoreApplication::translate("ChatGui", "Set PTT shortcuts…"), this);
|
||
layout->addWidget(button);
|
||
m_buttons << button;
|
||
for (int i = 0; i < 3; i++) {
|
||
auto* label = new QLabel(this);
|
||
label->setWordWrap(true); label->setTextFormat(Qt::PlainText);
|
||
layout->addWidget(label); m_labels << label;
|
||
}
|
||
m_portalStatus = new QLabel(this);
|
||
m_portalStatus->setWordWrap(true);
|
||
m_portalStatus->setTextFormat(Qt::PlainText);
|
||
m_portalStatus->setStyleSheet("color: gray; font-size: 11px;");
|
||
layout->addWidget(m_portalStatus);
|
||
connect(button, &QPushButton::clicked, this, [this]() { PttHotkeyManager::instance()->configurePortal(this); });
|
||
connect(PttHotkeyManager::instance(), &PttHotkeyManager::portalChanged, this, &RadioSettingsPage::updatePortalLabels);
|
||
updatePortalLabels();
|
||
layout->addStretch(1);
|
||
return;
|
||
}
|
||
auto* hint = new QLabel(
|
||
QCoreApplication::translate("ChatGui",
|
||
"Hold a shortcut to transmit from any application, even when ChatGUI is not focused. "
|
||
"Channel radio must be enabled. To record a shortcut, hold the desired keys together and "
|
||
"release them. Left and right Ctrl, Shift, Alt and Win are distinct. Fn is available only "
|
||
"if the keyboard reports it to the OS."), this);
|
||
hint->setWordWrap(true);
|
||
hint->setStyleSheet("color: gray; font-size: 11px;");
|
||
layout->addWidget(hint);
|
||
if (!PttHotkeyManager::isSupported()) {
|
||
auto* warn = new QLabel(QCoreApplication::translate("ChatGui",
|
||
"Global shortcuts are available on Windows and Linux/X11. Shortcut recording is "
|
||
"unavailable on this platform."), this);
|
||
warn->setWordWrap(true);
|
||
warn->setStyleSheet("color: #e74c3c; font-size: 12px;");
|
||
layout->addWidget(warn);
|
||
}
|
||
for (int i = 0; i < 3; i++) {
|
||
auto* row = new QHBoxLayout();
|
||
auto* button = new QPushButton(QCoreApplication::translate("ChatGui", "Set PTT shortcut %1").arg(i + 1), this);
|
||
button->setEnabled(PttHotkeyManager::isSupported());
|
||
auto* clear = new QPushButton(QCoreApplication::translate("ChatGui", "Clear"), this);
|
||
row->addWidget(button); row->addWidget(clear);
|
||
layout->addLayout(row);
|
||
auto* label = new QLabel(this);
|
||
label->setWordWrap(true);
|
||
label->setTextFormat(Qt::PlainText);
|
||
label->setStyleSheet("font-size: 13px; padding-bottom: 12px;");
|
||
layout->addWidget(label);
|
||
m_buttons << button; m_labels << label; m_chords << PttKeyChord();
|
||
connect(button, &QPushButton::clicked, this, [this, i]() {
|
||
if (m_captureIndex == i) finishCapture(false);
|
||
else startCapture(i);
|
||
});
|
||
connect(clear, &QPushButton::clicked, this, [this, i]() {
|
||
finishCapture(false);
|
||
m_chords[i].clear(); updateLabel(i);
|
||
});
|
||
}
|
||
connect(PttHotkeyManager::instance(), &PttHotkeyManager::keysChanged, this, [this](const PttKeyChord& held) {
|
||
if (m_captureIndex < 0) return;
|
||
if (m_capture.observe(held)) finishCapture(true);
|
||
else if (!held.isEmpty())
|
||
m_labels[m_captureIndex]->setText(PttHotkeyManager::instance()->describe(m_capture.candidate));
|
||
});
|
||
layout->addStretch(1);
|
||
loadFromDb();
|
||
}
|
||
|
||
RadioSettingsPage::~RadioSettingsPage() {
|
||
finishCapture(false);
|
||
if (m_portalStatus && isVisible()) PttHotkeyManager::instance()->inhibitPortal(false);
|
||
}
|
||
|
||
void RadioSettingsPage::startCapture(int index) {
|
||
finishCapture(false);
|
||
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "PTT: recording requested slot=%d", index + 1);
|
||
if (!PttHotkeyManager::instance()->beginCapture()) {
|
||
m_labels[index]->setText(QCoreApplication::translate("ChatGui", "Failed to start key recording. See the radio log for details."));
|
||
return;
|
||
}
|
||
m_captureIndex = index;
|
||
m_capture.candidate.clear();
|
||
m_buttons[index]->setText(QCoreApplication::translate("ChatGui", "Cancel recording"));
|
||
m_labels[index]->setText(QCoreApplication::translate("ChatGui", "Press one or more keys together…"));
|
||
qApp->installEventFilter(this);
|
||
}
|
||
|
||
void RadioSettingsPage::finishCapture(bool save) {
|
||
if (m_captureIndex < 0) return;
|
||
int index = m_captureIndex;
|
||
if (save) {
|
||
m_chords[index] = m_capture.candidate;
|
||
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "PTT: captured slot=%d chord=[%s] codes=[%s]", index + 1,
|
||
qPrintable(PttHotkeyManager::instance()->describe(m_capture.candidate)), qPrintable(pttEncodeChord(m_capture.candidate)));
|
||
} else {
|
||
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "PTT: recording cancelled slot=%d candidate=[%s]", index + 1,
|
||
qPrintable(pttEncodeChord(m_capture.candidate)));
|
||
}
|
||
m_captureIndex = -1;
|
||
qApp->removeEventFilter(this);
|
||
PttHotkeyManager::instance()->endCapture();
|
||
m_buttons[index]->setText(QCoreApplication::translate("ChatGui", "Set PTT shortcut %1").arg(index + 1));
|
||
updateLabel(index);
|
||
}
|
||
|
||
bool RadioSettingsPage::eventFilter(QObject* object, QEvent* event) {
|
||
if (m_captureIndex >= 0) {
|
||
if (event->type() == QEvent::ShortcutOverride) { event->accept(); return true; }
|
||
if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
|
||
auto* key = static_cast<QKeyEvent*>(event);
|
||
// Только ручная запись: сравниваем доставку событий окну с независимым опросом ОС.
|
||
if (!key->isAutoRepeat()) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_DEBUG, "PTT: capture window event=%s slot=%d qt=0x%x native_vk=%u scan=%u modifiers=0x%x",
|
||
event->type() == QEvent::KeyPress ? "press" : "release", m_captureIndex + 1,
|
||
unsigned(key->key()), unsigned(key->nativeVirtualKey()), unsigned(key->nativeScanCode()),
|
||
unsigned(key->nativeModifiers()));
|
||
#ifdef Q_OS_WIN
|
||
int vk = int(key->nativeVirtualKey());
|
||
if (vk > 0 && vk < 256) {
|
||
unsigned asyncState = static_cast<unsigned short>(GetAsyncKeyState(vk));
|
||
unsigned queueState = static_cast<unsigned short>(GetKeyState(vk));
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_DEBUG, "PTT: capture Windows vk=%d async=0x%04x queue=0x%04x remote_session=%d",
|
||
vk, asyncState, queueState, GetSystemMetrics(SM_REMOTESESSION));
|
||
}
|
||
#endif
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
return QWidget::eventFilter(object, event);
|
||
}
|
||
|
||
void RadioSettingsPage::showEvent(QShowEvent* event) {
|
||
if (m_portalStatus) PttHotkeyManager::instance()->inhibitPortal(true);
|
||
QWidget::showEvent(event);
|
||
}
|
||
|
||
void RadioSettingsPage::hideEvent(QHideEvent* event) {
|
||
if (m_portalStatus) PttHotkeyManager::instance()->inhibitPortal(false);
|
||
finishCapture(false);
|
||
QWidget::hideEvent(event);
|
||
}
|
||
|
||
void RadioSettingsPage::updateLabel(int index) {
|
||
m_labels[index]->setText(PttHotkeyManager::instance()->describe(m_chords[index]));
|
||
}
|
||
|
||
void RadioSettingsPage::loadFromDb() {
|
||
m_activation->loadSettings();
|
||
if (m_portalStatus) { updatePortalLabels(); return; }
|
||
finishCapture(false);
|
||
QStringList values;
|
||
if (m_db && m_db->isOpen()) values = m_db->getUiState("radio_ptt_hotkeys").split('|', Qt::KeepEmptyParts);
|
||
for (int i = 0; i < m_chords.size(); i++) {
|
||
m_chords[i] = i < values.size() ? pttDecodeChord(values[i]) : PttKeyChord();
|
||
updateLabel(i);
|
||
}
|
||
}
|
||
|
||
QStringList RadioSettingsPage::hotkeys() const {
|
||
QStringList values;
|
||
// Пустые позиции тоже сохраняем, чтобы хоткей №3 не переезжал в №1 после открытия.
|
||
for (const auto& chord : m_chords) values << pttEncodeChord(chord);
|
||
return values;
|
||
}
|
||
|
||
bool RadioSettingsPage::apply() {
|
||
if (!m_activation->apply()) return false;
|
||
if (m_portalStatus) return true;
|
||
finishCapture(false);
|
||
PttHotkeyManager::instance()->setHotkeys(hotkeys());
|
||
return true;
|
||
}
|
||
|
||
void RadioSettingsPage::updatePortalLabels() {
|
||
auto* manager = PttHotkeyManager::instance();
|
||
const auto descriptions = manager->portalDescriptions();
|
||
for (int i = 0; i < m_labels.size(); i++) {
|
||
QString text = descriptions.value(i);
|
||
m_labels[i]->setText(QCoreApplication::translate("ChatGui",
|
||
"PTT shortcut %1: %2").arg(i + 1).arg(text.isEmpty() ? QCoreApplication::translate("ChatGui",
|
||
"Not set") : text));
|
||
}
|
||
m_portalStatus->setText(manager->portalStatus());
|
||
m_buttons[0]->setEnabled(!manager->portalBusy());
|
||
}
|