Introduce PostProcessingSettings. Remove utils/dsoStrings and add translation me…

…thods directly to the location where the relevant enums are declared. Remove union for math-channel/coupling value: Some compilers have issues here.

Introduce PostProcessingSettings. Remove utils/dsoStrings and add translation me…
…thods directly to the location where the relevant enums are declared. Remove union for math-channel/coupling value: Some compilers have issues here.
David Graeff · David Gräff
1 parent 9b32a462
Showing 25 changed files with 316 additions and 346 deletions
openhantek/readme.md
openhantek/src/configdialog/DsoConfigAnalysisPage.cpp
openhantek/src/docks/HorizontalDock.cpp
openhantek/src/docks/SpectrumDock.cpp
openhantek/src/docks/TriggerDock.cpp
openhantek/src/docks/VoltageDock.cpp
openhantek/src/docks/VoltageDock.h
openhantek/src/docks/dockwindows.cpp
openhantek/src/dsowidget.cpp
openhantek/src/dsowidget.h
openhantek/src/hantekdso/enums.cpp
openhantek/src/hantekdso/enums.h
openhantek/src/hantekdso/hantekdsocontrol.cpp
openhantek/src/hantekdso/hantekdsocontrol.h
openhantek/src/post/enums.cpp
openhantek/src/post/mathchannelgenerator.cpp
openhantek/src/post/postprocessingsettings.cpp
openhantek/src/post/enums.h → openhantek/src/post/postprocessingsettings.h
openhantek/src/post/spectrumgenerator.cpp
openhantek/src/post/spectrumgenerator.h
@@ -52,8 +52,28 @@ and the graphical part.
 All OpenGL rendering takes place in the `GlScope` class. A helper class `GlScopeGraph` contains exactly one
 data sample snapshot including all channels for voltage and spectrum and a pointer to the respective GPU buffer.
-`GlScope` works for OpenGL 3.2 and OpenGL ES 2.0, but this needs to be decided at compile time. Usually Qt
-selects the right interface.
+`GlScope` works for OpenGL 3.2 and OpenGL ES 2.0. If both is present, OpenGL will be prefered, but can be
+overwritten by the user via a command flag.
+
+### Export
+
+All export related funtionality is within *src/exporting*.
+
+The following exporters are implemented:
+
+* Export to comma separated value file (CSV): Write to a user selected file,
+* Export to an image/pdf: Writes an image/pdf to a user selected file,
+* Print exporter: Creates a printable document and opens the print dialog.
+
+All export classes (exportcsv, exportimage, exportprint) implement the
+ExporterInterface and are registered to the ExporterRegistry in the main.cpp.
+
+Some export classes are still using the legacyExportDrawer class to
+draw the grid and paint all the labels, values and graphs.
+
+The plan is to retire this legacy class and replace the paint code with
+a `GlScope` class shared OpenGL drawing code for at least the grid and the
+scope graphs.
 ## Data flow
@@ -15,14 +15,14 @@ DsoConfigAnalysisPage::DsoConfigAnalysisPage(DsoSettings *settings, QWidget *par
     windowFunctionLabel = new QLabel(tr("Window function"));
     windowFunctionComboBox = new QComboBox();
     windowFunctionComboBox->addItems(windowFunctionStrings);
-    windowFunctionComboBox->setCurrentIndex((int)settings->scope.spectrumWindow);
+    windowFunctionComboBox->setCurrentIndex((int)settings->post.spectrumWindow);
     referenceLevelLabel = new QLabel(tr("Reference level"));
     referenceLevelSpinBox = new QDoubleSpinBox();
     referenceLevelSpinBox->setDecimals(1);
     referenceLevelSpinBox->setMinimum(-40.0);
     referenceLevelSpinBox->setMaximum(100.0);
-    referenceLevelSpinBox->setValue(settings->scope.spectrumReference);
+    referenceLevelSpinBox->setValue(settings->post.spectrumReference);
     referenceLevelUnitLabel = new QLabel(tr("dBm"));
     referenceLevelLayout = new QHBoxLayout();
     referenceLevelLayout->addWidget(referenceLevelSpinBox);
@@ -33,7 +33,7 @@ DsoConfigAnalysisPage::DsoConfigAnalysisPage(DsoSettings *settings, QWidget *par
     minimumMagnitudeSpinBox->setDecimals(1);
     minimumMagnitudeSpinBox->setMinimum(-40.0);
     minimumMagnitudeSpinBox->setMaximum(100.0);
-    minimumMagnitudeSpinBox->setValue(settings->scope.spectrumLimit);
+    minimumMagnitudeSpinBox->setValue(settings->post.spectrumLimit);
     minimumMagnitudeUnitLabel = new QLabel(tr("dBm"));
     minimumMagnitudeLayout = new QHBoxLayout();
     minimumMagnitudeLayout->addWidget(minimumMagnitudeSpinBox);
@@ -59,7 +59,7 @@ DsoConfigAnalysisPage::DsoConfigAnalysisPage(DsoSettings *settings, QWidget *par
 /// \brief Saves the new settings.
 void DsoConfigAnalysisPage::saveSettings() {
-    settings->scope.spectrumWindow = (Dso::WindowFunction)windowFunctionComboBox->currentIndex();
-    settings->scope.spectrumReference = referenceLevelSpinBox->value();
-    settings->scope.spectrumLimit = minimumMagnitudeSpinBox->value();
+    settings->post.spectrumWindow = (Dso::WindowFunction)windowFunctionComboBox->currentIndex();
+    settings->post.spectrumReference = referenceLevelSpinBox->value();
+    settings->post.spectrumLimit = minimumMagnitudeSpinBox->value();
 }
@@ -15,7 +15,6 @@
 #include "scopesettings.h"
 #include "sispinbox.h"
-#include "utils/dsoStrings.h"
 #include "utils/printutils.h"
 template<typename... Args> struct SELECT {
@@ -14,7 +14,6 @@
 #include "settings.h"
 #include "sispinbox.h"
-#include "utils/dsoStrings.h"
 #include "utils/printutils.h"
 template<typename... Args> struct SELECT {
@@ -15,7 +15,6 @@
 #include "hantekdso/controlspecification.h"
 #include "settings.h"
 #include "sispinbox.h"
-#include "utils/dsoStrings.h"
 #include "utils/printutils.h"
 TriggerDock::TriggerDock(DsoSettingsScope *scope, const Dso::ControlSpecification *spec, QWidget *parent,
@@ -14,7 +14,6 @@
 #include "settings.h"
 #include "sispinbox.h"
-#include "utils/dsoStrings.h"
 #include "utils/printutils.h"
 template<typename... Args> struct SELECT {
@@ -66,9 +65,9 @@ VoltageDock::VoltageDock(DsoSettingsScope *scope, const Dso::ControlSpecificatio
         dockLayout->addWidget(b.invertCheckBox, (int)channel * 3 + 2, 1);
         if (channel < spec->channels)
-            setCoupling(channel, scope->voltage[channel].couplingIndex);
+            setCoupling(channel, scope->voltage[channel].couplingOrMathIndex);
         else
-            setMode(scope->voltage[channel].math);
+            setMode(scope->voltage[channel].couplingOrMathIndex);
         setGain(channel, scope->voltage[channel].gainStepIndex);
         setUsed(channel, scope->voltage[channel].used);
@@ -80,12 +79,11 @@ VoltageDock::VoltageDock(DsoSettingsScope *scope, const Dso::ControlSpecificatio
             this->scope->voltage[channel].inverted = checked;
         });
         connect(b.miscComboBox, SELECT<int>::OVERLOAD_OF(&QComboBox::currentIndexChanged), [this,channel,spec,scope](int index){
+            this->scope->voltage[channel].couplingOrMathIndex = (unsigned)index;
             if (channel < spec->channels) {
-                this->scope->voltage[channel].couplingIndex = (unsigned)index;
                 emit couplingChanged(channel, scope->coupling(channel, spec));
             } else {
-                this->scope->voltage[channel].math = (Dso::MathMode) index;
-                emit modeChanged(this->scope->voltage[channel].math);
+                emit modeChanged(Dso::getMathMode(this->scope->voltage[channel]));
             }
         });
         connect(b.usedCheckBox, &QAbstractButton::toggled, [this,channel](bool checked) {
@@ -119,9 +117,9 @@ void VoltageDock::setGain(ChannelID channel, unsigned gainStepIndex) {
     channelBlocks[channel].gainComboBox->setCurrentIndex((unsigned)gainStepIndex);
 }
-void VoltageDock::setMode(Dso::MathMode mode) {
+void VoltageDock::setMode(unsigned mathModeIndex) {
     QSignalBlocker blocker(channelBlocks[spec->channels].miscComboBox);
-    channelBlocks[spec->channels].miscComboBox->setCurrentIndex((int)mode);
+    channelBlocks[spec->channels].miscComboBox->setCurrentIndex((int)mathModeIndex);
 }
 void VoltageDock::setUsed(ChannelID channel, bool used) {
@@ -10,6 +10,7 @@
 #include "scopesettings.h"
 #include "hantekdso/controlspecification.h"
+#include "post/postprocessingsettings.h"
 class SiSpinBox;
@@ -28,7 +29,7 @@ class VoltageDock : public QDockWidget {
     /// \brief Sets the coupling for a channel.
     /// \param channel The channel, whose coupling should be set.
-    /// \param coupling The coupling-mode.
+    /// \param couplingIndex The coupling-mode index.
     void setCoupling(ChannelID channel, unsigned couplingIndex);
     /// \brief Sets the gain for a channel.
@@ -37,8 +38,8 @@ class VoltageDock : public QDockWidget {
     void setGain(ChannelID channel, unsigned gainStepIndex);
     /// \brief Sets the mode for the math channel.
-    /// \param mode The math-mode.
-    void setMode(Dso::MathMode mode);
+    /// \param mathModeIndex The math-mode index.
+    void setMode(unsigned mathModeIndex);
     /// \brief Enables/disables a channel.
     /// \param channel The channel, that should be enabled/disabled.
@@ -8,7 +8,7 @@
 #include <cmath>
-#include "post/enums.h"
+#include "post/postprocessingsettings.h"
 #include "hantekdso/enums.h"
 #include "hantekprotocol/types.h"
 #include "dockwindows.h"
@@ -10,10 +10,10 @@
 #include "dsowidget.h"
+#include "post/postprocessingsettings.h"
 #include "post/graphgenerator.h"
 #include "post/ppresult.h"
-#include "utils/dsoStrings.h"
 #include "utils/printutils.h"
 #include "glscope.h"
@@ -252,10 +252,6 @@ void DsoWidget::setupSliders(DsoWidget::Sliders &amp;sliders) {
     }
 }
-void DsoWidget::setExporterForNextFrame(std::unique_ptr<Exporter> exporter) {
-    this->exportNextFrame = std::move(exporter);
-}
-
 /// \brief Set the trigger level sliders minimum and maximum to the new values.
 void DsoWidget::adaptTriggerLevelSlider(DsoWidget::Sliders &sliders, ChannelID channel) {
     sliders.triggerLevelSlider->setLimits((int)channel,
@@ -422,7 +418,8 @@ void DsoWidget::updateVoltageCoupling(ChannelID channel) {
 /// \brief Handles modeChanged signal from the voltage dock.
 void DsoWidget::updateMathMode() {
-    measurementMiscLabel[spec->channels]->setText(Dso::mathModeString(scope->voltage[spec->channels].math));
+    measurementMiscLabel[spec->channels]->setText(
+        Dso::mathModeString(Dso::getMathMode(scope->voltage[spec->channels])));
 }
 /// \brief Handles gainChanged signal from the voltage dock.
@@ -486,15 +483,8 @@ void DsoWidget::updateZoom(bool enabled) {
 /// \brief Prints analyzed data.
 void DsoWidget::showNew(std::shared_ptr<PPresult> data) {
-    if (exportNextFrame) {
-        exportNextFrame->exportSamples(data.get());
-        exportNextFrame.reset(nullptr);
-    }
-
-    mainScope->showData(data.get());
-    mainScope->update();
-    zoomScope->showData(data.get());
-    zoomScope->update();
+    mainScope->showData(data);
+    zoomScope->showData(data);
     if (spec->isSoftwareTriggerDevice) {
         QPalette triggerLabelPalette = palette();
@@ -8,7 +8,6 @@
 #include <QGridLayout>
 #include <memory>
-#include "exporting/exporter.h"
 #include "glscope.h"
 #include "levelslider.h"
 #include "hantekdso/controlspecification.h"
@@ -36,7 +35,6 @@ class DsoWidget : public QWidget {
     /// \param parent The parent widget.
     /// \param flags Flags for the window manager.
     DsoWidget(DsoSettingsScope* scope, DsoSettingsView* view, const Dso::ControlSpecification* spec, QWidget *parent = 0, Qt::WindowFlags flags = 0);
-    void setExporterForNextFrame(std::unique_ptr<Exporter> exporter);
     // Data arrived
     void showNew(std::shared_ptr<PPresult> data);
@@ -87,7 +85,6 @@ class DsoWidget : public QWidget {
     GlScope *mainScope;     ///< The main scope screen
     GlScope *zoomScope;     ///< The optional magnified scope screen
-    std::unique_ptr<Exporter> exportNextFrame;
   public slots:
     // Horizontal axis
 #include "enums.h"
+#include <QCoreApplication>
 namespace Dso {
     Enum<Dso::TriggerMode, Dso::TriggerMode::HARDWARE_SOFTWARE, Dso::TriggerMode::SINGLE> TriggerModeEnum;
     Enum<Dso::Slope, Dso::Slope::Positive, Dso::Slope::Negative> SlopeEnum;
     Enum<Dso::GraphFormat, Dso::GraphFormat::TY, Dso::GraphFormat::XY> GraphFormatEnum;
+
+    /// \brief Return string representation of the given channel mode.
+    /// \param mode The ::ChannelMode that should be returned as string.
+    /// \return The string that should be used in labels etc., empty when invalid.
+    QString channelModeString(ChannelMode mode) {
+        switch (mode) {
+        case ChannelMode::Voltage:
+            return QCoreApplication::tr("Voltage");
+        case ChannelMode::Spectrum:
+            return QCoreApplication::tr("Spectrum");
+        }
+        return QString();
+    }
+
+    /// \brief Return string representation of the given graph format.
+    /// \param format The ::GraphFormat that should be returned as string.
+    /// \return The string that should be used in labels etc.
+    QString graphFormatString(GraphFormat format) {
+        switch (format) {
+        case GraphFormat::TY:
+            return QCoreApplication::tr("T - Y");
+        case GraphFormat::XY:
+            return QCoreApplication::tr("X - Y");
+        }
+        return QString();
+    }
+
+    /// \brief Return string representation of the given channel coupling.
+    /// \param coupling The ::Coupling that should be returned as string.
+    /// \return The string that should be used in labels etc.
+    QString couplingString(Coupling coupling) {
+        switch (coupling) {
+        case Coupling::AC:
+            return QCoreApplication::tr("AC");
+        case Coupling::DC:
+            return QCoreApplication::tr("DC");
+        case Coupling::GND:
+            return QCoreApplication::tr("GND");
+        }
+        return QString();
+    }
+
+
+    /// \brief Return string representation of the given trigger mode.
+    /// \param mode The ::TriggerMode that should be returned as string.
+    /// \return The string that should be used in labels etc.
+    QString triggerModeString(TriggerMode mode) {
+        switch (mode) {
+        case TriggerMode::WAIT_FORCE:
+            return QCoreApplication::tr("Wait/Force");
+        case TriggerMode::HARDWARE_SOFTWARE:
+            return QCoreApplication::tr("Hard-/Software");
+        case TriggerMode::SINGLE:
+            return QCoreApplication::tr("Single");
+        }
+        return QString();
+    }
+
+    /// \brief Return string representation of the given trigger slope.
+    /// \param slope The ::Slope that should be returned as string.
+    /// \return The string that should be used in labels etc.
+    QString slopeString(Slope slope) {
+        switch (slope) {
+        case Slope::Positive:
+            return QString::fromUtf8("\u2197");
+        case Slope::Negative:
+            return QString::fromUtf8("\u2198");
+        default:
+            return QString();
+        }
+    }
+
+    /// \brief Return string representation of the given graph interpolation mode.
+    /// \param interpolation The ::InterpolationMode that should be returned as
+    /// string.
+    /// \return The string that should be used in labels etc.
+    QString interpolationModeString(InterpolationMode interpolation) {
+        switch (interpolation) {
+        case INTERPOLATION_OFF:
+            return QCoreApplication::tr("Off");
+        case INTERPOLATION_LINEAR:
+            return QCoreApplication::tr("Linear");
+        case INTERPOLATION_SINC:
+            return QCoreApplication::tr("Sinc");
+        default:
+            return QString();
+        }
+    }
 }
@@ -2,6 +2,7 @@
 #include "utils/enumclass.h"
 #include <QMetaType>
+#include <QString>
 namespace Dso {
 /// \enum ChannelMode
 /// \brief The channel display modes.
@@ -52,6 +53,13 @@ enum InterpolationMode {
     INTERPOLATION_SINC,    ///< Smooth graph through the dots
     INTERPOLATION_COUNT    ///< Total number of interpolation modes
 };
+
+QString channelModeString(ChannelMode mode);
+QString graphFormatString(GraphFormat format);
+QString couplingString(Coupling coupling);
+QString triggerModeString(TriggerMode mode);
+QString slopeString(Slope slope);
+QString interpolationModeString(InterpolationMode interpolation);
 }
 Q_DECLARE_METATYPE(Dso::TriggerMode)
@@ -22,30 +22,17 @@ using namespace Hantek;
 using namespace Dso;
 /// \brief Start sampling process.
-void HantekDsoControl::startSampling() {
-    sampling = true;
+void HantekDsoControl::enableSampling(bool enabled) {
+    sampling = enabled;
     // Emit signals for initial settings
-    emit availableRecordLengthsChanged(controlsettings.samplerate.limits->recordLengths);
-    updateSamplerateLimits();
-    emit recordLengthChanged(getRecordLength());
-    if (!isRollMode()) emit recordTimeChanged((double)getRecordLength() / controlsettings.samplerate.current);
-    emit samplerateChanged(controlsettings.samplerate.current);
+    //    emit availableRecordLengthsChanged(controlsettings.samplerate.limits->recordLengths);
+    //    updateSamplerateLimits();
+    //    emit recordLengthChanged(getRecordLength());
+    //    if (!isRollMode()) emit recordTimeChanged((double)getRecordLength() / controlsettings.samplerate.current);
+    //    emit samplerateChanged(controlsettings.samplerate.current);
-    if (specification->isFixedSamplerateDevice) {
-        // Convert to GUI presentable values (1e5 -> 1.0, 48e6 -> 480.0 etc)
-        QList<double> sampleSteps;
-        for (auto &v : specification->fixedSampleRates) { sampleSteps << v.samplerate / 1e5; }
-        emit samplerateSet(1, sampleSteps);
-    }
-
-    emit samplingStarted();
-}
-
-/// \brief Stop sampling process.
-void HantekDsoControl::stopSampling() {
-    sampling = false;
-    emit samplingStopped();
+    emit samplingStatusChanged(enabled);
 }
 const USBDevice *HantekDsoControl::getDevice() const { return device; }
@@ -91,25 +78,27 @@ int HantekDsoControl::bulkCommand(const std::vector&lt;unsigned char&gt; *command, int
     return device->bulkWrite(command->data(), command->size(), attempts);
 }
-unsigned HantekDsoControl::getChannelCount() { return specification->channels; }
+unsigned HantekDsoControl::getChannelCount() const { return specification->channels; }
 const ControlSettings *HantekDsoControl::getDeviceSettings() const { return &controlsettings; }
-const std::vector<unsigned> &HantekDsoControl::getAvailableRecordLengths() { //
+const std::vector<unsigned> &HantekDsoControl::getAvailableRecordLengths() const { //
     return controlsettings.samplerate.limits->recordLengths;
 }
-double HantekDsoControl::getMinSamplerate() {
+double HantekDsoControl::getMinSamplerate() const {
     return (double)specification->samplerate.single.base / specification->samplerate.single.maxDownsampler;
 }
-double HantekDsoControl::getMaxSamplerate() {
+double HantekDsoControl::getMaxSamplerate() const {
     if (controlsettings.usedChannels <= 1)
         return specification->samplerate.multi.max;
     else
         return specification->samplerate.single.max;
 }
+bool HantekDsoControl::isSampling() const { return sampling; }
+
 /// \brief Updates the interval of the periodic thread timer.
 void HantekDsoControl::updateInterval() {
     // Check the current oscilloscope state everytime 25% of the time the buffer
@@ -593,13 +582,21 @@ void HantekDsoControl::restoreTargets() {
 }
 void HantekDsoControl::updateSamplerateLimits() {
-    // Works only if the minimum samplerate for normal mode is lower than for fast
-    // rate mode, which is the case for all models
-    const double min = (double)specification->samplerate.single.base / specification->samplerate.single.maxDownsampler;
-    const double max = getMaxSamplerate();
-
-    emit samplerateLimitsChanged(min / specification->bufferDividers[controlsettings.recordLengthId],
-                                 max / specification->bufferDividers[controlsettings.recordLengthId]);
+    if (specification->isFixedSamplerateDevice) {
+        // Convert to GUI presentable values (1e5 -> 1.0, 48e6 -> 480.0 etc)
+        QList<double> sampleSteps;
+        for (auto &v : specification->fixedSampleRates) { sampleSteps << v.samplerate / 1e5; }
+        emit samplerateSet(1, sampleSteps);
+    } else {
+        // Works only if the minimum samplerate for normal mode is lower than for fast
+        // rate mode, which is the case for all models
+        const double min =
+            (double)specification->samplerate.single.base / specification->samplerate.single.maxDownsampler;
+        const double max = getMaxSamplerate();
+
+        emit samplerateLimitsChanged(min / specification->bufferDividers[controlsettings.recordLengthId],
+                                     max / specification->bufferDividers[controlsettings.recordLengthId]);
+    }
 }
 Dso::ErrorCode HantekDsoControl::setRecordLength(unsigned index) {
@@ -1175,7 +1172,7 @@ void HantekDsoControl::run() {
             // Check if we're in single trigger mode
             if (controlsettings.trigger.mode == Dso::TriggerMode::SINGLE && this->_samplingStarted)
-                this->stopSampling();
+                this->enableSampling(false);
             // Sampling completed, restart it when necessary
             this->_samplingStarted = false;
@@ -1216,7 +1213,7 @@ void HantekDsoControl::run() {
             // Check if we're in single trigger mode
             if (controlsettings.trigger.mode == Dso::TriggerMode::SINGLE && this->_samplingStarted)
-                this->stopSampling();
+                this->enableSampling(false);
             // Sampling completed, restart it when necessary
             this->_samplingStarted = false;
@@ -52,7 +52,7 @@ class HantekDsoControl : public QObject {
     /// \brief Gets the physical channel count for this oscilloscope.
     /// \return The number of physical channels.
-    unsigned getChannelCount();
+    unsigned getChannelCount() const;
     /// Return the read-only device control settings. Use the set- Methods to change
     /// device settings.
@@ -60,15 +60,17 @@ class HantekDsoControl : public QObject {
     /// \brief Get available record lengths for this oscilloscope.
     /// \return The number of physical channels, empty list for continuous.
-    const std::vector<unsigned> &getAvailableRecordLengths();
+    const std::vector<unsigned> &getAvailableRecordLengths() const;
     /// \brief Get minimum samplerate for this oscilloscope.
     /// \return The minimum samplerate for the current configuration in S/s.
-    double getMinSamplerate();
+    double getMinSamplerate() const;
     /// \brief Get maximum samplerate for this oscilloscope.
     /// \return The maximum samplerate for the current configuration in S/s.
-    double getMaxSamplerate();
+    double getMaxSamplerate() const;
+
+    bool isSampling() const;
     /// Return the associated usb device.
     const USBDevice *getDevice() const;
@@ -182,8 +184,8 @@ class HantekDsoControl : public QObject {
     bool sampling = false; ///< true, if the oscilloscope is taking samples
     // Device setup
-    const Dso::ControlSpecification* specification; ///< The specifications of the device
-    Dso::ControlSettings controlsettings;    ///< The current settings of the device
+    const Dso::ControlSpecification *specification; ///< The specifications of the device
+    Dso::ControlSettings controlsettings;           ///< The current settings of the device
     // Results
     DSOsamples result;
@@ -206,8 +208,10 @@ class HantekDsoControl : public QObject {
     int bulkCommand(const std::vector<unsigned char> *command, int attempts = HANTEK_ATTEMPTS) const;
   public slots:
-    void startSampling();
-    void stopSampling();
+    /// \brief If sampling is disabled, no samplesAvailable() signals are send anymore, no samples
+    /// are fetched from the device and no processing takes place.
+    /// \param enabled Enables/Disables sampling
+    void enableSampling(bool enabled);
     /// \brief Sets the size of the oscilloscopes sample buffer.
     /// \param index The record length index that should be set.
@@ -270,19 +274,21 @@ class HantekDsoControl : public QObject {
     void forceTrigger();
   signals:
-    void samplingStarted();                                  ///< The oscilloscope started sampling/waiting for trigger
-    void samplingStopped();                                  ///< The oscilloscope stopped sampling/waiting for trigger
+    void samplingStatusChanged(bool enabled); ///< The oscilloscope started/stopped sampling/waiting for trigger
     void statusMessage(const QString &message, int timeout); ///< Status message about the oscilloscope
     void samplesAvailable(const DSOsamples *samples);        ///< New sample data is available
     void availableRecordLengthsChanged(const std::vector<unsigned> &recordLengths); ///< The available record
                                                                                     /// lengths, empty list for
-    void samplerateLimitsChanged(double minimum, double maximum); ///< The minimum or maximum samplerate has changed
-    void recordLengthChanged(unsigned long duration);             ///< The record length has changed
-    void recordTimeChanged(double duration);                      ///< The record time duration has changed
-    void samplerateChanged(double samplerate);                    ///< The samplerate has changed
-    void samplerateSet(int mode, QList<double> sampleSteps);      ///< The samplerate has changed
+    /// The available samplerate range has changed
+    void samplerateLimitsChanged(double minimum, double maximum);
+    /// The available samplerate for fixed samplerate devices has changed
+    void samplerateSet(int mode, QList<double> sampleSteps);
+
+    void recordLengthChanged(unsigned long duration); ///< The record length has changed
+    void recordTimeChanged(double duration);          ///< The record time duration has changed
+    void samplerateChanged(double samplerate);        ///< The samplerate has changed
     void communicationError() const;
 };
-#include "enums.h"
-
-namespace Dso {
-
-Enum<Dso::MathMode,Dso::MathMode::ADD_CH1_CH2,Dso::MathMode::SUB_CH1_FROM_CH2> MathModeEnum;
-Enum<Dso::WindowFunction,Dso::WindowFunction::RECTANGULAR,Dso::WindowFunction::FLATTOP> WindowFunctionEnum;
-
-}
 #include "mathchannelgenerator.h"
 #include "scopesettings.h"
+#include "post/postprocessingsettings.h"
+#include "enums.h"
 MathChannelGenerator::MathChannelGenerator(const DsoSettingsScope *scope, unsigned physicalChannels)
     : physicalChannels(physicalChannels), scope(scope) {}
@@ -27,7 +29,7 @@ void MathChannelGenerator::process(PPresult *result) {
         std::vector<double>::const_iterator ch1Iterator = result->data(0)->voltage.sample.begin();
         std::vector<double>::const_iterator ch2Iterator = result->data(1)->voltage.sample.begin();
         for (std::vector<double>::iterator it = resultData.begin(); it != resultData.end(); ++it) {
-            switch (scope->voltage[physicalChannels].math) {
+            switch (Dso::getMathMode(scope->voltage[physicalChannels])) {
             case Dso::MathMode::ADD_CH1_CH2:
                 *it = *ch1Iterator + *ch2Iterator;
                 break;
+#include "postprocessingsettings.h"
+
+#include <QCoreApplication>
+#include <QString>
+
+namespace Dso {
+
+Enum<Dso::MathMode, Dso::MathMode::ADD_CH1_CH2, Dso::MathMode::SUB_CH1_FROM_CH2> MathModeEnum;
+Enum<Dso::WindowFunction, Dso::WindowFunction::RECTANGULAR, Dso::WindowFunction::FLATTOP> WindowFunctionEnum;
+
+/// \brief Return string representation of the given math mode.
+/// \param mode The ::MathMode that should be returned as string.
+/// \return The string that should be used in labels etc.
+QString mathModeString(MathMode mode) {
+    switch (mode) {
+    case MathMode::ADD_CH1_CH2:
+        return QCoreApplication::tr("CH1 + CH2");
+    case MathMode::SUB_CH2_FROM_CH1:
+        return QCoreApplication::tr("CH1 - CH2");
+    case MathMode::SUB_CH1_FROM_CH2:
+        return QCoreApplication::tr("CH2 - CH1");
+    }
+    return QString();
+}
+/// \brief Return string representation of the given dft window function.
+/// \param window The ::WindowFunction that should be returned as string.
+/// \return The string that should be used in labels etc.
+QString windowFunctionString(WindowFunction window) {
+    switch (window) {
+    case WindowFunction::RECTANGULAR:
+        return QCoreApplication::tr("Rectangular");
+    case WindowFunction::HAMMING:
+        return QCoreApplication::tr("Hamming");
+    case WindowFunction::HANN:
+        return QCoreApplication::tr("Hann");
+    case WindowFunction::COSINE:
+        return QCoreApplication::tr("Cosine");
+    case WindowFunction::LANCZOS:
+        return QCoreApplication::tr("Lanczos");
+    case WindowFunction::BARTLETT:
+        return QCoreApplication::tr("Bartlett");
+    case WindowFunction::TRIANGULAR:
+        return QCoreApplication::tr("Triangular");
+    case WindowFunction::GAUSS:
+        return QCoreApplication::tr("Gauss");
+    case WindowFunction::BARTLETTHANN:
+        return QCoreApplication::tr("Bartlett-Hann");
+    case WindowFunction::BLACKMAN:
+        return QCoreApplication::tr("Blackman");
+    // case WindowFunction::WINDOW_KAISER:
+    //	return QCoreApplication::tr("Kaiser");
+    case WindowFunction::NUTTALL:
+        return QCoreApplication::tr("Nuttall");
+    case WindowFunction::BLACKMANHARRIS:
+        return QCoreApplication::tr("Blackman-Harris");
+    case WindowFunction::BLACKMANNUTTALL:
+        return QCoreApplication::tr("Blackman-Nuttall");
+    case WindowFunction::FLATTOP:
+        return QCoreApplication::tr("Flat top");
+    }
+    return QString();
+}
+}
 #pragma once
-#include <QMetaType>
 #include "utils/enumclass.h"
+#include <QMetaType>
 namespace Dso {
 /// \enum MathMode
 /// \brief The different math modes for the math-channel.
-enum class MathMode {
-    ADD_CH1_CH2,
-    SUB_CH2_FROM_CH1,
-    SUB_CH1_FROM_CH2
-};
-extern Enum<Dso::MathMode,Dso::MathMode::ADD_CH1_CH2,Dso::MathMode::SUB_CH1_FROM_CH2> MathModeEnum;
+enum class MathMode : unsigned { ADD_CH1_CH2, SUB_CH2_FROM_CH1, SUB_CH1_FROM_CH2 };
+extern Enum<Dso::MathMode, Dso::MathMode::ADD_CH1_CH2, Dso::MathMode::SUB_CH1_FROM_CH2> MathModeEnum;
+
+template<class T>
+inline MathMode getMathMode(T& t) { return (MathMode)t.couplingOrMathIndex; }
 /// \enum WindowFunction
 /// \brief The supported window functions.
 /// These are needed for spectrum analysis and are applied to the sample values
 /// before calculating the DFT.
-enum class WindowFunction: int {
+enum class WindowFunction : int {
     RECTANGULAR,  ///< Rectangular window (aka Dirichlet)
     HAMMING,      ///< Hamming window
     HANN,         ///< Hann window
@@ -32,12 +31,19 @@ enum class WindowFunction: int {
     NUTTALL,         ///< Nuttall window, cont. first deriv.
     BLACKMANHARRIS,  ///< Blackman-Harris window
     BLACKMANNUTTALL, ///< Blackman-Nuttall window
-    FLATTOP         ///< Flat top window
+    FLATTOP          ///< Flat top window
 };
-extern Enum<Dso::WindowFunction,Dso::WindowFunction::RECTANGULAR,Dso::WindowFunction::FLATTOP> WindowFunctionEnum;
+extern Enum<Dso::WindowFunction, Dso::WindowFunction::RECTANGULAR, Dso::WindowFunction::FLATTOP> WindowFunctionEnum;
+QString mathModeString(MathMode mode);
+QString windowFunctionString(WindowFunction window);
 }
 Q_DECLARE_METATYPE(Dso::MathMode)
 Q_DECLARE_METATYPE(Dso::WindowFunction)
+struct DsoSettingsPostProcessing {
+    Dso::WindowFunction spectrumWindow = Dso::WindowFunction::HANN; ///< Window function for DFT
+    double spectrumReference = 0.0;                                 ///< Reference level for spectrum in dBm
+    double spectrumLimit = -20.0; ///< Minimum magnitude of the spectrum (Avoids peaks)
+};
@@ -16,7 +16,8 @@
 #include "utils/printutils.h"
 /// \brief Analyzes the data from the dso.
-SpectrumGenerator::SpectrumGenerator(const DsoSettingsScope *scope) : scope(scope) {}
+SpectrumGenerator::SpectrumGenerator(const DsoSettingsScope *scope, const DsoSettingsPostProcessing *postprocessing)
+    : scope(scope), postprocessing(postprocessing) {}
 SpectrumGenerator::~SpectrumGenerator() {
     if (lastWindowBuffer) fftw_free(lastWindowBuffer);
@@ -36,15 +37,15 @@ void SpectrumGenerator::process(PPresult *result) {
         // Calculate new window
         size_t sampleCount = channelData->voltage.sample.size();
-        if (!lastWindowBuffer || lastWindow != scope->spectrumWindow || lastRecordLength != sampleCount) {
+        if (!lastWindowBuffer || lastWindow != postprocessing->spectrumWindow || lastRecordLength != sampleCount) {
             if (lastWindowBuffer) fftw_free(lastWindowBuffer);
             lastWindowBuffer = fftw_alloc_real(sampleCount);
             lastRecordLength = (unsigned)sampleCount;
             unsigned int windowEnd = lastRecordLength - 1;
-            lastWindow = scope->spectrumWindow;
+            lastWindow = postprocessing->spectrumWindow;
-            switch (scope->spectrumWindow) {
+            switch (postprocessing->spectrumWindow) {
             case Dso::WindowFunction::HAMMING:
                 for (unsigned int windowPosition = 0; windowPosition < lastRecordLength; ++windowPosition)
                     *(lastWindowBuffer + windowPosition) = 0.54 - 0.46 * cos(2.0 * M_PI * windowPosition / windowEnd);
@@ -210,8 +211,8 @@ void SpectrumGenerator::process(PPresult *result) {
         // Finally calculate the real spectrum if we want it
         if (scope->spectrum[channel].used) {
             // Convert values into dB (Relative to the reference level)
-            double offset = 60 - scope->spectrumReference - 20 * log10(dftLength);
-            double offsetLimit = scope->spectrumLimit - scope->spectrumReference;
+            double offset = 60 - postprocessing->spectrumReference - 20 * log10(dftLength);
+            double offsetLimit = postprocessing->spectrumLimit - postprocessing->spectrumReference;
             for (std::vector<double>::iterator spectrumIterator = channelData->spectrum.sample.begin();
                  spectrumIterator != channelData->spectrum.sample.end(); ++spectrumIterator) {
                 double value = 20 * log10(fabs(*spectrumIterator)) + offset;
@@ -11,7 +11,7 @@
 #include "ppresult.h"
 #include "dsosamples.h"
 #include "utils/printutils.h"
-#include "enums.h"
+#include "postprocessingsettings.h"
 #include "processor.h"
@@ -23,12 +23,13 @@ struct DsoSettingsScope;
 /// time-/frequencysteps between two values.
 class SpectrumGenerator : public Processor {
   public:
-    SpectrumGenerator(const DsoSettingsScope* scope);
+    SpectrumGenerator(const DsoSettingsScope* scope, const DsoSettingsPostProcessing* postprocessing);
     virtual ~SpectrumGenerator();
     virtual void process(PPresult *data) override;
   private:
     const DsoSettingsScope* scope;
+    const DsoSettingsPostProcessing* postprocessing;
     unsigned int lastRecordLength = 0;                        ///< The record length of the previously analyzed data
     Dso::WindowFunction lastWindow = (Dso::WindowFunction)-1; ///< The previously used dft window function
     double *lastWindowBuffer = nullptr;
@@ -7,7 +7,6 @@
 #include "hantekdso/controlspecification.h"
 #include "hantekdso/enums.h"
 #include "hantekprotocol/definitions.h"
-#include "post/enums.h"
 #include <vector>
 #define MARKER_COUNT 2 ///< Number of markers
@@ -52,37 +51,30 @@ struct DsoSettingsScopeSpectrum {
 /// \brief Holds the settings for the normal voltage graphs.
 /// TODO Use ControlSettingsVoltage
 struct DsoSettingsScopeVoltage {
-    double offset = 0.0;        ///< Vertical offset in divs
-    double trigger = 0.0;       ///< Trigger level in V
-    unsigned gainStepIndex = 6; ///< The vertical resolution in V/div (default = 1.0)
-    union {                     ///< Different enums, coupling for real- and mode for math-channels
-        Dso::MathMode math;
-        unsigned couplingIndex = 0;
-        int rawValue;
-    };
-    QString name;          ///< Name of this channel
-    bool inverted = false; ///< true if the channel is inverted (mirrored on cross-axis)
-    bool used = false;     ///< true if this channel is enabled
+    double offset = 0.0;              ///< Vertical offset in divs
+    double trigger = 0.0;             ///< Trigger level in V
+    unsigned gainStepIndex = 6;       ///< The vertical resolution in V/div (default = 1.0)
+    unsigned couplingOrMathIndex = 0; ///< Different index: coupling for real- and mode for math-channels
+    QString name;                     ///< Name of this channel
+    bool inverted = false;            ///< true if the channel is inverted (mirrored on cross-axis)
+    bool used = false;                ///< true if this channel is enabled
 };
 /// \brief Holds the settings for the oscilloscope.
 struct DsoSettingsScope {
     std::vector<double> gainSteps = {1e-2, 2e-2, 5e-2, 1e-1, 2e-1,
                                      5e-1, 1e0,  2e0,  5e0};        ///< The selectable voltage gain steps in V/div
-    Dso::WindowFunction spectrumWindow = Dso::WindowFunction::HANN; ///< Window function for DFT
     std::vector<DsoSettingsScopeSpectrum> spectrum;                 ///< Spectrum analysis settings
     std::vector<DsoSettingsScopeVoltage> voltage;                   ///< Settings for the normal graphs
     DsoSettingsScopeHorizontal horizontal;                          ///< Settings for the horizontal axis
     DsoSettingsScopeTrigger trigger;                                ///< Settings for the trigger
-    double spectrumReference = 0.0;                                 ///< Reference level for spectrum in dBm
-    double spectrumLimit = -20.0; ///< Minimum magnitude of the spectrum (Avoids peaks)
     double gain(unsigned channel) const { return gainSteps[voltage[channel].gainStepIndex]; }
     bool anyUsed(ChannelID channel) { return voltage[channel].used | spectrum[channel].used; }
-    Dso::Coupling coupling(ChannelID channel, const Dso::ControlSpecification *deviceSpecification) {
-        return deviceSpecification->couplings[voltage[channel].couplingIndex];
+    Dso::Coupling coupling(ChannelID channel, const Dso::ControlSpecification *deviceSpecification) const {
+        return deviceSpecification->couplings[voltage[channel].couplingOrMathIndex];
     }
     // Channels, including math channels
-    unsigned countChannels() { return (unsigned)voltage.size(); }
+    unsigned countChannels() const { return (unsigned)voltage.size(); }
 };
@@ -35,7 +35,7 @@ DsoSettings::DsoSettings(const Dso::ControlSpecification* deviceSpecification) {
     scope.spectrum.push_back(newSpectrum);
     DsoSettingsScopeVoltage newVoltage;
-    newVoltage.math = Dso::MathMode::ADD_CH1_CH2;
+    newVoltage.couplingOrMathIndex = (unsigned)Dso::MathMode::ADD_CH1_CH2;
     newVoltage.name = QApplication::tr("MATH");
     scope.voltage.push_back(newVoltage);
@@ -106,19 +106,20 @@ void DsoSettings::load() {
     for (ChannelID channel = 0; channel < scope.voltage.size(); ++channel) {
         store->beginGroup(QString("vertical%1").arg(channel));
         if (store->contains("gainStepIndex")) scope.voltage[channel].gainStepIndex = store->value("gainStepIndex").toUInt();
-        if (store->contains("couplingIndex")) scope.voltage[channel].couplingIndex = store->value("couplingIndex").toUInt();
+        if (store->contains("couplingOrMathIndex")) scope.voltage[channel].couplingOrMathIndex = store->value("couplingIndex").toUInt();
         if (store->contains("inverted")) scope.voltage[channel].inverted = store->value("inverted").toBool();
-        if (store->contains("misc")) scope.voltage[channel].rawValue = store->value("misc").toInt();
         if (store->contains("offset")) scope.voltage[channel].offset = store->value("offset").toDouble();
         if (store->contains("trigger")) scope.voltage[channel].trigger = store->value("trigger").toDouble();
         if (store->contains("used")) scope.voltage[channel].used = store->value("used").toBool();
         store->endGroup();
     }
-    if (store->contains("spectrumLimit")) scope.spectrumLimit = store->value("spectrumLimit").toDouble();
+
+    // Post processing
+    if (store->contains("spectrumLimit")) post.spectrumLimit = store->value("spectrumLimit").toDouble();
     if (store->contains("spectrumReference"))
-        scope.spectrumReference = store->value("spectrumReference").toDouble();
+        post.spectrumReference = store->value("spectrumReference").toDouble();
     if (store->contains("spectrumWindow"))
-        scope.spectrumWindow = (Dso::WindowFunction)store->value("spectrumWindow").toInt();
+        post.spectrumWindow = (Dso::WindowFunction)store->value("spectrumWindow").toInt();
     store->endGroup();
     // View
@@ -209,17 +210,18 @@ void DsoSettings::save() {
     for (ChannelID channel = 0; channel < scope.voltage.size(); ++channel) {
         store->beginGroup(QString("vertical%1").arg(channel));
         store->setValue("gainStepIndex", scope.voltage[channel].gainStepIndex);
-        store->setValue("couplingIndex", scope.voltage[channel].couplingIndex);
+        store->setValue("couplingOrMathIndex", scope.voltage[channel].couplingOrMathIndex);
         store->setValue("inverted", scope.voltage[channel].inverted);
-        store->setValue("misc", scope.voltage[channel].rawValue);
         store->setValue("offset", scope.voltage[channel].offset);
         store->setValue("trigger", scope.voltage[channel].trigger);
         store->setValue("used", scope.voltage[channel].used);
         store->endGroup();
     }
-    store->setValue("spectrumLimit", scope.spectrumLimit);
-    store->setValue("spectrumReference", scope.spectrumReference);
-    store->setValue("spectrumWindow", (int)scope.spectrumWindow);
+
+    // Post processing
+    store->setValue("spectrumLimit", post.spectrumLimit);
+    store->setValue("spectrumReference", post.spectrumReference);
+    store->setValue("spectrumWindow", (int)post.spectrumWindow);
     store->endGroup();
     // View
@@ -7,22 +7,22 @@
 #include <QString>
 #include <memory>
+#include "exporting/exportsettings.h"
+#include "post/postprocessingsettings.h"
 #include "scopesettings.h"
 #include "viewsettings.h"
-#include "exporting/exportsettings.h"
-#include "hantekdso/controlspecification.h"
-#include "hantekdso/controlsettings.h"
 /// \brief Holds the settings of the program.
 class DsoSettings {
   public:
-    explicit DsoSettings(const Dso::ControlSpecification* deviceSpecification);
+    explicit DsoSettings(const Dso::ControlSpecification *deviceSpecification);
     bool setFilename(const QString &filename);
-    DsoSettingsExport exporting; ///< General options of the program
-    DsoSettingsScope scope;     ///< All oscilloscope related settings
-    DsoSettingsView view;       ///< All view related settings
-    bool alwaysSave = true;            ///< Always save the settings on exit
+    DsoSettingsExport exporting;    ///< General options of the program
+    DsoSettingsScope scope;         ///< All oscilloscope related settings
+    DsoSettingsView view;           ///< All view related settings
+    DsoSettingsPostProcessing post; ///< All post processing related settings
+    bool alwaysSave = true;         ///< Always save the settings on exit
     QByteArray mainWindowGeometry; ///< Geometry of the main window
     QByteArray mainWindowState;    ///< State of docking windows and toolbars
-////////////////////////////////////////////////////////////////////////////////
-//
-//  OpenHantek
-//  dso.cpp
-//
-//  Copyright (C) 2010  Oliver Haag
-//  oliver.haag@gmail.com
-//
-//  This program is free software: you can redistribute it and/or modify it
-//  under the terms of the GNU General Public License as published by the Free
-//  Software Foundation, either version 3 of the License, or (at your option)
-//  any later version.
-//
-//  This program is distributed in the hope that it will be useful, but WITHOUT
-//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
-//  more details.
-//
-//  You should have received a copy of the GNU General Public License along with
-//  this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include <QApplication>
-
-#include "dsoStrings.h"
-
-namespace Dso {
-/// \brief Return string representation of the given channel mode.
-/// \param mode The ::ChannelMode that should be returned as string.
-/// \return The string that should be used in labels etc., empty when invalid.
-QString channelModeString(ChannelMode mode) {
-    switch (mode) {
-    case ChannelMode::Voltage:
-        return QApplication::tr("Voltage");
-    case ChannelMode::Spectrum:
-        return QApplication::tr("Spectrum");
-    }
-    return QString();
-}
-
-/// \brief Return string representation of the given graph format.
-/// \param format The ::GraphFormat that should be returned as string.
-/// \return The string that should be used in labels etc.
-QString graphFormatString(GraphFormat format) {
-    switch (format) {
-    case GraphFormat::TY:
-        return QApplication::tr("T - Y");
-    case GraphFormat::XY:
-        return QApplication::tr("X - Y");
-    }
-    return QString();
-}
-
-/// \brief Return string representation of the given channel coupling.
-/// \param coupling The ::Coupling that should be returned as string.
-/// \return The string that should be used in labels etc.
-QString couplingString(Coupling coupling) {
-    switch (coupling) {
-    case Coupling::AC:
-        return QApplication::tr("AC");
-    case Coupling::DC:
-        return QApplication::tr("DC");
-    case Coupling::GND:
-        return QApplication::tr("GND");
-    }
-    return QString();
-}
-
-/// \brief Return string representation of the given math mode.
-/// \param mode The ::MathMode that should be returned as string.
-/// \return The string that should be used in labels etc.
-QString mathModeString(MathMode mode) {
-    switch (mode) {
-    case MathMode::ADD_CH1_CH2:
-        return QApplication::tr("CH1 + CH2");
-    case MathMode::SUB_CH2_FROM_CH1:
-        return QApplication::tr("CH1 - CH2");
-    case MathMode::SUB_CH1_FROM_CH2:
-        return QApplication::tr("CH2 - CH1");
-    }
-    return QString();
-}
-
-/// \brief Return string representation of the given trigger mode.
-/// \param mode The ::TriggerMode that should be returned as string.
-/// \return The string that should be used in labels etc.
-QString triggerModeString(TriggerMode mode) {
-    switch (mode) {
-    case TriggerMode::WAIT_FORCE:
-        return QApplication::tr("Wait/Force");
-    case TriggerMode::HARDWARE_SOFTWARE:
-        return QApplication::tr("Hard-/Software");
-    case TriggerMode::SINGLE:
-        return QApplication::tr("Single");
-    }
-    return QString();
-}
-
-/// \brief Return string representation of the given trigger slope.
-/// \param slope The ::Slope that should be returned as string.
-/// \return The string that should be used in labels etc.
-QString slopeString(Slope slope) {
-    switch (slope) {
-    case Slope::Positive:
-        return QString::fromUtf8("\u2197");
-    case Slope::Negative:
-        return QString::fromUtf8("\u2198");
-    default:
-        return QString();
-    }
-}
-
-/// \brief Return string representation of the given dft window function.
-/// \param window The ::WindowFunction that should be returned as string.
-/// \return The string that should be used in labels etc.
-QString windowFunctionString(WindowFunction window) {
-    switch (window) {
-    case WindowFunction::RECTANGULAR:
-        return QApplication::tr("Rectangular");
-    case WindowFunction::HAMMING:
-        return QApplication::tr("Hamming");
-    case WindowFunction::HANN:
-        return QApplication::tr("Hann");
-    case WindowFunction::COSINE:
-        return QApplication::tr("Cosine");
-    case WindowFunction::LANCZOS:
-        return QApplication::tr("Lanczos");
-    case WindowFunction::BARTLETT:
-        return QApplication::tr("Bartlett");
-    case WindowFunction::TRIANGULAR:
-        return QApplication::tr("Triangular");
-    case WindowFunction::GAUSS:
-        return QApplication::tr("Gauss");
-    case WindowFunction::BARTLETTHANN:
-        return QApplication::tr("Bartlett-Hann");
-    case WindowFunction::BLACKMAN:
-        return QApplication::tr("Blackman");
-    // case WindowFunction::WINDOW_KAISER:
-    //	return QApplication::tr("Kaiser");
-    case WindowFunction::NUTTALL:
-        return QApplication::tr("Nuttall");
-    case WindowFunction::BLACKMANHARRIS:
-        return QApplication::tr("Blackman-Harris");
-    case WindowFunction::BLACKMANNUTTALL:
-        return QApplication::tr("Blackman-Nuttall");
-    case WindowFunction::FLATTOP:
-        return QApplication::tr("Flat top");
-    default:
-        return QString();
-    }
-}
-
-/// \brief Return string representation of the given graph interpolation mode.
-/// \param interpolation The ::InterpolationMode that should be returned as
-/// string.
-/// \return The string that should be used in labels etc.
-QString interpolationModeString(InterpolationMode interpolation) {
-    switch (interpolation) {
-    case INTERPOLATION_OFF:
-        return QApplication::tr("Off");
-    case INTERPOLATION_LINEAR:
-        return QApplication::tr("Linear");
-    case INTERPOLATION_SINC:
-        return QApplication::tr("Sinc");
-    default:
-        return QString();
-    }
-}
-}
-// SPDX-License-Identifier: GPL-2.0+
-
-#pragma once
-#include <QString>
-#include "post/enums.h"
-#include "hantekdso/enums.h"
-
-#define MARKER_COUNT 2 ///< Number of markers
-
-/// \namespace Dso
-/// \brief All DSO specific things for different modes and so on.
-namespace Dso {
-
-QString channelModeString(ChannelMode mode);
-QString graphFormatString(GraphFormat format);
-QString couplingString(Coupling coupling);
-QString mathModeString(MathMode mode);
-QString triggerModeString(TriggerMode mode);
-QString slopeString(Slope slope);
-QString windowFunctionString(WindowFunction window);
-QString interpolationModeString(InterpolationMode interpolation);
-}