Hide unfinished sensors tab

AdaptiveBrightness/AdaptiveBrightness.ui

@@ -60,6 +60,9 @@
              <layout class="QGridLayout" name="gridLayout_9">
               <item row="1" column="1">
                <widget class="QSlider" name="monitorMaxBrightnessSlider">
+                <property name="value">
+                 <number>50</number>
+                </property>
                 <property name="orientation">
                  <enum>Qt::Horizontal</enum>
                 </property>
@@ -74,6 +77,9 @@
               </item>
               <item row="0" column="1">
                <widget class="QSlider" name="monitorMinBrightnessSlider">
+                <property name="value">
+                 <number>50</number>
+                </property>
                 <property name="orientation">
                  <enum>Qt::Horizontal</enum>
                 </property>
@@ -117,6 +123,9 @@
              <layout class="QGridLayout" name="gridLayout_2">
               <item row="0" column="0">
                <widget class="QSlider" name="monitorBrightnessSlider">
+                <property name="value">
+                 <number>50</number>
+                </property>
                 <property name="orientation">
                  <enum>Qt::Horizontal</enum>
                 </property>
@@ -160,6 +169,9 @@
            </item>
            <item row="0" column="1">
             <widget class="QSlider" name="monitorOverallMinBrightnessSlider">
+             <property name="value">
+              <number>50</number>
+             </property>
              <property name="orientation">
               <enum>Qt::Horizontal</enum>
              </property>
@@ -184,6 +196,9 @@
            </item>
            <item row="1" column="1">
             <widget class="QSlider" name="monitorOverallMaxBrightnessSlider">
+             <property name="value">
+              <number>50</number>
+             </property>
              <property name="orientation">
               <enum>Qt::Horizontal</enum>
              </property>
@@ -243,6 +258,9 @@
           <layout class="QGridLayout" name="gridLayout">
            <item row="0" column="0">
             <widget class="QSlider" name="monitorOverallBrightnessSlider">
+             <property name="value">
+              <number>50</number>
+             </property>
              <property name="orientation">
               <enum>Qt::Horizontal</enum>
              </property>

AdaptiveBrightness/log_to_file.hpp

@@ -17,7 +17,7 @@ static inline void rotateLog(const std::filesystem::path& logFileName, int numRo
     const auto generateRotateNames = [&]() {
         std::vector<QString> rotateFileNames = {QString().fromStdString(logFileName.string())};
 
-        for(size_t i = 1; i < numRotatingLogs; ++i) {
+        for(int i = 1; i < numRotatingLogs; ++i) {
             auto rotateName = logFileName.stem();
             rotateName += std::string(".") + std::to_string(i);
             rotateName += logFileName.extension();

AdaptiveBrightness/main_window.cpp

@@ -5,6 +5,7 @@
 
 #include <cmath>
 
+#include <QAbstractButton>
 #include <QCloseEvent>
 #include <QGroupBox>
 #include <QSlider>
@@ -24,60 +25,15 @@ MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent)
 
     m_ui.setupUi(this);
 
-    connect(m_ui.monitorBrightnessSlider, &QSlider::valueChanged, [this](int value) {
-        const auto mappedBrightness = utils::map(value, 0, 100, 0.f, 1.f);
-        const auto newBrightness = std::clamp(mappedBrightness, 0.f, 1.f);
-        qDebug(ltr("Overriding brightness with %1").arg(newBrightness));
-        m_brightness = newBrightness;
-    });
+    enumSensors();
+    enumMonitors();
 
-    loadIcons();
+    setupMonitorsTab();
+    setupSensorsTab();
 
-    if(!QSystemTrayIcon::isSystemTrayAvailable()) {
-        qWarning(ltr("System tray is not available -> tray icon will be disabled"));
-    }
-    else {
-        qDebug(ltr("System tray is available"));
+    setupTrayIcon();
 
-        m_trayIconMenu = new QMenu(this);
-        m_showHideAction = m_trayIconMenu->addAction(tr("Show"), [this]() {
-            if(m_visibility) {
-                m_showHideAction->setText(tr("Show"));
-                hide();
-            }
-            else {
-                m_showHideAction->setText(tr("Hide"));
-                show();
-            }
-            m_visibility = !m_visibility;
-        });
-        m_trayIconMenu->addSeparator();
-        m_trayIconMenu->addAction(tr("Quit"), this, &QCoreApplication::quit);
-
-        qDebug(ltr("Tray icon context menu initialized"));
-
-        m_trayIcon = new QSystemTrayIcon(this);
-        m_trayIcon->setIcon(*m_errorIcon);
-        m_trayIcon->setContextMenu(m_trayIconMenu);
-        m_trayIcon->show();
-        m_trayIcon->setToolTip(tr("AdaptiveBrightness"));
-        connect(m_trayIcon, &QSystemTrayIcon::activated, this, &MainWindow::trayIconClicked);
-
-        qDebug(ltr("Tray icon initialized"));
-    }
-
-    m_timerThread = new QThread(this);
-    m_timer = new QTimer(nullptr);
-    m_timer->setInterval(1000);
-    m_timer->moveToThread(m_timerThread);
-    m_timerThread->connect(m_timer, &QTimer::timeout, this, &MainWindow::updateState, Qt::DirectConnection);
-    m_timer->connect(m_timerThread, SIGNAL(started()), SLOT(start()));
-    m_timerThread->start();
-
-    qDebug(ltr("Tray icon update timer started"));
-
-    m_sensors = enumerateSensors();
-    m_monitors = enumerateMonitors();
+    setupCallbackTimer();
 }
 
 MainWindow::~MainWindow()
@@ -96,6 +52,33 @@ void MainWindow::closeEvent(QCloseEvent* event)
     event->ignore();
 }
 
+void MainWindow::enumSensors()
+{
+    auto sensors = enumerateSensors();
+
+    for(auto& sensor: sensors) {
+        m_sensors.push_back({std::move(sensor)});
+    }
+}
+
+void MainWindow::enumMonitors()
+{
+    m_mtx.lock();
+
+    m_ui.monitorDropdown->clear();
+    m_monitors.clear();
+
+    auto monitors = enumerateMonitors();
+
+    for(auto& monitor: monitors) {
+        const auto currentBrightness = monitor.getBrightness();
+        m_monitors.push_back({std::move(monitor), 0.f, 1.f, currentBrightness, false});
+        m_ui.monitorDropdown->addItem(m_monitors.back().driver.getName());
+    }
+
+    m_mtx.unlock();
+}
+
 void MainWindow::loadIcons()
 {
     qDebug(ltr("Loading icons"));
@@ -131,13 +114,194 @@ void MainWindow::loadIcons()
     qDebug(ltr("Icons loaded"));
 }
 
+void MainWindow::setupMonitorsTab()
+{
+    connect(m_ui.monitorDropdown, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &MainWindow::updateCurrentMonitorGUI);
+    connect(m_ui.monitorEnumerateButton, &QAbstractButton::clicked, [this](bool) { enumMonitors(); });
+    connect(m_ui.monitorResetButton, &QAbstractButton::clicked, [this](bool) { resetAllMonitorSettings(); });
+
+    setupLimitsSlider();
+    setupOverallLimitsSlider();
+
+    setupBrightness();
+    setupOverallBrightness();
+
+    resetAllMonitorSettings();
+}
+
+void MainWindow::setupLimitsSlider()
+{
+    connect(m_ui.monitorMinBrightnessSlider, &QSlider::valueChanged, [this](int value) {
+        m_ui.monitorMinBrightnessValueLabel->setText(tr("%1%").arg(value, 3));
+        if(value > m_ui.monitorMaxBrightnessSlider->value()) {
+            m_ui.monitorMaxBrightnessSlider->setValue(value);
+        }
+        const auto curIdx = m_ui.monitorDropdown->currentIndex();
+        m_monitors[curIdx].minBrightness = utils::map(value, 0, 100, 0.f, 1.f);
+    });
+    connect(m_ui.monitorMaxBrightnessSlider, &QSlider::valueChanged, [this](int value) {
+        m_ui.monitorMaxBrightnessValueLabel->setText(tr("%1%").arg(value, 3));
+        if(value < m_ui.monitorMinBrightnessSlider->value()) {
+            m_ui.monitorMinBrightnessSlider->setValue(value);
+        }
+        const auto curIdx = m_ui.monitorDropdown->currentIndex();
+        m_monitors[curIdx].maxBrightness = utils::map(value, 0, 100, 0.f, 1.f);
+    });
+}
+
+void MainWindow::setupOverallLimitsSlider()
+{
+    connect(m_ui.monitorOverallMinBrightnessSlider, &QSlider::valueChanged, [this](int value) {
+        m_ui.monitorOverallMinBrightnessValueLabel->setText(tr("%1%").arg(value, 3));
+        if(value > m_ui.monitorOverallMaxBrightnessSlider->value()) {
+            m_ui.monitorOverallMaxBrightnessSlider->setValue(value);
+        }
+        for(auto& monitor: m_monitors) {
+            monitor.minBrightness = utils::map(value, 0, 100, 0.f, 1.f);
+        }
+        updateCurrentMonitorGUI(m_ui.monitorDropdown->currentIndex());
+    });
+    connect(m_ui.monitorOverallMaxBrightnessSlider, &QSlider::valueChanged, [this](int value) {
+        m_ui.monitorOverallMaxBrightnessValueLabel->setText(tr("%1%").arg(value, 3));
+        if(value < m_ui.monitorOverallMinBrightnessSlider->value()) {
+            m_ui.monitorOverallMinBrightnessSlider->setValue(value);
+        }
+        for(auto& monitor: m_monitors) {
+            monitor.maxBrightness = utils::map(value, 0, 100, 0.f, 1.f);
+        }
+        updateCurrentMonitorGUI(m_ui.monitorDropdown->currentIndex());
+    });
+}
+
+void MainWindow::setupBrightness()
+{
+    m_ui.monitorBrightnessSlider->setDisabled(true);
+
+    connect(m_ui.monitorBrightnessSlider, &QSlider::valueChanged, [this](int value) {
+        m_ui.monitorBrightnessValueLabel->setText(tr("%1%").arg(value, 3));
+        const auto newBrightness = utils::map(value, 0, 100, 0.f, 1.f);
+        qDebug(ltr("Overriding brightness with %1").arg(newBrightness));
+        const auto curIdx = m_ui.monitorDropdown->currentIndex();
+        m_monitors[curIdx].brightness = newBrightness;
+    });
+
+    m_ui.monitorOverrideCheck->setChecked(false);
+    connect(m_ui.monitorOverrideCheck, &QCheckBox::stateChanged, [this](int state) {
+        m_ui.monitorBrightnessSlider->setEnabled(state == Qt::CheckState::Checked);
+        const auto curIdx = m_ui.monitorDropdown->currentIndex();
+        m_monitors[curIdx].manualOverride = state == Qt::CheckState::Checked;
+    });
+}
+
+void MainWindow::setupOverallBrightness()
+{
+    m_ui.monitorOverallBrightnessSlider->setDisabled(true);
+
+    connect(m_ui.monitorOverallBrightnessSlider, &QSlider::valueChanged, [this](int value) {
+        m_ui.monitorOverallBrightnessValueLabel->setText(tr("%1%").arg(value, 3));
+        const auto newBrightness = utils::map(value, 0, 100, 0.f, 1.f);
+        qDebug(ltr("Overriding overall brightness with %1").arg(newBrightness));
+        for(auto& monitor: m_monitors) {
+            if(monitor.manualOverride) {
+                monitor.brightness = newBrightness;
+            }
+        }
+        updateCurrentMonitorGUI(m_ui.monitorDropdown->currentIndex());
+    });
+
+    m_ui.monitorOverallOverrideCheck->setChecked(false);
+    connect(m_ui.monitorOverallOverrideCheck, &QCheckBox::stateChanged, [this](int state) {
+        m_ui.monitorOverallBrightnessSlider->setEnabled(state == Qt::CheckState::Checked);
+        for(auto& monitor: m_monitors) {
+            monitor.manualOverride = state == Qt::CheckState::Checked;
+        }
+        updateCurrentMonitorGUI(m_ui.monitorDropdown->currentIndex());
+    });
+}
+
+void MainWindow::setupSensorsTab()
+{
+    m_ui.tabs->removeTab(1);
+}
+
+void MainWindow::setupTrayIcon()
+{
+    loadIcons();
+
+    if(!QSystemTrayIcon::isSystemTrayAvailable()) {
+        qWarning(ltr("System tray is not available -> tray icon will be disabled"));
+    }
+    else {
+        qDebug(ltr("System tray is available"));
+
+        m_trayIconMenu = new QMenu(this);
+        m_showHideAction = m_trayIconMenu->addAction(tr("Show"), [this]() {
+            if(m_visibility) {
+                m_showHideAction->setText(tr("Show"));
+                hide();
+            }
+            else {
+                m_showHideAction->setText(tr("Hide"));
+                show();
+            }
+            m_visibility = !m_visibility;
+        });
+        m_trayIconMenu->addSeparator();
+        m_trayIconMenu->addAction(tr("Quit"), this, &QCoreApplication::quit);
+
+        qDebug(ltr("Tray icon context menu initialized"));
+
+        m_trayIcon = new QSystemTrayIcon(this);
+        m_trayIcon->setIcon(*m_errorIcon);
+        m_trayIcon->setContextMenu(m_trayIconMenu);
+        m_trayIcon->show();
+        m_trayIcon->setToolTip(tr("AdaptiveBrightness"));
+        connect(m_trayIcon, &QSystemTrayIcon::activated, this, &MainWindow::trayIconClicked);
+
+        qDebug(ltr("Tray icon initialized"));
+    }
+}
+
+void MainWindow::setupCallbackTimer()
+{
+    m_timerThread = new QThread(this);
+    m_timer = new QTimer(nullptr);
+    m_timer->setInterval(1000);
+    m_timer->moveToThread(m_timerThread);
+    m_timerThread->connect(m_timer, &QTimer::timeout, this, &MainWindow::updateState, Qt::DirectConnection);
+    m_timer->connect(m_timerThread, SIGNAL(started()), SLOT(start()));
+    m_timerThread->start();
+
+    qDebug(ltr("Callback timer started"));
+}
+
+void MainWindow::resetAllMonitorSettings()
+{
+    m_ui.monitorOverallMinBrightnessSlider->setValue(0);
+    m_ui.monitorOverallMaxBrightnessSlider->setValue(100);
+    m_ui.monitorOverallOverrideCheck->setCheckState(Qt::CheckState::Unchecked);
+}
+
+void MainWindow::updateCurrentMonitorGUI(int index)
+{
+    if(index == -1) {
+        return;
+    }
+
+    m_ui.monitorMinBrightnessSlider->setValue(utils::map(m_monitors[index].minBrightness, 0.f, 1.f, 0, 100));
+    m_ui.monitorMaxBrightnessSlider->setValue(utils::map(m_monitors[index].maxBrightness, 0.f, 1.f, 0, 100));
+    m_ui.monitorBrightnessSlider->setValue(utils::map(m_monitors[index].brightness, 0.f, 1.f, 0, 100));
+    m_ui.monitorOverrideCheck->setChecked(m_monitors[index].manualOverride);
+}
+
 void MainWindow::updateState()
 {
+    m_mtx.lock();
+
     qDebug(ltr("Updating state"));
 
     bool sensorError = false;
     bool monitorError = false;
-    size_t iconBrightness = 0;
 
     const auto getAverageSensorValue = [this](float& brightness) {
         if(m_sensors.empty()) {
@@ -147,8 +311,8 @@ void MainWindow::updateState()
         std::vector<float> values;
 
         for(auto& sensor: m_sensors) {
-            const auto sensorValues = sensor.readValues();
-            if(!sensor) {
+            const auto sensorValues = sensor.driver.readValues();
+            if(!sensor.driver) {
                 return false;
             }
             values.insert(values.end(), sensorValues.begin(), sensorValues.end());
@@ -158,35 +322,22 @@ void MainWindow::updateState()
         return true;
     };
 
-    const auto setAllMonitorsBrightness = [this](float& brightness) {
-        if(m_monitors.empty()) {
-            return false;
-        }
+    auto brightness = NAN;
 
-        bool errorOccurred = false;
-        for(auto& monitor: m_monitors) {
-            if(!monitor.setBrightness(brightness)) {
-                errorOccurred = true;
-            }
-        }
-        return !errorOccurred;
-    };
-
-    if(!getAverageSensorValue(m_brightness)) {
-        m_sensors = enumerateSensors();
+    if(!getAverageSensorValue(brightness)) {
+        enumSensors();
         qInfo(ltr("At least one sensor became invalid, re-enumerating sensors found %1 valid sensor(s)").arg(m_sensors.size()));
         sensorError = true;
     }
 
-    const auto roundedBrightness = std::round(utils::map(m_brightness, 0.f, 1.f, 0, 8));
-    iconBrightness = std::clamp<size_t>(roundedBrightness, 0, 8);
-
-    if(!setAllMonitorsBrightness(m_brightness)) {
-        m_monitors = enumerateMonitors();
+    if(!setMonitorBrightness(brightness)) {
+        enumMonitors();
         qInfo(ltr("At least one monitor became invalid, re-enumerating monitors found %1 valid monitor(s)").arg(m_monitors.size()));
         monitorError = true;
     }
 
+    const auto iconBrightness = utils::map(brightness, 0.f, 1.f, size_t{0}, size_t{8});
+
     if(!sensorError && !monitorError && m_trayIcon) {
         m_trayIcon->setIcon(*m_sensorStateIcons[iconBrightness]);
     }
@@ -198,10 +349,52 @@ void MainWindow::updateState()
     }
 
     if(m_trayIcon) {
-        m_trayIcon->setToolTip(tr("AdaptiveBrightness - %1%").arg(m_brightness * 100, 0, 'f', 0));
+        m_trayIcon->setToolTip(tr("AdaptiveBrightness - %1%").arg(brightness * 100, 0, 'f', 0));
     }
 
-    m_ui.monitorBrightnessSlider->setValue(utils::map(m_brightness, 0.f, 1.f, 0, 100));
+    m_mtx.unlock();
+}
+
+bool MainWindow::setMonitorBrightness(float& brightness)
+{
+    if(m_monitors.empty()) {
+        return false;
+    }
+
+    bool errorOccurred = false;
+    bool allMonitorsSameBrightness = true;
+
+    for(size_t i = 0; i < m_monitors.size(); ++i) {
+        if(!std::isnan(brightness) && !m_monitors[i].manualOverride) {
+            m_monitors[i].brightness = brightness;
+        }
+
+        m_monitors[i].brightness = std::clamp(m_monitors[i].brightness, m_monitors[i].minBrightness, m_monitors[i].maxBrightness);
+
+        if(i > 0 && m_monitors[i - 1].brightness != m_monitors[i].brightness) {
+            allMonitorsSameBrightness = false;
+        }
+
+        if(!m_monitors[i].driver.setBrightness(m_monitors[i].brightness)) {
+            errorOccurred = true;
+        }
+        else if(m_ui.monitorDropdown->currentIndex() == static_cast<int>(i)) {
+            updateCurrentMonitorGUI(static_cast<int>(i));
+        }
+    }
+
+    if(!errorOccurred) {
+        auto avgBrightness = 0.f;
+        std::for_each(m_monitors.begin(), m_monitors.end(), [&avgBrightness](const auto& mon) { avgBrightness += mon.brightness; });
+        avgBrightness /= m_monitors.size();
+        brightness = avgBrightness;
+    }
+
+    if(allMonitorsSameBrightness) {
+        m_ui.monitorOverallBrightnessSlider->setValue(utils::map(brightness, 0.f, 1.f, 0, 100));
+    }
+
+    return !errorOccurred;
 }
 
 void MainWindow::trayIconClicked(QSystemTrayIcon::ActivationReason reason)

AdaptiveBrightness/main_window.hpp

@@ -8,6 +8,7 @@
 #include <QIcon>
 #include <QMainWindow>
 #include <QMenu>
+#include <QMutex>
 #include <QSlider>
 #include <QSystemTrayIcon>
 #include <QThread>
@@ -28,10 +29,30 @@ class MainWindow : public QMainWindow {
   private:
     void closeEvent(QCloseEvent* event) override;
 
+    void enumSensors();
+    void enumMonitors();
+
     void loadIcons();
 
+    void setupMonitorsTab();
+    void setupLimitsSlider();
+    void setupOverallLimitsSlider();
+    void setupBrightness();
+    void setupOverallBrightness();
+
+    void setupSensorsTab();
+
+    void setupTrayIcon();
+    void setupCallbackTimer();
+
+    void resetAllMonitorSettings();
+
+    void updateCurrentMonitorGUI(int index);
+
     void updateState();
 
+    bool setMonitorBrightness(float& brightness);
+
     void trayIconClicked(QSystemTrayIcon::ActivationReason reason);
 
     Ui::MainWindow m_ui;
@@ -47,9 +68,20 @@ class MainWindow : public QMainWindow {
 
     QThread* m_timerThread = nullptr;
     QTimer* m_timer = nullptr;
+    QMutex m_mtx;
 
-    float m_brightness = 0.5f;
+    struct SensorData {
+        Sensor driver;
+    };
 
-    std::vector<Sensor> m_sensors;
-    std::vector<Monitor> m_monitors;
+    struct MonitorData {
+        Monitor driver;
+        float minBrightness;
+        float maxBrightness;
+        float brightness;
+        bool manualOverride;
+    };
+
+    std::vector<SensorData> m_sensors;
+    std::vector<MonitorData> m_monitors;
 };

AdaptiveBrightness/monitor.hpp

@@ -10,6 +10,8 @@
     #include <physicalmonitorenumerationapi.h>
     #include <windows.h>
 
+    #include <QString>
+
 namespace detail {
 
 extern BOOL enumMonitorsCallback(HMONITOR, HDC, LPRECT, LPARAM);
@@ -26,6 +28,8 @@ class Monitor {
     bool setBrightness(float percentage);
     float getBrightness();
 
+    QString getName() const;
+
     operator bool() const;
 
   private:
@@ -53,6 +57,8 @@ class Monitor {
 
 #if defined(__clang__) || defined(__GNUC__)
 
+    #include <QString>
+
 class Monitor {
   public:
     Monitor();
@@ -60,6 +66,8 @@ class Monitor {
     bool setBrightness(float);
     float getBrightness();
 
+    QString getName() const;
+
     operator bool() const;
 
   private:

AdaptiveBrightness/monitor_linux.cpp

@@ -26,6 +26,12 @@ float Monitor::getBrightness()
     return NAN;
 }
 
+QString Monitor::getName() const
+{
+    qWarning(ltr("Getting monitor name not implemented"));
+    return "Unknown";
+}
+
 Monitor::operator bool() const
 {
     qWarning(ltr("Checking monitor validity not implemented"));

AdaptiveBrightness/monitor_win.cpp

@@ -24,6 +24,8 @@ Monitor::Monitor(Monitor&& other) noexcept
     other.m_hMonitor = 0;
     other.m_physicalMonitor.name.clear();
     other.m_physicalMonitor.handle = 0;
+    other.m_brightnessRange.reset();
+    other.m_errorOccurred = false;
 }
 
 Monitor::~Monitor()
@@ -62,8 +64,7 @@ bool Monitor::setBrightness(float percentage)
             return false;
     }
 
-    const auto mappedBrightness = utils::map(percentage, 0.f, 1.f, m_brightnessRange->first, m_brightnessRange->second);
-    const auto newBrightness = std::clamp<DWORD>(std::round(mappedBrightness), m_brightnessRange->first, m_brightnessRange->second);
+    const auto newBrightness = utils::map(percentage, 0.f, 1.f, m_brightnessRange->first, m_brightnessRange->second);
 
     if(!SetMonitorBrightness(m_physicalMonitor.handle, newBrightness)) {
         qCritical(ltr("Failed to set brightness of monitor '%1' with handle '0x%2' and physical handle '0x%3', error: %4")
@@ -108,7 +109,15 @@ float Monitor::getBrightness()
     m_brightnessRange = std::pair{minBrightness, maxBrightness};
     m_errorOccurred = false;
 
-    return std::clamp(utils::map(brightness, minBrightness, maxBrightness, 0.f, 1.f), 0.f, 1.f);
+    return utils::map(brightness, minBrightness, maxBrightness, 0.f, 1.f);
+}
+
+QString Monitor::getName() const
+{
+    return QString("%1 (0x%2:0x%3)")
+        .arg(m_physicalMonitor.name)
+        .arg(reinterpret_cast<qulonglong>(m_hMonitor), 0, 16)
+        .arg(reinterpret_cast<qulonglong>(m_physicalMonitor.handle), 0, 16);
 }
 
 Monitor::operator bool() const

AdaptiveBrightness/sensor.cpp

@@ -15,6 +15,13 @@ Sensor::~Sensor()
     qDebug(ltr("Destroying sensor on serial port %1").arg(m_serialPortName));
 }
 
+Sensor::Sensor(Sensor&& other) noexcept : m_serialPortName(other.m_serialPortName), m_errorOccurred(other.m_errorOccurred), m_range(other.m_range)
+{
+    other.m_serialPortName.clear();
+    other.m_errorOccurred = false;
+    other.m_range.reset();
+}
+
 std::vector<float> Sensor::readValues()
 {
     qDebug(ltr("Reading values of sensor on port %1").arg(m_serialPortName));
@@ -40,8 +47,7 @@ std::vector<float> Sensor::readValues()
     std::vector<float> normalizedValues;
 
     for(const auto& value: values) {
-        const auto mappedValue = utils::map(value, m_range->first, m_range->second, 0.f, 1.f);
-        normalizedValues.push_back(std::clamp(mappedValue, 0.f, 1.f));
+        normalizedValues.push_back(utils::map(value, m_range->first, m_range->second, 0.f, 1.f));
     }
 
     return normalizedValues;

AdaptiveBrightness/sensor.hpp

@@ -11,6 +11,8 @@
 
 class Sensor {
   public:
+    Sensor(const Sensor&) = delete;
+    Sensor(Sensor&& other) noexcept;
     ~Sensor();
 
     std::vector<float> readValues();
@@ -26,7 +28,7 @@ class Sensor {
 
     static constexpr auto SUPPORTED_FIRMWARE = std::string_view{"AdaptiveBrightness v1.2"};
 
-    const QString m_serialPortName;
+    QString m_serialPortName;
     bool m_errorOccurred = false;
 
     std::optional<std::pair<int, int>> m_range;

AdaptiveBrightness/sensor_driver.cpp

@@ -21,7 +21,7 @@ std::vector<Sensor> enumerateSensors()
         auto sensor = Sensor(portInfo.portName());
         if(sensor.isValidSensor()) {
             qInfo(ltr("Successfully enumerated sensor on port %1").arg(portInfo.portName()));
-            sensors.push_back(sensor);
+            sensors.push_back(std::move(sensor));
         }
     }
 

AdaptiveBrightness/utils.hpp

@@ -1,17 +1,30 @@
 #pragma once
 
+#include <algorithm>
 #include <array>
+#include <type_traits>
 
+#include <cmath>
 #include <cstddef>
 
 namespace utils {
 
 template<typename InType, typename OutType>
-auto map(InType value, InType inMin, InType inMax, OutType outMin, OutType outMax)
+auto interpolate(InType value, InType inMin, InType inMax, OutType outMin, OutType outMax)
 {
     return (value - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
 }
 
+template<typename InType, typename OutType>
+auto map(InType value, InType inMin, InType inMax, OutType outMin, OutType outMax)
+{
+    if constexpr(std::is_integral_v<OutType>) {
+        return std::clamp(static_cast<OutType>(std::round(interpolate(value, inMin, inMax, outMin, outMax))), outMin, outMax);
+    }
+
+    return std::clamp(static_cast<OutType>(interpolate(value, inMin, inMax, outMin, outMax)), outMin, outMax);
+}
+
 template<typename>
 struct array_size;
 

CMakeLists.txt

@@ -71,10 +71,16 @@ target_link_libraries(AdaptiveBrightness
                       Qt5::SerialPort
 )
 
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|AppleClang")
+    target_link_libraries(AdaptiveBrightness
+                          stdc++fs
+    )
+endif()
+
 if(MSVC)
-target_link_libraries(AdaptiveBrightness
+    target_link_libraries(AdaptiveBrightness
                           Dxva2.lib
-)
+    )
 endif()
 
 if(MSVC)