From e5528e931769e43da61278561c7ebe8f17974081 Mon Sep 17 00:00:00 2001 From: Vlad Zahorodnii Date: Fri, 14 Jun 2024 17:53:37 +0300 Subject: [PATCH] plugins/nightlight: Rename variables and functions to adhere to the KDE coding conventions The variables and functions should be fully spelled out, with temporary variables being an exception. --- src/plugins/nightlight/nightlightmanager.cpp | 208 +++++++++---------- src/plugins/nightlight/nightlightmanager.h | 28 +-- 2 files changed, 118 insertions(+), 118 deletions(-) diff --git a/src/plugins/nightlight/nightlightmanager.cpp b/src/plugins/nightlight/nightlightmanager.cpp index b94dc99316..af207250f8 100644 --- a/src/plugins/nightlight/nightlightmanager.cpp +++ b/src/plugins/nightlight/nightlightmanager.cpp @@ -38,9 +38,9 @@ static const int QUICK_ADJUST_DURATION = 2000; static const int TEMPERATURE_STEP = 50; static NightLightManager *s_instance = nullptr; -static bool checkLocation(double lat, double lng) +static bool checkLocation(double latitude, double longitude) { - return -90 <= lat && lat <= 90 && -180 <= lng && lng <= 180; + return -90 <= latitude && latitude <= 90 && -180 <= longitude && longitude <= 180; } NightLightManager *NightLightManager::self() @@ -143,7 +143,7 @@ void NightLightManager::hardReset() if (isEnabled() && !isInhibited()) { setRunning(true); - commitGammaRamps(currentTargetTemp()); + commitGammaRamps(currentTargetTemperature()); } resetAllTimers(); } @@ -198,7 +198,7 @@ bool NightLightManager::isRunning() const int NightLightManager::currentTemperature() const { - return m_currentTemp; + return m_currentTemperature; } int NightLightManager::targetTemperature() const @@ -233,13 +233,13 @@ qint64 NightLightManager::scheduledTransitionDuration() const void NightLightManager::readConfig() { - NightLightSettings *s = NightLightSettings::self(); - s->load(); + NightLightSettings *settings = NightLightSettings::self(); + settings->load(); - setEnabled(s->active()); + setEnabled(settings->active()); - const NightLightMode mode = s->mode(); - switch (s->mode()) { + const NightLightMode mode = settings->mode(); + switch (settings->mode()) { case NightLightMode::Automatic: case NightLightMode::Location: case NightLightMode::Timings: @@ -252,51 +252,52 @@ void NightLightManager::readConfig() break; } - m_dayTargetTemp = std::clamp(s->dayTemperature(), MIN_TEMPERATURE, DEFAULT_DAY_TEMPERATURE); - m_nightTargetTemp = std::clamp(s->nightTemperature(), MIN_TEMPERATURE, DEFAULT_DAY_TEMPERATURE); + m_dayTargetTemperature = std::clamp(settings->dayTemperature(), MIN_TEMPERATURE, DEFAULT_DAY_TEMPERATURE); + m_nightTargetTemperature = std::clamp(settings->nightTemperature(), MIN_TEMPERATURE, DEFAULT_DAY_TEMPERATURE); - double lat, lng; - auto correctReadin = [&lat, &lng]() { - if (!checkLocation(lat, lng)) { + double latitude, longitude; + auto correctReadin = [&latitude, &longitude]() { + if (!checkLocation(latitude, longitude)) { // out of domain - lat = 0; - lng = 0; + latitude = 0; + longitude = 0; } }; // automatic - lat = s->latitudeAuto(); - lng = s->longitudeAuto(); + latitude = settings->latitudeAuto(); + longitude = settings->longitudeAuto(); correctReadin(); - m_latAuto = lat; - m_lngAuto = lng; + m_latitudeAuto = latitude; + m_longitudeAuto = longitude; // fixed location - lat = s->latitudeFixed(); - lng = s->longitudeFixed(); + latitude = settings->latitudeFixed(); + longitude = settings->longitudeFixed(); correctReadin(); - m_latFixed = lat; - m_lngFixed = lng; + m_latitudeFixed = latitude; + m_longitudeFixed = longitude; // fixed timings - QTime mrB = QTime::fromString(s->morningBeginFixed(), "hhmm"); - QTime evB = QTime::fromString(s->eveningBeginFixed(), "hhmm"); - if (mrB >= evB) { - mrB = QTime(6, 0); - evB = QTime(18, 0); + QTime morning = QTime::fromString(settings->morningBeginFixed(), "hhmm"); + QTime evening = QTime::fromString(settings->eveningBeginFixed(), "hhmm"); + if (morning >= evening) { + morning = QTime(6, 0); + evening = QTime(18, 0); } - int diffME = mrB.msecsTo(evB); - int diffMin = std::min(diffME, MSC_DAY - diffME); + const int dayDuration = morning.msecsTo(evening); + const int nightDuration = MSC_DAY - dayDuration; + const int maximumTransitionDuration = std::min(dayDuration, nightDuration); - int trTime = s->transitionTime() * 1000 * 60; - if (trTime < 0 || diffMin <= trTime) { + int transitionDuration = settings->transitionTime() * 1000 * 60; + if (transitionDuration < 0 || maximumTransitionDuration <= transitionDuration) { // transition time too long - use defaults - mrB = QTime(6, 0); - evB = QTime(18, 0); - trTime = FALLBACK_SLOW_UPDATE_TIME; + morning = QTime(6, 0); + evening = QTime(18, 0); + transitionDuration = FALLBACK_SLOW_UPDATE_TIME; } - m_morning = mrB; - m_evening = evB; - m_trTime = std::max(trTime / 1000 / 60, 1); + m_morning = morning; + m_evening = evening; + m_transitionDuration = std::max(transitionDuration / 1000 / 60, 1); } void NightLightManager::resetAllTimers() @@ -306,7 +307,7 @@ void NightLightManager::resetAllTimers() // we do this also for active being false in order to reset the temperature back to the day value updateTransitionTimings(QDateTime::currentDateTime()); updateTargetTemperature(); - resetQuickAdjustTimer(currentTargetTemp()); + resetQuickAdjustTimer(currentTargetTemperature()); } void NightLightManager::cancelAllTimers() @@ -316,16 +317,16 @@ void NightLightManager::cancelAllTimers() m_quickAdjustTimer.reset(); } -void NightLightManager::resetQuickAdjustTimer(int targetTemp) +void NightLightManager::resetQuickAdjustTimer(int targetTemperature) { - int tempDiff = std::abs(targetTemp - m_currentTemp); + int tempDiff = std::abs(targetTemperature - m_currentTemperature); // allow tolerance of one TEMPERATURE_STEP to compensate if a slow update is coincidental if (tempDiff > TEMPERATURE_STEP) { cancelAllTimers(); m_quickAdjustTimer = std::make_unique(); m_quickAdjustTimer->setSingleShot(false); - connect(m_quickAdjustTimer.get(), &QTimer::timeout, this, [this, targetTemp]() { - quickAdjust(targetTemp); + connect(m_quickAdjustTimer.get(), &QTimer::timeout, this, [this, targetTemperature]() { + quickAdjust(targetTemperature); }); int interval = (QUICK_ADJUST_DURATION / (m_previewTimer && m_previewTimer->isActive() ? 8 : 1)) / (tempDiff / TEMPERATURE_STEP); @@ -338,22 +339,21 @@ void NightLightManager::resetQuickAdjustTimer(int targetTemp) } } -void NightLightManager::quickAdjust(int targetTemp) +void NightLightManager::quickAdjust(int targetTemperature) { if (!m_quickAdjustTimer) { return; } - int nextTemp; - - if (m_currentTemp < targetTemp) { - nextTemp = std::min(m_currentTemp + TEMPERATURE_STEP, targetTemp); + int nextTemperature; + if (m_currentTemperature < targetTemperature) { + nextTemperature = std::min(m_currentTemperature + TEMPERATURE_STEP, targetTemperature); } else { - nextTemp = std::max(m_currentTemp - TEMPERATURE_STEP, targetTemp); + nextTemperature = std::max(m_currentTemperature - TEMPERATURE_STEP, targetTemperature); } - commitGammaRamps(nextTemp); + commitGammaRamps(nextTemperature); - if (nextTemp == targetTemp) { + if (nextTemperature == targetTemperature) { // stop timer, we reached the target temp m_quickAdjustTimer.reset(); resetSlowUpdateTimers(); @@ -375,7 +375,7 @@ void NightLightManager::resetSlowUpdateTimers() return; } - const QDateTime todayNow = QDateTime::currentDateTime(); + const QDateTime dateTime = QDateTime::currentDateTime(); // set up the next slow update m_slowUpdateStartTimer = std::make_unique(); @@ -383,10 +383,10 @@ void NightLightManager::resetSlowUpdateTimers() connect(m_slowUpdateStartTimer.get(), &QTimer::timeout, this, [this]() { resetSlowUpdateTimers(); }); - updateTransitionTimings(todayNow); + updateTransitionTimings(dateTime); updateTargetTemperature(); - const int diff = todayNow.msecsTo(m_next.first); + const int diff = dateTime.msecsTo(m_next.first); if (diff <= 0) { qCCritical(KWIN_NIGHTLIGHT) << "Error in time calculation. Deactivating Night Light."; return; @@ -397,12 +397,12 @@ void NightLightManager::resetSlowUpdateTimers() m_slowUpdateTimer.reset(); // We've reached the target color temperature or the transition time is zero. - if (m_prev.first == m_prev.second || m_currentTemp == m_targetTemperature) { + if (m_prev.first == m_prev.second || m_currentTemperature == m_targetTemperature) { commitGammaRamps(m_targetTemperature); return; } - if (todayNow < m_prev.second) { + if (dateTime < m_prev.second) { m_slowUpdateTimer = std::make_unique(); m_slowUpdateTimer->setSingleShot(false); connect(m_slowUpdateTimer.get(), &QTimer::timeout, this, [this]() { @@ -410,7 +410,7 @@ void NightLightManager::resetSlowUpdateTimers() }); // calculate interval such as temperature is changed by TEMPERATURE_STEP K per timer timeout - int interval = todayNow.msecsTo(m_prev.second) * TEMPERATURE_STEP / std::abs(m_targetTemperature - m_currentTemp); + int interval = dateTime.msecsTo(m_prev.second) * TEMPERATURE_STEP / std::abs(m_targetTemperature - m_currentTemperature); if (interval == 0) { interval = 1; } @@ -420,19 +420,19 @@ void NightLightManager::resetSlowUpdateTimers() } } -void NightLightManager::slowUpdate(int targetTemp) +void NightLightManager::slowUpdate(int targetTemperature) { if (!m_slowUpdateTimer) { return; } - int nextTemp; - if (m_currentTemp < targetTemp) { - nextTemp = std::min(m_currentTemp + TEMPERATURE_STEP, targetTemp); + int nextTemperature; + if (m_currentTemperature < targetTemperature) { + nextTemperature = std::min(m_currentTemperature + TEMPERATURE_STEP, targetTemperature); } else { - nextTemp = std::max(m_currentTemp - TEMPERATURE_STEP, targetTemp); + nextTemperature = std::max(m_currentTemperature - TEMPERATURE_STEP, targetTemperature); } - commitGammaRamps(nextTemp); - if (nextTemp == targetTemp) { + commitGammaRamps(nextTemperature); + if (nextTemperature == targetTemperature) { // stop timer, we reached the target temp m_slowUpdateTimer.reset(); } @@ -466,13 +466,13 @@ void NightLightManager::stopPreview() if (m_previewTimer && m_previewTimer->isActive()) { updateTransitionTimings(QDateTime::currentDateTime()); updateTargetTemperature(); - resetQuickAdjustTimer(currentTargetTemp()); + resetQuickAdjustTimer(currentTargetTemperature()); } } void NightLightManager::updateTargetTemperature() { - const int targetTemperature = mode() != NightLightMode::Constant && daylight() ? m_dayTargetTemp : m_nightTargetTemp; + const int targetTemperature = mode() != NightLightMode::Constant && daylight() ? m_dayTargetTemperature : m_nightTargetTemperature; if (m_targetTemperature == targetTemperature) { return; @@ -483,7 +483,7 @@ void NightLightManager::updateTargetTemperature() Q_EMIT targetTemperatureChanged(); } -void NightLightManager::updateTransitionTimings(const QDateTime &todayNow) +void NightLightManager::updateTransitionTimings(const QDateTime &dateTime) { const auto oldPrev = m_prev; const auto oldNext = m_next; @@ -499,42 +499,42 @@ void NightLightManager::updateTransitionTimings(const QDateTime &todayNow) m_next = DateTimes(); m_prev = DateTimes(); } else if (m_mode == NightLightMode::Timings) { - const bool passedMorning = todayNow.time().secsTo(m_morning) <= granularity; - const bool passedEvening = todayNow.time().secsTo(m_evening) <= granularity; + const bool passedMorning = dateTime.time().secsTo(m_morning) <= granularity; + const bool passedEvening = dateTime.time().secsTo(m_evening) <= granularity; - const QDateTime nextMorB = QDateTime(todayNow.date().addDays(passedMorning), m_morning); - const QDateTime nextMorE = nextMorB.addSecs(m_trTime * 60); - const QDateTime nextEveB = QDateTime(todayNow.date().addDays(passedEvening), m_evening); - const QDateTime nextEveE = nextEveB.addSecs(m_trTime * 60); + const QDateTime nextEarlyMorning = QDateTime(dateTime.date().addDays(passedMorning), m_morning); + const QDateTime nextLateMorning = nextEarlyMorning.addSecs(m_transitionDuration * 60); + const QDateTime nextEarlyEvening = QDateTime(dateTime.date().addDays(passedEvening), m_evening); + const QDateTime nextLateEvening = nextEarlyEvening.addSecs(m_transitionDuration * 60); - if (nextEveB < nextMorB) { + if (nextEarlyEvening < nextEarlyMorning) { setDaylight(true); - m_next = DateTimes(nextEveB, nextEveE); - m_prev = DateTimes(nextMorB.addDays(-1), nextMorE.addDays(-1)); + m_next = DateTimes(nextEarlyEvening, nextLateEvening); + m_prev = DateTimes(nextEarlyMorning.addDays(-1), nextLateMorning.addDays(-1)); } else { setDaylight(false); - m_next = DateTimes(nextMorB, nextMorE); - m_prev = DateTimes(nextEveB.addDays(-1), nextEveE.addDays(-1)); + m_next = DateTimes(nextEarlyMorning, nextLateMorning); + m_prev = DateTimes(nextEarlyEvening.addDays(-1), nextLateEvening.addDays(-1)); } } else { - double lat, lng; + double latitude, longitude; if (m_mode == NightLightMode::Automatic) { - lat = m_latAuto; - lng = m_lngAuto; + latitude = m_latitudeAuto; + longitude = m_longitudeAuto; } else { - lat = m_latFixed; - lng = m_lngFixed; + latitude = m_latitudeFixed; + longitude = m_longitudeFixed; } - const DateTimes morning = getSunTimings(todayNow, lat, lng, true); - if (todayNow.secsTo(morning.first) > granularity) { + const DateTimes morning = getSunTimings(dateTime, latitude, longitude, true); + if (dateTime.secsTo(morning.first) > granularity) { // have not reached the morning yet setDaylight(false); - m_prev = getSunTimings(todayNow.addDays(-1), lat, lng, false); + m_prev = getSunTimings(dateTime.addDays(-1), latitude, longitude, false); m_next = morning; } else { - const DateTimes evening = getSunTimings(todayNow, lat, lng, false); - if (todayNow.secsTo(evening.first) > granularity) { + const DateTimes evening = getSunTimings(dateTime, latitude, longitude, false); + if (dateTime.secsTo(evening.first) > granularity) { // have not reached the evening yet, it's daylight setDaylight(true); m_prev = morning; @@ -543,7 +543,7 @@ void NightLightManager::updateTransitionTimings(const QDateTime &todayNow) // we are passed the evening, it's night time setDaylight(false); m_prev = evening; - m_next = getSunTimings(todayNow.addDays(1), lat, lng, true); + m_next = getSunTimings(dateTime.addDays(1), latitude, longitude, true); } } } @@ -586,34 +586,34 @@ bool NightLightManager::daylight() const return m_daylight; } -int NightLightManager::currentTargetTemp() const +int NightLightManager::currentTargetTemperature() const { if (!m_running) { return DEFAULT_DAY_TEMPERATURE; } if (m_mode == NightLightMode::Constant) { - return m_nightTargetTemp; + return m_nightTargetTemperature; } - const QDateTime todayNow = QDateTime::currentDateTime(); + const QDateTime dateTime = QDateTime::currentDateTime(); - auto f = [this, todayNow](int target1, int target2) -> int { - if (todayNow <= m_prev.first) { + auto f = [this, dateTime](int target1, int target2) -> int { + if (dateTime <= m_prev.first) { return target1; } - if (todayNow >= m_prev.second) { + if (dateTime >= m_prev.second) { return target2; } - const double progress = double(m_prev.first.msecsTo(todayNow)) / m_prev.first.msecsTo(m_prev.second); + const double progress = double(m_prev.first.msecsTo(dateTime)) / m_prev.first.msecsTo(m_prev.second); return std::lerp(target1, target2, progress); }; if (daylight()) { - return f(m_nightTargetTemp, m_dayTargetTemp); + return f(m_nightTargetTemperature, m_dayTargetTemperature); } else { - return f(m_dayTargetTemp, m_nightTargetTemp); + return f(m_dayTargetTemperature, m_nightTargetTemperature); } } @@ -636,12 +636,12 @@ void NightLightManager::autoLocationUpdate(double latitude, double longitude) } // we tolerate small deviations with minimal impact on sun timings - if (std::abs(m_latAuto - latitude) < 2 && std::abs(m_lngAuto - longitude) < 1) { + if (std::abs(m_latitudeAuto - latitude) < 2 && std::abs(m_longitudeAuto - longitude) < 1) { return; } cancelAllTimers(); - m_latAuto = latitude; - m_lngAuto = longitude; + m_latitudeAuto = latitude; + m_longitudeAuto = longitude; NightLightSettings *s = NightLightSettings::self(); s->setLatitudeAuto(latitude); @@ -672,10 +672,10 @@ void NightLightManager::setRunning(bool running) void NightLightManager::setCurrentTemperature(int temperature) { - if (m_currentTemp == temperature) { + if (m_currentTemperature == temperature) { return; } - m_currentTemp = temperature; + m_currentTemperature = temperature; Q_EMIT currentTemperatureChanged(); } diff --git a/src/plugins/nightlight/nightlightmanager.h b/src/plugins/nightlight/nightlightmanager.h index 42d33a38ab..4ac6c1e180 100644 --- a/src/plugins/nightlight/nightlightmanager.h +++ b/src/plugins/nightlight/nightlightmanager.h @@ -179,7 +179,7 @@ public: /** * Previews a given temperature for a short time (15s). */ - void preview(uint previewTemp); + void preview(uint previewTemperature); /** * Stops an ongoing preview. @@ -188,7 +188,7 @@ public: void stopPreview(); public Q_SLOTS: - void quickAdjust(int targetTemp); + void quickAdjust(int targetTemperature); Q_SIGNALS: /** @@ -239,21 +239,21 @@ Q_SIGNALS: private: void readConfig(); void hardReset(); - void slowUpdate(int targetTemp); + void slowUpdate(int targetTemperature); void resetAllTimers(); - int currentTargetTemp() const; + int currentTargetTemperature() const; void cancelAllTimers(); /** * Quick shift on manual change to current target Temperature */ - void resetQuickAdjustTimer(int targetTemp); + void resetQuickAdjustTimer(int targetTemperature); /** * Slow shift to daytime target Temperature */ void resetSlowUpdateTimers(); void updateTargetTemperature(); - void updateTransitionTimings(const QDateTime &todayNow); + void updateTransitionTimings(const QDateTime &dateTime); DateTimes getSunTimings(const QDateTime &dateTime, double latitude, double longitude, bool morning) const; void commitGammaRamps(int temperature); @@ -288,24 +288,24 @@ private: // manual times from config QTime m_morning = QTime(6, 0); QTime m_evening = QTime(18, 0); - int m_trTime = 30; // saved in minutes > 1 + int m_transitionDuration = 30; // saved in minutes > 1 // auto location provided by work space - double m_latAuto; - double m_lngAuto; + double m_latitudeAuto; + double m_longitudeAuto; // manual location from config - double m_latFixed; - double m_lngFixed; + double m_latitudeFixed; + double m_longitudeFixed; std::unique_ptr m_slowUpdateStartTimer; std::unique_ptr m_slowUpdateTimer; std::unique_ptr m_quickAdjustTimer; std::unique_ptr m_previewTimer; - int m_currentTemp = DEFAULT_DAY_TEMPERATURE; + int m_currentTemperature = DEFAULT_DAY_TEMPERATURE; int m_targetTemperature = DEFAULT_DAY_TEMPERATURE; - int m_dayTargetTemp = DEFAULT_DAY_TEMPERATURE; - int m_nightTargetTemp = DEFAULT_NIGHT_TEMPERATURE; + int m_dayTargetTemperature = DEFAULT_DAY_TEMPERATURE; + int m_nightTargetTemperature = DEFAULT_NIGHT_TEMPERATURE; int m_inhibitReferenceCount = 0; KConfigWatcher::Ptr m_configWatcher;