AdaptiveBrightness/AdaptiveBrightness/main_window.cpp

#include "main_window.hpp"

#include <algorithm>
#include <numeric>

#include <cmath>

#include <QAbstractButton>
#include <QCloseEvent>
#include <QGroupBox>
#include <QSlider>
#include <QTabWidget>
#include <QWidget>
#include <QtDebug>
#include <QtGlobal>

#include "log_tr.hpp"
#include "monitor_control.hpp"
#include "sensor_driver.hpp"
#include "utils.hpp"

MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent), m_mtx(QMutex::RecursionMode::Recursive)
{
    qDebug(ltr("Creating main window"));

    m_ui.setupUi(this);

    enumSensors();
    enumMonitors();

    setupMonitorsTab();
    setupSensorsTab();

    setupTrayIcon();

    setupCallbackTimer();
}

MainWindow::~MainWindow()
{
    qDebug(ltr("Destroying main window"));

    m_timerThread->quit();
    if(!m_timerThread->wait()) {
        qCritical(ltr("Timer thread did not terminate cleanly"));
    }
}

void MainWindow::closeEvent(QCloseEvent* event)
{
    m_showHideAction->activate(QAction::Trigger);
    event->ignore();
}

void MainWindow::enumSensors()
{
    m_sensors.clear();

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

    constexpr auto NO_SENSOR_ICON_PATHS = std::array{
        ":/AdaptiveBrightness/resources/nosense_0.ico", ":/AdaptiveBrightness/resources/nosense_1.ico", ":/AdaptiveBrightness/resources/nosense_2.ico",
        ":/AdaptiveBrightness/resources/nosense_3.ico", ":/AdaptiveBrightness/resources/nosense_4.ico", ":/AdaptiveBrightness/resources/nosense_5.ico",
        ":/AdaptiveBrightness/resources/nosense_6.ico", ":/AdaptiveBrightness/resources/nosense_7.ico", ":/AdaptiveBrightness/resources/nosense_8.ico",
    };

    static_assert(NO_SENSOR_ICON_PATHS.size() == utils::array_size_v<decltype(m_noSensorStateIcons)>, "Number of paths does not match number of icons");

    constexpr auto SENSOR_ICON_PATHS = std::array{
        ":/AdaptiveBrightness/resources/sense_0.ico", ":/AdaptiveBrightness/resources/sense_1.ico", ":/AdaptiveBrightness/resources/sense_2.ico",
        ":/AdaptiveBrightness/resources/sense_3.ico", ":/AdaptiveBrightness/resources/sense_4.ico", ":/AdaptiveBrightness/resources/sense_5.ico",
        ":/AdaptiveBrightness/resources/sense_6.ico", ":/AdaptiveBrightness/resources/sense_7.ico", ":/AdaptiveBrightness/resources/sense_8.ico",
    };

    static_assert(SENSOR_ICON_PATHS.size() == utils::array_size_v<decltype(m_sensorStateIcons)>, "Number of paths does not match number of icons");

    constexpr auto ERROR_ICON_PATH = ":/AdaptiveBrightness/resources/error.ico";

    for(std::size_t i = 0; i < NO_SENSOR_ICON_PATHS.size(); ++i) {
        m_noSensorStateIcons[i] = std::make_unique<QIcon>(NO_SENSOR_ICON_PATHS[i]);
    }

    for(std::size_t i = 0; i < SENSOR_ICON_PATHS.size(); ++i) {
        m_sensorStateIcons[i] = std::make_unique<QIcon>(SENSOR_ICON_PATHS[i]);
    }

    m_errorIcon = std::make_unique<QIcon>(ERROR_ICON_PATH);

    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;

    const auto getAverageSensorValue = [this](float& brightness) {
        if(m_sensors.empty()) {
            return false;
        }

        std::vector<float> values;

        for(auto& sensor: m_sensors) {
            const auto sensorValues = sensor.driver.readValues();
            if(!sensor.driver) {
                return false;
            }
            values.insert(values.end(), sensorValues.begin(), sensorValues.end());
        }

        brightness = std::accumulate(values.begin(), values.end(), 0.f) / values.size();
        return true;
    };

    auto brightness = NAN;

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

    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]);
    }
    else if(sensorError && !monitorError && m_trayIcon) {
        m_trayIcon->setIcon(*m_noSensorStateIcons[iconBrightness]);
    }
    else if(m_trayIcon) {
        m_trayIcon->setIcon(*m_errorIcon);
    }

    if(m_trayIcon) {
        m_trayIcon->setToolTip(tr("AdaptiveBrightness - %1%").arg(brightness * 100, 0, 'f', 0));
    }

    m_mtx.unlock();
}

bool MainWindow::setMonitorBrightness(float& brightness)
{
    constexpr auto hysteresis = [](const auto& lowThreshold, const auto& highThreshold, const auto& currentValue, const auto& newValue) {
        if(newValue > highThreshold || newValue < lowThreshold)
            return newValue;
        return currentValue;
    };

    if(m_monitors.empty()) {
        return false;
    }

    bool errorOccurred = false;
    bool allMonitorsSameBrightness = true;

    for(size_t i = 0; i < m_monitors.size(); ++i) {
        const auto updateMonitorBrightness = [&] {
            const auto brightnessRange = m_monitors[i].maxBrightness - m_monitors[i].minBrightness;
            const auto hysteresisDelta = m_monitors[i].manualOverride ? 0.f : m_monitors[i].HYSTERESIS_THRESHOLD * brightnessRange;
            const auto lowThreshold = std::clamp(m_monitors[i].prevBrightness - hysteresisDelta, m_monitors[i].minBrightness, m_monitors[i].maxBrightness);
            const auto highThreshold = std::clamp(m_monitors[i].prevBrightness + hysteresisDelta, m_monitors[i].minBrightness, m_monitors[i].maxBrightness);
            if(hysteresis(lowThreshold, highThreshold, m_monitors[i].prevBrightness, m_monitors[i].brightness) != m_monitors[i].prevBrightness) {
                qDebug(ltr("Setting monitor %1 brightness from %2 to %3")
                           .arg(i)
                           .arg(m_monitors[i].prevBrightness, 0, 'f', 2)
                           .arg(m_monitors[i].brightness, 0, 'f', 2));
                m_monitors[i].prevBrightness = m_monitors[i].brightness;
                return m_monitors[i].driver.setBrightness(m_monitors[i].brightness);
            }
            else {
                qDebug(ltr("Hysteresis prevented setting monitor %1 brightness from %2 to %3")
                           .arg(i)
                           .arg(m_monitors[i].prevBrightness, 0, 'f', 2)
                           .arg(m_monitors[i].brightness, 0, 'f', 2));
            }
            return true;
        };

        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(!updateMonitorBrightness()) {
            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)
{
    if(reason == QSystemTrayIcon::ActivationReason::Trigger) {
        m_showHideAction->trigger();
    }
}