Presets now have steps instead of a single slider state

devicesmodel.cpp

@@ -375,11 +375,14 @@ bool DevicesModel::insertRows(int row, int count, const QModelIndex &parent)
 
         for (auto &preset : m_controller->lightProject().presets)
         {
-            auto &sliderStates = preset.sliders;
+            for (auto &step : preset.steps)
-            if (sliderStates.size() > row)
             {
-                sliderStates.insert(std::begin(sliderStates) + row, count, {});
+                auto &sliderStates = step.sliders;
-                emit m_controller->sliderStatesChanged(sliderStates);
+                if (sliderStates.size() > row)
+                {
+                    sliderStates.insert(std::begin(sliderStates) + row, count, {});
+                    emit m_controller->sliderStatesChanged(sliderStates);
+                }
             }
         }
     }
@@ -448,13 +451,14 @@ bool DevicesModel::removeRows(int row, int count, const QModelIndex &parent)
 
         for (auto &preset : m_controller->lightProject().presets)
         {
-            if (auto &sliderStates = preset.sliders; sliderStates.size() > row)
+            for (auto &step : preset.steps)
-            {
+                if (auto &sliderStates = step.sliders; sliderStates.size() > row)
-                auto begin = std::begin(sliderStates) + row;
+                {
-                auto end = begin + std::min<size_t>(count, sliderStates.size() - row + count);
+                    auto begin = std::begin(sliderStates) + row;
-                sliderStates.erase(begin, end);
+                    auto end = begin + std::min<size_t>(count, sliderStates.size() - row + count);
-                emit m_controller->sliderStatesChanged(sliderStates);
+                    sliderStates.erase(begin, end);
-            }
+                    emit m_controller->sliderStatesChanged(sliderStates);
+                }
         }
     }
     endRemoveRows();

dmxcontroller.cpp

@@ -10,18 +10,6 @@
 
 #include "projectloader.h"
 
-void doFun(auto &y)
-{
-    return;
-    double i{-10};
-    for (auto &x : y.devices)
-    {
-        x.position.setX(i);
-        x.position.setZ(std::sin(i / 2.) * 10.);
-        i += 20./double(y.devices.size());
-    }
-}
-
 DmxController::DmxController(ScheinCommanderSettings &settings, QObject *parent) :
     QObject{parent},
     m_settings{settings},
@@ -181,7 +169,6 @@ DmxController::DmxController(ScheinCommanderSettings &settings, QObject *parent)
         }
     }
 {
-    doFun(m_lightProject);
 }
 
 bool DmxController::start()
@@ -253,12 +240,10 @@ bool DmxController::loadProject(const QString &name)
     }
     else
     {
-        qDebug() << proj.error();
+        qFatal("loading project failed: %s", qPrintable(proj.error()));
         return false;
     }
 
-    doFun(m_lightProject);
-
     return true;
 }
 
@@ -342,6 +327,7 @@ void DmxController::setSliderStates(const sliders_state_t &sliderStates)
 void DmxController::sendDmxBuffer()
 {
     const auto now = QDateTime::currentDateTime();
+    const auto secsSinceEpoch = now.toSecsSinceEpoch();
 
     char buf[513] {0};
 
@@ -413,7 +399,14 @@ void DmxController::sendDmxBuffer()
                 iter++;
                 continue;
             }
-            apply(preset.sliders, *iter);
+            if (preset.steps.empty())
+            {
+                iter++;
+                continue;
+            }
+
+            const auto &sliders = preset.steps[secsSinceEpoch % preset.steps.size()].sliders;
+            apply(sliders, *iter);
             iter++;
         }
     }

lightproject.h

@@ -113,11 +113,16 @@ public:
 
 using sliders_state_t = std::vector<std::vector<quint8>>;
 
+struct PresetStepConfig
+{
+    sliders_state_t sliders;
+};
+
 struct PresetConfig
 {
     int id;
     QString name;
-    sliders_state_t sliders;
+    std::vector<PresetStepConfig> steps;
 };
 
 class PresetsContainer : public std::vector<PresetConfig>

presetmodel.cpp

@@ -62,7 +62,7 @@ void PresetModel::copyFromFaders()
 
     {
         QMutexLocker locker{&m_controller->mutex()};
-        preset.sliders = m_controller->sliderStates();
+        preset.steps = { { .sliders=m_controller->sliderStates() } };
     }
 }
 
@@ -89,7 +89,13 @@ void PresetModel::copyToFaders()
 
     const auto &preset = *presetPtr;
 
-    m_controller->setSliderStates(preset.sliders);
+    if (preset.steps.empty())
+    {
+        qDebug() << "hilfe" << __LINE__;
+        return;
+    }
+
+    m_controller->setSliderStates(preset.steps.front().sliders);
 }
 
 void PresetModel::setAllFadersLow()

projectloader.cpp

@@ -34,7 +34,8 @@ concept LoadableFromObject = std::same_as<T, LightProject> ||
                              std::same_as<T, DeviceConfig> ||
                              std::same_as<T, DeviceTypeConfig> ||
                              std::same_as<T, DeviceTypeRegisterConfig> ||
-                             std::same_as<T, PresetConfig>;
+                             std::same_as<T, PresetConfig> ||
+                             std::same_as<T, PresetStepConfig>;
 
 template<typename T>
 concept JsonNumber = (std::integral<T> && !std::same_as<T, bool> && !std::is_enum_v<T>) ||
@@ -245,6 +246,17 @@ std::expected<T, QString> load(const QJsonObject &json) {
     return dc;
 }
 
+template<std::same_as<PresetStepConfig> T>
+std::expected<T, QString> load(const QJsonObject &json) {
+    PresetStepConfig rgc;
+    if (auto val = loadIfExists<decltype(rgc.sliders)>(json, "sliders"); val) {
+        rgc.sliders = val.value();
+    } else {
+        return std::unexpected(QString("sliders: %1").arg(val.error()));
+    }
+    return rgc;
+}
+
 template<std::same_as<PresetConfig> T>
 std::expected<T, QString> load(const QJsonObject &json) {
     PresetConfig rgc;
@@ -258,10 +270,10 @@ std::expected<T, QString> load(const QJsonObject &json) {
     } else {
         return std::unexpected(QString("name: %1").arg(val.error()));
     }
-    if (auto val = loadIfExists<decltype(rgc.sliders)>(json, "sliders"); val) {
+    if (auto val = loadIfExists<decltype(rgc.steps)>(json, "steps"); val) {
-        rgc.sliders = val.value();
+        rgc.steps = val.value();
     } else {
-        return std::unexpected(QString("sliders: %1").arg(val.error()));
+        return std::unexpected(QString("steps: %1").arg(val.error()));
     }
 
     return rgc;
@@ -392,6 +404,17 @@ std::expected<QJsonObject, QString> save(const T &val) {
     return json;
 }
 
+template<std::same_as<PresetStepConfig> T>
+std::expected<QJsonObject, QString> save(const T &val) {
+    QJsonObject json;
+    if (auto sliders = save<decltype(val.sliders)>(val.sliders); sliders) {
+        json["sliders"] = sliders.value();
+    } else {
+        return std::unexpected(QString("sliders: %1").arg(sliders.error()));
+    }
+    return json;
+}
+
 template<std::same_as<PresetConfig> T>
 std::expected<QJsonObject, QString> save(const T &val) {
     QJsonObject json;
@@ -405,10 +428,10 @@ std::expected<QJsonObject, QString> save(const T &val) {
     } else {
         return std::unexpected(QString("name: %1").arg(name.error()));
     }
-    if (auto sliders = save<decltype(val.sliders)>(val.sliders); sliders) {
+    if (auto steps = save<decltype(val.steps)>(val.steps); steps) {
-        json["sliders"] = sliders.value();
+        json["steps"] = steps.value();
     } else {
-        return std::unexpected(QString("sliders: %1").arg(sliders.error()));
+        return std::unexpected(QString("steps: %1").arg(steps.error()));
     }
 
     return json;