VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2024-11-11 02:46:12 -05:00
Code Issues Projects Releases Wiki Activity
77665162b7
sdrangel/plugins/channelrx/freqscanner/freqscannergui.cpp
Daniele Forsi 8c3f7e3775 Remove unused includes and use more direct includes
2024-04-11 23:31:34 +02:00

1098 lines
41 KiB
C++
Raw Blame History

///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2023 Jon Beniston, M7RCE <jon@beniston.com> //
// //
// This program is free software; you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation as version 3 of the License, or //
// (at your option) any later version. //
// //
// This program is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License V3 for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
///////////////////////////////////////////////////////////////////////////////////
#include <QDebug>
#include <QAction>
#include <QClipboard>
#include <QMenu>
#include <QTableWidget>
#include <QTableWidgetItem>
#include <QComboBox>
#include "device/deviceset.h"
#include "device/deviceuiset.h"
#include "dsp/dspengine.h"
#include "dsp/dspcommands.h"
#include "ui_freqscannergui.h"
#include "gui/basicchannelsettingsdialog.h"
#include "dsp/dspengine.h"
#include "gui/tabletapandhold.h"
#include "gui/dialogpositioner.h"
#include "gui/decimaldelegate.h"
#include "gui/frequencydelegate.h"
#include "gui/int64delegate.h"
#include "gui/glspectrum.h"
#include "channel/channelwebapiutils.h"
#include "maincore.h"
#include "freqscannergui.h"
#include "freqscanneraddrangedialog.h"
#include "freqscanner.h"
FreqScannerGUI* FreqScannerGUI::create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel)
{
FreqScannerGUI* gui = new FreqScannerGUI(pluginAPI, deviceUISet, rxChannel);
return gui;
}
void FreqScannerGUI::destroy()
{
delete this;
}
void FreqScannerGUI::resetToDefaults()
{
m_settings.resetToDefaults();
displaySettings();
applyAllSettings();
}
QByteArray FreqScannerGUI::serialize() const
{
return m_settings.serialize();
}
bool FreqScannerGUI::deserialize(const QByteArray& data)
{
if(m_settings.deserialize(data))
{
displaySettings();
applyAllSettings();
return true;
}
else
{
resetToDefaults();
return false;
}
}
bool FreqScannerGUI::handleMessage(const Message& message)
{
if (FreqScanner::MsgConfigureFreqScanner::match(message))
{
qDebug("FreqScannerGUI::handleMessage: FreqScanner::MsgConfigureFreqScanner");
const FreqScanner::MsgConfigureFreqScanner& cfg = (FreqScanner::MsgConfigureFreqScanner&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
m_channelMarker.updateSettings(static_cast<const ChannelMarker*>(m_settings.m_channelMarker));
displaySettings();
blockApplySettings(false);
return true;
}
else if (DSPSignalNotification::match(message))
{
DSPSignalNotification& notif = (DSPSignalNotification&) message;
m_deviceCenterFrequency = notif.getCenterFrequency();
m_basebandSampleRate = notif.getSampleRate();
if (m_basebandSampleRate != 0)
{
ui->deltaFrequency->setValueRange(true, 8, 0, m_basebandSampleRate/2);
ui->deltaFrequencyLabel->setToolTip(tr("Range %1 %L2 Hz").arg(QChar(0xB1)).arg(m_basebandSampleRate/2));
ui->channelBandwidth->setValueRange(true, 8, 0, m_basebandSampleRate);
}
if (m_channelMarker.getBandwidth() == 0) {
m_channelMarker.setBandwidth(m_basebandSampleRate);
}
updateAbsoluteCenterFrequency();
return true;
}
else if (FreqScanner::MsgReportChannels::match(message))
{
FreqScanner::MsgReportChannels& report = (FreqScanner::MsgReportChannels&)message;
updateChannelsList(report.getChannels(), report.getRenameFrom(), report.getRenameTo());
return true;
}
else if (FreqScanner::MsgStatus::match(message))
{
FreqScanner::MsgStatus& report = (FreqScanner::MsgStatus&)message;
ui->status->setText(report.getText());
return true;
}
else if (FreqScanner::MsgReportScanning::match(message))
{
ui->status->setText("Scanning");
ui->table->clearSelection();
ui->channelPower->setText("-");
return true;
}
else if (FreqScanner::MsgScanComplete::match(message))
{
ui->startStop->setChecked(false);
return true;
}
else if (FreqScanner::MsgReportActiveFrequency::match(message))
{
FreqScanner::MsgReportActiveFrequency& report = (FreqScanner::MsgReportActiveFrequency&)message;
qint64 f = report.getCenterFrequency();
QString frequency;
QString annotation;
QList<QTableWidgetItem*> items = ui->table->findItems(QString::number(f), Qt::MatchExactly);
if (items.size() > 0)
{
ui->table->selectRow(items[0]->row());
frequency = ui->table->item(items[0]->row(), COL_FREQUENCY)->text();
annotation = ui->table->item(items[0]->row(), COL_ANNOTATION)->text();
}
FrequencyDelegate freqDelegate("Auto", 3);
QString formattedFrequency = freqDelegate.displayText(frequency, QLocale::system());
ui->status->setText(QString("Active: %1 %2").arg(formattedFrequency).arg(annotation));
return true;
}
else if (FreqScanner::MsgReportActivePower::match(message))
{
FreqScanner::MsgReportActivePower& report = (FreqScanner::MsgReportActivePower&)message;
float power = report.getPower();
ui->channelPower->setText(QString::number(power, 'f', 1));
return true;
}
else if (FreqScanner::MsgReportScanRange::match(message))
{
FreqScanner::MsgReportScanRange& report = (FreqScanner::MsgReportScanRange&)message;
m_channelMarker.setCenterFrequency(report.getCenterFrequency());
m_channelMarker.setBandwidth(report.getTotalBandwidth());
m_channelMarker.setVisible(report.getTotalBandwidth() < m_basebandSampleRate); // Hide marker if full bandwidth
return true;
}
else if (FreqScanner::MsgScanResult::match(message))
{
FreqScanner::MsgScanResult& report = (FreqScanner::MsgScanResult&)message;
QList<FreqScanner::MsgScanResult::ScanResult> results = report.getScanResults();
// Clear column
for (int i = 0; i < ui->table->rowCount(); i++)
{
QTableWidgetItem* item = ui->table->item(i, COL_POWER);
item->setText("");
item->setBackground(QBrush());
}
// Add results
for (int i = 0; i < results.size(); i++)
{
qint64 freq = results[i].m_frequency;
QList<QTableWidgetItem *> items = ui->table->findItems(QString::number(freq), Qt::MatchExactly);
for (auto item : items)
{
int row = item->row();
QTableWidgetItem* powerItem = ui->table->item(row, COL_POWER);
powerItem->setData(Qt::DisplayRole, results[i].m_power);
FreqScannerSettings::FrequencySettings *frequencySettings = m_settings.getFrequencySettings(freq);
Real threshold = m_settings.getThreshold(frequencySettings);
bool active = results[i].m_power >= threshold;
if (active)
{
powerItem->setBackground(Qt::darkGreen);
QTableWidgetItem* activeCountItem = ui->table->item(row, COL_ACTIVE_COUNT);
activeCountItem->setData(Qt::DisplayRole, activeCountItem->data(Qt::DisplayRole).toInt() + 1);
}
}
}
return true;
}
return false;
}
void FreqScannerGUI::updateChannelsCombo(QComboBox *combo, const AvailableChannelOrFeatureList& channels, const QString& channel, bool empty)
{
combo->blockSignals(true);
combo->clear();
if (empty) {
combo->addItem("");
}
for (const auto& channel : channels)
{
// Add channels in this device set, other than ourself (Don't use ChannelGUI::getDeviceSetIndex()/getIndex() as not valid when this is first called)
if ((channel.m_superIndex == m_freqScanner->getDeviceSetIndex()) && (channel.m_index != m_freqScanner->getIndexInDeviceSet())) {
combo->addItem(channel.getId());
}
}
// Channel can be created after this plugin, so select it
// if the chosen channel appears
int channelIndex = combo->findText(channel);
if (channelIndex >= 0) {
combo->setCurrentIndex(channelIndex);
} else {
combo->setCurrentIndex(-1); // return to nothing selected
}
combo->blockSignals(false);
}
void FreqScannerGUI::updateChannelsList(const AvailableChannelOrFeatureList& channels, const QStringList& renameFrom, const QStringList& renameTo)
{
m_availableChannels = channels;
// Update channel setting if it has been renamed
if (renameFrom.contains(m_settings.m_channel))
{
m_settings.m_channel = renameTo[renameFrom.indexOf(m_settings.m_channel)];
applySetting("channel");
}
bool rename = false;
for (auto& setting : m_settings.m_frequencySettings)
{
if (renameFrom.contains(setting.m_channel))
{
setting.m_channel = renameTo[renameFrom.indexOf(setting.m_channel)];
rename = true;
}
}
if (rename) {
applySetting("frequencySettings");
}
updateChannelsCombo(ui->channels, channels, m_settings.m_channel, false);
for (int row = 0; row < ui->table->rowCount(); row++)
{
QComboBox *combo = qobject_cast<QComboBox *>(ui->table->cellWidget(row, COL_CHANNEL));
updateChannelsCombo(combo, channels, m_settings.m_frequencySettings[row].m_channel, true);
}
}
void FreqScannerGUI::on_channels_currentIndexChanged(int index)
{
if (index >= 0)
{
m_settings.m_channel = ui->channels->currentText();
applySetting("channel");
}
}
void FreqScannerGUI::handleInputMessages()
{
Message* message;
while ((message = getInputMessageQueue()->pop()) != 0)
{
if (handleMessage(*message)) {
delete message;
}
}
}
void FreqScannerGUI::channelMarkerChangedByCursor()
{
}
void FreqScannerGUI::channelMarkerHighlightedByCursor()
{
setHighlighted(m_channelMarker.getHighlighted());
}
void FreqScannerGUI::on_deltaFrequency_changed(qint64 value)
{
m_settings.m_channelFrequencyOffset = value;
applySetting("channelFrequencyOffset");
}
void FreqScannerGUI::on_channelBandwidth_changed(qint64 value)
{
m_settings.m_channelBandwidth = value;
applySetting("channelBandwidth");
}
void FreqScannerGUI::on_scanTime_valueChanged(int value)
{
ui->scanTimeText->setText(QString("%1 s").arg(value / 10.0, 0, 'f', 1));
m_settings.m_scanTime = value / 10.0;
applySetting("scanTime");
}
void FreqScannerGUI::on_retransmitTime_valueChanged(int value)
{
ui->retransmitTimeText->setText(QString("%1 s").arg(value / 10.0, 0, 'f', 1));
m_settings.m_retransmitTime = value / 10.0;
applySetting("retransmitTime");
}
void FreqScannerGUI::on_tuneTime_valueChanged(int value)
{
ui->tuneTimeText->setText(QString("%1 ms").arg(value));
m_settings.m_tuneTime = value;
applySetting("tuneTime");
}
void FreqScannerGUI::on_thresh_valueChanged(int value)
{
ui->threshText->setText(QString("%1 dB").arg(value / 10.0, 0, 'f', 1));
m_settings.m_threshold = value / 10.0;
applySetting("threshold");
}
void FreqScannerGUI::on_priority_currentIndexChanged(int index)
{
m_settings.m_priority = (FreqScannerSettings::Priority)index;
applySetting("priority");
}
void FreqScannerGUI::on_measurement_currentIndexChanged(int index)
{
m_settings.m_measurement = (FreqScannerSettings::Measurement)index;
applySetting("measurement");
}
void FreqScannerGUI::on_mode_currentIndexChanged(int index)
{
m_settings.m_mode = (FreqScannerSettings::Mode)index;
applySetting("mode");
}
void FreqScannerGUI::onWidgetRolled(QWidget* widget, bool rollDown)
{
(void) widget;
(void) rollDown;
getRollupContents()->saveState(m_rollupState);
applySetting("rollupState");
}
void FreqScannerGUI::onMenuDialogCalled(const QPoint &p)
{
if (m_contextMenuType == ContextMenuChannelSettings)
{
BasicChannelSettingsDialog dialog(&m_channelMarker, this);
dialog.setUseReverseAPI(m_settings.m_useReverseAPI);
dialog.setReverseAPIAddress(m_settings.m_reverseAPIAddress);
dialog.setReverseAPIPort(m_settings.m_reverseAPIPort);
dialog.setReverseAPIDeviceIndex(m_settings.m_reverseAPIDeviceIndex);
dialog.setReverseAPIChannelIndex(m_settings.m_reverseAPIChannelIndex);
dialog.setDefaultTitle(m_displayedName);
if (m_deviceUISet->m_deviceMIMOEngine)
{
dialog.setNumberOfStreams(m_freqScanner->getNumberOfDeviceStreams());
dialog.setStreamIndex(m_settings.m_streamIndex);
}
dialog.move(p);
new DialogPositioner(&dialog, false);
dialog.exec();
m_settings.m_rgbColor = m_channelMarker.getColor().rgb();
m_settings.m_title = m_channelMarker.getTitle();
m_settings.m_useReverseAPI = dialog.useReverseAPI();
m_settings.m_reverseAPIAddress = dialog.getReverseAPIAddress();
m_settings.m_reverseAPIPort = dialog.getReverseAPIPort();
m_settings.m_reverseAPIDeviceIndex = dialog.getReverseAPIDeviceIndex();
m_settings.m_reverseAPIChannelIndex = dialog.getReverseAPIChannelIndex();
setWindowTitle(m_settings.m_title);
setTitle(m_channelMarker.getTitle());
setTitleColor(m_settings.m_rgbColor);
QList<QString> settingsKeys({
"rgbColor",
"title",
"useReverseAPI",
"reverseAPIAddress",
"reverseAPIPort",
"reverseAPIDeviceIndex",
"reverseAPIChannelIndex"
});
if (m_deviceUISet->m_deviceMIMOEngine)
{
m_settings.m_streamIndex = dialog.getSelectedStreamIndex();
m_channelMarker.clearStreamIndexes();
m_channelMarker.addStreamIndex(m_settings.m_streamIndex);
updateIndexLabel();
}
applySettings(settingsKeys);
}
resetContextMenuType();
}
FreqScannerGUI::FreqScannerGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel, QWidget* parent) :
ChannelGUI(parent),
ui(new Ui::FreqScannerGUI),
m_pluginAPI(pluginAPI),
m_deviceUISet(deviceUISet),
m_channelMarker(this),
m_deviceCenterFrequency(0),
m_doApplySettings(true)
{
setAttribute(Qt::WA_DeleteOnClose, true);
m_helpURL = "plugins/channelrx/freqscanner/readme.md";
RollupContents *rollupContents = getRollupContents();
ui->setupUi(rollupContents);
setSizePolicy(rollupContents->sizePolicy());
rollupContents->arrangeRollups();
connect(rollupContents, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool)));
connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(onMenuDialogCalled(const QPoint &)));
m_freqScanner = reinterpret_cast<FreqScanner*>(rxChannel);
m_freqScanner->setMessageQueueToGUI(getInputMessageQueue());
ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
ui->deltaFrequency->setValueRange(true, 8, 0, 9999999);
ui->channelBandwidth->setColorMapper(ColorMapper(ColorMapper::GrayGreenYellow));
ui->channelBandwidth->setValueRange(true, 8, 0, 9999999);
m_channelMarker.setColor(Qt::yellow);
m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
m_channelMarker.setTitle("Frequency Scanner");
m_channelMarker.blockSignals(false);
m_channelMarker.setVisible(true);
setTitleColor(m_channelMarker.getColor());
m_settings.setChannelMarker(&m_channelMarker);
m_settings.setRollupState(&m_rollupState);
m_deviceUISet->addChannelMarker(&m_channelMarker);
connect(&m_channelMarker, SIGNAL(changedByCursor()), this, SLOT(channelMarkerChangedByCursor()));
connect(&m_channelMarker, SIGNAL(highlightedByCursor()), this, SLOT(channelMarkerHighlightedByCursor()));
connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
// Resize the table using dummy data
resizeTable();
// Allow user to reorder columns
ui->table->horizontalHeader()->setSectionsMovable(true);
// Add context menu to allow hiding/showing of columns
m_menu = new QMenu(ui->table);
for (int i = 0; i < ui->table->horizontalHeader()->count(); i++)
{
QString text = ui->table->horizontalHeaderItem(i)->text();
m_menu->addAction(createCheckableItem(text, i, true));
}
ui->table->horizontalHeader()->setContextMenuPolicy(Qt::CustomContextMenu);
connect(ui->table->horizontalHeader(), SIGNAL(customContextMenuRequested(QPoint)), SLOT(columnSelectMenu(QPoint)));
// Get signals when columns change
connect(ui->table->horizontalHeader(), SIGNAL(sectionMoved(int, int, int)), SLOT(table_sectionMoved(int, int, int)));
connect(ui->table->horizontalHeader(), SIGNAL(sectionResized(int, int, int)), SLOT(table_sectionResized(int, int, int)));
// Context menu
ui->table->setContextMenuPolicy(Qt::CustomContextMenu);
connect(ui->table, &QTableWidget::customContextMenuRequested, this, &FreqScannerGUI::table_customContextMenuRequested);
TableTapAndHold* tableTapAndHold = new TableTapAndHold(ui->table);
connect(tableTapAndHold, &TableTapAndHold::tapAndHold, this, &FreqScannerGUI::table_customContextMenuRequested);
ui->startStop->setStyleSheet(QString("QToolButton{ background-color: blue; } QToolButton:checked{ background-color: green; }"));
displaySettings();
makeUIConnections();
applyAllSettings();
m_resizer.enableChildMouseTracking();
ui->table->setItemDelegateForColumn(COL_FREQUENCY, new FrequencyDelegate("Auto", 3));
ui->table->setItemDelegateForColumn(COL_POWER, new DecimalDelegate(1));
ui->table->setItemDelegateForColumn(COL_CHANNEL_BW, new Int64Delegate(0, 10000000));
ui->table->setItemDelegateForColumn(COL_TH, new DecimalDelegate(1, -120.0, 0.0));
ui->table->setItemDelegateForColumn(COL_SQ, new DecimalDelegate(1, -120.0, 0.0));
connect(m_deviceUISet->m_spectrum->getSpectrumView(), &GLSpectrumView::updateAnnotations, this, &FreqScannerGUI::updateAnnotations);
}
FreqScannerGUI::~FreqScannerGUI()
{
delete ui;
}
void FreqScannerGUI::blockApplySettings(bool block)
{
m_doApplySettings = !block;
}
void FreqScannerGUI::applySetting(const QString& settingsKey)
{
applySettings({settingsKey});
}
void FreqScannerGUI::applySettings(const QStringList& settingsKeys, bool force)
{
m_settingsKeys.append(settingsKeys);
if (m_doApplySettings)
{
FreqScanner::MsgConfigureFreqScanner* message = FreqScanner::MsgConfigureFreqScanner::create(m_settings, m_settingsKeys, force);
m_freqScanner->getInputMessageQueue()->push(message);
m_settingsKeys.clear();
}
}
void FreqScannerGUI::applyAllSettings()
{
applySettings(QStringList(), true);
}
void FreqScannerGUI::displaySettings()
{
m_channelMarker.blockSignals(true);
m_channelMarker.setBandwidth(m_basebandSampleRate);
m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
m_channelMarker.setTitle(m_settings.m_title);
m_channelMarker.blockSignals(false);
m_channelMarker.setColor(m_settings.m_rgbColor); // activate signal on the last setting only
setTitleColor(m_settings.m_rgbColor);
setWindowTitle(m_channelMarker.getTitle());
setTitle(m_channelMarker.getTitle());
blockApplySettings(true);
int channelIndex = ui->channels->findText(m_settings.m_channel);
if (channelIndex >= 0) {
ui->channels->setCurrentIndex(channelIndex);
}
ui->deltaFrequency->setValue(m_settings.m_channelFrequencyOffset);
ui->channelBandwidth->setValue(m_settings.m_channelBandwidth);
ui->scanTime->setValue(m_settings.m_scanTime * 10.0);
ui->scanTimeText->setText(QString("%1 s").arg(m_settings.m_scanTime, 0, 'f', 1));
ui->retransmitTime->setValue(m_settings.m_retransmitTime * 10.0);
ui->retransmitTimeText->setText(QString("%1 s").arg(m_settings.m_retransmitTime, 0, 'f', 1));
ui->tuneTime->setValue(m_settings.m_tuneTime);
ui->tuneTimeText->setText(QString("%1 ms").arg(m_settings.m_tuneTime));
ui->thresh->setValue(m_settings.m_threshold * 10.0);
ui->threshText->setText(QString("%1 dB").arg(m_settings.m_threshold, 0, 'f', 1));
ui->priority->setCurrentIndex((int)m_settings.m_priority);
ui->measurement->setCurrentIndex((int)m_settings.m_measurement);
ui->mode->setCurrentIndex((int)m_settings.m_mode);
ui->table->blockSignals(true);
ui->table->setRowCount(0);
for (int i = 0; i < m_settings.m_frequencySettings.size(); i++)
{
addRow(m_settings.m_frequencySettings[i]);
updateAnnotation(i);
}
ui->table->blockSignals(false);
// Order and size columns
QHeaderView* header = ui->table->horizontalHeader();
for (int i = 0; i < m_settings.m_columnSizes.size(); i++)
{
bool hidden = m_settings.m_columnSizes[i] == 0;
header->setSectionHidden(i, hidden);
m_menu->actions().at(i)->setChecked(!hidden);
if (m_settings.m_columnSizes[i] > 0) {
ui->table->setColumnWidth(i, m_settings.m_columnSizes[i]);
}
header->moveSection(header->visualIndex(i), m_settings.m_columnIndexes[i]);
}
updateIndexLabel();
getRollupContents()->restoreState(m_rollupState);
updateAbsoluteCenterFrequency();
blockApplySettings(false);
}
void FreqScannerGUI::leaveEvent(QEvent* event)
{
m_channelMarker.setHighlighted(false);
ChannelGUI::leaveEvent(event);
}
void FreqScannerGUI::enterEvent(EnterEventType* event)
{
m_channelMarker.setHighlighted(true);
ChannelGUI::enterEvent(event);
}
void FreqScannerGUI::on_startStop_clicked(bool checked)
{
if (checked)
{
FreqScanner::MsgStartScan* message = FreqScanner::MsgStartScan::create();
m_freqScanner->getInputMessageQueue()->push(message);
}
else
{
FreqScanner::MsgStopScan* message = FreqScanner::MsgStopScan::create();
m_freqScanner->getInputMessageQueue()->push(message);
}
}
void FreqScannerGUI::addRow(const FreqScannerSettings::FrequencySettings& frequencySettings)
{
int row = ui->table->rowCount();
ui->table->setRowCount(row + 1);
// Must create before frequency so updateAnnotation can work
QTableWidgetItem* annotationItem = new QTableWidgetItem();
annotationItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
ui->table->setItem(row, COL_ANNOTATION, annotationItem);
ui->table->setItem(row, COL_FREQUENCY, new QTableWidgetItem(QString("%1").arg(frequencySettings.m_frequency)));
QTableWidgetItem *enableItem = new QTableWidgetItem();
enableItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
enableItem->setCheckState(frequencySettings.m_enabled ? Qt::Checked : Qt::Unchecked);
ui->table->setItem(row, COL_ENABLE, enableItem);
QTableWidgetItem* powerItem = new QTableWidgetItem();
powerItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
ui->table->setItem(row, COL_POWER, powerItem);
QTableWidgetItem *activeCountItem = new QTableWidgetItem();
activeCountItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
ui->table->setItem(row, COL_ACTIVE_COUNT, activeCountItem);
activeCountItem->setData(Qt::DisplayRole, 0);
QTableWidgetItem* notesItem = new QTableWidgetItem(frequencySettings.m_notes);
ui->table->setItem(row, COL_NOTES, notesItem);
QComboBox *channelComboBox = new QComboBox();
updateChannelsCombo(channelComboBox, m_availableChannels, frequencySettings.m_channel, true);
ui->table->setCellWidget(row, COL_CHANNEL, channelComboBox);
connect(channelComboBox, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &FreqScannerGUI::on_table_channel_currentIndexChanged);
QTableWidgetItem* channelBandwidthItem = new QTableWidgetItem(frequencySettings.m_channelBandwidth);
ui->table->setItem(row, COL_CHANNEL_BW, channelBandwidthItem);
QTableWidgetItem* thresholdItem = new QTableWidgetItem(frequencySettings.m_threshold);
ui->table->setItem(row, COL_TH, thresholdItem);
QTableWidgetItem* squelchItem = new QTableWidgetItem(frequencySettings.m_squelch);
ui->table->setItem(row, COL_SQ, squelchItem);
}
void FreqScannerGUI::on_table_channel_currentIndexChanged(int index)
{
if (index >= 0)
{
QComboBox *combo = qobject_cast<QComboBox *>(sender());
QModelIndex tableIndex = ui->table->indexAt(combo->pos());
on_table_cellChanged(tableIndex.row(), tableIndex.column());
}
}
void FreqScannerGUI::on_addSingle_clicked()
{
FreqScannerSettings::FrequencySettings frequencySettings;
frequencySettings.m_frequency = 0;
frequencySettings.m_enabled = true;
addRow(frequencySettings);
}
void FreqScannerGUI::on_addRange_clicked()
{
FreqScannerAddRangeDialog dialog(m_settings.m_channelBandwidth, this);
new DialogPositioner(&dialog, false);
if (dialog.exec())
{
blockApplySettings(true);
for (const auto f : dialog.m_frequencies)
{
FreqScannerSettings::FrequencySettings frequencySettings;
frequencySettings.m_frequency = f;
frequencySettings.m_enabled = true;
addRow(frequencySettings);
}
blockApplySettings(false);
applySetting("frequencySettings");
}
}
void FreqScannerGUI::on_remove_clicked()
{
QList<QTableWidgetItem*> items = ui->table->selectedItems();
for (auto item : items)
{
int row = ui->table->row(item);
ui->table->removeRow(row);
m_settings.m_frequencySettings.removeAt(row);
}
applySetting("frequencySettings");
}
void FreqScannerGUI::on_removeInactive_clicked()
{
for (int i = ui->table->rowCount() - 1; i >= 0; i--)
{
if (ui->table->item(i, COL_ACTIVE_COUNT)->data(Qt::DisplayRole).toInt() == 0)
{
ui->table->removeRow(i);
m_settings.m_frequencySettings.removeAt(i);
}
}
applySetting("frequencySettings");
}
static QList<QTableWidgetItem*> takeRow(QTableWidget* table, int row)
{
QList<QTableWidgetItem*> rowItems;
for (int col = 0; col < table->columnCount(); col++) {
rowItems.append(table->takeItem(row, col));
}
return rowItems;
}
static void setRow(QTableWidget* table, int row, const QList<QTableWidgetItem*>& rowItems)
{
for (int col = 0; col < rowItems.size(); col++) {
table->setItem(row, col, rowItems.at(col));
}
}
void FreqScannerGUI::on_up_clicked()
{
QList<QTableWidgetItem*> items = ui->table->selectedItems();
for (auto item : items)
{
int row = ui->table->row(item);
if (row > 0)
{
QList<QTableWidgetItem*> sourceItems = takeRow(ui->table, row);
QList<QTableWidgetItem*> destItems = takeRow(ui->table, row - 1);
setRow(ui->table, row - 1, sourceItems);
setRow(ui->table, row, destItems);
ui->table->setCurrentCell(row - 1, 0);
}
}
}
void FreqScannerGUI::on_down_clicked()
{
QList<QTableWidgetItem*> items = ui->table->selectedItems();
for (auto item : items)
{
int row = ui->table->row(item);
if (row < ui->table->rowCount() - 1)
{
QList<QTableWidgetItem*> sourceItems = takeRow(ui->table, row);
QList<QTableWidgetItem*> destItems = takeRow(ui->table, row + 1);
setRow(ui->table, row + 1, sourceItems);
setRow(ui->table, row, destItems);
ui->table->setCurrentCell(row + 1, 0);
}
}
}
void FreqScannerGUI::on_clearActiveCount_clicked()
{
for (int i = 0; i < ui->table->rowCount(); i++) {
ui->table->item(i, COL_ACTIVE_COUNT)->setData(Qt::DisplayRole, 0);
}
}
void FreqScannerGUI::on_table_cellChanged(int row, int column)
{
QTableWidgetItem* item = ui->table->item(row, column);
if (item)
{
if (column == COL_FREQUENCY)
{
qint64 value = item->text().toLongLong();
while (m_settings.m_frequencySettings.size() <= row)
{
FreqScannerSettings::FrequencySettings frequencySettings;
frequencySettings.m_frequency = 0;
frequencySettings.m_enabled = true;
m_settings.m_frequencySettings.append(frequencySettings);
}
m_settings.m_frequencySettings[row].m_frequency = value;
updateAnnotation(row);
applySetting("frequencySettings");
}
else if (column == COL_ENABLE)
{
m_settings.m_frequencySettings[row].m_enabled = item->checkState() == Qt::Checked;
applySetting("frequencySettings");
}
else if (column == COL_NOTES)
{
m_settings.m_frequencySettings[row].m_notes = item->text();
applySetting("frequencySettings");
}
else if (column == COL_CHANNEL_BW)
{
m_settings.m_frequencySettings[row].m_channelBandwidth = item->text();
applySetting("frequencySettings");
}
else if (column == COL_TH)
{
m_settings.m_frequencySettings[row].m_threshold = item->text();
applySetting("frequencySettings");
}
else if (column == COL_SQ)
{
m_settings.m_frequencySettings[row].m_squelch = item->text();
applySetting("frequencySettings");
}
}
else if (column == COL_CHANNEL)
{
QComboBox *combo = qobject_cast<QComboBox *>(ui->table->cellWidget(row, COL_CHANNEL));
m_settings.m_frequencySettings[row].m_channel = combo->currentText();
qDebug() << "Setting row" << row << "to" << combo->currentText();
applySetting("frequencySettings");
}
}
void FreqScannerGUI::updateAnnotation(int row)
{
QTableWidgetItem* item = ui->table->item(row, COL_FREQUENCY);
QTableWidgetItem* annotationItem = ui->table->item(row, COL_ANNOTATION);
if (item && annotationItem)
{
qint64 frequency = item->text().toLongLong();
const QList<SpectrumAnnotationMarker>& markers = m_deviceUISet->m_spectrum->getAnnotationMarkers();
const SpectrumAnnotationMarker* closest = nullptr;
for (const auto& marker : markers)
{
qint64 start1 = marker.m_startFrequency;
qint64 stop1 = marker.m_startFrequency + marker.m_bandwidth;
qint64 start2 = frequency - m_settings.m_channelBandwidth / 2;
qint64 stop2 = frequency + m_settings.m_channelBandwidth / 2;
if ( ((start2 >= start1) && (start2 <= stop1))
|| ((stop2 >= start1) && (stop2 <= stop1))
)
{
if (marker.m_bandwidth == (unsigned)m_settings.m_channelBandwidth) {
// Exact match
annotationItem->setText(marker.m_text);
return;
}
else if (!closest)
{
closest = &marker;
}
else
{
if (marker.m_bandwidth < closest->m_bandwidth) {
closest = &marker;
}
}
}
}
if (closest) {
annotationItem->setText(closest->m_text);
}
}
}
void FreqScannerGUI::updateAnnotations()
{
for (int i = 0; i < ui->table->rowCount(); i++) {
updateAnnotation(i);
}
}
void FreqScannerGUI::setAllEnabled(bool enable)
{
for (int i = 0; i < ui->table->rowCount(); i++) {
ui->table->item(i, COL_ENABLE)->setCheckState(enable ? Qt::Checked : Qt::Unchecked);
}
}
void FreqScannerGUI::table_customContextMenuRequested(QPoint pos)
{
QTableWidgetItem* item = ui->table->itemAt(pos);
if (item)
{
int row = item->row();
QMenu* tableContextMenu = new QMenu(ui->table);
connect(tableContextMenu, &QMenu::aboutToHide, tableContextMenu, &QMenu::deleteLater);
// Copy current cell
QAction* copyAction = new QAction("Copy", tableContextMenu);
const QString text = item->text();
connect(copyAction, &QAction::triggered, this, [text]()->void {
QClipboard* clipboard = QGuiApplication::clipboard();
clipboard->setText(text);
});
tableContextMenu->addAction(copyAction);
tableContextMenu->addSeparator();
// Enable all
QAction* enableAllAction = new QAction("Enable all", tableContextMenu);
connect(enableAllAction, &QAction::triggered, this, [this]()->void {
setAllEnabled(true);
});
tableContextMenu->addAction(enableAllAction);
// Disable all
QAction* disableAllAction = new QAction("Disable all", tableContextMenu);
connect(disableAllAction, &QAction::triggered, this, [this]()->void {
setAllEnabled(false);
});
tableContextMenu->addAction(disableAllAction);
// Remove selected rows
QAction* removeAction = new QAction("Remove", tableContextMenu);
connect(removeAction, &QAction::triggered, this, [this]()->void {
on_remove_clicked();
});
tableContextMenu->addAction(removeAction);
tableContextMenu->addSeparator();
// Tune to frequency
qint64 frequency = ui->table->item(row, COL_FREQUENCY)->text().toLongLong();
FreqScannerSettings::FrequencySettings *frequencySettings = m_settings.getFrequencySettings(frequency);
QString channel = m_settings.getChannel(frequencySettings);
unsigned int scanDeviceSetIndex, scanChannelIndex;
if (MainCore::getDeviceAndChannelIndexFromId(channel, scanDeviceSetIndex, scanChannelIndex))
{
ButtonSwitch *startStop = ui->startStop;
QAction* findChannelMapAction = new QAction(QString("Tune %1 to %2").arg(channel).arg(frequency), tableContextMenu);
connect(findChannelMapAction, &QAction::triggered, this, [this, scanDeviceSetIndex, scanChannelIndex, frequency, startStop]()->void {
// Stop scanning
if (startStop->isChecked()) {
startStop->click();
}
// Mute all channels
m_freqScanner->muteAll(m_settings);
// Tune to frequency
if ((frequency - m_settings.m_channelBandwidth / 2 < m_deviceCenterFrequency - m_basebandSampleRate / 2)
|| (frequency + m_settings.m_channelBandwidth / 2 >= m_deviceCenterFrequency + m_basebandSampleRate / 2))
{
qint64 centerFrequency = frequency;
int offset = 0;
while (frequency - centerFrequency < m_settings.m_channelFrequencyOffset)
{
centerFrequency -= m_settings.m_channelBandwidth;
offset += m_settings.m_channelBandwidth;
}
if (!ChannelWebAPIUtils::setCenterFrequency(getDeviceSetIndex(), centerFrequency)) {
qWarning() << "Scanner failed to set frequency" << centerFrequency;
}
ChannelWebAPIUtils::setFrequencyOffset(scanDeviceSetIndex, scanChannelIndex, offset);
}
else
{
int offset = frequency - m_deviceCenterFrequency;
ChannelWebAPIUtils::setFrequencyOffset(scanDeviceSetIndex, scanChannelIndex, offset);
}
// Unmute channel
ChannelWebAPIUtils::setAudioMute(scanDeviceSetIndex, scanChannelIndex, false);
});
tableContextMenu->addAction(findChannelMapAction);
}
else
{
qDebug() << "Failed to parse channel" << m_settings.m_channel;
}
tableContextMenu->popup(ui->table->viewport()->mapToGlobal(pos));
}
}
// Columns in table reordered
void FreqScannerGUI::table_sectionMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex)
{
(void)oldVisualIndex;
m_settings.m_columnIndexes[logicalIndex] = newVisualIndex;
}
// Column in table resized (when hidden size is 0)
void FreqScannerGUI::table_sectionResized(int logicalIndex, int oldSize, int newSize)
{
(void)oldSize;
m_settings.m_columnSizes[logicalIndex] = newSize;
}
// Right click in ADSB table header - show column select menu
void FreqScannerGUI::columnSelectMenu(QPoint pos)
{
m_menu->popup(ui->table->horizontalHeader()->viewport()->mapToGlobal(pos));
}
// Hide/show column when menu selected
void FreqScannerGUI::columnSelectMenuChecked(bool checked)
{
(void)checked;
QAction* action = qobject_cast<QAction*>(sender());
if (action != nullptr)
{
int idx = action->data().toInt(nullptr);
ui->table->setColumnHidden(idx, !action->isChecked());
}
}
// Create column select menu item
QAction* FreqScannerGUI::createCheckableItem(QString& text, int idx, bool checked)
{
QAction* action = new QAction(text, this);
action->setCheckable(true);
action->setChecked(checked);
action->setData(QVariant(idx));
connect(action, SIGNAL(triggered()), this, SLOT(columnSelectMenuChecked()));
return action;
}
void FreqScannerGUI::resizeTable()
{
// Fill table with a row of dummy data that will size the columns nicely
int row = ui->table->rowCount();
ui->table->setRowCount(row + 1);
ui->table->setItem(row, COL_FREQUENCY, new QTableWidgetItem("800,000.5 MHz"));
ui->table->setItem(row, COL_ANNOTATION, new QTableWidgetItem("London VOLMET"));
ui->table->setItem(row, COL_ENABLE, new QTableWidgetItem("Enable"));
ui->table->setItem(row, COL_POWER, new QTableWidgetItem("-100.0"));
ui->table->setItem(row, COL_ACTIVE_COUNT, new QTableWidgetItem("10000"));
ui->table->setItem(row, COL_NOTES, new QTableWidgetItem("A channel name"));
ui->table->setItem(row, COL_CHANNEL, new QTableWidgetItem("Enter some notes"));
ui->table->setItem(row, COL_CHANNEL_BW, new QTableWidgetItem("100000000"));
ui->table->setItem(row, COL_TH, new QTableWidgetItem("-100.0"));
ui->table->setItem(row, COL_SQ, new QTableWidgetItem("-100.0"));
ui->table->resizeColumnsToContents();
ui->table->setRowCount(row);
}
void FreqScannerGUI::makeUIConnections()
{
QObject::connect(ui->channels, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &FreqScannerGUI::on_channels_currentIndexChanged);
QObject::connect(ui->deltaFrequency, &ValueDialZ::changed, this, &FreqScannerGUI::on_deltaFrequency_changed);
QObject::connect(ui->channelBandwidth, &ValueDialZ::changed, this, &FreqScannerGUI::on_channelBandwidth_changed);
QObject::connect(ui->scanTime, &QDial::valueChanged, this, &FreqScannerGUI::on_scanTime_valueChanged);
QObject::connect(ui->retransmitTime, &QDial::valueChanged, this, &FreqScannerGUI::on_retransmitTime_valueChanged);
QObject::connect(ui->tuneTime, &QDial::valueChanged, this, &FreqScannerGUI::on_tuneTime_valueChanged);
QObject::connect(ui->thresh, &QDial::valueChanged, this, &FreqScannerGUI::on_thresh_valueChanged);
QObject::connect(ui->priority, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &FreqScannerGUI::on_priority_currentIndexChanged);
QObject::connect(ui->measurement, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &FreqScannerGUI::on_measurement_currentIndexChanged);
QObject::connect(ui->mode, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &FreqScannerGUI::on_mode_currentIndexChanged);
QObject::connect(ui->startStop, &ButtonSwitch::clicked, this, &FreqScannerGUI::on_startStop_clicked);
QObject::connect(ui->table, &QTableWidget::cellChanged, this, &FreqScannerGUI::on_table_cellChanged);
QObject::connect(ui->addSingle, &QToolButton::clicked, this, &FreqScannerGUI::on_addSingle_clicked);
QObject::connect(ui->addRange, &QToolButton::clicked, this, &FreqScannerGUI::on_addRange_clicked);
QObject::connect(ui->remove, &QToolButton::clicked, this, &FreqScannerGUI::on_remove_clicked);
QObject::connect(ui->removeInactive, &QToolButton::clicked, this, &FreqScannerGUI::on_removeInactive_clicked);
QObject::connect(ui->up, &QToolButton::clicked, this, &FreqScannerGUI::on_up_clicked);
QObject::connect(ui->down, &QToolButton::clicked, this, &FreqScannerGUI::on_down_clicked);
QObject::connect(ui->clearActiveCount, &QToolButton::clicked, this, &FreqScannerGUI::on_clearActiveCount_clicked);
}
void FreqScannerGUI::updateAbsoluteCenterFrequency()
{
setStatusFrequency(m_deviceCenterFrequency + m_settings.m_inputFrequencyOffset);
}
Reference in New Issue View Git Blame Copy Permalink