SDRAngel  4.11.5
Developer docs for <a href="https://github.com/f4exb/sdrangel">SDRangel<\a>, an Open Source Qt5 / OpenGL 3.0+ SDR and signal analyzer frontend to various hardware.
ssbdemodgui.cpp
Go to the documentation of this file.
1 #include <QPixmap>
2 
3 #include "ssbdemodgui.h"
4 
5 #include "device/deviceuiset.h"
6 
7 #include "ui_ssbdemodgui.h"
8 #include "dsp/spectrumvis.h"
9 #include "dsp/dspengine.h"
10 #include "dsp/dspcommands.h"
11 #include "gui/glspectrum.h"
13 #include "plugin/pluginapi.h"
14 #include "util/simpleserializer.h"
15 #include "util/db.h"
16 #include "gui/crightclickenabler.h"
17 #include "gui/audioselectdialog.h"
18 #include "mainwindow.h"
19 #include "ssbdemod.h"
20 
22 {
23  SSBDemodGUI* gui = new SSBDemodGUI(pluginAPI, deviceUISet, rxChannel);
24  return gui;
25 }
26 
28 {
29  delete this;
30 }
31 
32 void SSBDemodGUI::setName(const QString& name)
33 {
34  setObjectName(name);
35 }
36 
37 QString SSBDemodGUI::getName() const
38 {
39  return objectName();
40 }
41 
43 {
45 }
46 
47 void SSBDemodGUI::setCenterFrequency(qint64 centerFrequency)
48 {
49  m_channelMarker.setCenterFrequency(centerFrequency);
51  applySettings();
52 }
53 
55 {
57 }
58 
59 QByteArray SSBDemodGUI::serialize() const
60 {
61  return m_settings.serialize();
62 }
63 
64 bool SSBDemodGUI::deserialize(const QByteArray& data)
65 {
66  if(m_settings.deserialize(data))
67  {
69  applyBandwidths(m_settings.m_spanLog2, true); // does applySettings(true)
70  return true;
71  }
72  else
73  {
76  applyBandwidths(m_settings.m_spanLog2, true); // does applySettings(true)
77  return false;
78  }
79 }
80 
81 bool SSBDemodGUI::handleMessage(const Message& message)
82 {
84  {
85  qDebug("SSBDemodGUI::handleMessage: SSBDemod::MsgConfigureSSBDemod");
87  m_settings = cfg.getSettings();
88  blockApplySettings(true);
90  blockApplySettings(false);
91  return true;
92  }
93  else if (DSPConfigureAudio::match(message))
94  {
95  qDebug("SSBDemodGUI::handleMessage: DSPConfigureAudio: %d", m_ssbDemod->getAudioSampleRate());
96  applyBandwidths(5 - ui->spanLog2->value()); // will update spectrum details with new sample rate
97  return true;
98  }
99  else
100  {
101  return false;
102  }
103 }
104 
106 {
107  Message* message;
108 
109  while ((message = getInputMessageQueue()->pop()) != 0)
110  {
111  if (handleMessage(*message))
112  {
113  delete message;
114  }
115  }
116 }
117 
119 {
120  ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency());
122  applySettings();
123 }
124 
126 {
128 }
129 
131 {
132  m_audioBinaural = binaural;
133  m_settings.m_audioBinaural = binaural;
134  applySettings();
135 }
136 
138 {
139  m_audioFlipChannels = flip;
141  applySettings();
142 }
143 
145 {
146  ui->flipSidebands->setEnabled(!dsb);
147  applyBandwidths(5 - ui->spanLog2->value());
148 }
149 
151 {
154  applySettings();
155 }
156 
158 {
159  (void) value;
160  applyBandwidths(5 - ui->spanLog2->value());
161 }
162 
164 {
165  (void) value;
166  applyBandwidths(5 - ui->spanLog2->value());
167 }
168 
170 {
171  ui->volumeText->setText(QString("%1").arg(value / 10.0, 0, 'f', 1));
172  m_settings.m_volume = value / 10.0;
173  applySettings();
174 }
175 
176 void SSBDemodGUI::on_agc_toggled(bool checked)
177 {
178  m_settings.m_agc = checked;
179  applySettings();
180 }
181 
183 {
184  m_settings.m_agcClamping = checked;
185  applySettings();
186 }
187 
189 {
190  QString s = QString::number((1<<value), 'f', 0);
191  ui->agcTimeText->setText(s);
192  m_settings.m_agcTimeLog2 = value;
193  applySettings();
194 }
195 
197 {
200  applySettings();
201 }
202 
204 {
205  int agcThresholdGate = value < 20 ? value : ((value - 20) * 10) + 20;
206  QString s = QString::number(agcThresholdGate, 'f', 0);
207  ui->agcThresholdGateText->setText(s);
208  m_settings.m_agcThresholdGate = agcThresholdGate;
209  applySettings();
210 }
211 
213 {
214  m_audioMute = checked;
215  m_settings.m_audioMute = checked;
216  applySettings();
217 }
218 
220 {
221  if ((value < 0) || (value > 4)) {
222  return;
223  }
224 
225  applyBandwidths(5 - ui->spanLog2->value());
226 }
227 
229 {
230  (void) checked;
231  int bwValue = ui->BW->value();
232  int lcValue = ui->lowCut->value();
233  ui->BW->setValue(-bwValue);
234  ui->lowCut->setValue(-lcValue);
235 }
236 
237 void SSBDemodGUI::onMenuDialogCalled(const QPoint &p)
238 {
240  {
247 
248  dialog.move(p);
249  dialog.exec();
250 
259 
260  setWindowTitle(m_settings.m_title);
262 
263  applySettings();
264  }
265 
267 }
268 
269 void SSBDemodGUI::onWidgetRolled(QWidget* widget, bool rollDown)
270 {
271  (void) widget;
272  (void) rollDown;
273 }
274 
275 SSBDemodGUI::SSBDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel, QWidget* parent) :
276  RollupWidget(parent),
277  ui(new Ui::SSBDemodGUI),
278  m_pluginAPI(pluginAPI),
279  m_deviceUISet(deviceUISet),
280  m_channelMarker(this),
281  m_doApplySettings(true),
282  m_spectrumRate(6000),
283  m_audioBinaural(false),
284  m_audioFlipChannels(false),
285  m_audioMute(false),
286  m_squelchOpen(false)
287 {
288  ui->setupUi(this);
289  setAttribute(Qt::WA_DeleteOnClose, true);
290  connect(this, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool)));
291  connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(onMenuDialogCalled(const QPoint &)));
292 
293  m_spectrumVis = new SpectrumVis(SDR_RX_SCALEF, ui->glSpectrum);
294  m_ssbDemod = (SSBDemod*) rxChannel; //new SSBDemod(m_deviceUISet->m_deviceSourceAPI);
297 
298  CRightClickEnabler *audioMuteRightClickEnabler = new CRightClickEnabler(ui->audioMute);
299  connect(audioMuteRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(audioSelect()));
300 
301  ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
302  ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
303  ui->deltaFrequency->setValueRange(false, 7, -9999999, 9999999);
304  ui->channelPowerMeter->setColorTheme(LevelMeterSignalDB::ColorGreenAndBlue);
305 
306  ui->glSpectrum->setCenterFrequency(m_spectrumRate/2);
307  ui->glSpectrum->setSampleRate(m_spectrumRate);
308  ui->glSpectrum->setDisplayWaterfall(true);
309  ui->glSpectrum->setDisplayMaxHold(true);
310  ui->glSpectrum->setSsbSpectrum(true);
311  ui->glSpectrum->connectTimer(MainWindow::getInstance()->getMasterTimer());
312 
313  connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
314 
315  m_channelMarker.blockSignals(true);
316  m_channelMarker.setColor(Qt::green);
319  m_channelMarker.setTitle("SSB Demodulator");
320  m_channelMarker.blockSignals(false);
321  m_channelMarker.setVisible(true); // activate signal on the last setting only
322 
324 
326  m_settings.setSpectrumGUI(ui->spectrumGUI);
327 
331 
332  connect(&m_channelMarker, SIGNAL(changedByCursor()), this, SLOT(channelMarkerChangedByCursor()));
333  connect(&m_channelMarker, SIGNAL(highlightedByCursor()), this, SLOT(channelMarkerHighlightedByCursor()));
334  connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
335 
336  ui->spectrumGUI->setBuddies(m_spectrumVis->getInputMessageQueue(), m_spectrumVis, ui->glSpectrum);
337 
338  m_iconDSBUSB.addPixmap(QPixmap("://dsb.png"), QIcon::Normal, QIcon::On);
339  m_iconDSBUSB.addPixmap(QPixmap("://usb.png"), QIcon::Normal, QIcon::Off);
340  m_iconDSBLSB.addPixmap(QPixmap("://dsb.png"), QIcon::Normal, QIcon::On);
341  m_iconDSBLSB.addPixmap(QPixmap("://lsb.png"), QIcon::Normal, QIcon::Off);
342 
343  displaySettings();
344  applyBandwidths(m_settings.m_spanLog2, true); // does applySettings(true)
345 }
346 
348 {
350  delete m_ssbDemod; // TODO: check this: when the GUI closes it has to delete the demodulator
351  delete m_spectrumVis;
352  delete ui;
353 }
354 
356 {
357  bool ret = !m_doApplySettings;
358  m_doApplySettings = !block;
359  return ret;
360 }
361 
363 {
364  if (m_doApplySettings)
365  {
368  m_ssbDemod->getInputMessageQueue()->push(channelConfigMsg);
369 
371  m_ssbDemod->getInputMessageQueue()->push(message);
372  }
373 }
374 
375 int SSBDemodGUI::spanLog2Limit(int spanLog2)
376 {
377  while (((m_ssbDemod->getAudioSampleRate() / (1<<spanLog2)) > m_ssbDemod->getInputSampleRate()) && (spanLog2 < 4)) {
378  spanLog2++;
379  }
380 
381  return spanLog2;
382 }
383 
384 void SSBDemodGUI::applyBandwidths(int spanLog2, bool force)
385 {
386  spanLog2 = spanLog2Limit(spanLog2);
387  ui->spanLog2->setMaximum(5 - spanLog2Limit(1));
388  bool dsb = ui->dsb->isChecked();
389  //int spanLog2 = ui->spanLog2->value();
390  m_spectrumRate = m_ssbDemod->getAudioSampleRate() / (1<<spanLog2);
391  int bw = ui->BW->value();
392  int lw = ui->lowCut->value();
393  int bwMax = std::min(m_ssbDemod->getAudioSampleRate() / (100*(1<<spanLog2)), m_ssbDemod->getInputSampleRate()/100);
394  int tickInterval = m_spectrumRate / 1200;
395  tickInterval = tickInterval == 0 ? 1 : tickInterval;
396 
397  qDebug() << "SSBDemodGUI::applyBandwidths:"
398  << " dsb: " << dsb
399  << " spanLog2: " << spanLog2
400  << " m_spectrumRate: " << m_spectrumRate
401  << " bw: " << bw
402  << " lw: " << lw
403  << " bwMax: " << bwMax
404  << " tickInterval: " << tickInterval;
405 
406  ui->BW->setTickInterval(tickInterval);
407  ui->lowCut->setTickInterval(tickInterval);
408 
409  bw = bw < -bwMax ? -bwMax : bw > bwMax ? bwMax : bw;
410 
411  if (bw < 0) {
412  lw = lw < bw+1 ? bw+1 : lw < 0 ? lw : 0;
413  } else if (bw > 0) {
414  lw = lw > bw-1 ? bw-1 : lw < 0 ? 0 : lw;
415  } else {
416  lw = 0;
417  }
418 
419  if (dsb)
420  {
421  bw = bw < 0 ? -bw : bw;
422  lw = 0;
423  }
424 
425  QString spanStr = QString::number(bwMax/10.0, 'f', 1);
426  QString bwStr = QString::number(bw/10.0, 'f', 1);
427  QString lwStr = QString::number(lw/10.0, 'f', 1);
428 
429  if (dsb)
430  {
431  ui->BWText->setText(tr("%1%2k").arg(QChar(0xB1, 0x00)).arg(bwStr));
432  ui->spanText->setText(tr("%1%2k").arg(QChar(0xB1, 0x00)).arg(spanStr));
433  ui->scaleMinus->setText("0");
434  ui->scaleCenter->setText("");
435  ui->scalePlus->setText(tr("%1").arg(QChar(0xB1, 0x00)));
436  ui->lsbLabel->setText("");
437  ui->usbLabel->setText("");
438  ui->glSpectrum->setCenterFrequency(0);
439  ui->glSpectrum->setSampleRate(2*m_spectrumRate);
440  ui->glSpectrum->setSsbSpectrum(false);
441  ui->glSpectrum->setLsbDisplay(false);
442  }
443  else
444  {
445  ui->BWText->setText(tr("%1k").arg(bwStr));
446  ui->spanText->setText(tr("%1k").arg(spanStr));
447  ui->scaleMinus->setText("-");
448  ui->scaleCenter->setText("0");
449  ui->scalePlus->setText("+");
450  ui->lsbLabel->setText("LSB");
451  ui->usbLabel->setText("USB");
452  ui->glSpectrum->setCenterFrequency(m_spectrumRate/2);
453  ui->glSpectrum->setSampleRate(m_spectrumRate);
454  ui->glSpectrum->setSsbSpectrum(true);
455  ui->glSpectrum->setLsbDisplay(bw < 0);
456  }
457 
458  ui->lowCutText->setText(tr("%1k").arg(lwStr));
459 
460 
461  ui->BW->blockSignals(true);
462  ui->lowCut->blockSignals(true);
463 
464  ui->BW->setMaximum(bwMax);
465  ui->BW->setMinimum(dsb ? 0 : -bwMax);
466  ui->BW->setValue(bw);
467 
468  ui->lowCut->setMaximum(dsb ? 0 : bwMax);
469  ui->lowCut->setMinimum(dsb ? 0 : -bwMax);
470  ui->lowCut->setValue(lw);
471 
472  ui->lowCut->blockSignals(false);
473  ui->BW->blockSignals(false);
474 
475  ui->channelPowerMeter->setRange(SSBDemodSettings::m_minPowerThresholdDB, 0);
476 
477  m_settings.m_dsb = dsb;
478  m_settings.m_spanLog2 = spanLog2;
479  m_settings.m_rfBandwidth = bw * 100;
480  m_settings.m_lowCutoff = lw * 100;
481 
482  applySettings(force);
483 
484  bool wasBlocked = blockApplySettings(true);
485  m_channelMarker.setBandwidth(bw * 200);
487  ui->dsb->setIcon(bw < 0 ? m_iconDSBLSB: m_iconDSBUSB);
488  if (!dsb) { m_channelMarker.setLowCutoff(lw * 100); }
489  blockApplySettings(wasBlocked);
490 }
491 
493 {
494  m_channelMarker.blockSignals(true);
499 
500  ui->flipSidebands->setEnabled(!m_settings.m_dsb);
501 
502  if (m_settings.m_dsb) {
504  } else {
505  if (m_settings.m_rfBandwidth < 0) {
507  ui->dsb->setIcon(m_iconDSBLSB);
508  } else {
510  ui->dsb->setIcon(m_iconDSBUSB);
511  }
512  }
513 
514  m_channelMarker.blockSignals(false);
515  m_channelMarker.setColor(m_settings.m_rgbColor); // activate signal on the last setting only
516 
518  setWindowTitle(m_channelMarker.getTitle());
519 
520  blockApplySettings(true);
521 
522  ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency());
523 
524  ui->agc->setChecked(m_settings.m_agc);
525  ui->agcClamping->setChecked(m_settings.m_agcClamping);
526  ui->audioBinaural->setChecked(m_settings.m_audioBinaural);
527  ui->audioFlipChannels->setChecked(m_settings.m_audioFlipChannels);
528  ui->audioMute->setChecked(m_settings.m_audioMute);
529  ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency());
530 
531  // Prevent uncontrolled triggering of applyBandwidths
532  ui->spanLog2->blockSignals(true);
533  ui->dsb->blockSignals(true);
534  ui->BW->blockSignals(true);
535 
536  ui->dsb->setChecked(m_settings.m_dsb);
537  ui->spanLog2->setValue(5 - m_settings.m_spanLog2);
538 
539  ui->BW->setValue(m_settings.m_rfBandwidth / 100.0);
540  QString s = QString::number(m_settings.m_rfBandwidth/1000.0, 'f', 1);
541 
542  if (m_settings.m_dsb)
543  {
544  ui->BWText->setText(tr("%1%2k").arg(QChar(0xB1, 0x00)).arg(s));
545  }
546  else
547  {
548  ui->BWText->setText(tr("%1k").arg(s));
549  }
550 
551  ui->spanLog2->blockSignals(false);
552  ui->dsb->blockSignals(false);
553  ui->BW->blockSignals(false);
554 
555  // The only one of the four signals triggering applyBandwidths will trigger it once only with all other values
556  // set correctly and therefore validate the settings and apply them to dependent widgets
557  ui->lowCut->setValue(m_settings.m_lowCutoff / 100.0);
558  ui->lowCutText->setText(tr("%1k").arg(m_settings.m_lowCutoff / 1000.0));
559 
560  ui->volume->setValue(m_settings.m_volume * 10.0);
561  ui->volumeText->setText(QString("%1").arg(m_settings.m_volume, 0, 'f', 1));
562 
563  ui->agcTimeLog2->setValue(m_settings.m_agcTimeLog2);
564  s = QString::number((1<<ui->agcTimeLog2->value()), 'f', 0);
565  ui->agcTimeText->setText(s);
566 
567  ui->agcPowerThreshold->setValue(m_settings.m_agcPowerThreshold);
568  displayAGCPowerThreshold(ui->agcPowerThreshold->value());
570 
571  blockApplySettings(false);
572 }
573 
575 {
577  {
578  ui->agcPowerThresholdText->setText("---");
579  }
580  else
581  {
582  QString s = QString::number(value, 'f', 0);
583  ui->agcPowerThresholdText->setText(s);
584  }
585 }
586 
588 {
589  QString s = QString::number(value, 'f', 0);
590  ui->agcThresholdGateText->setText(s);
591  int dialValue = value;
592 
593  if (value > 20) {
594  dialValue = ((value - 20) / 10) + 20;
595  }
596 
597  ui->agcThresholdGate->setValue(dialValue);
598 }
599 
601 {
603 }
604 
606 {
608 }
609 
611 {
612  qDebug("SSBDemodGUI::audioSelect");
614  audioSelect.exec();
615 
616  if (audioSelect.m_selected)
617  {
619  applySettings();
620  }
621 }
622 
624 {
625  double magsqAvg, magsqPeak;
626  int nbMagsqSamples;
627  m_ssbDemod->getMagSqLevels(magsqAvg, magsqPeak, nbMagsqSamples);
628  double powDbAvg = CalcDb::dbPower(magsqAvg);
629  double powDbPeak = CalcDb::dbPower(magsqPeak);
630 
631  ui->channelPowerMeter->levelChanged(
634  nbMagsqSamples);
635 
636  if (m_tickCount % 4 == 0) {
637  ui->channelPower->setText(tr("%1 dB").arg(powDbAvg, 0, 'f', 1));
638  }
639 
640  bool squelchOpen = m_ssbDemod->getAudioActive();
641 
642  if (squelchOpen != m_squelchOpen)
643  {
644  if (squelchOpen) {
645  ui->audioMute->setStyleSheet("QToolButton { background-color : green; }");
646  } else {
647  ui->audioMute->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
648  }
649 
650  m_squelchOpen = squelchOpen;
651  }
652 
653  m_tickCount++;
654 }
static MainWindow * getInstance()
Definition: mainwindow.h:73
const QString & getReverseAPIAddress() const
virtual void destroy()
Definition: ssbdemodgui.cpp:27
void on_agcPowerThreshold_valueChanged(int value)
int getCenterFrequency() const
Definition: channelmarker.h:42
void setLowCutoff(int lowCutoff)
void on_dsb_toggled(bool dsb)
uint16_t m_reverseAPIPort
void push(Message *message, bool emitSignal=true)
Push message onto queue.
void on_audioMute_toggled(bool checked)
void on_audioFlipChannels_toggled(bool flip)
void on_audioBinaural_toggled(bool binaural)
static double dbPower(double magsq, double floor=1e-12)
Definition: db.cpp:22
void channelMarkerChangedByCursor()
virtual void setCenterFrequency(qint64 centerFrequency)
Definition: ssbdemodgui.cpp:47
MessageQueue * getInputMessageQueue()
Get the queue for asynchronous inbound communication.
PluginAPI * m_pluginAPI
Definition: ssbdemodgui.h:49
int spanLog2Limit(int spanLog2)
virtual qint64 getCenterFrequency() const
Definition: ssbdemodgui.cpp:42
virtual bool handleMessage(const Message &message)
Definition: ssbdemodgui.cpp:81
bool m_squelchOpen
Definition: ssbdemodgui.h:58
QByteArray serialize() const
Definition: ssbdemodgui.cpp:59
static SSBDemodGUI * create(PluginAPI *pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel)
Definition: ssbdemodgui.cpp:21
SpectrumVis * m_spectrumVis
Definition: ssbdemodgui.h:62
static const QString m_channelIdURI
Definition: ssbdemod.h:176
int m_spectrumRate
Definition: ssbdemodgui.h:54
static MsgConfigureChannelizer * create(int sampleRate, int centerFrequency)
Definition: ssbdemod.h:81
static const int m_minPowerThresholdDB
void resetToDefaults()
Definition: ssbdemodgui.cpp:54
void setReverseAPIChannelIndex(uint16_t channelIndex)
QByteArray serialize() const
void resetContextMenuType()
Definition: rollupwidget.h:50
void addChannelMarker(ChannelMarker *channelMarker)
Add channel marker to spectrum.
Definition: deviceuiset.cpp:72
SSBDemodGUI(PluginAPI *pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel, QWidget *parent=0)
void getMagSqLevels(double &avg, double &peak, int &nbSamples)
Definition: ssbdemod.h:144
void on_agcThresholdGate_valueChanged(int value)
void applySettings(bool force=false)
bool m_doApplySettings
Definition: ssbdemodgui.h:53
ChannelMarker m_channelMarker
Definition: ssbdemodgui.h:51
void on_spanLog2_valueChanged(int value)
ContextMenuType m_contextMenuType
Definition: rollupwidget.h:33
bool deserialize(const QByteArray &data)
Fixed< IntType, IntBits > arg(const std::complex< Fixed< IntType, IntBits > > &val)
Definition: fixed.h:2401
void setReverseAPIDeviceIndex(uint16_t deviceIndex)
#define SDR_RX_SCALEF
Definition: dsptypes.h:33
void displayAGCPowerThreshold(int value)
void setSampleSink(BasebandSampleSink *sampleSink)
Definition: ssbdemod.h:100
SSBDemodSettings m_settings
Definition: ssbdemodgui.h:52
virtual void setMessageQueueToGUI(MessageQueue *queue)
static DSPEngine * instance()
Definition: dspengine.cpp:51
void setTitleColor(const QColor &c)
void setHighlighted(bool highlighted)
void applyBandwidths(int spanLog2, bool force=false)
const SSBDemodSettings & getSettings() const
Definition: ssbdemod.h:55
uint32_t m_tickCount
Definition: ssbdemodgui.h:59
void handleInputMessages()
void registerRxChannelInstance(const QString &channelName, PluginInstanceGUI *pluginGUI)
Definition: deviceuiset.cpp:82
bool deserialize(const QByteArray &data)
Definition: ssbdemodgui.cpp:64
void addRollupWidget(QWidget *widget)
Add rollup widget to channel window.
Definition: deviceuiset.cpp:77
QString getName() const
Definition: ssbdemodgui.cpp:37
void removeRxChannelInstance(PluginInstanceGUI *pluginGUI)
Definition: deviceuiset.cpp:94
const QString & getTitle() const
Definition: channelmarker.h:38
bool blockApplySettings(bool block)
static bool match(const Message *message)
Definition: message.cpp:45
bool getHighlighted() const
Definition: channelmarker.h:61
void on_agcTimeLog2_valueChanged(int value)
void on_BW_valueChanged(int value)
void leaveEvent(QEvent *)
void on_agc_toggled(bool checked)
uint16_t m_reverseAPIDeviceIndex
virtual ~SSBDemodGUI()
void on_lowCut_valueChanged(int value)
void displayAGCThresholdGate(int value)
uint32_t getAudioSampleRate() const
Definition: ssbdemod.h:139
void setReverseAPIAddress(const QString &address)
void setHighlighted(bool highlighted)
uint16_t m_reverseAPIChannelIndex
qint32 m_inputFrequencyOffset
void setSpectrumGUI(Serializable *spectrumGUI)
void setColor(const QColor &color)
void displaySettings()
uint32_t getInputSampleRate() const
Definition: ssbdemod.h:140
QIcon m_iconDSBLSB
Definition: ssbdemodgui.h:66
void setVisible(bool visible)
void on_volume_valueChanged(int value)
bool getAudioActive() const
Definition: ssbdemod.h:142
bool m_audioMute
Definition: ssbdemodgui.h:57
void on_agcClamping_toggled(bool checked)
void setBandwidth(int bandwidth)
QString m_reverseAPIAddress
void on_deltaFrequency_changed(qint64 value)
const QColor & getColor() const
Definition: channelmarker.h:64
void setTitle(const QString &title)
Ui::SSBDemodGUI * ui
Definition: ssbdemodgui.h:48
void setName(const QString &name)
Definition: ssbdemodgui.cpp:32
QIcon m_iconDSBUSB
Definition: ssbdemodgui.h:65
void channelMarkerHighlightedByCursor()
static const float m_mminPowerThresholdDBf
void setCenterFrequency(int centerFrequency)
void setSidebands(sidebands_t sidebands)
static MsgConfigureSSBDemod * create(const SSBDemodSettings &settings, bool force)
Definition: ssbdemod.h:58
SSBDemod * m_ssbDemod
Definition: ssbdemodgui.h:61
void onMenuDialogCalled(const QPoint &p)
void on_flipSidebands_clicked(bool checked)
void audioSelect()
void widgetRolled(QWidget *widget, bool rollDown)
bool m_audioFlipChannels
Definition: ssbdemodgui.h:56
void setUseReverseAPI(bool useReverseAPI)
bool m_audioBinaural
Definition: ssbdemodgui.h:55
void enterEvent(QEvent *)
void onWidgetRolled(QWidget *widget, bool rollDown)
DeviceUISet * m_deviceUISet
Definition: ssbdemodgui.h:50
void setChannelMarker(Serializable *channelMarker)
virtual MessageQueue * getInputMessageQueue()
Definition: ssbdemodgui.h:40
T min(const T &x, const T &y)
Definition: framework.h:440