Add tab for loop station

DrumMachine.pro

@@ -15,19 +15,20 @@ SOURCES += \
     audioformat.cpp \
     audioplayer.cpp \
     drummachinesettings.cpp \
-    filesmodel.cpp \
+    drumpadfilesmodel.cpp \
+    drumpadpresets.cpp \
+    drumpadpresetsmodel.cpp \
     graphrenderer.cpp \
     jsonconverters.cpp \
     main.cpp \
     midicontainers.cpp \
     midiinwrapper.cpp \
     midioutwrapper.cpp \
-    presets.cpp \
-    presetsmodel.cpp \
     synthisizer.cpp \
     treetotableproxymodel.cpp \
     widgets/djwidget.cpp \
     widgets/drumpadwidget.cpp \
+    widgets/loopstationwidget.cpp \
     widgets/mainwindow.cpp \
     widgets/midibutton.cpp \
     widgets/presetdetailwidget.cpp \
@@ -44,18 +45,19 @@ HEADERS += \
     audioformat.h \
     audioplayer.h \
     drummachinesettings.h \
-    filesmodel.h \
+    drumpadfilesmodel.h \
+    drumpadpresets.h \
+    drumpadpresetsmodel.h \
     graphrenderer.h \
     jsonconverters.h \
     midicontainers.h \
     midiinwrapper.h \
     midioutwrapper.h \
-    presets.h \
-    presetsmodel.h \
     synthisizer.h \
     treetotableproxymodel.h \
     widgets/djwidget.h \
     widgets/drumpadwidget.h \
+    widgets/loopstationwidget.h \
     widgets/mainwindow.h \
     widgets/midibutton.h \
     widgets/presetdetailwidget.h \
@@ -70,6 +72,7 @@ HEADERS += \
 FORMS += \
     widgets/djwidget.ui \
     widgets/drumpadwidget.ui \
+    widgets/loopstationwidget.ui \
     widgets/mainwindow.ui \
     widgets/presetdetailwidget.ui \
     widgets/sampleswidget.ui \

audioformat.h

@@ -2,6 +2,8 @@
 
 #include <QAudioFormat>
 
+#include <array>
+
 static constexpr int frameRate = 44100;
 static constexpr int channelCount = 2;
 static constexpr int sampleSize = 32;
@@ -9,6 +11,6 @@ static constexpr auto codec = "audio/pcm";
 static constexpr QAudioFormat::Endian byteOrder = QAudioFormat::LittleEndian;
 static constexpr QAudioFormat::SampleType sampleType = QAudioFormat::Float;
 using sample_t = float;
-using frame_t = std::array<sample_t, channelCount>;
+struct frame_t : std::array<sample_t, channelCount> {};
 
 const QAudioFormat &audioFormat();

audioplayer.cpp

@@ -3,6 +3,8 @@
 #include <algorithm>
 #include <cmath>
 
+#include "audioformat.h"
+
 AudioPlayer::AudioPlayer(QObject *parent) :
     QObject{parent}
 {

audioplayer.h

@@ -8,7 +8,7 @@
 #include <QtGlobal>
 #include <QDateTime>
 
-#include "audioformat.h"
+struct frame_t;
 
 class AudioPlayer : public QObject
 {

drumpadfilesmodel.cpp

@@ -1,4 +1,4 @@
-#include "filesmodel.h"
+#include "drumpadfilesmodel.h"
 
 #include <iterator>
 
@@ -14,26 +14,26 @@ enum {
     NumberOfColumns
 };
 
-FilesModel::~FilesModel() = default;
+DrumPadFilesModel::~DrumPadFilesModel() = default;
 
-const presets::File &FilesModel::getFile(const QModelIndex &index) const
+const drumpad_presets::File &DrumPadFilesModel::getFile(const QModelIndex &index) const
 {
     return getFile(index.row());
 }
 
-const presets::File &FilesModel::getFile(int row) const
+const drumpad_presets::File &DrumPadFilesModel::getFile(int row) const
 {
     return m_files->at(row);
 }
 
-void FilesModel::setPreset(const presets::Preset &preset)
+void DrumPadFilesModel::setPreset(const drumpad_presets::Preset &preset)
 {
     beginResetModel();
     m_files = preset.files;
     endResetModel();
 }
 
-int FilesModel::rowCount(const QModelIndex &parent) const
+int DrumPadFilesModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
 
@@ -43,14 +43,14 @@ int FilesModel::rowCount(const QModelIndex &parent) const
     return std::size(*m_files);
 }
 
-int FilesModel::columnCount(const QModelIndex &parent) const
+int DrumPadFilesModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
 
     return NumberOfColumns;
 }
 
-QVariant FilesModel::data(const QModelIndex &index, int role) const
+QVariant DrumPadFilesModel::data(const QModelIndex &index, int role) const
 {
     if (role != Qt::DisplayRole && role != Qt::EditRole && role != Qt::FontRole && role != Qt::ForegroundRole)
         return {};
@@ -63,7 +63,7 @@ QVariant FilesModel::data(const QModelIndex &index, int role) const
         return {};
     if (index.row() < 0)
         return {};
-    if (index.row() >= std::size(*m_files))
+    if (index.row() >= int(std::size(*m_files)))
         return {};
 
     const auto &file = getFile(index);
@@ -103,7 +103,7 @@ QVariant FilesModel::data(const QModelIndex &index, int role) const
     Q_UNREACHABLE();
 }
 
-QVariant FilesModel::headerData(int section, Qt::Orientation orientation, int role) const
+QVariant DrumPadFilesModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (role != Qt::DisplayRole && role != Qt::EditRole)
         return {};

drumpadfilesmodel.h

@@ -4,22 +4,22 @@
 
 #include <QAbstractTableModel>
 
-#include "presets.h"
+#include "drumpadpresets.h"
 
-namespace presets { class Preset; class File; }
+namespace drumpad_presets { class Preset; class File; }
 
-class FilesModel : public QAbstractTableModel
+class DrumPadFilesModel : public QAbstractTableModel
 {
     Q_OBJECT
 
 public:
     using QAbstractTableModel::QAbstractTableModel;
-    ~FilesModel() override;
+    ~DrumPadFilesModel() override;
 
-    const presets::File &getFile(const QModelIndex &index) const;
+    const drumpad_presets::File &getFile(const QModelIndex &index) const;
-    const presets::File &getFile(int row) const;
+    const drumpad_presets::File &getFile(int row) const;
 
-    void setPreset(const presets::Preset &preset);
+    void setPreset(const drumpad_presets::Preset &preset);
 
     int rowCount(const QModelIndex &parent) const override;
     int columnCount(const QModelIndex &parent) const override;
@@ -27,5 +27,5 @@ public:
     QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
 
 private:
-    std::optional<std::array<presets::File, 24>> m_files;
+    std::optional<std::array<drumpad_presets::File, 24>> m_files;
 };

drumpadpresets.cpp

@@ -1,6 +1,6 @@
-#include "presets.h"
+#include "drumpadpresets.h"
 
-namespace presets
+namespace drumpad_presets
 {
 
 bool File::operator==(const File &other) const

drumpadpresets.h

@@ -8,7 +8,7 @@
 #include <QString>
 #include <QDateTime>
 
-namespace presets
+namespace drumpad_presets
 {
 struct Filter
 {
@@ -73,7 +73,7 @@ struct Preset
     std::optional<QString> imagePreview1;
     std::optional<QString> videoPreview;
     std::optional<QString> videoTutorial;
-    std::optional<std::array<presets::File, 24>> files;
+    std::optional<std::array<drumpad_presets::File, 24>> files;
     std::optional<std::map<QString, std::vector<Sequence>>> beatSchool;
     std::optional<std::map<QString, std::vector<Sequence>>> easyPlay;
     std::optional<QDateTime> timestamp;

drumpadpresetsmodel.cpp

@@ -1,11 +1,11 @@
-#include "presetsmodel.h"
+#include "drumpadpresetsmodel.h"
 
 #include <iterator>
 
 #include <QFont>
 #include <QColor>
 
-#include "presets.h"
+#include "drumpadpresets.h"
 
 enum {
     ColumnId,
@@ -32,96 +32,96 @@ enum {
     NumberOfColumns
 };
 
-PresetsModel::PresetsModel(QObject *parent) :
+DrumPadPresetsModel::DrumPadPresetsModel(QObject *parent) :
     QAbstractTableModel{parent}
 {
 }
 
-PresetsModel::PresetsModel(const std::map<QString, presets::Preset> &presets, QObject *parent) :
+DrumPadPresetsModel::DrumPadPresetsModel(const std::map<QString, drumpad_presets::Preset> &drumpad_presets, QObject *parent) :
     QAbstractTableModel{parent}
 {
-    m_presets.reserve(std::size(presets));
+    m_drumpad_presets.reserve(std::size(drumpad_presets));
-    for (const auto &pair : presets)
+    for (const auto &pair : drumpad_presets)
-        m_presets.emplace_back(pair.second);
+        m_drumpad_presets.emplace_back(pair.second);
 }
 
-PresetsModel::PresetsModel(std::vector<presets::Preset> &&presets, QObject *parent) :
+DrumPadPresetsModel::DrumPadPresetsModel(std::vector<drumpad_presets::Preset> &&drumpad_presets, QObject *parent) :
     QAbstractTableModel{parent}
 {
-    m_presets = std::move(presets);
+    m_drumpad_presets = std::move(drumpad_presets);
 }
 
-PresetsModel::PresetsModel(const std::vector<presets::Preset> &presets, QObject *parent) :
+DrumPadPresetsModel::DrumPadPresetsModel(const std::vector<drumpad_presets::Preset> &drumpad_presets, QObject *parent) :
     QAbstractTableModel{parent}
 {
-    m_presets = presets;
+    m_drumpad_presets = drumpad_presets;
 }
 
-PresetsModel::~PresetsModel() = default;
+DrumPadPresetsModel::~DrumPadPresetsModel() = default;
 
-void PresetsModel::setPresets(const std::map<QString, presets::Preset> &presets)
+void DrumPadPresetsModel::setPresets(const std::map<QString, drumpad_presets::Preset> &drumpad_presets)
 {
     beginResetModel();
-    m_presets.clear();
+    m_drumpad_presets.clear();
-    m_presets.reserve(std::size(presets));
+    m_drumpad_presets.reserve(std::size(drumpad_presets));
-    for (const auto &pair : presets)
+    for (const auto &pair : drumpad_presets)
-        m_presets.emplace_back(pair.second);
+        m_drumpad_presets.emplace_back(pair.second);
     endResetModel();
 }
 
-void PresetsModel::setPresets(std::vector<presets::Preset> &&presets)
+void DrumPadPresetsModel::setPresets(std::vector<drumpad_presets::Preset> &&drumpad_presets)
 {
     beginResetModel();
-    m_presets = std::move(presets);
+    m_drumpad_presets = std::move(drumpad_presets);
     endResetModel();
 }
 
-void PresetsModel::setPresets(const std::vector<presets::Preset> &presets)
+void DrumPadPresetsModel::setPresets(const std::vector<drumpad_presets::Preset> &drumpad_presets)
 {
     beginResetModel();
-    m_presets = presets;
+    m_drumpad_presets = drumpad_presets;
     endResetModel();
 }
 
-const presets::Preset &PresetsModel::getPreset(const QModelIndex &index) const
+const drumpad_presets::Preset &DrumPadPresetsModel::getPreset(const QModelIndex &index) const
 {
     return getPreset(index.row());
 }
 
-const presets::Preset &PresetsModel::getPreset(int row) const
+const drumpad_presets::Preset &DrumPadPresetsModel::getPreset(int row) const
 {
-    Q_ASSERT(row >= 0 && row < std::size(m_presets));
+    Q_ASSERT(row >= 0 && row < std::size(m_drumpad_presets));
-    return m_presets.at(row);
+    return m_drumpad_presets.at(row);
 }
 
-QModelIndex PresetsModel::findPresetById(const QString &id) const
+QModelIndex DrumPadPresetsModel::findPresetById(const QString &id) const
 {
-    for (auto iter = std::cbegin(m_presets); iter != std::cend(m_presets); iter++)
+    for (auto iter = std::cbegin(m_drumpad_presets); iter != std::cend(m_drumpad_presets); iter++)
     {
         if (iter->id != id)
             continue;
 
-        return createIndex(std::distance(std::cbegin(m_presets), iter), 0);
+        return createIndex(std::distance(std::cbegin(m_drumpad_presets), iter), 0);
     }
 
     return {};
 }
 
-int PresetsModel::rowCount(const QModelIndex &parent) const
+int DrumPadPresetsModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
 
-    return std::size(m_presets);
+    return std::size(m_drumpad_presets);
 }
 
-int PresetsModel::columnCount(const QModelIndex &parent) const
+int DrumPadPresetsModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
 
     return NumberOfColumns;
 }
 
-QVariant PresetsModel::data(const QModelIndex &index, int role) const
+QVariant DrumPadPresetsModel::data(const QModelIndex &index, int role) const
 {
     if (role != Qt::DisplayRole && role != Qt::EditRole && role != Qt::FontRole && role != Qt::ForegroundRole)
         return {};
@@ -132,7 +132,7 @@ QVariant PresetsModel::data(const QModelIndex &index, int role) const
         return {};
     if (index.row() < 0)
         return {};
-    if (index.row() >= std::size(m_presets))
+    if (index.row() >= std::size(m_drumpad_presets))
         return {};
 
     const auto &preset = getPreset(index);
@@ -230,7 +230,7 @@ QVariant PresetsModel::data(const QModelIndex &index, int role) const
     Q_UNREACHABLE();
 }
 
-QVariant PresetsModel::headerData(int section, Qt::Orientation orientation, int role) const
+QVariant DrumPadPresetsModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (role != Qt::DisplayRole && role != Qt::EditRole)
         return {};

drumpadpresetsmodel.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <vector>
+
+#include <QAbstractTableModel>
+
+namespace drumpad_presets { class Preset; }
+
+class DrumPadPresetsModel : public QAbstractTableModel
+{
+    Q_OBJECT
+
+public:
+    DrumPadPresetsModel(QObject *parent = nullptr);
+    DrumPadPresetsModel(const std::map<QString, drumpad_presets::Preset> &drumpad_presets, QObject *parent = nullptr);
+    DrumPadPresetsModel(std::vector<drumpad_presets::Preset> &&drumpad_presets, QObject *parent = nullptr);
+    DrumPadPresetsModel(const std::vector<drumpad_presets::Preset> &drumpad_presets, QObject *parent = nullptr);
+    ~DrumPadPresetsModel() override;
+
+    void setPresets(const std::map<QString, drumpad_presets::Preset> &drumpad_presets);
+    void setPresets(std::vector<drumpad_presets::Preset> &&drumpad_presets);
+    void setPresets(const std::vector<drumpad_presets::Preset> &drumpad_presets);
+
+    const drumpad_presets::Preset &getPreset(const QModelIndex &index) const;
+    const drumpad_presets::Preset &getPreset(int row) const;
+
+    QModelIndex findPresetById(const QString &id) const;
+
+    int rowCount(const QModelIndex &parent) const override;
+    int columnCount(const QModelIndex &parent) const override;
+    QVariant data(const QModelIndex &index, int role) const override;
+    QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
+
+private:
+    std::vector<drumpad_presets::Preset> m_drumpad_presets;
+};

graphrenderer.cpp

@@ -5,6 +5,10 @@
 #include <QPixmap>
 #include <QPainter>
 #include <QPalette>
+#include <QRect>
+#include <QPoint>
+
+#include "audioformat.h"
 
 QPixmap GraphRenderer::render(const QSize &size, const frame_t *begin, const frame_t *end, const QPalette &palette)
 {

graphrenderer.h

@@ -1,11 +1,15 @@
 #pragma once
 
+#include <utility>
+
 class QPixmap;
 class QSize;
 class QPainter;
 class QPalette;
+class QRect;
+class QPoint;
 
-#include "audioformat.h"
+struct frame_t;
 
 namespace GraphRenderer
 {

jsonconverters.cpp

@@ -83,9 +83,9 @@ std::vector<int> parseIntVectorIgnoreNulls(const QJsonValue &jsonValue)
     return vector;
 }
 
-presets::PresetsConfig parsePresetsConfig(const QJsonObject &jsonObj)
+drumpad_presets::PresetsConfig parseDrumPadPresetsConfig(const QJsonObject &jsonObj)
 {
-    presets::PresetsConfig presetConfig;
+    drumpad_presets::PresetsConfig presetConfig;
 
     for (auto iter = std::cbegin(jsonObj); iter != std::cend(jsonObj); iter++)
     {
@@ -100,12 +100,12 @@ presets::PresetsConfig parsePresetsConfig(const QJsonObject &jsonObj)
     return presetConfig;
 }
 
-std::vector<presets::Category> parseCategoryVector(const QJsonValue &jsonValue)
+std::vector<drumpad_presets::Category> parseCategoryVector(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isArray())
         throw std::runtime_error{"json value for vector of Category is not an array"};
 
-    std::vector<presets::Category> vector;
+    std::vector<drumpad_presets::Category> vector;
 
     for (const auto &jsonValue : jsonValue.toArray())
         vector.emplace_back(parseCategory(jsonValue));
@@ -113,14 +113,14 @@ std::vector<presets::Category> parseCategoryVector(const QJsonValue &jsonValue)
     return vector;
 }
 
-std::map<QString, presets::Preset> parsePresetMap(const QJsonValue &jsonValue)
+std::map<QString, drumpad_presets::Preset> parsePresetMap(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isObject())
         throw std::runtime_error{"json value for Preset map is not an object"};
 
     const auto jsonObj = jsonValue.toObject();
 
-    std::map<QString, presets::Preset> map;
+    std::map<QString, drumpad_presets::Preset> map;
 
     for (auto iter = std::cbegin(jsonObj); iter != std::cend(jsonObj); iter++)
         map[iter.key()] = parsePreset(iter.value());
@@ -128,14 +128,14 @@ std::map<QString, presets::Preset> parsePresetMap(const QJsonValue &jsonValue)
     return map;
 }
 
-presets::Category parseCategory(const QJsonValue &jsonValue)
+drumpad_presets::Category parseCategory(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isObject())
         throw std::runtime_error{"json value for Category is not an object"};
 
     const auto jsonObj = jsonValue.toObject();
 
-    presets::Category category;
+    drumpad_presets::Category category;
 
     for (auto iter = std::cbegin(jsonObj); iter != std::cend(jsonObj); iter++)
     {
@@ -150,14 +150,14 @@ presets::Category parseCategory(const QJsonValue &jsonValue)
     return category;
 }
 
-presets::Filter parseFilter(const QJsonValue &jsonValue)
+drumpad_presets::Filter parseFilter(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isObject())
         throw std::runtime_error{"json value for Filters is not an object"};
 
     const auto jsonObj = jsonValue.toObject();
 
-    presets::Filter filters;
+    drumpad_presets::Filter filters;
 
     for (auto iter = std::cbegin(jsonObj); iter != std::cend(jsonObj); iter++)
     {
@@ -170,14 +170,14 @@ presets::Filter parseFilter(const QJsonValue &jsonValue)
     return filters;
 }
 
-presets::Preset parsePreset(const QJsonValue &jsonValue)
+drumpad_presets::Preset parsePreset(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isObject())
         throw std::runtime_error{"json value for Preset is not an object"};
 
     const auto jsonObj = jsonValue.toObject();
 
-    presets::Preset preset;
+    drumpad_presets::Preset preset;
 
     for (auto iter = std::cbegin(jsonObj); iter != std::cend(jsonObj); iter++)
     {
@@ -241,7 +241,7 @@ presets::Preset parsePreset(const QJsonValue &jsonValue)
     return preset;
 }
 
-std::array<presets::File, 24> parseFileArray(const QJsonValue &jsonValue)
+std::array<drumpad_presets::File, 24> parseFileArray(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isObject())
         throw std::runtime_error{"json value for File array is not an object"};
@@ -251,7 +251,7 @@ std::array<presets::File, 24> parseFileArray(const QJsonValue &jsonValue)
     if (jsonObj.size() != 24)
         throw std::runtime_error{"json value for File array doesn't have exactly 24 entries"};
 
-    std::array<presets::File, 24> array;
+    std::array<drumpad_presets::File, 24> array;
 
     for (auto iter = std::cbegin(jsonObj); iter != std::cend(jsonObj); iter++)
     {
@@ -267,14 +267,14 @@ std::array<presets::File, 24> parseFileArray(const QJsonValue &jsonValue)
     return array;
 }
 
-presets::File parseFile(const QJsonValue &jsonValue)
+drumpad_presets::File parseFile(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isObject())
         throw std::runtime_error{"json value for File is not an object"};
 
     const auto jsonObj = jsonValue.toObject();
 
-    presets::File file;
+    drumpad_presets::File file;
 
     for (auto iter = std::cbegin(jsonObj); iter != std::cend(jsonObj); iter++)
     {
@@ -296,12 +296,12 @@ presets::File parseFile(const QJsonValue &jsonValue)
     return file;
 }
 
-std::vector<presets::Sequence> parseSequenceVector(const QJsonValue &jsonValue)
+std::vector<drumpad_presets::Sequence> parseSequenceVector(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isArray())
         throw std::runtime_error{"json value for vector of Sequence is not an array"};
 
-    std::vector<presets::Sequence> vector;
+    std::vector<drumpad_presets::Sequence> vector;
 
     for (const auto &jsonValue : jsonValue.toArray())
         vector.emplace_back(parseSequence(jsonValue));
@@ -309,14 +309,14 @@ std::vector<presets::Sequence> parseSequenceVector(const QJsonValue &jsonValue)
     return vector;
 }
 
-presets::Sequence parseSequence(const QJsonValue &jsonValue)
+drumpad_presets::Sequence parseSequence(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isObject())
         throw std::runtime_error{"json value for File is not an object"};
 
     const auto jsonObj = jsonValue.toObject();
 
-    presets::Sequence sequence;
+    drumpad_presets::Sequence sequence;
 
     for (auto iter = std::cbegin(jsonObj); iter != std::cend(jsonObj); iter++)
     {
@@ -342,14 +342,14 @@ presets::Sequence parseSequence(const QJsonValue &jsonValue)
     return sequence;
 }
 
-std::map<QString, std::vector<presets::Sequence>> parseSequenceVectorMap(const QJsonValue &jsonValue)
+std::map<QString, std::vector<drumpad_presets::Sequence>> parseSequenceVectorMap(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isObject())
         throw std::runtime_error{"json value for Sequence vector map is not an object"};
 
     const auto jsonObj = jsonValue.toObject();
 
-    std::map<QString, std::vector<presets::Sequence>> map;
+    std::map<QString, std::vector<drumpad_presets::Sequence>> map;
 
     for (auto iter = std::cbegin(jsonObj); iter != std::cend(jsonObj); iter++)
         map[iter.key()] = parseSequenceVector(iter.value());
@@ -357,14 +357,14 @@ std::map<QString, std::vector<presets::Sequence>> parseSequenceVectorMap(const Q
     return map;
 }
 
-presets::SequencePad parseSequencePad(const QJsonValue &jsonValue)
+drumpad_presets::SequencePad parseSequencePad(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isObject())
         throw std::runtime_error{"json value for File is not an object"};
 
     const auto jsonObj = jsonValue.toObject();
 
-    presets::SequencePad sequencePad;
+    drumpad_presets::SequencePad sequencePad;
 
     for (auto iter = std::cbegin(jsonObj); iter != std::cend(jsonObj); iter++)
     {
@@ -381,12 +381,12 @@ presets::SequencePad parseSequencePad(const QJsonValue &jsonValue)
     return sequencePad;
 }
 
-std::vector<presets::SequencePad> parseSequencePadVector(const QJsonValue &jsonValue)
+std::vector<drumpad_presets::SequencePad> parseSequencePadVector(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isArray())
         throw std::runtime_error{"json value for vector of SequencePad is not an array"};
 
-    std::vector<presets::SequencePad> vector;
+    std::vector<drumpad_presets::SequencePad> vector;
 
     for (const auto &jsonValue : jsonValue.toArray())
         vector.emplace_back(parseSequencePad(jsonValue));
@@ -394,14 +394,14 @@ std::vector<presets::SequencePad> parseSequencePadVector(const QJsonValue &jsonV
     return vector;
 }
 
-std::map<QString, std::vector<presets::SequencePad>> parseSequencePadVectorMap(const QJsonValue &jsonValue)
+std::map<QString, std::vector<drumpad_presets::SequencePad>> parseSequencePadVectorMap(const QJsonValue &jsonValue)
 {
     if (!jsonValue.isObject())
         throw std::runtime_error{"json value for SequencePad vector map is not an object"};
 
     const auto jsonObj = jsonValue.toObject();
 
-    std::map<QString, std::vector<presets::SequencePad>> map;
+    std::map<QString, std::vector<drumpad_presets::SequencePad>> map;
 
     for (auto iter = std::cbegin(jsonObj); iter != std::cend(jsonObj); iter++)
         map[iter.key()] = parseSequencePadVector(iter.value());

jsonconverters.h

@@ -4,7 +4,7 @@
 #include <QJsonArray>
 #include <QJsonObject>
 
-#include "presets.h"
+#include "drumpadpresets.h"
 
 namespace json_converters
 {
@@ -17,18 +17,18 @@ bool parseBool(const QJsonValue &jsonValue);
 std::vector<int> parseIntVector(const QJsonValue &jsonValue);
 std::vector<int> parseIntVectorIgnoreNulls(const QJsonValue &jsonValue);
 
-presets::PresetsConfig parsePresetsConfig(const QJsonObject &jsonObj);
+drumpad_presets::PresetsConfig parseDrumPadPresetsConfig(const QJsonObject &jsonObj);
-std::vector<presets::Category> parseCategoryVector(const QJsonValue &jsonValue);
+std::vector<drumpad_presets::Category> parseCategoryVector(const QJsonValue &jsonValue);
-std::map<QString, presets::Preset> parsePresetMap(const QJsonValue &jsonValue);
+std::map<QString, drumpad_presets::Preset> parsePresetMap(const QJsonValue &jsonValue);
-presets::Category parseCategory(const QJsonValue &jsonValue);
+drumpad_presets::Category parseCategory(const QJsonValue &jsonValue);
-presets::Filter parseFilter(const QJsonValue &jsonValue);
+drumpad_presets::Filter parseFilter(const QJsonValue &jsonValue);
-presets::Preset parsePreset(const QJsonValue &jsonValue);
+drumpad_presets::Preset parsePreset(const QJsonValue &jsonValue);
-std::array<presets::File, 24> parseFileArray(const QJsonValue &jsonValue);
+std::array<drumpad_presets::File, 24> parseFileArray(const QJsonValue &jsonValue);
-presets::File parseFile(const QJsonValue &jsonValue);
+drumpad_presets::File parseFile(const QJsonValue &jsonValue);
-std::vector<presets::Sequence> parseSequenceVector(const QJsonValue &jsonValue);
+std::vector<drumpad_presets::Sequence> parseSequenceVector(const QJsonValue &jsonValue);
-presets::Sequence parseSequence(const QJsonValue &jsonValue);
+drumpad_presets::Sequence parseSequence(const QJsonValue &jsonValue);
-std::map<QString, std::vector<presets::Sequence>> parseSequenceVectorMap(const QJsonValue &jsonValue);
+std::map<QString, std::vector<drumpad_presets::Sequence>> parseSequenceVectorMap(const QJsonValue &jsonValue);
-presets::SequencePad parseSequencePad(const QJsonValue &jsonValue);
+drumpad_presets::SequencePad parseSequencePad(const QJsonValue &jsonValue);
-std::vector<presets::SequencePad> parseSequencePadVector(const QJsonValue &jsonValue);
+std::vector<drumpad_presets::SequencePad> parseSequencePadVector(const QJsonValue &jsonValue);
-std::map<QString, std::vector<presets::SequencePad>> parseSequencePadVectorMap(const QJsonValue &jsonValue);
+std::map<QString, std::vector<drumpad_presets::SequencePad>> parseSequencePadVectorMap(const QJsonValue &jsonValue);
 }

presetsmodel.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <vector>
-
-#include <QAbstractTableModel>
-
-namespace presets { class Preset; }
-
-class PresetsModel : public QAbstractTableModel
-{
-    Q_OBJECT
-
-public:
-    PresetsModel(QObject *parent = nullptr);
-    PresetsModel(const std::map<QString, presets::Preset> &presets, QObject *parent = nullptr);
-    PresetsModel(std::vector<presets::Preset> &&presets, QObject *parent = nullptr);
-    PresetsModel(const std::vector<presets::Preset> &presets, QObject *parent = nullptr);
-    ~PresetsModel() override;
-
-    void setPresets(const std::map<QString, presets::Preset> &presets);
-    void setPresets(std::vector<presets::Preset> &&presets);
-    void setPresets(const std::vector<presets::Preset> &presets);
-
-    const presets::Preset &getPreset(const QModelIndex &index) const;
-    const presets::Preset &getPreset(int row) const;
-
-    QModelIndex findPresetById(const QString &id) const;
-
-    int rowCount(const QModelIndex &parent) const override;
-    int columnCount(const QModelIndex &parent) const override;
-    QVariant data(const QModelIndex &index, int role) const override;
-    QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
-
-private:
-    std::vector<presets::Preset> m_presets;
-};

synthisizer.cpp

@@ -2,6 +2,8 @@
 
 #include <cmath>
 
+#include "audioformat.h"
+
 constexpr double pi = std::acos(-1);
 
 void Synthisizer::writeSamples(frame_t *begin, frame_t *end)

synthisizer.h

@@ -2,7 +2,7 @@
 
 #include <QObject>
 
-#include "audioformat.h"
+struct frame_t;
 
 class DrumMachineSettings;
 

widgets/djwidget.cpp

@@ -3,6 +3,9 @@
 
 #include <QStandardPaths>
 
+#include "audioformat.h"
+#include "midicontainers.h"
+
 DjWidget::DjWidget(QWidget *parent) :
     QWidget{parent},
     m_ui{std::make_unique<Ui::DjWidget>()}

widgets/djwidget.h

@@ -6,12 +6,12 @@
 
 #include <memory>
 
-#include "audioformat.h"
-#include "midicontainers.h"
 #include "treetotableproxymodel.h"
 
 namespace Ui { class DjWidget; }
 class DrumMachineSettings;
+struct frame_t;
+namespace midi { struct MidiMessage; }
 
 class DjWidget : public QWidget
 {

widgets/djwidget.ui

@@ -10,9 +10,6 @@
     <height>519</height>
    </rect>
   </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
   <layout class="QVBoxLayout" name="verticalLayout" stretch="0,0,1">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout" stretch="1,0,1">

widgets/drumpadwidget.cpp

@@ -6,6 +6,7 @@
 #include <QNetworkAccessManager>
 #include <QMessageBox>
 
+#include "audioformat.h"
 #include "midicontainers.h"
 #include "jsonconverters.h"
 #include "drummachinesettings.h"
@@ -181,7 +182,7 @@ void DrumPadWidget::requestFinished()
 
     try
     {
-        auto result = json_converters::parsePresetsConfig(json_converters::loadJson(reply->readAll()));
+        auto result = json_converters::parseDrumPadPresetsConfig(json_converters::loadJson(reply->readAll()));
 
         if (!result.presets)
             throw std::runtime_error("presets missing in response");

widgets/drumpadwidget.h

@@ -5,9 +5,8 @@
 
 #include <memory>
 
-#include "audioformat.h"
+#include "drumpadpresetsmodel.h"
-#include "presetsmodel.h"
+#include "drumpadfilesmodel.h"
-#include "filesmodel.h"
 
 namespace Ui { class DrumPadWidget; }
 class SamplesWidget;
@@ -18,6 +17,7 @@ class QThread;
 class DrumMachineSettings;
 class QNetworkReply;
 namespace midi { struct MidiMessage; }
+struct frame_t;
 
 class DrumPadWidget : public QSplitter
 {
@@ -55,10 +55,10 @@ private:
 
     DrumMachineSettings *m_settings{};
 
-    PresetsModel m_presetsModel;
+    DrumPadPresetsModel m_presetsModel;
     QSortFilterProxyModel m_presetsProxyModel;
 
-    FilesModel m_filesModel;
+    DrumPadFilesModel m_filesModel;
 
     QNetworkAccessManager *m_networkAccessManager{};
 

widgets/loopstationwidget.cpp

@@ -0,0 +1,48 @@
+#include "loopstationwidget.h"
+#include "ui_loopstationwidget.h"
+
+#include "audioformat.h"
+
+LoopStationWidget::LoopStationWidget(QWidget *parent) :
+    QWidget{parent},
+    m_ui{std::make_unique<Ui::LoopStationWidget>()}
+{
+    m_ui->setupUi(this);
+}
+
+LoopStationWidget::~LoopStationWidget() = default;
+
+void LoopStationWidget::writeSamples(frame_t *begin, frame_t *end)
+{
+
+}
+
+void LoopStationWidget::injectNetworkAccessManager(QNetworkAccessManager &networkAccessManager)
+{
+
+}
+
+void LoopStationWidget::injectDecodingThread(QThread &thread)
+{
+
+}
+
+void LoopStationWidget::loadSettings(DrumMachineSettings &settings)
+{
+
+}
+
+void LoopStationWidget::unsendColors()
+{
+
+}
+
+void LoopStationWidget::sendColors()
+{
+
+}
+
+void LoopStationWidget::midiReceived(const midi::MidiMessage &message)
+{
+
+}

widgets/loopstationwidget.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <QWidget>
+
+#include <memory>
+
+namespace Ui { class LoopStationWidget; }
+namespace midi { struct MidiMessage; }
+class QNetworkAccessManager;
+class DrumMachineSettings;
+struct frame_t;
+
+class LoopStationWidget : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit LoopStationWidget(QWidget *parent = nullptr);
+    ~LoopStationWidget() override;
+
+    void writeSamples(frame_t *begin, frame_t *end);
+    void injectNetworkAccessManager(QNetworkAccessManager &networkAccessManager);
+    void injectDecodingThread(QThread &thread);
+    void loadSettings(DrumMachineSettings &settings);
+    void unsendColors();
+    void sendColors();
+
+signals:
+    void sendMidi(const midi::MidiMessage &midiMsg);
+
+public slots:
+    void midiReceived(const midi::MidiMessage &message);
+
+private:
+    const std::unique_ptr<Ui::LoopStationWidget> m_ui;
+};

widgets/loopstationwidget.ui

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>LoopStationWidget</class>
+ <widget class="QWidget" name="LoopStationWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <widget class="QLabel" name="label">
+   <property name="geometry">
+    <rect>
+     <x>40</x>
+     <y>50</y>
+     <width>261</width>
+     <height>18</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Hier könnte ihre LoopStation stehen.</string>
+   </property>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

widgets/mainwindow.cpp

@@ -9,7 +9,7 @@
 #include <QAudioDeviceInfo>
 #include <QDebug>
 
-#include "midiinwrapper.h"
+#include "audioformat.h"
 #include "midicontainers.h"
 
 namespace {
@@ -38,6 +38,7 @@ MainWindow::MainWindow(QWidget *parent) :
     m_networkAccessManager.setCache(&m_cache);
 
     m_ui->drumPadWidget->injectNetworkAccessManager(m_networkAccessManager);
+    m_ui->loopStationWidget->injectNetworkAccessManager(m_networkAccessManager);
 
     connect(&m_midiIn, &MidiInWrapper::midiReceived, this, &MainWindow::midiReceived);
 
@@ -49,6 +50,7 @@ MainWindow::MainWindow(QWidget *parent) :
     }
 
     m_ui->drumPadWidget->injectDecodingThread(m_decoderThread);
+    m_ui->loopStationWidget->injectDecodingThread(m_decoderThread);
     m_ui->djWidget->injectDecodingThread(m_decoderThread);
 
     updateAudioDevices();
@@ -89,6 +91,7 @@ paDefault:
     loadSettings();
 
     connect(m_ui->drumPadWidget, &DrumPadWidget::sendMidi, this, &MainWindow::sendMidi);
+    connect(m_ui->loopStationWidget, &LoopStationWidget::sendMidi, this, &MainWindow::sendMidi);
     connect(m_ui->djWidget, &DjWidget::sendMidi, this, &MainWindow::sendMidi);
     connect(m_ui->synthisizerWidget, &SynthisizerWidget::sendMidi, this, &MainWindow::sendMidi);
 
@@ -109,6 +112,7 @@ int MainWindow::writeSamples(frame_t *begin, frame_t *end)
     std::fill(begin, end, frame_t{0.,0.});
 
     m_ui->drumPadWidget->writeSamples(begin, end);
+    m_ui->loopStationWidget->writeSamples(begin, end);
     m_ui->djWidget->writeSamples(begin, end);
     m_ui->synthisizerWidget->writeSamples(begin, end);
 
@@ -229,8 +233,10 @@ void MainWindow::midiReceived(const midi::MidiMessage &message)
     if (m_ui->tabWidget->currentIndex() == 0)
         m_ui->drumPadWidget->midiReceived(message);
     else if (m_ui->tabWidget->currentIndex() == 1)
-        m_ui->djWidget->midiReceived(message);
+        m_ui->loopStationWidget->midiReceived(message);
     else if (m_ui->tabWidget->currentIndex() == 2)
+        m_ui->djWidget->midiReceived(message);
+    else if (m_ui->tabWidget->currentIndex() == 3)
         m_ui->synthisizerWidget->midiReceived(message);
 }
 
@@ -283,6 +289,7 @@ void MainWindow::updateMidiOutDevices()
 void MainWindow::loadSettings()
 {
     m_ui->drumPadWidget->loadSettings(m_settings);
+    m_ui->loopStationWidget->loadSettings(m_settings);
     m_ui->djWidget->loadSettings(m_settings);
     m_ui->synthisizerWidget->loadSettings(m_settings);
 }
@@ -292,8 +299,10 @@ void MainWindow::unsendColors(int index)
     if (index == 0)
         m_ui->drumPadWidget->unsendColors();
     else if (index == 1)
-        m_ui->djWidget->unsendColors();
+        m_ui->loopStationWidget->unsendColors();
     else if (index == 2)
+        m_ui->djWidget->unsendColors();
+    else if (index == 3)
         m_ui->synthisizerWidget->unsendColors();
 }
 
@@ -302,8 +311,10 @@ void MainWindow::sendColors(int index)
     if (index == 0)
         m_ui->drumPadWidget->sendColors();
     else if (index == 1)
-        m_ui->djWidget->sendColors();
+        m_ui->loopStationWidget->sendColors();
     else if (index == 2)
+        m_ui->djWidget->sendColors();
+    else if (index == 3)
         m_ui->synthisizerWidget->sendColors();
 
     return;

widgets/mainwindow.h

@@ -9,14 +9,13 @@
 
 #include "portaudio.h"
 
-#include "audioformat.h"
 #include "midiinwrapper.h"
 #include "midioutwrapper.h"
 #include "drummachinesettings.h"
 
 namespace Ui { class MainWindow; }
-namespace presets { struct PresetsConfig; }
 namespace midi { struct MidiMessage; }
+struct frame_t;
 
 class MainWindow : public QMainWindow
 {

widgets/mainwindow.ui

@@ -210,6 +210,11 @@
         <string>DrumPad</string>
        </attribute>
       </widget>
+      <widget class="LoopStationWidget" name="loopStationWidget">
+       <attribute name="title">
+        <string>LoopStation</string>
+       </attribute>
+      </widget>
       <widget class="DjWidget" name="djWidget">
        <attribute name="title">
         <string>DJ</string>
@@ -255,6 +260,12 @@
    <header>widgets/synthisizerwidget.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>LoopStationWidget</class>
+   <extends>QWidget</extends>
+   <header>widgets/loopstationwidget.h</header>
+   <container>1</container>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>

widgets/presetdetailwidget.cpp

@@ -10,7 +10,7 @@ PresetDetailWidget::PresetDetailWidget(QWidget *parent) :
 
 PresetDetailWidget::~PresetDetailWidget() = default;
 
-void PresetDetailWidget::setPreset(const presets::Preset &preset)
+void PresetDetailWidget::setPreset(const drumpad_presets::Preset &preset)
 {
     // TODO
 }

widgets/presetdetailwidget.h

@@ -5,7 +5,7 @@
 #include <QScrollArea>
 
 namespace Ui { class PresetDetailWidget; }
-namespace presets { class Preset; }
+namespace drumpad_presets { class Preset; }
 
 class PresetDetailWidget : public QScrollArea
 {
@@ -15,7 +15,7 @@ public:
     explicit PresetDetailWidget(QWidget *parent = nullptr);
     ~PresetDetailWidget() override;
 
-    void setPreset(const presets::Preset &preset);
+    void setPreset(const drumpad_presets::Preset &preset);
 
 private:
     const std::unique_ptr<Ui::PresetDetailWidget> m_ui;

widgets/previewwidget.cpp

@@ -5,6 +5,7 @@
 #include <QMouseEvent>
 
 #include "graphrenderer.h"
+#include "audioformat.h"
 
 PreviewWidget::PreviewWidget(QWidget *parent) :
     QWidget(parent)

widgets/sampleswidget.cpp

@@ -5,6 +5,7 @@
 
 #include <QDebug>
 
+#include "audioformat.h"
 #include "midicontainers.h"
 
 SamplesWidget::SamplesWidget(QWidget *parent) :
@@ -34,7 +35,7 @@ void SamplesWidget::loadSettings(DrumMachineSettings &settings)
         widget.loadSettings(settings);
 }
 
-void SamplesWidget::setPreset(const presets::Preset &preset)
+void SamplesWidget::setPreset(const drumpad_presets::Preset &preset)
 {
     m_preset = preset;
 

widgets/sampleswidget.h

@@ -6,14 +6,14 @@
 
 #include <QWidget>
 
-#include "audioformat.h"
+#include "drumpadpresets.h"
-#include "presets.h"
 
 namespace Ui { class SamplesWidget; }
 namespace midi { struct MidiMessage; }
 class QNetworkAccessManager;
 class SampleWidget;
 class DrumMachineSettings;
+struct frame_t;
 
 class SamplesWidget : public QWidget
 {
@@ -25,7 +25,7 @@ public:
 
     void loadSettings(DrumMachineSettings &settings);
 
-    void setPreset(const presets::Preset &preset);
+    void setPreset(const drumpad_presets::Preset &preset);
 
     void midiReceived(const midi::MidiMessage &message);
 
@@ -53,5 +53,5 @@ private:
 
     const std::unique_ptr<Ui::SamplesWidget> m_ui;
 
-    presets::Preset m_preset;
+    drumpad_presets::Preset m_preset;
 };

widgets/sampleswidget.ui

@@ -10,9 +10,6 @@
     <height>421</height>
    </rect>
   </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
   <layout class="QGridLayout" name="gridLayout" rowstretch="0,0,0,0,0" columnstretch="0,0,0,0,0,0,0,0,0">
    <item row="3" column="3">
     <widget class="SampleWidget" name="sampleWidget_9" native="true"/>

widgets/samplewidget.cpp

@@ -8,6 +8,7 @@
 #include <QNetworkAccessManager>
 #include <QMetaEnum>
 
+#include "audioformat.h"
 #include "audiodecoder.h"
 #include "drummachinesettings.h"
 #include "midicontainers.h"
@@ -46,7 +47,7 @@ void SampleWidget::loadSettings(DrumMachineSettings &settings)
     m_settings = &settings;
 }
 
-void SampleWidget::setFile(const QString &presetId, const presets::File &file)
+void SampleWidget::setFile(const QString &presetId, const drumpad_presets::File &file)
 {
     m_presetId = presetId;
     m_file = file;

widgets/samplewidget.h

@@ -4,8 +4,7 @@
 
 #include <QFrame>
 
-#include "audioformat.h"
+#include "drumpadpresets.h"
-#include "presets.h"
 #include "audioplayer.h"
 
 namespace Ui { class SampleWidget; }
@@ -15,6 +14,7 @@ class QAudioBuffer;
 class AudioDecoder;
 class DrumMachineSettings;
 namespace midi { struct MidiMessage; }
+struct frame_t;
 
 class SampleWidget : public QFrame
 {
@@ -29,7 +29,7 @@ public:
 
     void loadSettings(DrumMachineSettings &settings);
 
-    void setFile(const QString &presetId, const presets::File &file);
+    void setFile(const QString &presetId, const drumpad_presets::File &file);
 
     quint8 channel() const;
     void setChannel(quint8 channel);
@@ -86,7 +86,7 @@ private:
     AudioPlayer m_player;
 
     QString m_presetId;
-    std::optional<presets::File> m_file;
+    std::optional<drumpad_presets::File> m_file;
 
     QNetworkAccessManager *m_networkAccessManager{};
 

widgets/samplewidget.ui

@@ -10,9 +10,6 @@
     <height>157</height>
    </rect>
   </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
   <property name="autoFillBackground">
    <bool>true</bool>
   </property>

widgets/scratchwidget.cpp

@@ -5,10 +5,12 @@
 #include <QMouseEvent>
 #include <QDebug>
 
+#include "audioformat.h"
 #include "graphrenderer.h"
 
 ScratchWidget::ScratchWidget(QWidget *parent) :
-    QWidget{parent}
+    QWidget{parent},
+    m_framesPerBeat{frameRate/4}
 {
     connect(&m_timer, &QTimer::timeout, this, &ScratchWidget::timeout);
     m_timer.setSingleShot(true);

widgets/scratchwidget.h

@@ -6,8 +6,6 @@
 #include <QDateTime>
 #include <QTimer>
 
-#include "audioformat.h"
-
 class ScratchWidget : public QWidget
 {
     Q_OBJECT
@@ -49,7 +47,7 @@ private:
     QCache<int, QPixmap> m_graphCache;
 
     int m_beatWidth{100};
-    int m_framesPerBeat{frameRate/4};
+    int m_framesPerBeat;
 
     bool m_scratching{};
     bool m_dragging{};

widgets/sequencerwidget.cpp

@@ -5,7 +5,7 @@
 
 #include <QDebug>
 
-#include "presets.h"
+#include "drumpadpresets.h"
 #include "drummachinesettings.h"
 #include "midicontainers.h"
 
@@ -123,7 +123,7 @@ void SequencerWidget::sendColors()
     });
 }
 
-void SequencerWidget::setPreset(const presets::Preset &preset)
+void SequencerWidget::setPreset(const drumpad_presets::Preset &preset)
 {
     if (preset.tempo)
         m_ui->spinBoxTempo->setValue(*preset.tempo);
@@ -138,7 +138,7 @@ void SequencerWidget::setPreset(const presets::Preset &preset)
     m_sequences.clear();
     m_selectedSequence = nullptr;
 
-    const auto doit = [&](const QString &prefix, const std::optional<std::map<QString, std::vector<presets::Sequence>>> &value)
+    const auto doit = [&](const QString &prefix, const std::optional<std::map<QString, std::vector<drumpad_presets::Sequence>>> &value)
     {
         if (!value)
             return;
@@ -223,7 +223,7 @@ void SequencerWidget::timeout()
     {
         for (const auto &pair : *m_selectedSequence->pads)
         {
-            const auto iter = std::find_if(std::cbegin(pair.second), std::cend(pair.second), [&](const presets::SequencePad &sequencePad){
+            const auto iter = std::find_if(std::cbegin(pair.second), std::cend(pair.second), [&](const drumpad_presets::SequencePad &sequencePad){
                 return sequencePad.start && *sequencePad.start == m_pos;
             });
 

widgets/sequencerwidget.h

@@ -9,7 +9,7 @@
 
 class QLabel;
 namespace Ui { class SequencerWidget; }
-namespace presets { class Preset; class Sequence; }
+namespace drumpad_presets { class Preset; class Sequence; }
 class DrumMachineSettings;
 namespace midi { struct MidiMessage; }
 
@@ -25,7 +25,7 @@ public:
     void unsendColors();
     void sendColors();
 
-    void setPreset(const presets::Preset &preset);
+    void setPreset(const drumpad_presets::Preset &preset);
 
 signals:
     void sendMidi(const midi::MidiMessage &midiMsg);
@@ -50,8 +50,8 @@ private slots:
 private:
     const std::unique_ptr<Ui::SequencerWidget> m_ui;
 
-    std::vector<presets::Sequence> m_sequences;
+    std::vector<drumpad_presets::Sequence> m_sequences;
-    const presets::Sequence *m_selectedSequence{};
+    const drumpad_presets::Sequence *m_selectedSequence{};
 
     QTimer m_timer;
 

widgets/sequencerwidget.ui

@@ -10,9 +10,6 @@
     <height>611</height>
    </rect>
   </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
   <layout class="QVBoxLayout" name="verticalLayout" stretch="0,1">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout" stretch="0,0,0,0,0,0,0,1">

widgets/synthisizerwidget.cpp

@@ -3,6 +3,7 @@
 
 #include <cmath>
 
+#include "audioformat.h"
 #include "midicontainers.h"
 
 SynthisizerWidget::SynthisizerWidget(QWidget *parent) :

widgets/synthisizerwidget.h

@@ -4,11 +4,11 @@
 #include <memory>
 
 #include "synthisizer.h"
-#include "audioformat.h"
 
 namespace Ui { class SynthisizerWidget; }
 class DrumMachineSettings;
 namespace midi { struct MidiMessage; }
+struct frame_t;
 
 class SynthisizerWidget : public QWidget
 {

widgets/synthisizerwidget.ui

@@ -10,9 +10,6 @@
     <height>300</height>
    </rect>
   </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
   <widget class="QLabel" name="label">
    <property name="geometry">
     <rect>

widgets/trackdeck.cpp

@@ -11,6 +11,7 @@
 #include <QFileInfo>
 #include <QButtonGroup>
 
+#include "audioformat.h"
 #include "audiodecoder.h"
 
 TrackDeck::TrackDeck(QWidget *parent) :

widgets/trackdeck.h

@@ -8,12 +8,12 @@
 #include <QButtonGroup>
 #include <QTimer>
 
-#include "audioformat.h"
 #include "audioplayer.h"
 
 namespace Ui { class TrackDeck; }
 class AudioDecoder;
 class QAudioBuffer;
+struct frame_t;
 
 class TrackDeck : public QWidget
 {

widgets/trackdeck.ui

@@ -19,9 +19,6 @@
   <property name="acceptDrops">
    <bool>true</bool>
   </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
   <layout class="QHBoxLayout" name="horizontalLayout_2" stretch="0,0">
    <item>
     <layout class="QVBoxLayout" name="verticalLayout_2" stretch="0,0,0">