yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

plugins/nightlight: Rename variables and functions to adhere to the KDE coding conventions

Browse source 
The variables and functions should be fully spelled out, with temporary
variables being an exception.
This commit is contained in:
Vlad Zahorodnii 2024-06-14 17:53:37 +03:00
parent 786b3ffbae
commit e5528e9317
2 changed files with 118 additions and 118 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

208
src/plugins/nightlight/nightlightmanager.cpp
View file

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

28
src/plugins/nightlight/nightlightmanager.h
View file

@ -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<QTimer> m_slowUpdateStartTimer;
std::unique_ptr<QTimer> m_slowUpdateTimer;
std::unique_ptr<QTimer> m_quickAdjustTimer;
std::unique_ptr<QTimer> 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;