VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2024-09-28 07:46:37 -04:00
Code Issues Projects Releases Wiki Activity

Create channel registration methods for the Tx part in DeviceUISet

Browse Source
This commit is contained in:
f4exb 2017-10-31 22:37:57 +01:00
parent c0afeaefa3
commit e206fc84a8
16 changed files with 1275 additions and 1140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

998
plugins/channelrx/chanalyzer/chanalyzergui.cpp
View File

@ -1,499 +1,499 @@
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2015 Edouard Griffiths, F4EXB // // Copyright (C) 2015 Edouard Griffiths, F4EXB //
// // // //
// This program is free software; you can redistribute it and/or modify // // 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 // // it under the terms of the GNU General Public License as published by //
// the Free Software Foundation as version 3 of the License, or // // the Free Software Foundation as version 3 of the License, or //
// // // //
// This program is distributed in the hope that it will be useful, // // This program is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY; without even the implied warranty of // // but WITHOUT ANY WARRANTY; without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License V3 for more details. // // GNU General Public License V3 for more details. //
// // // //
// You should have received a copy of the GNU General Public License // // You should have received a copy of the GNU General Public License //
// along with this program. If not, see <http://www.gnu.org/licenses/>. // // along with this program. If not, see <http://www.gnu.org/licenses/>. //
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
#include "chanalyzergui.h" #include "chanalyzergui.h"
#include <device/devicesourceapi.h> #include <device/devicesourceapi.h>
#include "device/deviceuiset.h" #include "device/deviceuiset.h"
#include <dsp/downchannelizer.h> #include <dsp/downchannelizer.h>
#include <QDockWidget> #include <QDockWidget>
#include <QMainWindow> #include <QMainWindow>
#include "dsp/threadedbasebandsamplesink.h" #include "dsp/threadedbasebandsamplesink.h"
#include "ui_chanalyzergui.h" #include "ui_chanalyzergui.h"
#include "dsp/spectrumscopecombovis.h" #include "dsp/spectrumscopecombovis.h"
#include "dsp/spectrumvis.h" #include "dsp/spectrumvis.h"
#include "dsp/scopevis.h" #include "dsp/scopevis.h"
#include "gui/glspectrum.h" #include "gui/glspectrum.h"
#include "gui/glscope.h" #include "gui/glscope.h"
#include "plugin/pluginapi.h" #include "plugin/pluginapi.h"
#include "util/simpleserializer.h" #include "util/simpleserializer.h"
#include "util/db.h" #include "util/db.h"
#include "gui/basicchannelsettingswidget.h" #include "gui/basicchannelsettingswidget.h"
#include "dsp/dspengine.h" #include "dsp/dspengine.h"
#include "mainwindow.h" #include "mainwindow.h"
#include "chanalyzer.h" #include "chanalyzer.h"
const QString ChannelAnalyzerGUI::m_channelID = "org.f4exb.sdrangelove.channel.chanalyzer"; const QString ChannelAnalyzerGUI::m_channelID = "org.f4exb.sdrangelove.channel.chanalyzer";
ChannelAnalyzerGUI* ChannelAnalyzerGUI::create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet) ChannelAnalyzerGUI* ChannelAnalyzerGUI::create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet)
{ {
ChannelAnalyzerGUI* gui = new ChannelAnalyzerGUI(pluginAPI, deviceUISet); ChannelAnalyzerGUI* gui = new ChannelAnalyzerGUI(pluginAPI, deviceUISet);
return gui; return gui;
} }
void ChannelAnalyzerGUI::destroy() void ChannelAnalyzerGUI::destroy()
{ {
delete this; delete this;
} }
void ChannelAnalyzerGUI::setName(const QString& name) void ChannelAnalyzerGUI::setName(const QString& name)
{ {
setObjectName(name); setObjectName(name);
} }
QString ChannelAnalyzerGUI::getName() const QString ChannelAnalyzerGUI::getName() const
{ {
return objectName(); return objectName();
} }
qint64 ChannelAnalyzerGUI::getCenterFrequency() const qint64 ChannelAnalyzerGUI::getCenterFrequency() const
{ {
return m_channelMarker.getCenterFrequency(); return m_channelMarker.getCenterFrequency();
} }
void ChannelAnalyzerGUI::setCenterFrequency(qint64 centerFrequency) void ChannelAnalyzerGUI::setCenterFrequency(qint64 centerFrequency)
{ {
m_channelMarker.setCenterFrequency(centerFrequency); m_channelMarker.setCenterFrequency(centerFrequency);
applySettings(); applySettings();
} }
void ChannelAnalyzerGUI::resetToDefaults() void ChannelAnalyzerGUI::resetToDefaults()
{ {
blockApplySettings(true); blockApplySettings(true);
ui->BW->setValue(30); ui->BW->setValue(30);
ui->deltaFrequency->setValue(0); ui->deltaFrequency->setValue(0);
ui->spanLog2->setValue(3); ui->spanLog2->setValue(3);
blockApplySettings(false); blockApplySettings(false);
applySettings(); applySettings();
} }
QByteArray ChannelAnalyzerGUI::serialize() const QByteArray ChannelAnalyzerGUI::serialize() const
{ {
SimpleSerializer s(1); SimpleSerializer s(1);
s.writeS32(1, m_channelMarker.getCenterFrequency()); s.writeS32(1, m_channelMarker.getCenterFrequency());
s.writeS32(2, ui->BW->value()); s.writeS32(2, ui->BW->value());
s.writeBlob(3, ui->spectrumGUI->serialize()); s.writeBlob(3, ui->spectrumGUI->serialize());
s.writeU32(4, m_channelMarker.getColor().rgb()); s.writeU32(4, m_channelMarker.getColor().rgb());
s.writeS32(5, ui->lowCut->value()); s.writeS32(5, ui->lowCut->value());
s.writeS32(6, ui->spanLog2->value()); s.writeS32(6, ui->spanLog2->value());
s.writeBool(7, ui->ssb->isChecked()); s.writeBool(7, ui->ssb->isChecked());
s.writeBlob(8, ui->scopeGUI->serialize()); s.writeBlob(8, ui->scopeGUI->serialize());
return s.final(); return s.final();
} }
bool ChannelAnalyzerGUI::deserialize(const QByteArray& data) bool ChannelAnalyzerGUI::deserialize(const QByteArray& data)
{ {
SimpleDeserializer d(data); SimpleDeserializer d(data);
if(!d.isValid()) if(!d.isValid())
{ {
resetToDefaults(); resetToDefaults();
return false; return false;
} }
if(d.getVersion() == 1) if(d.getVersion() == 1)
{ {
QByteArray bytetmp; QByteArray bytetmp;
quint32 u32tmp; quint32 u32tmp;
qint32 tmp, bw, lowCut; qint32 tmp, bw, lowCut;
bool tmpBool; bool tmpBool;
blockApplySettings(true); blockApplySettings(true);
m_channelMarker.blockSignals(true); m_channelMarker.blockSignals(true);
d.readS32(1, &tmp, 0); d.readS32(1, &tmp, 0);
m_channelMarker.setCenterFrequency(tmp); m_channelMarker.setCenterFrequency(tmp);
d.readS32(2, &bw, 30); d.readS32(2, &bw, 30);
ui->BW->setValue(bw); ui->BW->setValue(bw);
d.readBlob(3, &bytetmp); d.readBlob(3, &bytetmp);
ui->spectrumGUI->deserialize(bytetmp); ui->spectrumGUI->deserialize(bytetmp);
if(d.readU32(4, &u32tmp)) if(d.readU32(4, &u32tmp))
{ {
m_channelMarker.setColor(u32tmp); m_channelMarker.setColor(u32tmp);
} }
d.readS32(5, &lowCut, 3); d.readS32(5, &lowCut, 3);
ui->lowCut->setValue(lowCut); ui->lowCut->setValue(lowCut);
d.readS32(6, &tmp, 20); d.readS32(6, &tmp, 20);
ui->spanLog2->setValue(tmp); ui->spanLog2->setValue(tmp);
setNewRate(tmp); setNewRate(tmp);
d.readBool(7, &tmpBool, false); d.readBool(7, &tmpBool, false);
ui->ssb->setChecked(tmpBool); ui->ssb->setChecked(tmpBool);
d.readBlob(8, &bytetmp); d.readBlob(8, &bytetmp);
ui->scopeGUI->deserialize(bytetmp); ui->scopeGUI->deserialize(bytetmp);
blockApplySettings(false); blockApplySettings(false);
m_channelMarker.blockSignals(false); m_channelMarker.blockSignals(false);
ui->BW->setValue(bw); ui->BW->setValue(bw);
ui->lowCut->setValue(lowCut); // does applySettings(); ui->lowCut->setValue(lowCut); // does applySettings();
return true; return true;
} }
else else
{ {
resetToDefaults(); resetToDefaults();
return false; return false;
} }
} }
bool ChannelAnalyzerGUI::handleMessage(const Message& message) bool ChannelAnalyzerGUI::handleMessage(const Message& message)
{ {
if (ChannelAnalyzer::MsgReportChannelSampleRateChanged::match(message)) if (ChannelAnalyzer::MsgReportChannelSampleRateChanged::match(message))
{ {
setNewRate(m_spanLog2); setNewRate(m_spanLog2);
return true; return true;
} }
return false; return false;
} }
void ChannelAnalyzerGUI::handleInputMessages() void ChannelAnalyzerGUI::handleInputMessages()
{ {
Message* message; Message* message;
while ((message = getInputMessageQueue()->pop()) != 0) while ((message = getInputMessageQueue()->pop()) != 0)
{ {
qDebug("ChannelAnalyzerGUI::handleInputMessages: message: %s", message->getIdentifier()); qDebug("ChannelAnalyzerGUI::handleInputMessages: message: %s", message->getIdentifier());
if (handleMessage(*message)) if (handleMessage(*message))
{ {
delete message; delete message;
} }
} }
} }
void ChannelAnalyzerGUI::viewChanged() void ChannelAnalyzerGUI::viewChanged()
{ {
applySettings(); applySettings();
} }
void ChannelAnalyzerGUI::tick() void ChannelAnalyzerGUI::tick()
{ {
Real powDb = CalcDb::dbPower(m_channelAnalyzer->getMagSq()); Real powDb = CalcDb::dbPower(m_channelAnalyzer->getMagSq());
m_channelPowerDbAvg.feed(powDb); m_channelPowerDbAvg.feed(powDb);
ui->channelPower->setText(QString::number(m_channelPowerDbAvg.average(), 'f', 1)); ui->channelPower->setText(QString::number(m_channelPowerDbAvg.average(), 'f', 1));
} }
void ChannelAnalyzerGUI::on_deltaMinus_toggled(bool minus) void ChannelAnalyzerGUI::on_deltaMinus_toggled(bool minus)
{ {
int deltaFrequency = m_channelMarker.getCenterFrequency(); int deltaFrequency = m_channelMarker.getCenterFrequency();
bool minusDelta = (deltaFrequency < 0); bool minusDelta = (deltaFrequency < 0);
if (minus ^ minusDelta) // sign change if (minus ^ minusDelta) // sign change
{ {
m_channelMarker.setCenterFrequency(-deltaFrequency); m_channelMarker.setCenterFrequency(-deltaFrequency);
} }
} }
void ChannelAnalyzerGUI::on_deltaFrequency_changed(quint64 value) void ChannelAnalyzerGUI::on_deltaFrequency_changed(quint64 value)
{ {
if (ui->deltaMinus->isChecked()) { if (ui->deltaMinus->isChecked()) {
m_channelMarker.setCenterFrequency(-value); m_channelMarker.setCenterFrequency(-value);
} else { } else {
m_channelMarker.setCenterFrequency(value); m_channelMarker.setCenterFrequency(value);
} }
} }
void ChannelAnalyzerGUI::on_BW_valueChanged(int value) void ChannelAnalyzerGUI::on_BW_valueChanged(int value)
{ {
QString s = QString::number(value/10.0, 'f', 1); QString s = QString::number(value/10.0, 'f', 1);
ui->BWText->setText(tr("%1k").arg(s)); ui->BWText->setText(tr("%1k").arg(s));
m_channelMarker.setBandwidth(value * 100 * 2); m_channelMarker.setBandwidth(value * 100 * 2);
if (ui->ssb->isChecked()) if (ui->ssb->isChecked())
{ {
if (value < 0) { if (value < 0) {
m_channelMarker.setSidebands(ChannelMarker::lsb); m_channelMarker.setSidebands(ChannelMarker::lsb);
} else { } else {
m_channelMarker.setSidebands(ChannelMarker::usb); m_channelMarker.setSidebands(ChannelMarker::usb);
} }
} }
else else
{ {
m_channelMarker.setSidebands(ChannelMarker::dsb); m_channelMarker.setSidebands(ChannelMarker::dsb);
} }
on_lowCut_valueChanged(m_channelMarker.getLowCutoff()/100); on_lowCut_valueChanged(m_channelMarker.getLowCutoff()/100);
} }
int ChannelAnalyzerGUI::getEffectiveLowCutoff(int lowCutoff) int ChannelAnalyzerGUI::getEffectiveLowCutoff(int lowCutoff)
{ {
int ssbBW = m_channelMarker.getBandwidth() / 2; int ssbBW = m_channelMarker.getBandwidth() / 2;
int effectiveLowCutoff = lowCutoff; int effectiveLowCutoff = lowCutoff;
const int guard = 100; const int guard = 100;
if (ssbBW < 0) { if (ssbBW < 0) {
if (effectiveLowCutoff < ssbBW + guard) { if (effectiveLowCutoff < ssbBW + guard) {
effectiveLowCutoff = ssbBW + guard; effectiveLowCutoff = ssbBW + guard;
} }
if (effectiveLowCutoff > 0) { if (effectiveLowCutoff > 0) {
effectiveLowCutoff = 0; effectiveLowCutoff = 0;
} }
} else { } else {
if (effectiveLowCutoff > ssbBW - guard) { if (effectiveLowCutoff > ssbBW - guard) {
effectiveLowCutoff = ssbBW - guard; effectiveLowCutoff = ssbBW - guard;
} }
if (effectiveLowCutoff < 0) { if (effectiveLowCutoff < 0) {
effectiveLowCutoff = 0; effectiveLowCutoff = 0;
} }
} }
return effectiveLowCutoff; return effectiveLowCutoff;
} }
void ChannelAnalyzerGUI::on_lowCut_valueChanged(int value) void ChannelAnalyzerGUI::on_lowCut_valueChanged(int value)
{ {
int lowCutoff = getEffectiveLowCutoff(value * 100); int lowCutoff = getEffectiveLowCutoff(value * 100);
m_channelMarker.setLowCutoff(lowCutoff); m_channelMarker.setLowCutoff(lowCutoff);
QString s = QString::number(lowCutoff/1000.0, 'f', 1); QString s = QString::number(lowCutoff/1000.0, 'f', 1);
ui->lowCutText->setText(tr("%1k").arg(s)); ui->lowCutText->setText(tr("%1k").arg(s));
ui->lowCut->setValue(lowCutoff/100); ui->lowCut->setValue(lowCutoff/100);
applySettings(); applySettings();
} }
void ChannelAnalyzerGUI::on_spanLog2_valueChanged(int value) void ChannelAnalyzerGUI::on_spanLog2_valueChanged(int value)
{ {
if (setNewRate(value)) { if (setNewRate(value)) {
applySettings(); applySettings();
} }
} }
void ChannelAnalyzerGUI::on_ssb_toggled(bool checked) void ChannelAnalyzerGUI::on_ssb_toggled(bool checked)
{ {
if (checked) if (checked)
{ {
if (ui->BW->value() < 0) { if (ui->BW->value() < 0) {
m_channelMarker.setSidebands(ChannelMarker::lsb); m_channelMarker.setSidebands(ChannelMarker::lsb);
} else { } else {
m_channelMarker.setSidebands(ChannelMarker::usb); m_channelMarker.setSidebands(ChannelMarker::usb);
} }
ui->glSpectrum->setCenterFrequency(m_rate/4); ui->glSpectrum->setCenterFrequency(m_rate/4);
ui->glSpectrum->setSampleRate(m_rate/2); ui->glSpectrum->setSampleRate(m_rate/2);
ui->glSpectrum->setSsbSpectrum(true); ui->glSpectrum->setSsbSpectrum(true);
on_lowCut_valueChanged(m_channelMarker.getLowCutoff()/100); on_lowCut_valueChanged(m_channelMarker.getLowCutoff()/100);
} }
else else
{ {
m_channelMarker.setSidebands(ChannelMarker::dsb); m_channelMarker.setSidebands(ChannelMarker::dsb);
ui->glSpectrum->setCenterFrequency(0); ui->glSpectrum->setCenterFrequency(0);
ui->glSpectrum->setSampleRate(m_rate); ui->glSpectrum->setSampleRate(m_rate);
ui->glSpectrum->setSsbSpectrum(false); ui->glSpectrum->setSsbSpectrum(false);
applySettings(); applySettings();
} }
} }
void ChannelAnalyzerGUI::onWidgetRolled(QWidget* widget __attribute__((unused)), bool rollDown __attribute__((unused))) void ChannelAnalyzerGUI::onWidgetRolled(QWidget* widget __attribute__((unused)), bool rollDown __attribute__((unused)))
{ {
/* /*
if((widget == ui->spectrumContainer) && (m_ssbDemod != NULL)) if((widget == ui->spectrumContainer) && (m_ssbDemod != NULL))
m_ssbDemod->setSpectrum(m_threadedSampleSink->getMessageQueue(), rollDown); m_ssbDemod->setSpectrum(m_threadedSampleSink->getMessageQueue(), rollDown);
*/ */
} }
void ChannelAnalyzerGUI::onMenuDoubleClicked() void ChannelAnalyzerGUI::onMenuDoubleClicked()
{ {
if(!m_basicSettingsShown) { if(!m_basicSettingsShown) {
m_basicSettingsShown = true; m_basicSettingsShown = true;
BasicChannelSettingsWidget* bcsw = new BasicChannelSettingsWidget(&m_channelMarker, this); BasicChannelSettingsWidget* bcsw = new BasicChannelSettingsWidget(&m_channelMarker, this);
bcsw->show(); bcsw->show();
} }
} }
ChannelAnalyzerGUI::ChannelAnalyzerGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget* parent) : ChannelAnalyzerGUI::ChannelAnalyzerGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget* parent) :
RollupWidget(parent), RollupWidget(parent),
ui(new Ui::ChannelAnalyzerGUI), ui(new Ui::ChannelAnalyzerGUI),
m_pluginAPI(pluginAPI), m_pluginAPI(pluginAPI),
// m_deviceAPI(deviceAPI), // m_deviceAPI(deviceAPI),
m_deviceUISet(deviceUISet), m_deviceUISet(deviceUISet),
m_channelMarker(this), m_channelMarker(this),
m_basicSettingsShown(false), m_basicSettingsShown(false),
m_doApplySettings(true), m_doApplySettings(true),
m_rate(6000), m_rate(6000),
m_spanLog2(3), m_spanLog2(3),
m_channelPowerDbAvg(40,0) m_channelPowerDbAvg(40,0)
{ {
ui->setupUi(this); ui->setupUi(this);
setAttribute(Qt::WA_DeleteOnClose, true); setAttribute(Qt::WA_DeleteOnClose, true);
connect(this, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool))); connect(this, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool)));
connect(this, SIGNAL(menuDoubleClickEvent()), this, SLOT(onMenuDoubleClicked())); connect(this, SIGNAL(menuDoubleClickEvent()), this, SLOT(onMenuDoubleClicked()));
m_spectrumVis = new SpectrumVis(ui->glSpectrum); m_spectrumVis = new SpectrumVis(ui->glSpectrum);
m_scopeVis = new ScopeVis(ui->glScope); m_scopeVis = new ScopeVis(ui->glScope);
m_spectrumScopeComboVis = new SpectrumScopeComboVis(m_spectrumVis, m_scopeVis); m_spectrumScopeComboVis = new SpectrumScopeComboVis(m_spectrumVis, m_scopeVis);
m_channelAnalyzer = new ChannelAnalyzer(m_deviceUISet->m_deviceSourceAPI); m_channelAnalyzer = new ChannelAnalyzer(m_deviceUISet->m_deviceSourceAPI);
m_channelAnalyzer->setSampleSink(m_spectrumScopeComboVis); m_channelAnalyzer->setSampleSink(m_spectrumScopeComboVis);
m_channelAnalyzer->setMessageQueueToGUI(getInputMessageQueue()); m_channelAnalyzer->setMessageQueueToGUI(getInputMessageQueue());
ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::ReverseGold)); ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::ReverseGold));
ui->deltaFrequency->setValueRange(7, 0U, 9999999U); ui->deltaFrequency->setValueRange(7, 0U, 9999999U);
ui->glSpectrum->setCenterFrequency(m_rate/2); ui->glSpectrum->setCenterFrequency(m_rate/2);
ui->glSpectrum->setSampleRate(m_rate); ui->glSpectrum->setSampleRate(m_rate);
ui->glSpectrum->setDisplayWaterfall(true); ui->glSpectrum->setDisplayWaterfall(true);
ui->glSpectrum->setDisplayMaxHold(true); ui->glSpectrum->setDisplayMaxHold(true);
ui->glSpectrum->setSsbSpectrum(true); ui->glSpectrum->setSsbSpectrum(true);
ui->glSpectrum->connectTimer(MainWindow::getInstance()->getMasterTimer()); ui->glSpectrum->connectTimer(MainWindow::getInstance()->getMasterTimer());
ui->glScope->connectTimer(MainWindow::getInstance()->getMasterTimer()); ui->glScope->connectTimer(MainWindow::getInstance()->getMasterTimer());
connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
//m_channelMarker = new ChannelMarker(this); //m_channelMarker = new ChannelMarker(this);
m_channelMarker.setColor(Qt::gray); m_channelMarker.setColor(Qt::gray);
m_channelMarker.setBandwidth(m_rate); m_channelMarker.setBandwidth(m_rate);
m_channelMarker.setSidebands(ChannelMarker::usb); m_channelMarker.setSidebands(ChannelMarker::usb);
m_channelMarker.setCenterFrequency(0); m_channelMarker.setCenterFrequency(0);
m_channelMarker.setVisible(true); m_channelMarker.setVisible(true);
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(viewChanged())); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(viewChanged()));
m_deviceUISet->registerChannelInstance(m_channelID, this); m_deviceUISet->registerRxChannelInstance(m_channelID, this);
m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this); m_deviceUISet->addRollupWidget(this);
ui->spectrumGUI->setBuddies(m_spectrumVis->getInputMessageQueue(), m_spectrumVis, ui->glSpectrum); ui->spectrumGUI->setBuddies(m_spectrumVis->getInputMessageQueue(), m_spectrumVis, ui->glSpectrum);
ui->scopeGUI->setBuddies(m_scopeVis->getInputMessageQueue(), m_scopeVis, ui->glScope); ui->scopeGUI->setBuddies(m_scopeVis->getInputMessageQueue(), m_scopeVis, ui->glScope);
connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages())); connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
applySettings(); applySettings();
setNewRate(m_spanLog2); setNewRate(m_spanLog2);
} }
ChannelAnalyzerGUI::~ChannelAnalyzerGUI() ChannelAnalyzerGUI::~ChannelAnalyzerGUI()
{ {
m_deviceUISet->removeChannelInstance(this); m_deviceUISet->removeRxChannelInstance(this);
delete m_channelAnalyzer; delete m_channelAnalyzer;
delete m_spectrumVis; delete m_spectrumVis;
delete m_scopeVis; delete m_scopeVis;
delete m_spectrumScopeComboVis; delete m_spectrumScopeComboVis;
//delete m_channelMarker; //delete m_channelMarker;
delete ui; delete ui;
} }
bool ChannelAnalyzerGUI::setNewRate(int spanLog2) bool ChannelAnalyzerGUI::setNewRate(int spanLog2)
{ {
qDebug("ChannelAnalyzerGUI::setNewRate"); qDebug("ChannelAnalyzerGUI::setNewRate");
if ((spanLog2 < 0) || (spanLog2 > 6)) { if ((spanLog2 < 0) || (spanLog2 > 6)) {
return false; return false;
} }
m_spanLog2 = spanLog2; m_spanLog2 = spanLog2;
//m_rate = 48000 / (1<<spanLog2); //m_rate = 48000 / (1<<spanLog2);
m_rate = m_channelAnalyzer->getSampleRate() / (1<<spanLog2); m_rate = m_channelAnalyzer->getSampleRate() / (1<<spanLog2);
if (ui->BW->value() < -m_rate/200) { if (ui->BW->value() < -m_rate/200) {
ui->BW->setValue(-m_rate/200); ui->BW->setValue(-m_rate/200);
m_channelMarker.setBandwidth(-m_rate*2); m_channelMarker.setBandwidth(-m_rate*2);
} else if (ui->BW->value() > m_rate/200) { } else if (ui->BW->value() > m_rate/200) {
ui->BW->setValue(m_rate/200); ui->BW->setValue(m_rate/200);
m_channelMarker.setBandwidth(m_rate*2); m_channelMarker.setBandwidth(m_rate*2);
} }
if (ui->lowCut->value() < -m_rate/200) { if (ui->lowCut->value() < -m_rate/200) {
ui->lowCut->setValue(-m_rate/200); ui->lowCut->setValue(-m_rate/200);
m_channelMarker.setLowCutoff(-m_rate); m_channelMarker.setLowCutoff(-m_rate);
} else if (ui->lowCut->value() > m_rate/200) { } else if (ui->lowCut->value() > m_rate/200) {
ui->lowCut->setValue(m_rate/200); ui->lowCut->setValue(m_rate/200);
m_channelMarker.setLowCutoff(m_rate); m_channelMarker.setLowCutoff(m_rate);
} }
ui->BW->setMinimum(-m_rate/200); ui->BW->setMinimum(-m_rate/200);
ui->lowCut->setMinimum(-m_rate/200); ui->lowCut->setMinimum(-m_rate/200);
ui->BW->setMaximum(m_rate/200); ui->BW->setMaximum(m_rate/200);
ui->lowCut->setMaximum(m_rate/200); ui->lowCut->setMaximum(m_rate/200);
QString s = QString::number(m_rate/1000.0, 'f', 1); QString s = QString::number(m_rate/1000.0, 'f', 1);
ui->spanText->setText(tr("%1k").arg(s)); ui->spanText->setText(tr("%1k").arg(s));
if (ui->ssb->isChecked()) if (ui->ssb->isChecked())
{ {
if (ui->BW->value() < 0) { if (ui->BW->value() < 0) {
m_channelMarker.setSidebands(ChannelMarker::lsb); m_channelMarker.setSidebands(ChannelMarker::lsb);
} else { } else {
m_channelMarker.setSidebands(ChannelMarker::usb); m_channelMarker.setSidebands(ChannelMarker::usb);
} }
ui->glSpectrum->setCenterFrequency(m_rate/4); ui->glSpectrum->setCenterFrequency(m_rate/4);
ui->glSpectrum->setSampleRate(m_rate/2); ui->glSpectrum->setSampleRate(m_rate/2);
ui->glSpectrum->setSsbSpectrum(true); ui->glSpectrum->setSsbSpectrum(true);
} }
else else
{ {
m_channelMarker.setSidebands(ChannelMarker::dsb); m_channelMarker.setSidebands(ChannelMarker::dsb);
ui->glSpectrum->setCenterFrequency(0); ui->glSpectrum->setCenterFrequency(0);
ui->glSpectrum->setSampleRate(m_rate); ui->glSpectrum->setSampleRate(m_rate);
ui->glSpectrum->setSsbSpectrum(false); ui->glSpectrum->setSsbSpectrum(false);
} }
ui->glScope->setSampleRate(m_rate); ui->glScope->setSampleRate(m_rate);
m_scopeVis->setSampleRate(m_rate); m_scopeVis->setSampleRate(m_rate);
return true; return true;
} }
void ChannelAnalyzerGUI::blockApplySettings(bool block) void ChannelAnalyzerGUI::blockApplySettings(bool block)
{ {
ui->glScope->blockSignals(block); ui->glScope->blockSignals(block);
ui->glSpectrum->blockSignals(block); ui->glSpectrum->blockSignals(block);
m_doApplySettings = !block; m_doApplySettings = !block;
} }
void ChannelAnalyzerGUI::applySettings() void ChannelAnalyzerGUI::applySettings()
{ {
if (m_doApplySettings) if (m_doApplySettings)
{ {
setTitleColor(m_channelMarker.getColor()); setTitleColor(m_channelMarker.getColor());
ui->deltaFrequency->setValue(abs(m_channelMarker.getCenterFrequency())); ui->deltaFrequency->setValue(abs(m_channelMarker.getCenterFrequency()));
ui->deltaMinus->setChecked(m_channelMarker.getCenterFrequency() < 0); ui->deltaMinus->setChecked(m_channelMarker.getCenterFrequency() < 0);
ChannelAnalyzer::MsgConfigureChannelizer *msg = ChannelAnalyzer::MsgConfigureChannelizer::create(m_channelMarker.getCenterFrequency()); ChannelAnalyzer::MsgConfigureChannelizer *msg = ChannelAnalyzer::MsgConfigureChannelizer::create(m_channelMarker.getCenterFrequency());
m_channelAnalyzer->getInputMessageQueue()->push(msg); m_channelAnalyzer->getInputMessageQueue()->push(msg);
m_channelAnalyzer->configure(m_channelAnalyzer->getInputMessageQueue(), m_channelAnalyzer->configure(m_channelAnalyzer->getInputMessageQueue(),
ui->BW->value() * 100.0, ui->BW->value() * 100.0,
ui->lowCut->value() * 100.0, ui->lowCut->value() * 100.0,
m_spanLog2, m_spanLog2,
ui->ssb->isChecked()); ui->ssb->isChecked());
} }
} }
void ChannelAnalyzerGUI::leaveEvent(QEvent*) void ChannelAnalyzerGUI::leaveEvent(QEvent*)
{ {
blockApplySettings(true); blockApplySettings(true);
m_channelMarker.setHighlighted(false); m_channelMarker.setHighlighted(false);
blockApplySettings(false); blockApplySettings(false);
} }
void ChannelAnalyzerGUI::enterEvent(QEvent*) void ChannelAnalyzerGUI::enterEvent(QEvent*)
{ {
blockApplySettings(true); blockApplySettings(true);
m_channelMarker.setHighlighted(true); m_channelMarker.setHighlighted(true);
blockApplySettings(false); blockApplySettings(false);
} }

1166
plugins/channelrx/chanalyzerng/chanalyzernggui.cpp
View File

File diff suppressed because it is too large Load Diff

4
plugins/channelrx/demodam/amdemodgui.cpp
View File

@ -206,7 +206,7 @@ AMDemodGUI::AMDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget*
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged())); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged()));
m_deviceUISet->registerChannelInstance(m_channelID, this); m_deviceUISet->registerRxChannelInstance(m_channelID, this);
m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this); m_deviceUISet->addRollupWidget(this);
@ -216,7 +216,7 @@ AMDemodGUI::AMDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget*
AMDemodGUI::~AMDemodGUI() AMDemodGUI::~AMDemodGUI()
{ {
m_deviceUISet->removeChannelInstance(this); m_deviceUISet->removeRxChannelInstance(this);
delete m_amDemod; delete m_amDemod;
delete ui; delete ui;
} }

4
plugins/channelrx/demodatv/atvdemodgui.cpp
View File

@ -313,7 +313,7 @@ ATVDemodGUI::ATVDemodGUI(PluginAPI* objPluginAPI, DeviceUISet *deviceUISet,
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(viewChanged())); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(viewChanged()));
m_deviceUISet->registerChannelInstance(m_strChannelID, this); m_deviceUISet->registerRxChannelInstance(m_strChannelID, this);
m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this); m_deviceUISet->addRollupWidget(this);
@ -348,7 +348,7 @@ ATVDemodGUI::ATVDemodGUI(PluginAPI* objPluginAPI, DeviceUISet *deviceUISet,
ATVDemodGUI::~ATVDemodGUI() ATVDemodGUI::~ATVDemodGUI()
{ {
m_deviceUISet->removeChannelInstance(this); m_deviceUISet->removeRxChannelInstance(this);
m_deviceUISet->m_deviceSourceAPI->removeThreadedSink(m_threadedChannelizer); m_deviceUISet->m_deviceSourceAPI->removeThreadedSink(m_threadedChannelizer);
delete m_threadedChannelizer; delete m_threadedChannelizer;
delete m_channelizer; delete m_channelizer;

4
plugins/channelrx/demodbfm/bfmdemodgui.cpp
View File

@ -364,7 +364,7 @@ BFMDemodGUI::BFMDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged())); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged()));
m_deviceUISet->registerChannelInstance(m_channelID, this); m_deviceUISet->registerRxChannelInstance(m_channelID, this);
m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this); m_deviceUISet->addRollupWidget(this);
@ -383,7 +383,7 @@ BFMDemodGUI::BFMDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget
BFMDemodGUI::~BFMDemodGUI() BFMDemodGUI::~BFMDemodGUI()
{ {
m_deviceUISet->removeChannelInstance(this); m_deviceUISet->removeRxChannelInstance(this);
delete m_bfmDemod; delete m_bfmDemod;
delete ui; delete ui;
} }

4
plugins/channelrx/demoddsd/dsddemodgui.cpp
View File

@ -281,7 +281,7 @@ DSDDemodGUI::DSDDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged())); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged()));
m_deviceUISet->registerChannelInstance(m_channelID, this); m_deviceUISet->registerRxChannelInstance(m_channelID, this);
m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this); m_deviceUISet->addRollupWidget(this);
@ -298,7 +298,7 @@ DSDDemodGUI::DSDDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget
DSDDemodGUI::~DSDDemodGUI() DSDDemodGUI::~DSDDemodGUI()
{ {
m_deviceUISet->removeChannelInstance(this); m_deviceUISet->removeRxChannelInstance(this);
delete m_dsdDemod; delete m_dsdDemod;
delete ui; delete ui;
} }

4
plugins/channelrx/demodlora/lorademodgui.cpp
View File

@ -153,7 +153,7 @@ LoRaDemodGUI::LoRaDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidg
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(viewChanged())); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(viewChanged()));
m_deviceUISet->registerChannelInstance(m_channelID, this); m_deviceUISet->registerRxChannelInstance(m_channelID, this);
m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this); m_deviceUISet->addRollupWidget(this);
@ -168,7 +168,7 @@ LoRaDemodGUI::LoRaDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidg
LoRaDemodGUI::~LoRaDemodGUI() LoRaDemodGUI::~LoRaDemodGUI()
{ {
m_deviceUISet->removeChannelInstance(this); m_deviceUISet->removeRxChannelInstance(this);
delete m_LoRaDemod; delete m_LoRaDemod;
delete m_spectrumVis; delete m_spectrumVis;
delete ui; delete ui;

4
plugins/channelrx/demodnfm/nfmdemodgui.cpp
View File

@ -284,7 +284,7 @@ NFMDemodGUI::NFMDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged())); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged()));
m_deviceUISet->registerChannelInstance(m_channelID, this); m_deviceUISet->registerRxChannelInstance(m_channelID, this);
m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this); m_deviceUISet->addRollupWidget(this);
@ -299,7 +299,7 @@ NFMDemodGUI::NFMDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget
NFMDemodGUI::~NFMDemodGUI() NFMDemodGUI::~NFMDemodGUI()
{ {
m_deviceUISet->removeChannelInstance(this); m_deviceUISet->removeRxChannelInstance(this);
delete m_nfmDemod; delete m_nfmDemod;
//delete m_channelMarker; //delete m_channelMarker;
delete ui; delete ui;

4
plugins/channelrx/demodssb/ssbdemodgui.cpp
View File

@ -331,7 +331,7 @@ SSBDemodGUI::SSBDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(viewChanged())); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(viewChanged()));
m_deviceUISet->registerChannelInstance(m_channelID, this); m_deviceUISet->registerRxChannelInstance(m_channelID, this);
m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this); m_deviceUISet->addRollupWidget(this);
@ -344,7 +344,7 @@ SSBDemodGUI::SSBDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget
SSBDemodGUI::~SSBDemodGUI() SSBDemodGUI::~SSBDemodGUI()
{ {
m_deviceUISet->removeChannelInstance(this); m_deviceUISet->removeRxChannelInstance(this);
delete m_ssbDemod; delete m_ssbDemod;
delete m_spectrumVis; delete m_spectrumVis;
delete ui; delete ui;

4
plugins/channelrx/demodwfm/wfmdemodgui.cpp
View File

@ -185,7 +185,7 @@ WFMDemodGUI::WFMDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged())); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged()));
m_deviceUISet->registerChannelInstance(m_channelID, this); m_deviceUISet->registerRxChannelInstance(m_channelID, this);
m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this); m_deviceUISet->addRollupWidget(this);
@ -197,7 +197,7 @@ WFMDemodGUI::WFMDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget
WFMDemodGUI::~WFMDemodGUI() WFMDemodGUI::~WFMDemodGUI()
{ {
m_deviceUISet->removeChannelInstance(this); m_deviceUISet->removeRxChannelInstance(this);
delete m_wfmDemod; delete m_wfmDemod;
//delete m_channelMarker; //delete m_channelMarker;
delete ui; delete ui;

4
plugins/channelrx/tcpsrc/tcpsrcgui.cpp
View File

@ -165,7 +165,7 @@ TCPSrcGUI::TCPSrcGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget* pa
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged())); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged()));
m_deviceUISet->registerChannelInstance(m_channelID, this); m_deviceUISet->registerRxChannelInstance(m_channelID, this);
m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this); m_deviceUISet->addRollupWidget(this);
@ -179,7 +179,7 @@ TCPSrcGUI::TCPSrcGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget* pa
TCPSrcGUI::~TCPSrcGUI() TCPSrcGUI::~TCPSrcGUI()
{ {
m_deviceUISet->removeChannelInstance(this); m_deviceUISet->removeRxChannelInstance(this);
delete m_tcpSrc; delete m_tcpSrc;
delete m_spectrumVis; delete m_spectrumVis;
delete ui; delete ui;

4
plugins/channelrx/udpsrc/udpsrcgui.cpp
View File

@ -185,7 +185,7 @@ UDPSrcGUI::UDPSrcGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget* pa
connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged())); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(channelMarkerChanged()));
m_deviceUISet->registerChannelInstance(m_channelID, this); m_deviceUISet->registerRxChannelInstance(m_channelID, this);
m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this); m_deviceUISet->addRollupWidget(this);
@ -198,7 +198,7 @@ UDPSrcGUI::UDPSrcGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget* pa
UDPSrcGUI::~UDPSrcGUI() UDPSrcGUI::~UDPSrcGUI()
{ {
m_deviceUISet->removeChannelInstance(this); m_deviceUISet->removeRxChannelInstance(this);
delete m_udpSrc; delete m_udpSrc;
delete m_spectrumVis; delete m_spectrumVis;
delete ui; delete ui;

8
sdrgui/device/devicesinkapi.h
View File

@ -67,9 +67,12 @@ public:
MessageQueue *getSampleSinkInputMessageQueue(); MessageQueue *getSampleSinkInputMessageQueue();
MessageQueue *getSampleSinkGUIMessageQueue(); MessageQueue *getSampleSinkGUIMessageQueue();
// device related stuff // device GUI related stuff
void addChannelMarker(ChannelMarker* channelMarker); //!< Add channel marker to spectrum void addChannelMarker(ChannelMarker* channelMarker); //!< Add channel marker to spectrum
void addRollupWidget(QWidget *widget); //!< Add rollup widget to channel window void addRollupWidget(QWidget *widget); //!< Add rollup widget to channel window
void freeChannels();
void loadChannelSettings(const Preset* preset, PluginAPI *pluginAPI);
void saveChannelSettings(Preset* preset);
void setHardwareId(const QString& id); void setHardwareId(const QString& id);
void setSampleSinkId(const QString& id); void setSampleSinkId(const QString& id);
@ -91,12 +94,9 @@ public:
void registerChannelInstance(const QString& channelName, PluginInstanceGUI* pluginGUI); void registerChannelInstance(const QString& channelName, PluginInstanceGUI* pluginGUI);
void removeChannelInstance(PluginInstanceGUI* pluginGUI); void removeChannelInstance(PluginInstanceGUI* pluginGUI);
void freeChannels();
void loadSinkSettings(const Preset* preset); void loadSinkSettings(const Preset* preset);
void saveSinkSettings(Preset* preset); void saveSinkSettings(Preset* preset);
void loadChannelSettings(const Preset* preset, PluginAPI *pluginAPI);
void saveChannelSettings(Preset* preset);
DSPDeviceSinkEngine *getDeviceSinkEngine() { return m_deviceSinkEngine; } DSPDeviceSinkEngine *getDeviceSinkEngine() { return m_deviceSinkEngine; }

176
sdrgui/device/deviceuiset.cpp
View File

@ -73,36 +73,65 @@ void DeviceUISet::addRollupWidget(QWidget *widget)
m_channelWindow->addRollupWidget(widget); m_channelWindow->addRollupWidget(widget);
} }
void DeviceUISet::registerChannelInstance(const QString& channelName, PluginInstanceGUI* pluginGUI) void DeviceUISet::registerRxChannelInstance(const QString& channelName, PluginInstanceGUI* pluginGUI)
{ {
m_channelInstanceRegistrations.append(ChannelInstanceRegistration(channelName, pluginGUI)); m_rxChannelInstanceRegistrations.append(ChannelInstanceRegistration(channelName, pluginGUI));
renameChannelInstances(); renameRxChannelInstances();
} }
void DeviceUISet::removeChannelInstance(PluginInstanceGUI* pluginGUI) void DeviceUISet::registerTxChannelInstance(const QString& channelName, PluginInstanceGUI* pluginGUI)
{ {
for(ChannelInstanceRegistrations::iterator it = m_channelInstanceRegistrations.begin(); it != m_channelInstanceRegistrations.end(); ++it) m_txChannelInstanceRegistrations.append(ChannelInstanceRegistration(channelName, pluginGUI));
renameRxChannelInstances();
}
void DeviceUISet::removeRxChannelInstance(PluginInstanceGUI* pluginGUI)
{
for(ChannelInstanceRegistrations::iterator it = m_rxChannelInstanceRegistrations.begin(); it != m_rxChannelInstanceRegistrations.end(); ++it)
{ {
if(it->m_gui == pluginGUI) if(it->m_gui == pluginGUI)
{ {
m_channelInstanceRegistrations.erase(it); m_rxChannelInstanceRegistrations.erase(it);
break; break;
} }
} }
renameChannelInstances(); renameRxChannelInstances();
} }
void DeviceUISet::freeChannels() void DeviceUISet::removeTxChannelInstance(PluginInstanceGUI* pluginGUI)
{ {
for(int i = 0; i < m_channelInstanceRegistrations.count(); i++) for(ChannelInstanceRegistrations::iterator it = m_txChannelInstanceRegistrations.begin(); it != m_txChannelInstanceRegistrations.end(); ++it)
{ {
qDebug("DeviceUISet::freeAll: destroying channel [%s]", qPrintable(m_channelInstanceRegistrations[i].m_channelName)); if(it->m_gui == pluginGUI)
m_channelInstanceRegistrations[i].m_gui->destroy(); {
m_txChannelInstanceRegistrations.erase(it);
break;
}
}
renameRxChannelInstances();
}
void DeviceUISet::freeRxChannels()
{
for(int i = 0; i < m_rxChannelInstanceRegistrations.count(); i++)
{
qDebug("DeviceUISet::freeAll: destroying channel [%s]", qPrintable(m_rxChannelInstanceRegistrations[i].m_channelName));
m_rxChannelInstanceRegistrations[i].m_gui->destroy();
} }
} }
void DeviceUISet::loadChannelSettings(const Preset *preset, PluginAPI *pluginAPI) void DeviceUISet::freeTxChannels()
{
for(int i = 0; i < m_txChannelInstanceRegistrations.count(); i++)
{
qDebug("DeviceUISet::freeAll: destroying channel [%s]", qPrintable(m_txChannelInstanceRegistrations[i].m_channelName));
m_txChannelInstanceRegistrations[i].m_gui->destroy();
}
}
void DeviceUISet::loadRxChannelSettings(const Preset *preset, PluginAPI *pluginAPI)
{ {
if (preset->isSourcePreset()) if (preset->isSourcePreset())
{ {
@ -112,8 +141,8 @@ void DeviceUISet::loadChannelSettings(const Preset *preset, PluginAPI *pluginAPI
PluginAPI::ChannelRegistrations *channelRegistrations = pluginAPI->getRxChannelRegistrations(); PluginAPI::ChannelRegistrations *channelRegistrations = pluginAPI->getRxChannelRegistrations();
// copy currently open channels and clear list // copy currently open channels and clear list
ChannelInstanceRegistrations openChannels = m_channelInstanceRegistrations; ChannelInstanceRegistrations openChannels = m_rxChannelInstanceRegistrations;
m_channelInstanceRegistrations.clear(); m_rxChannelInstanceRegistrations.clear();
qDebug("DeviceUISet::loadChannelSettings: %d channel(s) in preset", preset->getChannelCount()); qDebug("DeviceUISet::loadChannelSettings: %d channel(s) in preset", preset->getChannelCount());
@ -132,7 +161,7 @@ void DeviceUISet::loadChannelSettings(const Preset *preset, PluginAPI *pluginAPI
{ {
qDebug("DeviceSourceAPI::loadChannelSettings: channel [%s] found", qPrintable(openChannels[i].m_channelName)); qDebug("DeviceSourceAPI::loadChannelSettings: channel [%s] found", qPrintable(openChannels[i].m_channelName));
reg = openChannels.takeAt(i); reg = openChannels.takeAt(i);
m_channelInstanceRegistrations.append(reg); m_rxChannelInstanceRegistrations.append(reg);
break; break;
} }
} }
@ -170,7 +199,7 @@ void DeviceUISet::loadChannelSettings(const Preset *preset, PluginAPI *pluginAPI
openChannels[i].m_gui->destroy(); openChannels[i].m_gui->destroy();
} }
renameChannelInstances(); renameRxChannelInstances();
} }
else else
{ {
@ -178,16 +207,16 @@ void DeviceUISet::loadChannelSettings(const Preset *preset, PluginAPI *pluginAPI
} }
} }
void DeviceUISet::saveChannelSettings(Preset *preset) void DeviceUISet::saveRxChannelSettings(Preset *preset)
{ {
if (preset->isSourcePreset()) if (preset->isSourcePreset())
{ {
qSort(m_channelInstanceRegistrations.begin(), m_channelInstanceRegistrations.end()); // sort by increasing delta frequency and type qSort(m_rxChannelInstanceRegistrations.begin(), m_rxChannelInstanceRegistrations.end()); // sort by increasing delta frequency and type
for(int i = 0; i < m_channelInstanceRegistrations.count(); i++) for(int i = 0; i < m_rxChannelInstanceRegistrations.count(); i++)
{ {
qDebug("DeviceUISet::saveChannelSettings: channel [%s] saved", qPrintable(m_channelInstanceRegistrations[i].m_channelName)); qDebug("DeviceUISet::saveChannelSettings: channel [%s] saved", qPrintable(m_rxChannelInstanceRegistrations[i].m_channelName));
preset->addChannel(m_channelInstanceRegistrations[i].m_channelName, m_channelInstanceRegistrations[i].m_gui->serialize()); preset->addChannel(m_rxChannelInstanceRegistrations[i].m_channelName, m_rxChannelInstanceRegistrations[i].m_gui->serialize());
} }
} }
else else
@ -196,11 +225,110 @@ void DeviceUISet::saveChannelSettings(Preset *preset)
} }
} }
void DeviceUISet::renameChannelInstances() void DeviceUISet::loadTxChannelSettings(const Preset *preset, PluginAPI *pluginAPI)
{ {
for(int i = 0; i < m_channelInstanceRegistrations.count(); i++) if (preset->isSourcePreset())
{ {
m_channelInstanceRegistrations[i].m_gui->setName(QString("%1:%2").arg(m_channelInstanceRegistrations[i].m_channelName).arg(i)); qDebug("DeviceUISet::loadChannelSettings: Loading preset [%s | %s] not a sink preset", qPrintable(preset->getGroup()), qPrintable(preset->getDescription()));
}
else
{
qDebug("DeviceUISet::loadChannelSettings: Loading preset [%s | %s]", qPrintable(preset->getGroup()), qPrintable(preset->getDescription()));
// Available channel plugins
PluginAPI::ChannelRegistrations *channelRegistrations = pluginAPI->getTxChannelRegistrations();
// copy currently open channels and clear list
ChannelInstanceRegistrations openChannels = m_txChannelInstanceRegistrations;
m_txChannelInstanceRegistrations.clear();
qDebug("DeviceUISet::loadChannelSettings: %d channel(s) in preset", preset->getChannelCount());
for(int i = 0; i < preset->getChannelCount(); i++)
{
const Preset::ChannelConfig& channelConfig = preset->getChannelConfig(i);
ChannelInstanceRegistration reg;
// if we have one instance available already, use it
for(int i = 0; i < openChannels.count(); i++)
{
qDebug("DeviceUISet::loadChannelSettings: channels compare [%s] vs [%s]", qPrintable(openChannels[i].m_channelName), qPrintable(channelConfig.m_channel));
if(openChannels[i].m_channelName == channelConfig.m_channel)
{
qDebug("DeviceUISet::loadChannelSettings: channel [%s] found", qPrintable(openChannels[i].m_channelName));
reg = openChannels.takeAt(i);
m_txChannelInstanceRegistrations.append(reg);
break;
}
}
// if we haven't one already, create one
if(reg.m_gui == 0)
{
for(int i = 0; i < channelRegistrations->count(); i++)
{
if((*channelRegistrations)[i].m_channelName == channelConfig.m_channel)
{
qDebug("DeviceUISet::loadChannelSettings: creating new channel [%s]", qPrintable(channelConfig.m_channel));
// TODO: replace m_deviceSinkAPI by this
reg = ChannelInstanceRegistration(channelConfig.m_channel, (*channelRegistrations)[i].m_plugin->createTxChannel(channelConfig.m_channel, m_deviceSinkAPI));
break;
}
}
}
if(reg.m_gui != 0)
{
qDebug("DeviceUISet::loadChannelSettings: deserializing channel [%s]", qPrintable(channelConfig.m_channel));
reg.m_gui->deserialize(channelConfig.m_config);
}
}
// everything, that is still "available" is not needed anymore
for(int i = 0; i < openChannels.count(); i++)
{
qDebug("DeviceUISet::loadChannelSettings: destroying spare channel [%s]", qPrintable(openChannels[i].m_channelName));
openChannels[i].m_gui->destroy();
}
renameTxChannelInstances();
}
}
void DeviceUISet::saveTxChannelSettings(Preset *preset)
{
if (preset->isSourcePreset())
{
qDebug("DeviceUISet::saveChannelSettings: not a sink preset");
}
else
{
qSort(m_txChannelInstanceRegistrations.begin(), m_txChannelInstanceRegistrations.end()); // sort by increasing delta frequency and type
for(int i = 0; i < m_txChannelInstanceRegistrations.count(); i++)
{
qDebug("DeviceUISet::saveChannelSettings: channel [%s] saved", qPrintable(m_txChannelInstanceRegistrations[i].m_channelName));
preset->addChannel(m_txChannelInstanceRegistrations[i].m_channelName, m_txChannelInstanceRegistrations[i].m_gui->serialize());
}
}
}
void DeviceUISet::renameRxChannelInstances()
{
for(int i = 0; i < m_rxChannelInstanceRegistrations.count(); i++)
{
m_rxChannelInstanceRegistrations[i].m_gui->setName(QString("%1:%2").arg(m_rxChannelInstanceRegistrations[i].m_channelName).arg(i));
}
}
void DeviceUISet::renameTxChannelInstances()
{
for(int i = 0; i < m_txChannelInstanceRegistrations.count(); i++)
{
m_txChannelInstanceRegistrations[i].m_gui->setName(QString("%1:%2").arg(m_txChannelInstanceRegistrations[i].m_channelName).arg(i));
} }
} }

21
sdrgui/device/deviceuiset.h
View File

@ -51,11 +51,16 @@ struct DeviceUISet
void addChannelMarker(ChannelMarker* channelMarker); //!< Add channel marker to spectrum void addChannelMarker(ChannelMarker* channelMarker); //!< Add channel marker to spectrum
void addRollupWidget(QWidget *widget); //!< Add rollup widget to channel window void addRollupWidget(QWidget *widget); //!< Add rollup widget to channel window
void registerChannelInstance(const QString& channelName, PluginInstanceGUI* pluginGUI); void registerRxChannelInstance(const QString& channelName, PluginInstanceGUI* pluginGUI);
void removeChannelInstance(PluginInstanceGUI* pluginGUI); void registerTxChannelInstance(const QString& channelName, PluginInstanceGUI* pluginGUI);
void freeChannels(); void removeRxChannelInstance(PluginInstanceGUI* pluginGUI);
void loadChannelSettings(const Preset* preset, PluginAPI *pluginAPI); void removeTxChannelInstance(PluginInstanceGUI* pluginGUI);
void saveChannelSettings(Preset* preset); void freeRxChannels();
void freeTxChannels();
void loadRxChannelSettings(const Preset* preset, PluginAPI *pluginAPI);
void saveRxChannelSettings(Preset* preset);
void loadTxChannelSettings(const Preset* preset, PluginAPI *pluginAPI);
void saveTxChannelSettings(Preset* preset);
private: private:
struct ChannelInstanceRegistration struct ChannelInstanceRegistration
@ -78,9 +83,11 @@ private:
typedef QList<ChannelInstanceRegistration> ChannelInstanceRegistrations; typedef QList<ChannelInstanceRegistration> ChannelInstanceRegistrations;
ChannelInstanceRegistrations m_channelInstanceRegistrations; ChannelInstanceRegistrations m_rxChannelInstanceRegistrations;
ChannelInstanceRegistrations m_txChannelInstanceRegistrations;
void renameChannelInstances(); void renameRxChannelInstances();
void renameTxChannelInstances();
}; };

6
sdrgui/mainwindow.cpp
View File

@ -330,7 +330,7 @@ void MainWindow::removeLastDevice()
ui->tabSpectra->removeTab(ui->tabSpectra->count() - 1); ui->tabSpectra->removeTab(ui->tabSpectra->count() - 1);
// deletes old UI and input object // deletes old UI and input object
m_deviceUIs.back()->freeChannels(); // destroys the channel instances m_deviceUIs.back()->freeRxChannels(); // destroys the channel instances
m_deviceUIs.back()->m_deviceSourceAPI->getSampleSource()->setMessageQueueToGUI(0); // have source stop sending messages to the GUI m_deviceUIs.back()->m_deviceSourceAPI->getSampleSource()->setMessageQueueToGUI(0); // have source stop sending messages to the GUI
m_deviceUIs.back()->m_deviceSourceAPI->getPluginInterface()->deleteSampleSourcePluginInstanceGUI( m_deviceUIs.back()->m_deviceSourceAPI->getPluginInterface()->deleteSampleSourcePluginInstanceGUI(
m_deviceUIs.back()->m_deviceSourceAPI->getSampleSourcePluginInstanceGUI()); m_deviceUIs.back()->m_deviceSourceAPI->getSampleSourcePluginInstanceGUI());
@ -479,7 +479,7 @@ void MainWindow::loadPresetSettings(const Preset* preset, int tabIndex)
{ {
deviceUI->m_spectrumGUI->deserialize(preset->getSpectrumConfig()); deviceUI->m_spectrumGUI->deserialize(preset->getSpectrumConfig());
deviceUI->m_deviceSourceAPI->loadSourceSettings(preset); deviceUI->m_deviceSourceAPI->loadSourceSettings(preset);
deviceUI->loadChannelSettings(preset, m_pluginManager->getPluginAPI()); deviceUI->loadRxChannelSettings(preset, m_pluginManager->getPluginAPI());
} }
else if (deviceUI->m_deviceSinkEngine) // sink device else if (deviceUI->m_deviceSinkEngine) // sink device
{ {
@ -507,7 +507,7 @@ void MainWindow::savePresetSettings(Preset* preset, int tabIndex)
{ {
preset->setSpectrumConfig(deviceUI->m_spectrumGUI->serialize()); preset->setSpectrumConfig(deviceUI->m_spectrumGUI->serialize());
preset->clearChannels(); preset->clearChannels();
deviceUI->saveChannelSettings(preset); deviceUI->saveRxChannelSettings(preset);
deviceUI->m_deviceSourceAPI->saveSourceSettings(preset); deviceUI->m_deviceSourceAPI->saveSourceSettings(preset);
} }
else if (deviceUI->m_deviceSinkEngine) // sink device else if (deviceUI->m_deviceSinkEngine) // sink device