Differential D5928 Diff 20972 colorcorrection/nightcolor.cpp

Changeset View

Standalone View

View Options

colorcorrection/nightcolor.cpp

  • This file was added.
1​/********************************************************************
2​ KWin - the KDE window manager
3​ This file is part of the KDE project.
4​
5​Copyright 2017 Roman Gilg <subdiff@gmail.com>
6​
7​This program is free software; you can redistribute it and/or modify
8​it under the terms of the GNU General Public License as published by
9​the Free Software Foundation; either version 2 of the License, or
10​(at your option) any later version.
11​
12​This program is distributed in the hope that it will be useful,
13​but WITHOUT ANY WARRANTY; without even the implied warranty of
14​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15​GNU General Public License for more details.
16​
17​You should have received a copy of the GNU General Public License
18​along with this program. If not, see <http://www.gnu.org/licenses/>.
19​*********************************************************************/
20​#include "nightcolor.h"
21​#include "colorcorrectdbusinterface.h"
22​#include "suncalc.h"
23​#include "gammaramp.h"
24​#include "logging.h"
25​
26​#include <main.h>
27​#include <platform.h>
28​#include <screens.h>
29​#include <workspace.h>
30​#include <logind.h>
31​
32​#include <KConfigGroup>
33​
34​#include <QTimer>
35​#include <QDBusConnection>
36​#include <QSocketNotifier>
37​
38​#include <sys/timerfd.h>
39​#include <unistd.h>
40​#include <fcntl.h>
41​
42​namespace KWin {
43​namespace ColorCorrect {
44​
45​static const int QUICK_ADJUST_DURATION = 2000;
46​static const int TEMPERATURE_STEP = 50;
47​
48​static bool checkLocation(double lat, double lng)
49​{
50​ return -90 <= lat && lat <= 90 && -180 <= lng && lng <= 180;
51​}
52​
53​Manager::Manager(QObject *parent)
davidedmundsonUnsubmitted
Done

rename the class or the file

davidedmundson: rename the class or the file
romanggAuthorUnsubmitted
Done

Is there a general rule to it? Can I call the class NightColorManager instead and leave the file name untouched?

Is this about the generic class name or about the class name and the file name not being the same?

romangg: Is there a general rule to it? Can I call the class NightColorManager instead and leave the…
graesslinUnsubmitted
Done

I cannot answer for David, but I would say that class name and file name should be the same. I would have called it manager.h and manager.cpp. Though that's a little bit generic - also the class name Manager is rather generic. Granted it's in a namespace, but still.

graesslin: I cannot answer for David, but I would say that class name and file name should be the same. I…
54​ : QObject(parent)
55​{
56​ m_iface = new ColorCorrectDBusInterface(this);
57​ connect(kwinApp(), &Application::workspaceCreated, this, &Manager::init);
58​}
59​
60​void Manager::init()
61​{
62​ // we may always read in the current config
63​ readConfig();
64​
65​ if (!kwinApp()->platform()->supportsNightColor()) {
66​ // at least update the sun timings to make the values accessible via dbus
67​ updateSunTimings(true);
68​ return;
69​ }
70​
71​ connect(LogindIntegration::self(), &LogindIntegration::sessionActiveChanged, this,
72​ [this](bool active) {
73​ if (active) {
74​ hardReset();
75​ } else {
76​ cancelAllTimers();
77​ }
78​ }
79​ );
80​
81​#ifdef Q_OS_LINUX
82​ // monitor for system clock changes - from the time dataengine
davidedmundsonUnsubmitted
Done

This won't work on BSD, TimeEngine::init() has a relevant ifdef and a fallback.

davidedmundson: This won't work on BSD, TimeEngine::init() has a relevant ifdef and a fallback.
83​ auto timeChangedFd = ::timerfd_create(CLOCK_REALTIME, O_CLOEXEC | O_NONBLOCK);
84​ ::itimerspec timespec;
85​ //set all timers to 0, which creates a timer that won't do anything
86​ ::memset(&timespec, 0, sizeof(timespec));
87​
88​ // Monitor for the time changing (flags == TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET).
89​ // However these are not exposed in glibc so value is hardcoded:
90​ ::timerfd_settime(timeChangedFd, 3, &timespec, 0);
91​
92​ connect(this, &QObject::destroyed, [timeChangedFd]() {
93​ ::close(timeChangedFd);
94​ });
95​
96​ auto notifier = new QSocketNotifier(timeChangedFd, QSocketNotifier::Read, this);
97​ connect(notifier, &QSocketNotifier::activated, this, [this](int fd) {
98​ uint64_t c;
99​ ::read(fd, &c, 8);
100​
101​ // check if we're resuming from suspend - in this case do a hard reset
102​ // Note: We're using the time clock to detect a suspend phase instead of connecting to the
103​ // provided logind dbus signal, because this signal would be received way too late.
104​ QDBusMessage message = QDBusMessage::createMethodCall("org.freedesktop.login1",
105​ "/org/freedesktop/login1",
106​ "org.freedesktop.DBus.Properties",
107​ QStringLiteral("Get"));
108​ message.setArguments(QVariantList({"org.freedesktop.login1.Manager", QStringLiteral("PreparingForSleep")}));
109​ QDBusReply<QVariant> reply = QDBusConnection::systemBus().call(message);
110​ bool comingFromSuspend;
111​ if (reply.isValid()) {
112​ comingFromSuspend = reply.value().toBool();
davidedmundsonUnsubmitted
Done

I don't understand.

we're coming from suspend if PreparingForSleep is true?

davidedmundson: I don't understand. we're coming from suspend if PreparingForSleep is true?
romanggAuthorUnsubmitted
Done

Yes: https://www.freedesktop.org/wiki/Software/systemd/logind/

It's true between signal PrepareForSleep is emitted with arg true and after sleep again with false.

romangg: Yes: https://www.freedesktop.org/wiki/Software/systemd/logind/ It's true between signal…
davidedmundsonUnsubmitted
Done

How confusing. In any case we have a race condition.

We're triggering this on timeChangedFd so we have behaviour that basically changes depending on whether logind has processed resuming and sent a signal before or after kwin processes this.

Why do we have this check anyway? We need to resetAllTimers if the system time changes due to a timezone change too.

davidedmundson: How confusing. In any case we have a race condition. We're triggering this on timeChangedFd so…
romanggAuthorUnsubmitted
Done

Well, in my tests logind always changed the value of this property way later then the notifier was triggered (like 1 second), so I assumed that this is always the case. But you're right, that I don't know for sure.

Why do we have this check anyway?

It's only a small difference in look and it's working anyway, that's why I probably found the possible race condition not that important. Take a look at line 117. If it's true, we change the color temperature value without fade, otherwise we do. The else case is for example triggered on timezone change while running, so it fades nicely in. But this is a corner case, and we might just ignore it.

romangg: Well, in my tests logind always changed the value of this property way later then the notifier…
romanggAuthorUnsubmitted
Done

@davidedmundson and I talked about it and he said he is content with it.

romangg: @davidedmundson and I talked about it and he said he is content with it.
113​ } else {
114​ qCDebug(KWIN_COLORCORRECTION) << "Failed to get PreparingForSleep Property of logind session:" << reply.error().message();
115​ // Always do a hard reset in case we have no further information.
116​ comingFromSuspend = true;
117​ }
118​
119​ if (comingFromSuspend) {
120​ hardReset();
121​ } else {
122​ resetAllTimers();
123​ }
124​ });
125​#else
126​ // TODO: Alternative method for BSD.
127​#endif
128​
129​ hardReset();
130​}
131​
132​void Manager::hardReset()
133​{
134​ cancelAllTimers();
135​ updateSunTimings(true);
136​ if (kwinApp()->platform()->supportsNightColor() && m_active) {
137​ m_running = true;
138​ commitGammaRamps(currentTargetTemp());
139​ }
140​ resetAllTimers();
141​}
142​
143​void Manager::reparseConfigAndReset()
144​{
145​ cancelAllTimers();
146​ readConfig();
147​ hardReset();
148​}
149​
150​void Manager::readConfig()
151​{
152​ KConfigGroup cfgGroup(kwinApp()->config(), "NightColor");
graesslinUnsubmitted
Done

You could also consider to use a kcfgc here. See https://techbase.kde.org/Development/Tutorials/Using_KConfig_XT

We use it in e.g. all effects and it reduces quite a lot the boiler plate code. Especially for things like mapping to an enum.

graesslin: You could also consider to use a kcfgc here. See https://techbase.kde.
153​
154​ m_active = cfgGroup.readEntry("Active", false);
155​
156​ int mode = cfgGroup.readEntry("Mode", 0);
157​ if (mode == 1) {
158​ m_mode = Mode::Location;
159​ } else if (mode == 2) {
160​ m_mode = Mode::Timings;
161​ } else {
162​ m_mode = Mode::Automatic;
163​ }
164​
165​ m_nightTargetTemp = qBound(MIN_TEMPERATURE, cfgGroup.readEntry("NightTemperature", DEFAULT_NIGHT_TEMPERATURE), NEUTRAL_TEMPERATURE);
166​
167​ double lat, lng;
168​ auto correctReadin = [&lat, &lng]() {
169​ if (!checkLocation(lat, lng)) {
170​ // out of domain
171​ lat = 0;
172​ lng = 0;
173​ }
174​ };
175​ // automatic
176​ lat = cfgGroup.readEntry("LatitudeAuto", 0.);
177​ lng = cfgGroup.readEntry("LongitudeAuto", 0.);
178​ correctReadin();
179​ m_latAuto = lat;
180​ m_lngAuto = lng;
181​ // fixed location
182​ lat = cfgGroup.readEntry("LatitudeFixed", 0.);
183​ lng = cfgGroup.readEntry("LongitudeFixed", 0.);
184​ correctReadin();
185​ m_latFixed = lat;
186​ m_lngFixed = lng;
187​
188​ // fixed timings
189​ QTime mrB = QTime::fromString(cfgGroup.readEntry("MorningBeginFixed", "0600"), "hhmm");
190​ QTime evB = QTime::fromString(cfgGroup.readEntry("EveningBeginFixed", "1800"), "hhmm");
191​
192​ int diffME = mrB.msecsTo(evB);
193​ if (diffME <= 0) {
194​ // morning not strictly before evening - use defaults
195​ mrB = QTime(6,0);
196​ evB = QTime(18,0);
197​ diffME = mrB.msecsTo(evB);
198​ }
199​ int diffMin = qMin(diffME, MSC_DAY - diffME);
200​
201​ int trTime = cfgGroup.readEntry("TransitionTime", FALLBACK_SLOW_UPDATE_TIME / 1000 / 60) * 1000 * 60;
202​ if (trTime < 0 || diffMin <= trTime) {
203​ // transition time too long - use defaults
204​ mrB = QTime(6,0);
205​ evB = QTime(18,0);
206​ trTime = FALLBACK_SLOW_UPDATE_TIME;
207​ }
208​ m_morning = mrB;
209​ m_evening = evB;
210​ m_trTime = qMax(trTime / 1000 / 60, 1);
211​}
212​
213​void Manager::resetAllTimers()
214​{
215​ cancelAllTimers();
216​ if (kwinApp()->platform()->supportsNightColor()) {
217​ if (m_active) {
218​ m_running = true;
219​ }
220​ // we do this also for active being false in order to reset the temperature back to the day value
221​ resetQuickAdjustTimer();
222​ } else {
223​ m_running = false;
224​ }
225​}
226​
227​void Manager::cancelAllTimers()
228​{
229​ delete m_slowUpdateStartTimer;
230​ delete m_slowUpdateTimer;
231​ delete m_quickAdjustTimer;
232​
233​ m_slowUpdateStartTimer = nullptr;
234​ m_slowUpdateTimer = nullptr;
235​ m_quickAdjustTimer = nullptr;
236​}
237​
238​void Manager::resetQuickAdjustTimer()
239​{
240​ updateSunTimings(false);
241​
242​ int tempDiff = qAbs(currentTargetTemp() - m_currentTemp);
243​ // allow tolerance of one TEMPERATURE_STEP to compensate if a slow update is coincidental
244​ if (tempDiff > TEMPERATURE_STEP) {
245​ cancelAllTimers();
246​ m_quickAdjustTimer = new QTimer(this);
247​ m_quickAdjustTimer->setSingleShot(false);
248​ connect(m_quickAdjustTimer, &QTimer::timeout, this, &Manager::quickAdjust);
249​
250​ int interval = QUICK_ADJUST_DURATION / (tempDiff / TEMPERATURE_STEP);
251​ if (interval == 0) {
252​ interval = 1;
253​ }
254​ m_quickAdjustTimer->start(interval);
255​ } else {
256​ resetSlowUpdateStartTimer();
257​ }
258​}
259​
260​void Manager::quickAdjust()
261​{
262​ if (!m_quickAdjustTimer) {
263​ return;
264​ }
265​
266​ int nextTemp;
267​ int targetTemp = currentTargetTemp();
268​
269​ if (m_currentTemp < targetTemp) {
270​ nextTemp = qMin(m_currentTemp + TEMPERATURE_STEP, targetTemp);
271​ } else {
272​ nextTemp = qMax(m_currentTemp - TEMPERATURE_STEP, targetTemp);
273​ }
274​ commitGammaRamps(nextTemp);
275​
276​ if (nextTemp == targetTemp) {
277​ // stop timer, we reached the target temp
278​ delete m_quickAdjustTimer;
279​ m_quickAdjustTimer = nullptr;
280​ resetSlowUpdateStartTimer();
281​ }
282​}
283​
284​void Manager::resetSlowUpdateStartTimer()
285​{
286​ delete m_slowUpdateStartTimer;
287​ m_slowUpdateStartTimer = nullptr;
288​
289​ if (!m_running || m_quickAdjustTimer) {
290​ // only reenable the slow update start timer when quick adjust is not active anymore
291​ return;
292​ }
293​
294​ // set up the next slow update
295​ m_slowUpdateStartTimer = new QTimer(this);
296​ m_slowUpdateStartTimer->setSingleShot(true);
297​ connect(m_slowUpdateStartTimer, &QTimer::timeout, this, &Manager::resetSlowUpdateStartTimer);
298​
299​ updateSunTimings(false);
300​ int diff;
301​ if (m_mode == Mode::Timings) {
302​ // Timings mode is in local time
303​ diff = QDateTime::currentDateTime().msecsTo(m_next.first);
304​ } else {
305​ diff = QDateTime::currentDateTimeUtc().msecsTo(m_next.first);
306​ }
307​ if (diff <= 0) {
308​ qCCritical(KWIN_COLORCORRECTION) << "Error in time calculation. Deactivating Night Color.";
309​ return;
310​ }
311​ m_slowUpdateStartTimer->start(diff);
312​
313​ // start the current slow update
314​ resetSlowUpdateTimer();
315​}
316​
317​void Manager::resetSlowUpdateTimer()
318​{
319​ delete m_slowUpdateTimer;
320​ m_slowUpdateTimer = nullptr;
321​
322​ QDateTime now = QDateTime::currentDateTimeUtc();
323​ bool isDay = daylight();
324​ int targetTemp = isDay ? m_dayTargetTemp : m_nightTargetTemp;
325​
326​ if (m_prev.first == m_prev.second) {
327​ // transition time is zero
328​ commitGammaRamps(isDay ? m_dayTargetTemp : m_nightTargetTemp);
329​ return;
330​ }
331​
332​ if (m_prev.first <= now && now <= m_prev.second) {
333​ int availTime = now.msecsTo(m_prev.second);
334​ m_slowUpdateTimer = new QTimer(this);
335​ m_slowUpdateTimer->setSingleShot(false);
336​ if (isDay) {
337​ connect(m_slowUpdateTimer, &QTimer::timeout, this, [this]() {slowUpdate(m_dayTargetTemp);});
338​ } else {
339​ connect(m_slowUpdateTimer, &QTimer::timeout, this, [this]() {slowUpdate(m_nightTargetTemp);});
340​ }
341​
342​ // calculate interval such as temperature is changed by TEMPERATURE_STEP K per timer timeout
343​ int interval = availTime / (qAbs(targetTemp - m_currentTemp) / TEMPERATURE_STEP);
344​ if (interval == 0) {
345​ interval = 1;
346​ }
347​ m_slowUpdateTimer->start(interval);
348​ }
349​}
350​
351​void Manager::slowUpdate(int targetTemp)
352​{
353​ if (!m_slowUpdateTimer) {
354​ return;
355​ }
356​ int nextTemp;
357​ if (m_currentTemp < targetTemp) {
358​ nextTemp = qMin(m_currentTemp + TEMPERATURE_STEP, targetTemp);
359​ } else {
360​ nextTemp = qMax(m_currentTemp - TEMPERATURE_STEP, targetTemp);
361​ }
362​ commitGammaRamps(nextTemp);
363​ if (nextTemp == targetTemp) {
364​ // stop timer, we reached the target temp
365​ delete m_slowUpdateTimer;
366​ m_slowUpdateTimer = nullptr;
367​ }
368​}
369​
370​void Manager::updateSunTimings(bool force)
371​{
372​ QDateTime todayNow = QDateTime::currentDateTimeUtc();
373​
374​ if (m_mode == Mode::Timings) {
375​
376​ QDateTime todayNowLocal = QDateTime::currentDateTime();
377​
378​ QDateTime morB = QDateTime(todayNowLocal.date(), m_morning);
379​ QDateTime morE = morB.addSecs(m_trTime * 60);
380​ QDateTime eveB = QDateTime(todayNowLocal.date(), m_evening);
381​ QDateTime eveE = eveB.addSecs(m_trTime * 60);
382​
383​ if (morB <= todayNowLocal && todayNowLocal < eveB) {
384​ m_next = DATETIMES(eveB, eveE);
385​ m_prev = DATETIMES(morB, morE);
386​ } else if (todayNowLocal < morB) {
387​ m_next = DATETIMES(morB, morE);
388​ m_prev = DATETIMES(eveB.addDays(-1), eveE.addDays(-1));
389​ } else {
390​ m_next = DATETIMES(morB.addDays(1), morE.addDays(1));
391​ m_prev = DATETIMES(eveB, eveE);
392​ }
393​ return;
394​ }
395​
396​ double lat, lng;
397​ if (m_mode == Mode::Automatic) {
398​ lat = m_latAuto;
399​ lng = m_lngAuto;
400​ } else {
401​ lat = m_latFixed;
402​ lng = m_lngFixed;
403​ }
404​
405​ if (!force) {
406​ // first try by only switching the timings
407​ if (daylight()) {
408​ // next is morning
409​ m_prev = m_next;
410​ m_next = getSunTimings(todayNow.date().addDays(1), lat, lng, true);
411​ } else {
412​ // next is evening
413​ m_prev = m_next;
414​ m_next = getSunTimings(todayNow.date(), lat, lng, false);
415​ }
416​ }
417​
418​ if (force || !checkAutomaticSunTimings()) {
419​ // in case this fails, reset them
420​ DATETIMES morning = getSunTimings(todayNow.date(), lat, lng, true);
421​ if (todayNow < morning.first) {
422​ m_prev = getSunTimings(todayNow.date().addDays(-1), lat, lng, false);
423​ m_next = morning;
424​ } else {
425​ DATETIMES evening = getSunTimings(todayNow.date(), lat, lng, false);
426​ if (todayNow < evening.first) {
427​ m_prev = morning;
428​ m_next = evening;
429​ } else {
430​ m_prev = evening;
431​ m_next = getSunTimings(todayNow.date().addDays(1), lat, lng, true);
432​ }
433​ }
434​ }
435​}
436​
437​DATETIMES Manager::getSunTimings(QDate date, double latitude, double longitude, bool morning) const
438​{
439​ TIMES times = calculateSunTimings(date, latitude, longitude, morning);
440​ // At locations near the poles it is possible, that we can't
441​ // calculate some or all sun timings (midnight sun).
442​ // In this case try to fallback to sensible default values.
443​ bool beginDefined = !times.first.isNull();
444​ bool endDefined = !times.second.isNull();
445​ if (!beginDefined || !endDefined) {
446​ if (beginDefined) {
447​ times.second = times.first.addMSecs( FALLBACK_SLOW_UPDATE_TIME );
448​ } else if (endDefined) {
449​ times.first = times.second.addMSecs( - FALLBACK_SLOW_UPDATE_TIME);
450​ } else {
451​ // Just use default values for morning and evening, but the user
452​ // will probably deactivate Night Color anyway if he is living
453​ // in a region without clear sun rise and set.
454​ times.first = morning ? QTime(6,0,0) : QTime(18,0,0);
455​ times.second = times.first.addMSecs( FALLBACK_SLOW_UPDATE_TIME );
456​ }
457​ }
458​ return DATETIMES(QDateTime(date, times.first, Qt::UTC), QDateTime(date, times.second, Qt::UTC));
459​}
460​
461​bool Manager::checkAutomaticSunTimings() const
462​{
463​ if (m_prev.first.isValid() && m_prev.second.isValid() &&
464​ m_next.first.isValid() && m_next.second.isValid()) {
465​ QDateTime todayNow = QDateTime::currentDateTimeUtc();
466​ return m_prev.first <= todayNow && todayNow < m_next.first &&
467​ m_prev.first.msecsTo(m_next.first) < MSC_DAY * 23./24;
468​ }
469​ return false;
470​}
471​
472​bool Manager::daylight() const
473​{
474​ return m_prev.first.date() == m_next.first.date();
475​}
476​
477​int Manager::currentTargetTemp() const
478​{
479​ if (!m_active) {
480​ return NEUTRAL_TEMPERATURE;
481​ }
482​
483​ QDateTime todayNow = QDateTime::currentDateTimeUtc();
484​
485​ auto f = [this, todayNow](int target1, int target2) {
486​ if (todayNow <= m_prev.second) {
487​ double residueQuota = todayNow.msecsTo(m_prev.second) / (double)m_prev.first.msecsTo(m_prev.second);
488​
489​ double ret = (int)((1. - residueQuota) * (double)target2 + residueQuota * (double)target1);
490​ // remove single digits
491​ ret = ((int)(0.1 * ret)) * 10;
492​ return (int)ret;
493​ } else {
494​ return target2;
495​ }
496​ };
497​
498​ if (daylight()) {
499​ return f(m_nightTargetTemp, m_dayTargetTemp);
500​ } else {
501​ return f(m_dayTargetTemp, m_nightTargetTemp);
502​ }
503​}
504​
505​void Manager::commitGammaRamps(int temperature)
506​{
507​ int nscreens = Screens::self()->count();
508​
509​ for (int screen = 0; screen < nscreens; screen++) {
510​ int rampsize = kwinApp()->platform()->gammaRampSize(screen);
511​ GammaRamp ramp(rampsize);
512​
513​ /*
514​ * The gamma calculation below is based on the Redshift app:
515​ * https://github.com/jonls/redshift
516​ */
517​
518​ // linear default state
519​ for (int i = 0; i < rampsize; i++) {
520​ uint16_t value = (double)i / rampsize * (UINT16_MAX + 1);
521​ ramp.red[i] = value;
522​ ramp.green[i] = value;
523​ ramp.blue[i] = value;
524​ }
525​
526​ // approximate white point
527​ float whitePoint[3];
528​ float alpha = (temperature % 100) / 100.;
529​ int bbCIndex = ((temperature - 1000) / 100) * 3;
530​ whitePoint[0] = (1. - alpha) * blackbodyColor[bbCIndex] + alpha * blackbodyColor[bbCIndex + 3];
531​ whitePoint[1] = (1. - alpha) * blackbodyColor[bbCIndex + 1] + alpha * blackbodyColor[bbCIndex + 4];
532​ whitePoint[2] = (1. - alpha) * blackbodyColor[bbCIndex + 2] + alpha * blackbodyColor[bbCIndex + 5];
533​
534​ for (int i = 0; i < rampsize; i++) {
535​ ramp.red[i] = (double)ramp.red[i] / (UINT16_MAX+1) * whitePoint[0] * (UINT16_MAX+1);
536​ ramp.green[i] = (double)ramp.green[i] / (UINT16_MAX+1) * whitePoint[1] * (UINT16_MAX+1);
537​ ramp.blue[i] = (double)ramp.blue[i] / (UINT16_MAX+1) * whitePoint[2] * (UINT16_MAX+1);
538​ }
539​
540​ if (kwinApp()->platform()->setGammaRamp(screen, ramp)) {
541​ m_currentTemp = temperature;
542​ m_failedCommitAttempts = 0;
543​ } else {
544​ m_failedCommitAttempts++;
545​ if (m_failedCommitAttempts < 10) {
546​ qCWarning(KWIN_COLORCORRECTION).nospace() << "Committing Gamma Ramp failed for screen " << screen <<
547​ ". Trying " << (10 - m_failedCommitAttempts) << " times more.";
548​ } else {
549​ // TODO: On multi monitor setups we could try to rollback earlier changes for already commited outputs
550​ qCWarning(KWIN_COLORCORRECTION) << "Gamma Ramp commit failed too often. Deactivating color correction for now.";
551​ m_failedCommitAttempts = 0; // reset so we can try again later (i.e. after suspend phase or config change)
552​ m_running = false;
553​ cancelAllTimers();
554​ }
555​ }
556​ }
557​}
558​
559​QHash<QString, QVariant> Manager::info() const
560​{
561​ QHash<QString, QVariant> ret;
562​ ret["Available"] = kwinApp()->platform()->supportsNightColor();
563​
564​ ret["ActiveEnabled"] = true;
565​ ret["Active"] = m_active;
566​
567​ ret["ModeEnabled"] = true;
568​ ret["Mode"] = (int)m_mode;
569​
570​ ret["NightTemperatureEnabled"] = true;
571​ ret["NightTemperature"] = m_nightTargetTemp;
572​
573​ ret["Running"] = m_running;
574​ ret["CurrentColorTemperature"] = m_currentTemp;
575​
576​ ret["LatitudeAuto"] = m_latAuto;
577​ ret["LongitudeAuto"] = m_lngAuto;
578​
579​ ret["LocationEnabled"] = true;
580​ ret["LatitudeFixed"] = m_latFixed;
581​ ret["LongitudeFixed"] = m_lngFixed;
582​
583​ ret["TimingsEnabled"] = true;
584​ ret["MorningBeginFixed"] = m_morning.toString(Qt::ISODate);
585​ ret["EveningBeginFixed"] = m_evening.toString(Qt::ISODate);
586​ ret["TransitionTime"] = m_trTime;
587​
588​ return ret;
graesslinUnsubmitted
Done

Please use initializer list:

return QHash<QString, QVariant>{
    { QStringLiteral{"Avaliable"}, kwinApp()->platform()->supportsNightColor()},
    {QStringLiterall{"ActiveEnabled"}, true},
   /* and so on */
};
graesslin: Please use initializer list: ``` return QHash<QString, QVariant>{ {…
589​}
590​
591​bool Manager::changeConfiguration(QHash<QString, QVariant> data)
592​{
593​ bool activeUpdate, modeUpdate, tempUpdate, locUpdate, timeUpdate;
594​ activeUpdate = modeUpdate = tempUpdate = locUpdate = timeUpdate = false;
595​
596​ bool active = m_active;
597​ Mode mode = m_mode;
598​ int nightT = m_nightTargetTemp;
599​
600​ double lat = m_latFixed;
601​ double lng = m_lngFixed;
602​
603​ QTime mor = m_morning;
604​ QTime eve = m_evening;
605​ int trT = m_trTime;
606​
607​ QHash<QString, QVariant>::const_iterator iter1, iter2, iter3;
608​
609​ iter1 = data.constFind("Active");
610​ if (iter1 != data.constEnd()) {
611​ if (!iter1.value().canConvert<bool>()) {
612​ return false;
613​ }
614​ bool act = iter1.value().toBool();
615​ activeUpdate = m_active != act;
616​ active = act;
617​ }
618​
619​ iter1 = data.constFind("Mode");
620​ if (iter1 != data.constEnd()) {
621​ if (!iter1.value().canConvert<int>()) {
622​ return false;
623​ }
624​ int mo = iter1.value().toInt();
625​ if (mo < 0 || 2 < mo) {
626​ return false;
627​ }
628​ Mode moM;
629​ switch (mo) {
630​ case 0:
631​ moM = Mode::Automatic;
632​ break;
633​ case 1:
634​ moM = Mode::Location;
635​ break;
636​ case 2:
637​ moM = Mode::Timings;
638​ }
639​ modeUpdate = m_mode != moM;
640​ mode = moM;
641​ }
642​
643​ iter1 = data.constFind("NightTemperature");
644​ if (iter1 != data.constEnd()) {
645​ if (!iter1.value().canConvert<int>()) {
646​ return false;
647​ }
648​ int nT = iter1.value().toInt();
649​ if (nT < MIN_TEMPERATURE || NEUTRAL_TEMPERATURE < nT) {
650​ return false;
651​ }
652​ tempUpdate = m_nightTargetTemp != nT;
653​ nightT = nT;
654​ }
655​
656​ iter1 = data.constFind("LatitudeFixed");
657​ iter2 = data.constFind("LongitudeFixed");
658​ if (iter1 != data.constEnd() && iter2 != data.constEnd()) {
659​ if (!iter1.value().canConvert<double>() || !iter2.value().canConvert<double>()) {
660​ return false;
661​ }
662​ double la = iter1.value().toDouble();
663​ double ln = iter2.value().toDouble();
664​ if (!checkLocation(la, ln)) {
665​ return false;
666​ }
667​ locUpdate = m_latFixed != la || m_lngFixed != ln;
668​ lat = la;
669​ lng = ln;
670​ }
671​
672​ iter1 = data.constFind("MorningBeginFixed");
673​ iter2 = data.constFind("EveningBeginFixed");
674​ iter3 = data.constFind("TransitionTime");
675​ if (iter1 != data.constEnd() && iter2 != data.constEnd() && iter3 != data.constEnd()) {
676​ if (!iter1.value().canConvert<QString>() || !iter2.value().canConvert<QString>() || !iter3.value().canConvert<int>()) {
677​ return false;
678​ }
679​ QTime mo = QTime::fromString(iter1.value().toString(), Qt::ISODate);
680​ QTime ev = QTime::fromString(iter2.value().toString(), Qt::ISODate);
681​ if (!mo.isValid() || !ev.isValid()) {
682​ return false;
683​ }
684​ int tT = iter3.value().toInt();
685​
686​ int diffME = mo.msecsTo(ev);
687​ if (diffME <= 0 || qMin(diffME, MSC_DAY - diffME) <= tT * 60 * 1000 || tT < 1) {
688​ // morning not strictly before evening, transition time too long or transition time out of bounds
689​ return false;
690​ }
691​
692​ timeUpdate = m_morning != mo || m_evening != ev || m_trTime != tT;
693​ mor = mo;
694​ eve = ev;
695​ trT = tT;
696​ }
697​
698​ if (!(activeUpdate || modeUpdate || tempUpdate || locUpdate || timeUpdate)) {
699​ return true;
700​ }
701​
702​ bool resetNeeded = activeUpdate || modeUpdate || tempUpdate ||
703​ (locUpdate && mode == Mode::Location) ||
704​ (timeUpdate && mode == Mode::Timings);
705​
706​ if (resetNeeded) {
707​ cancelAllTimers();
708​ }
709​
710​ KConfigGroup cfgGroup(kwinApp()->config(), "NightColor");
711​ if (activeUpdate) {
712​ m_active = active;
713​ cfgGroup.writeEntry("Active", active);
714​ }
715​
716​ if (modeUpdate) {
717​ m_mode = mode;
718​ cfgGroup.writeEntry("Mode", (int)mode);
719​ }
720​
721​ if (tempUpdate) {
722​ m_nightTargetTemp = nightT;
723​ cfgGroup.writeEntry("NightTemperature", nightT);
724​ }
725​
726​ if (locUpdate) {
727​ m_latFixed = lat;
728​ m_lngFixed = lng;
729​ cfgGroup.writeEntry("LatitudeFixed", lat);
730​ cfgGroup.writeEntry("LongitudeFixed", lng);
731​ }
732​
733​ if (timeUpdate) {
734​ m_morning = mor;
735​ m_evening = eve;
736​ m_trTime = trT;
737​ cfgGroup.writeEntry("MorningBeginFixed", mor.toString("hhmm"));
738​ cfgGroup.writeEntry("EveningBeginFixed", eve.toString("hhmm"));
739​ cfgGroup.writeEntry("TransitionTime", trT);
740​ }
741​ cfgGroup.sync();
742​
743​ if (resetNeeded) {
744​ resetAllTimers();
745​ }
746​ emit configChange(info());
747​ return true;
748​}
749​
750​void Manager::autoLocationUpdate(double latitude, double longitude)
751​{
752​ if (!checkLocation(latitude, longitude)) {
753​ return;
754​ }
755​
756​ // we tolerate small deviations with minimal impact on sun timings
757​ if (qAbs(m_latAuto - latitude) < 2 && qAbs(m_lngAuto - longitude) < 1) {
758​ return;
759​ }
760​ cancelAllTimers();
761​ m_latAuto = latitude;
762​ m_lngAuto = longitude;
763​
764​ KConfigGroup cfgGroup(kwinApp()->config(), "NightColor");
765​ cfgGroup.writeEntry("LatitudeAuto", latitude);
766​ cfgGroup.writeEntry("LongitudeAuto", longitude);
767​ cfgGroup.sync();
768​
769​ resetAllTimers();
770​ emit configChange(info());
771​}
772​
773​}
774​}