VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2025-03-29 15:48:52 -04:00
Code Issues Projects Releases Wiki Activity

Make a static getter of Main Window reference as it is de facto a singleton. Use it in place of plugin API getter

Browse Source
This commit is contained in:
f4exb 2017-10-24 13:45:10 +02:00
parent 78490ffff0
commit a106deeaf7
19 changed files with 1879 additions and 1874 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,497 +1,497 @@
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
// 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 <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, DeviceSourceAPI *deviceAPI) ChannelAnalyzerGUI* ChannelAnalyzerGUI::create(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI)
{ {
ChannelAnalyzerGUI* gui = new ChannelAnalyzerGUI(pluginAPI, deviceAPI); ChannelAnalyzerGUI* gui = new ChannelAnalyzerGUI(pluginAPI, deviceAPI);
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, DeviceSourceAPI *deviceAPI, QWidget* parent) : ChannelAnalyzerGUI::ChannelAnalyzerGUI(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI, 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_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_deviceAPI); m_channelAnalyzer = new ChannelAnalyzer(m_deviceAPI);
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(m_pluginAPI->getMainWindow()->getMasterTimer()); ui->glSpectrum->connectTimer(MainWindow::getInstance()->getMasterTimer());
ui->glScope->connectTimer(m_pluginAPI->getMainWindow()->getMasterTimer()); ui->glScope->connectTimer(MainWindow::getInstance()->getMasterTimer());
connect(&m_pluginAPI->getMainWindow()->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_deviceAPI->registerChannelInstance(m_channelID, this); m_deviceAPI->registerChannelInstance(m_channelID, this);
m_deviceAPI->addChannelMarker(&m_channelMarker); m_deviceAPI->addChannelMarker(&m_channelMarker);
m_deviceAPI->addRollupWidget(this); m_deviceAPI->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_deviceAPI->removeChannelInstance(this); m_deviceAPI->removeChannelInstance(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);
} }

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

File diff suppressed because it is too large Load Diff

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

@ -186,7 +186,7 @@ AMDemodGUI::AMDemodGUI(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI, QWidget
m_amDemod = new AMDemod(m_deviceAPI); m_amDemod = new AMDemod(m_deviceAPI);
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); // 50 ms connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); // 50 ms
ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03))); ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold)); ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));

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

File diff suppressed because it is too large Load Diff

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

@ -347,7 +347,7 @@ BFMDemodGUI::BFMDemodGUI(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI, QWidg
ui->glSpectrum->setDisplayMaxHold(false); ui->glSpectrum->setDisplayMaxHold(false);
ui->glSpectrum->setSsbSpectrum(true); ui->glSpectrum->setSsbSpectrum(true);
m_spectrumVis->configure(m_spectrumVis->getInputMessageQueue(), 64, 10, FFTWindow::BlackmanHarris); m_spectrumVis->configure(m_spectrumVis->getInputMessageQueue(), 64, 10, FFTWindow::BlackmanHarris);
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
m_channelMarker.setTitle("Broadcast FM Demod"); m_channelMarker.setTitle("Broadcast FM Demod");
m_channelMarker.setBandwidth(12500); m_channelMarker.setBandwidth(12500);

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

@ -260,9 +260,9 @@ DSDDemodGUI::DSDDemodGUI(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI, QWidg
ui->glScope->setSampleRate(48000); ui->glScope->setSampleRate(48000);
m_scopeVis->setSampleRate(48000); m_scopeVis->setSampleRate(48000);
ui->glScope->connectTimer(m_pluginAPI->getMainWindow()->getMasterTimer()); ui->glScope->connectTimer(MainWindow::getInstance()->getMasterTimer());
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
ui->audioMute->setStyleSheet("QToolButton { background:rgb(79,79,79); }"); ui->audioMute->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
@ -304,8 +304,8 @@ DSDDemodGUI::~DSDDemodGUI()
void DSDDemodGUI::updateMyPosition() void DSDDemodGUI::updateMyPosition()
{ {
float latitude = m_pluginAPI->getMainWindow()->getMainSettings().getLatitude(); float latitude = MainWindow::getInstance()->getMainSettings().getLatitude();
float longitude = m_pluginAPI->getMainWindow()->getMainSettings().getLongitude(); float longitude = MainWindow::getInstance()->getMainSettings().getLongitude();
if ((m_myLatitude != latitude) || (m_myLongitude != longitude)) if ((m_myLatitude != latitude) || (m_myLongitude != longitude))
{ {

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

@ -241,7 +241,7 @@ NFMDemodGUI::NFMDemodGUI(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI, QWidg
m_nfmDemod = new NFMDemod(m_deviceAPI); m_nfmDemod = new NFMDemod(m_deviceAPI);
m_nfmDemod->setMessageQueueToGUI(getInputMessageQueue()); m_nfmDemod->setMessageQueueToGUI(getInputMessageQueue());
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
blockApplySettings(true); blockApplySettings(true);

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

@ -319,9 +319,9 @@ SSBDemodGUI::SSBDemodGUI(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI, QWidg
ui->glSpectrum->setDisplayWaterfall(true); ui->glSpectrum->setDisplayWaterfall(true);
ui->glSpectrum->setDisplayMaxHold(true); ui->glSpectrum->setDisplayMaxHold(true);
ui->glSpectrum->connectTimer(m_pluginAPI->getMainWindow()->getMasterTimer()); ui->glSpectrum->connectTimer(MainWindow::getInstance()->getMasterTimer());
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
m_channelMarker.setVisible(true); m_channelMarker.setVisible(true);

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

@ -173,7 +173,7 @@ WFMDemodGUI::WFMDemodGUI(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI, QWidg
m_wfmDemod = new WFMDemod(m_deviceAPI); m_wfmDemod = new WFMDemod(m_deviceAPI);
connect(&m_pluginAPI->getMainWindow()->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.setBandwidth(WFMDemodSettings::getRFBW(4)); m_channelMarker.setBandwidth(WFMDemodSettings::getRFBW(4));

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

@ -153,8 +153,8 @@ TCPSrcGUI::TCPSrcGUI(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI, QWidget*
ui->glSpectrum->setDisplayMaxHold(true); ui->glSpectrum->setDisplayMaxHold(true);
m_spectrumVis->configure(m_spectrumVis->getInputMessageQueue(), 64, 10, FFTWindow::BlackmanHarris); m_spectrumVis->configure(m_spectrumVis->getInputMessageQueue(), 64, 10, FFTWindow::BlackmanHarris);
ui->glSpectrum->connectTimer(m_pluginAPI->getMainWindow()->getMasterTimer()); ui->glSpectrum->connectTimer(MainWindow::getInstance()->getMasterTimer());
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
m_channelMarker.setBandwidth(16000); m_channelMarker.setBandwidth(16000);
m_channelMarker.setCenterFrequency(0); m_channelMarker.setCenterFrequency(0);

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

@ -166,8 +166,8 @@ UDPSrcGUI::UDPSrcGUI(PluginAPI* pluginAPI, DeviceSourceAPI *deviceAPI, QWidget*
ui->glSpectrum->setDisplayMaxHold(true); ui->glSpectrum->setDisplayMaxHold(true);
m_spectrumVis->configure(m_spectrumVis->getInputMessageQueue(), 64, 10, FFTWindow::BlackmanHarris); m_spectrumVis->configure(m_spectrumVis->getInputMessageQueue(), 64, 10, FFTWindow::BlackmanHarris);
ui->glSpectrum->connectTimer(m_pluginAPI->getMainWindow()->getMasterTimer()); ui->glSpectrum->connectTimer(MainWindow::getInstance()->getMasterTimer());
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
m_channelMarker.setBandwidth(16000); m_channelMarker.setBandwidth(16000);
m_channelMarker.setCenterFrequency(0); m_channelMarker.setCenterFrequency(0);

2
plugins/channeltx/modam/ammodgui.cpp
View File

@ -291,7 +291,7 @@ AMModGUI::AMModGUI(PluginAPI* pluginAPI, DeviceSinkAPI *deviceAPI, QWidget* pare
m_amMod = new AMMod(m_deviceAPI); m_amMod = new AMMod(m_deviceAPI);
m_amMod->setMessageQueueToGUI(getInputMessageQueue()); m_amMod->setMessageQueueToGUI(getInputMessageQueue());
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03))); ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold)); ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));

2
plugins/channeltx/modatv/atvmodgui.cpp
View File

@ -611,7 +611,7 @@ ATVModGUI::ATVModGUI(PluginAPI* pluginAPI, DeviceSinkAPI *deviceAPI, QWidget* pa
m_atvMod = new ATVMod(m_deviceAPI); m_atvMod = new ATVMod(m_deviceAPI);
m_atvMod->setMessageQueueToGUI(getInputMessageQueue()); m_atvMod->setMessageQueueToGUI(getInputMessageQueue());
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03))); ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold)); ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));

2
plugins/channeltx/modnfm/nfmmodgui.cpp
View File

@ -319,7 +319,7 @@ NFMModGUI::NFMModGUI(PluginAPI* pluginAPI, DeviceSinkAPI *deviceAPI, QWidget* pa
m_nfmMod = new NFMMod(m_deviceAPI); m_nfmMod = new NFMMod(m_deviceAPI);
m_nfmMod->setMessageQueueToGUI(getInputMessageQueue()); m_nfmMod->setMessageQueueToGUI(getInputMessageQueue());
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03))); ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold)); ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));

4
plugins/channeltx/modssb/ssbmodgui.cpp
View File

@ -472,9 +472,9 @@ SSBModGUI::SSBModGUI(PluginAPI* pluginAPI, DeviceSinkAPI *deviceAPI, QWidget* pa
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(m_pluginAPI->getMainWindow()->getMasterTimer()); ui->glSpectrum->connectTimer(MainWindow::getInstance()->getMasterTimer());
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03))); ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold)); ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));

2
plugins/channeltx/modwfm/wfmmodgui.cpp
View File

@ -308,7 +308,7 @@ WFMModGUI::WFMModGUI(PluginAPI* pluginAPI, DeviceSinkAPI *deviceAPI, QWidget* pa
m_wfmMod = new WFMMod(m_deviceAPI); m_wfmMod = new WFMMod(m_deviceAPI);
m_wfmMod->setMessageQueueToGUI(getInputMessageQueue()); m_wfmMod->setMessageQueueToGUI(getInputMessageQueue());
connect(&m_pluginAPI->getMainWindow()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03))); ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold)); ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));

4
plugins/channeltx/udpsink/udpsinkgui.cpp
View File

@ -134,8 +134,8 @@ UDPSinkGUI::UDPSinkGUI(PluginAPI* pluginAPI, DeviceSinkAPI *deviceAPI, QWidget*
ui->glSpectrum->setDisplayMaxHold(true); ui->glSpectrum->setDisplayMaxHold(true);
m_spectrumVis->configure(m_spectrumVis->getInputMessageQueue(), 64, 10, FFTWindow::BlackmanHarris); m_spectrumVis->configure(m_spectrumVis->getInputMessageQueue(), 64, 10, FFTWindow::BlackmanHarris);
ui->glSpectrum->connectTimer(m_pluginAPI->getMainWindow()->getMasterTimer()); ui->glSpectrum->connectTimer(MainWindow::getInstance()->getMasterTimer());
connect(&m_pluginAPI->getMainWindow()->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.setBandwidth(16000); m_channelMarker.setBandwidth(16000);

3
sdrgui/mainwindow.cpp
View File

@ -54,6 +54,8 @@
#include <string> #include <string>
#include <QDebug> #include <QDebug>
MainWindow *MainWindow::m_instance = 0;
MainWindow::MainWindow(QWidget* parent) : MainWindow::MainWindow(QWidget* parent) :
QMainWindow(parent), QMainWindow(parent),
ui(new Ui::MainWindow), ui(new Ui::MainWindow),
@ -68,6 +70,7 @@ MainWindow::MainWindow(QWidget* parent) :
{ {
qDebug() << "MainWindow::MainWindow: start"; qDebug() << "MainWindow::MainWindow: start";
m_instance = this;
m_settings.setAudioDeviceInfo(&m_audioDeviceInfo); m_settings.setAudioDeviceInfo(&m_audioDeviceInfo);
ui->setupUi(this); ui->setupUi(this);

2
sdrgui/mainwindow.h
View File

@ -76,6 +76,7 @@ public:
explicit MainWindow(QWidget* parent = 0); explicit MainWindow(QWidget* parent = 0);
~MainWindow(); ~MainWindow();
static MainWindow *getInstance() { return m_instance; } // Main Window is de facto a singleton so this just returns its reference
MessageQueue* getInputMessageQueue() { return &m_inputMessageQueue; } MessageQueue* getInputMessageQueue() { return &m_inputMessageQueue; }
@ -100,6 +101,7 @@ private:
QString tabName; QString tabName;
}; };
static MainWindow *m_instance;
Ui::MainWindow* ui; Ui::MainWindow* ui;
AudioDeviceInfo m_audioDeviceInfo; AudioDeviceInfo m_audioDeviceInfo;
MessageQueue m_inputMessageQueue; MessageQueue m_inputMessageQueue;