feedc0de/DrumMachine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add tab for loop station

Browse Source
This commit is contained in:
0xFEEDC0DE64
2022-12-27 21:19:21 +01:00
parent 626d27653a
commit b2f688c178
48 changed files with 346 additions and 204 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
DrumMachine.pro
View File

@ -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 \

4
audioformat.h
View File

@ -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();

2
audioplayer.cpp
View File

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

2
audioplayer.h
View File

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

20
filesmodel.cpp → drumpadfilesmodel.cpp
View File

@ -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 {};

16
filesmodel.h → drumpadfilesmodel.h
View File

@ -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 presets::File &getFile(int row) const;
const drumpad_presets::File &getFile(const QModelIndex &index) 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;
};

4
presets.cpp → drumpadpresets.cpp
View File

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

4
presets.h → drumpadpresets.h
View File

@ -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;

68
presetsmodel.cpp → drumpadpresetsmodel.cpp
View File

@ -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));
for (const auto &pair : presets)
m_presets.emplace_back(pair.second);
m_drumpad_presets.reserve(std::size(drumpad_presets));
for (const auto &pair : drumpad_presets)
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_presets.reserve(std::size(presets));
for (const auto &pair : presets)
m_presets.emplace_back(pair.second);
m_drumpad_presets.clear();
m_drumpad_presets.reserve(std::size(drumpad_presets));
for (const auto &pair : drumpad_presets)
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));
return m_presets.at(row);
Q_ASSERT(row >= 0 && row < std::size(m_drumpad_presets));
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 {};

36
drumpadpresetsmodel.h Executable file
View File

@ -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;
};

4
graphrenderer.cpp
View File

@ -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)
{

6
graphrenderer.h
View File

@ -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
{

56
jsonconverters.cpp
View File

@ -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());

30
jsonconverters.h
View File

@ -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);
std::vector<presets::Category> parseCategoryVector(const QJsonValue &jsonValue);
std::map<QString, presets::Preset> parsePresetMap(const QJsonValue &jsonValue);
presets::Category parseCategory(const QJsonValue &jsonValue);
presets::Filter parseFilter(const QJsonValue &jsonValue);
presets::Preset parsePreset(const QJsonValue &jsonValue);
std::array<presets::File, 24> parseFileArray(const QJsonValue &jsonValue);
presets::File parseFile(const QJsonValue &jsonValue);
std::vector<presets::Sequence> parseSequenceVector(const QJsonValue &jsonValue);
presets::Sequence parseSequence(const QJsonValue &jsonValue);
std::map<QString, std::vector<presets::Sequence>> parseSequenceVectorMap(const QJsonValue &jsonValue);
presets::SequencePad parseSequencePad(const QJsonValue &jsonValue);
std::vector<presets::SequencePad> parseSequencePadVector(const QJsonValue &jsonValue);
std::map<QString, std::vector<presets::SequencePad>> parseSequencePadVectorMap(const QJsonValue &jsonValue);
drumpad_presets::PresetsConfig parseDrumPadPresetsConfig(const QJsonObject &jsonObj);
std::vector<drumpad_presets::Category> parseCategoryVector(const QJsonValue &jsonValue);
std::map<QString, drumpad_presets::Preset> parsePresetMap(const QJsonValue &jsonValue);
drumpad_presets::Category parseCategory(const QJsonValue &jsonValue);
drumpad_presets::Filter parseFilter(const QJsonValue &jsonValue);
drumpad_presets::Preset parsePreset(const QJsonValue &jsonValue);
std::array<drumpad_presets::File, 24> parseFileArray(const QJsonValue &jsonValue);
drumpad_presets::File parseFile(const QJsonValue &jsonValue);
std::vector<drumpad_presets::Sequence> parseSequenceVector(const QJsonValue &jsonValue);
drumpad_presets::Sequence parseSequence(const QJsonValue &jsonValue);
std::map<QString, std::vector<drumpad_presets::Sequence>> parseSequenceVectorMap(const QJsonValue &jsonValue);
drumpad_presets::SequencePad parseSequencePad(const QJsonValue &jsonValue);
std::vector<drumpad_presets::SequencePad> parseSequencePadVector(const QJsonValue &jsonValue);
std::map<QString, std::vector<drumpad_presets::SequencePad>> parseSequencePadVectorMap(const QJsonValue &jsonValue);
}

36
presetsmodel.h
View File

@ -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;
};

2
synthisizer.cpp
View File

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

2
synthisizer.h
View File

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

3
widgets/djwidget.cpp
View File

@ -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>()}

4
widgets/djwidget.h
View File

@ -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
{

3
widgets/djwidget.ui
View File

@ -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">

3
widgets/drumpadwidget.cpp
View File

@ -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");

10
widgets/drumpadwidget.h
View File

@ -5,9 +5,8 @@
#include <memory>
#include "audioformat.h"
#include "presetsmodel.h"
#include "filesmodel.h"
#include "drumpadpresetsmodel.h"
#include "drumpadfilesmodel.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{};

48
widgets/loopstationwidget.cpp Normal file
View File

@ -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)
{
}

36
widgets/loopstationwidget.h Normal file
View File

@ -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;
};

29
widgets/loopstationwidget.ui Normal file
View File

@ -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>

19
widgets/mainwindow.cpp
View File

@ -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;

3
widgets/mainwindow.h
View File

@ -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
{

11
widgets/mainwindow.ui
View File

@ -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/>

2
widgets/presetdetailwidget.cpp
View File

@ -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
}

4
widgets/presetdetailwidget.h
View File

@ -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;

1
widgets/previewwidget.cpp
View File

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

3
widgets/sampleswidget.cpp
View File

@ -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;

8
widgets/sampleswidget.h
View File

@ -6,14 +6,14 @@
#include <QWidget>
#include "audioformat.h"
#include "presets.h"
#include "drumpadpresets.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;
};

3
widgets/sampleswidget.ui
View File

@ -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"/>

3
widgets/samplewidget.cpp
View File

@ -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;

8
widgets/samplewidget.h
View File

@ -4,8 +4,7 @@
#include <QFrame>
#include "audioformat.h"
#include "presets.h"
#include "drumpadpresets.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{};

3
widgets/samplewidget.ui
View File

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

4
widgets/scratchwidget.cpp
View File

@ -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);

4
widgets/scratchwidget.h
View File

@ -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{};

8
widgets/sequencerwidget.cpp
View File

@ -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;
});

8
widgets/sequencerwidget.h
View File

@ -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;
const presets::Sequence *m_selectedSequence{};
std::vector<drumpad_presets::Sequence> m_sequences;
const drumpad_presets::Sequence *m_selectedSequence{};
QTimer m_timer;

3
widgets/sequencerwidget.ui
View File

@ -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">

1
widgets/synthisizerwidget.cpp
View File

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

2
widgets/synthisizerwidget.h
View File

@ -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
{

3
widgets/synthisizerwidget.ui
View File

@ -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>

1
widgets/trackdeck.cpp
View File

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

2
widgets/trackdeck.h
View File

@ -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
{

3
widgets/trackdeck.ui
View File

@ -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">