[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
/********************************************************************
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
|
|
|
|
|
|
|
Copyright 2017 Roman Gilg <subdiff@gmail.com>
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*********************************************************************/
|
|
|
|
#include "manager.h"
|
2020-01-07 18:12:11 +03:00
|
|
|
#include "clockskewnotifier.h"
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
#include "colorcorrectdbusinterface.h"
|
|
|
|
#include "suncalc.h"
|
|
|
|
#include <colorcorrect_logging.h>
|
|
|
|
|
|
|
|
#include <main.h>
|
|
|
|
#include <platform.h>
|
2018-03-30 16:03:37 +03:00
|
|
|
#include <abstract_output.h>
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
#include <screens.h>
|
|
|
|
#include <workspace.h>
|
|
|
|
#include <logind.h>
|
|
|
|
|
|
|
|
#include <colorcorrect_settings.h>
|
|
|
|
|
2019-07-09 16:52:16 +03:00
|
|
|
#include <KGlobalAccel>
|
|
|
|
#include <KLocalizedString>
|
|
|
|
|
|
|
|
#include <QAction>
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
#include <QDBusConnection>
|
2019-07-09 16:52:16 +03:00
|
|
|
#include <QTimer>
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
|
|
|
|
namespace KWin {
|
|
|
|
namespace ColorCorrect {
|
|
|
|
|
|
|
|
static const int QUICK_ADJUST_DURATION = 2000;
|
|
|
|
static const int TEMPERATURE_STEP = 50;
|
|
|
|
|
|
|
|
static bool checkLocation(double lat, double lng)
|
|
|
|
{
|
|
|
|
return -90 <= lat && lat <= 90 && -180 <= lng && lng <= 180;
|
|
|
|
}
|
|
|
|
|
|
|
|
Manager::Manager(QObject *parent)
|
|
|
|
: QObject(parent)
|
|
|
|
{
|
|
|
|
m_iface = new ColorCorrectDBusInterface(this);
|
2020-01-07 18:12:11 +03:00
|
|
|
m_skewNotifier = new ClockSkewNotifier(this);
|
|
|
|
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
connect(kwinApp(), &Application::workspaceCreated, this, &Manager::init);
|
2020-01-07 18:09:55 +03:00
|
|
|
|
|
|
|
// Display a message when Night Color is (un)inhibited.
|
|
|
|
connect(this, &Manager::inhibitedChanged, this, [this] {
|
|
|
|
// TODO: Maybe use different icons?
|
|
|
|
const QString iconName = isInhibited()
|
|
|
|
? QStringLiteral("preferences-desktop-display-nightcolor-off")
|
|
|
|
: QStringLiteral("preferences-desktop-display-nightcolor-on");
|
|
|
|
|
|
|
|
const QString text = isInhibited()
|
|
|
|
? i18nc("Night Color was disabled", "Night Color Off")
|
|
|
|
: i18nc("Night Color was enabled", "Night Color On");
|
|
|
|
|
|
|
|
QDBusMessage message = QDBusMessage::createMethodCall(
|
|
|
|
QStringLiteral("org.kde.plasmashell"),
|
|
|
|
QStringLiteral("/org/kde/osdService"),
|
|
|
|
QStringLiteral("org.kde.osdService"),
|
|
|
|
QStringLiteral("showText"));
|
|
|
|
message.setArguments({ iconName, text });
|
|
|
|
|
|
|
|
QDBusConnection::sessionBus().asyncCall(message);
|
|
|
|
});
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::init()
|
|
|
|
{
|
|
|
|
Settings::instance(kwinApp()->config());
|
|
|
|
// we may always read in the current config
|
|
|
|
readConfig();
|
|
|
|
|
2020-01-07 18:11:56 +03:00
|
|
|
if (!isAvailable()) {
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-03-26 13:53:47 +03:00
|
|
|
connect(Screens::self(), &Screens::countChanged, this, &Manager::hardReset);
|
|
|
|
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
connect(LogindIntegration::self(), &LogindIntegration::sessionActiveChanged, this,
|
|
|
|
[this](bool active) {
|
|
|
|
if (active) {
|
|
|
|
hardReset();
|
|
|
|
} else {
|
|
|
|
cancelAllTimers();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2020-01-07 18:12:11 +03:00
|
|
|
connect(m_skewNotifier, &ClockSkewNotifier::clockSkewed, this, [this]() {
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
// check if we're resuming from suspend - in this case do a hard reset
|
|
|
|
// Note: We're using the time clock to detect a suspend phase instead of connecting to the
|
|
|
|
// provided logind dbus signal, because this signal would be received way too late.
|
|
|
|
QDBusMessage message = QDBusMessage::createMethodCall("org.freedesktop.login1",
|
|
|
|
"/org/freedesktop/login1",
|
|
|
|
"org.freedesktop.DBus.Properties",
|
|
|
|
QStringLiteral("Get"));
|
|
|
|
message.setArguments(QVariantList({"org.freedesktop.login1.Manager", QStringLiteral("PreparingForSleep")}));
|
|
|
|
QDBusReply<QVariant> reply = QDBusConnection::systemBus().call(message);
|
|
|
|
bool comingFromSuspend;
|
|
|
|
if (reply.isValid()) {
|
|
|
|
comingFromSuspend = reply.value().toBool();
|
|
|
|
} else {
|
|
|
|
qCDebug(KWIN_COLORCORRECTION) << "Failed to get PreparingForSleep Property of logind session:" << reply.error().message();
|
|
|
|
// Always do a hard reset in case we have no further information.
|
|
|
|
comingFromSuspend = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (comingFromSuspend) {
|
|
|
|
hardReset();
|
|
|
|
} else {
|
|
|
|
resetAllTimers();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
hardReset();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::hardReset()
|
|
|
|
{
|
|
|
|
cancelAllTimers();
|
[colorcorrection] Add "Constant" mode
Summary:
Currently, the Night Color manager supports three operation modes:
* Automatic: in this mode, screen color temperature is computed based on
the current position of the Sun. In order to calculate sunrise & sunset
times, the manager needs coordinates of the user, which are provided by
Plasma;
* Location: this mode is very similar to the Automatic, except one minor
detail: user needs to provide his/her/their location. This mode can be
very useful if coordinates provided by Plasma are incorrect;
* Timings: unfortunately we can't compute timings of the Sun for people
living near Earth poles. This mode allows the user to specify timings of
sunrise and sunset as well the transition time.
This change introduces another mode, called Constant. With this mode the
screen color temperature is constant throughout the day. The new mode
can be useful for people wishing constant screen color temperature or
just for people living near Earth's North or South poles.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: ngraham, davidedmundson, romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21948
2019-07-22 00:30:38 +03:00
|
|
|
|
2020-01-13 23:41:36 +03:00
|
|
|
updateTransitionTimings(true);
|
2020-01-07 18:11:56 +03:00
|
|
|
updateTargetTemperature();
|
[colorcorrection] Add "Constant" mode
Summary:
Currently, the Night Color manager supports three operation modes:
* Automatic: in this mode, screen color temperature is computed based on
the current position of the Sun. In order to calculate sunrise & sunset
times, the manager needs coordinates of the user, which are provided by
Plasma;
* Location: this mode is very similar to the Automatic, except one minor
detail: user needs to provide his/her/their location. This mode can be
very useful if coordinates provided by Plasma are incorrect;
* Timings: unfortunately we can't compute timings of the Sun for people
living near Earth poles. This mode allows the user to specify timings of
sunrise and sunset as well the transition time.
This change introduces another mode, called Constant. With this mode the
screen color temperature is constant throughout the day. The new mode
can be useful for people wishing constant screen color temperature or
just for people living near Earth's North or South poles.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: ngraham, davidedmundson, romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21948
2019-07-22 00:30:38 +03:00
|
|
|
|
2020-01-07 18:11:56 +03:00
|
|
|
if (isAvailable() && isEnabled() && !isInhibited()) {
|
|
|
|
setRunning(true);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
commitGammaRamps(currentTargetTemp());
|
|
|
|
}
|
|
|
|
resetAllTimers();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::reparseConfigAndReset()
|
|
|
|
{
|
|
|
|
cancelAllTimers();
|
|
|
|
readConfig();
|
|
|
|
hardReset();
|
|
|
|
}
|
|
|
|
|
2020-01-07 18:09:55 +03:00
|
|
|
void Manager::toggle()
|
2019-07-09 16:52:16 +03:00
|
|
|
{
|
2020-01-07 18:09:55 +03:00
|
|
|
m_isGloballyInhibited = !m_isGloballyInhibited;
|
|
|
|
m_isGloballyInhibited ? inhibit() : uninhibit();
|
2019-07-09 16:52:16 +03:00
|
|
|
}
|
|
|
|
|
2020-01-07 18:09:55 +03:00
|
|
|
bool Manager::isInhibited() const
|
2019-07-09 16:52:16 +03:00
|
|
|
{
|
2020-01-07 18:09:55 +03:00
|
|
|
return m_inhibitReferenceCount;
|
|
|
|
}
|
2019-07-09 16:52:16 +03:00
|
|
|
|
2020-01-07 18:09:55 +03:00
|
|
|
void Manager::inhibit()
|
|
|
|
{
|
|
|
|
m_inhibitReferenceCount++;
|
2019-07-09 16:52:16 +03:00
|
|
|
|
2020-01-07 18:09:55 +03:00
|
|
|
if (m_inhibitReferenceCount == 1) {
|
|
|
|
resetAllTimers();
|
|
|
|
emit inhibitedChanged();
|
|
|
|
}
|
|
|
|
}
|
2019-07-09 16:52:16 +03:00
|
|
|
|
2020-01-07 18:09:55 +03:00
|
|
|
void Manager::uninhibit()
|
|
|
|
{
|
|
|
|
m_inhibitReferenceCount--;
|
|
|
|
|
|
|
|
if (!m_inhibitReferenceCount) {
|
|
|
|
resetAllTimers();
|
|
|
|
emit inhibitedChanged();
|
|
|
|
}
|
2019-07-09 16:52:16 +03:00
|
|
|
}
|
|
|
|
|
2020-01-07 18:11:56 +03:00
|
|
|
bool Manager::isEnabled() const
|
|
|
|
{
|
|
|
|
return m_active;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Manager::isRunning() const
|
|
|
|
{
|
|
|
|
return m_running;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Manager::isAvailable() const
|
|
|
|
{
|
|
|
|
return kwinApp()->platform()->supportsGammaControl();
|
|
|
|
}
|
|
|
|
|
|
|
|
int Manager::currentTemperature() const
|
|
|
|
{
|
|
|
|
return m_currentTemp;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Manager::targetTemperature() const
|
|
|
|
{
|
|
|
|
return m_targetTemperature;
|
|
|
|
}
|
|
|
|
|
|
|
|
NightColorMode Manager::mode() const
|
|
|
|
{
|
|
|
|
return m_mode;
|
|
|
|
}
|
|
|
|
|
2020-01-13 23:41:36 +03:00
|
|
|
QDateTime Manager::previousTransitionDateTime() const
|
|
|
|
{
|
|
|
|
return m_prev.first;
|
|
|
|
}
|
|
|
|
|
|
|
|
qint64 Manager::previousTransitionDuration() const
|
|
|
|
{
|
|
|
|
return m_prev.first.msecsTo(m_prev.second);
|
|
|
|
}
|
|
|
|
|
|
|
|
QDateTime Manager::scheduledTransitionDateTime() const
|
|
|
|
{
|
|
|
|
return m_next.first;
|
|
|
|
}
|
|
|
|
|
|
|
|
qint64 Manager::scheduledTransitionDuration() const
|
|
|
|
{
|
|
|
|
return m_next.first.msecsTo(m_next.second);
|
|
|
|
}
|
|
|
|
|
2019-07-09 16:52:16 +03:00
|
|
|
void Manager::initShortcuts()
|
|
|
|
{
|
|
|
|
QAction *toggleAction = new QAction(this);
|
|
|
|
toggleAction->setProperty("componentName", QStringLiteral(KWIN_NAME));
|
|
|
|
toggleAction->setObjectName(i18n("Toggle Night Color"));
|
|
|
|
toggleAction->setText(i18n("Toggle Night Color"));
|
|
|
|
KGlobalAccel::setGlobalShortcut(toggleAction, QList<QKeySequence>());
|
|
|
|
input()->registerShortcut(QKeySequence(), toggleAction, this, &Manager::toggle);
|
|
|
|
}
|
|
|
|
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
void Manager::readConfig()
|
|
|
|
{
|
|
|
|
Settings *s = Settings::self();
|
|
|
|
s->load();
|
|
|
|
|
2020-01-07 18:11:56 +03:00
|
|
|
setEnabled(s->active());
|
2017-12-15 02:50:34 +03:00
|
|
|
|
2019-09-26 11:41:05 +03:00
|
|
|
const NightColorMode mode = s->mode();
|
[colorcorrection] Add "Constant" mode
Summary:
Currently, the Night Color manager supports three operation modes:
* Automatic: in this mode, screen color temperature is computed based on
the current position of the Sun. In order to calculate sunrise & sunset
times, the manager needs coordinates of the user, which are provided by
Plasma;
* Location: this mode is very similar to the Automatic, except one minor
detail: user needs to provide his/her/their location. This mode can be
very useful if coordinates provided by Plasma are incorrect;
* Timings: unfortunately we can't compute timings of the Sun for people
living near Earth poles. This mode allows the user to specify timings of
sunrise and sunset as well the transition time.
This change introduces another mode, called Constant. With this mode the
screen color temperature is constant throughout the day. The new mode
can be useful for people wishing constant screen color temperature or
just for people living near Earth's North or South poles.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: ngraham, davidedmundson, romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21948
2019-07-22 00:30:38 +03:00
|
|
|
switch (s->mode()) {
|
|
|
|
case NightColorMode::Automatic:
|
|
|
|
case NightColorMode::Location:
|
|
|
|
case NightColorMode::Timings:
|
|
|
|
case NightColorMode::Constant:
|
2020-01-07 18:11:56 +03:00
|
|
|
setMode(mode);
|
[colorcorrection] Add "Constant" mode
Summary:
Currently, the Night Color manager supports three operation modes:
* Automatic: in this mode, screen color temperature is computed based on
the current position of the Sun. In order to calculate sunrise & sunset
times, the manager needs coordinates of the user, which are provided by
Plasma;
* Location: this mode is very similar to the Automatic, except one minor
detail: user needs to provide his/her/their location. This mode can be
very useful if coordinates provided by Plasma are incorrect;
* Timings: unfortunately we can't compute timings of the Sun for people
living near Earth poles. This mode allows the user to specify timings of
sunrise and sunset as well the transition time.
This change introduces another mode, called Constant. With this mode the
screen color temperature is constant throughout the day. The new mode
can be useful for people wishing constant screen color temperature or
just for people living near Earth's North or South poles.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: ngraham, davidedmundson, romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21948
2019-07-22 00:30:38 +03:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// Fallback for invalid setting values.
|
2020-01-07 18:11:56 +03:00
|
|
|
setMode(NightColorMode::Automatic);
|
[colorcorrection] Add "Constant" mode
Summary:
Currently, the Night Color manager supports three operation modes:
* Automatic: in this mode, screen color temperature is computed based on
the current position of the Sun. In order to calculate sunrise & sunset
times, the manager needs coordinates of the user, which are provided by
Plasma;
* Location: this mode is very similar to the Automatic, except one minor
detail: user needs to provide his/her/their location. This mode can be
very useful if coordinates provided by Plasma are incorrect;
* Timings: unfortunately we can't compute timings of the Sun for people
living near Earth poles. This mode allows the user to specify timings of
sunrise and sunset as well the transition time.
This change introduces another mode, called Constant. With this mode the
screen color temperature is constant throughout the day. The new mode
can be useful for people wishing constant screen color temperature or
just for people living near Earth's North or South poles.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: ngraham, davidedmundson, romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21948
2019-07-22 00:30:38 +03:00
|
|
|
break;
|
2017-12-15 02:50:34 +03:00
|
|
|
}
|
|
|
|
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
m_nightTargetTemp = qBound(MIN_TEMPERATURE, s->nightTemperature(), NEUTRAL_TEMPERATURE);
|
|
|
|
|
|
|
|
double lat, lng;
|
|
|
|
auto correctReadin = [&lat, &lng]() {
|
|
|
|
if (!checkLocation(lat, lng)) {
|
|
|
|
// out of domain
|
|
|
|
lat = 0;
|
|
|
|
lng = 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
// automatic
|
|
|
|
lat = s->latitudeAuto();
|
|
|
|
lng = s->longitudeAuto();
|
|
|
|
correctReadin();
|
|
|
|
m_latAuto = lat;
|
|
|
|
m_lngAuto = lng;
|
|
|
|
// fixed location
|
|
|
|
lat = s->latitudeFixed();
|
|
|
|
lng = s->longitudeFixed();
|
|
|
|
correctReadin();
|
|
|
|
m_latFixed = lat;
|
|
|
|
m_lngFixed = lng;
|
|
|
|
|
|
|
|
// fixed timings
|
|
|
|
QTime mrB = QTime::fromString(s->morningBeginFixed(), "hhmm");
|
|
|
|
QTime evB = QTime::fromString(s->eveningBeginFixed(), "hhmm");
|
|
|
|
|
|
|
|
int diffME = mrB.msecsTo(evB);
|
|
|
|
if (diffME <= 0) {
|
|
|
|
// morning not strictly before evening - use defaults
|
|
|
|
mrB = QTime(6,0);
|
|
|
|
evB = QTime(18,0);
|
|
|
|
diffME = mrB.msecsTo(evB);
|
|
|
|
}
|
|
|
|
int diffMin = qMin(diffME, MSC_DAY - diffME);
|
|
|
|
|
|
|
|
int trTime = s->transitionTime() * 1000 * 60;
|
|
|
|
if (trTime < 0 || diffMin <= trTime) {
|
|
|
|
// transition time too long - use defaults
|
|
|
|
mrB = QTime(6,0);
|
|
|
|
evB = QTime(18,0);
|
|
|
|
trTime = FALLBACK_SLOW_UPDATE_TIME;
|
|
|
|
}
|
|
|
|
m_morning = mrB;
|
|
|
|
m_evening = evB;
|
|
|
|
m_trTime = qMax(trTime / 1000 / 60, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::resetAllTimers()
|
|
|
|
{
|
|
|
|
cancelAllTimers();
|
2020-01-07 18:11:56 +03:00
|
|
|
if (isAvailable()) {
|
|
|
|
setRunning(isEnabled() && !isInhibited());
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
// we do this also for active being false in order to reset the temperature back to the day value
|
|
|
|
resetQuickAdjustTimer();
|
|
|
|
} else {
|
2020-01-07 18:11:56 +03:00
|
|
|
setRunning(false);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::cancelAllTimers()
|
|
|
|
{
|
|
|
|
delete m_slowUpdateStartTimer;
|
|
|
|
delete m_slowUpdateTimer;
|
|
|
|
delete m_quickAdjustTimer;
|
|
|
|
|
|
|
|
m_slowUpdateStartTimer = nullptr;
|
|
|
|
m_slowUpdateTimer = nullptr;
|
|
|
|
m_quickAdjustTimer = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::resetQuickAdjustTimer()
|
|
|
|
{
|
2020-01-13 23:41:36 +03:00
|
|
|
updateTransitionTimings(false);
|
2020-01-07 18:11:56 +03:00
|
|
|
updateTargetTemperature();
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
|
|
|
|
int tempDiff = qAbs(currentTargetTemp() - m_currentTemp);
|
|
|
|
// allow tolerance of one TEMPERATURE_STEP to compensate if a slow update is coincidental
|
|
|
|
if (tempDiff > TEMPERATURE_STEP) {
|
|
|
|
cancelAllTimers();
|
|
|
|
m_quickAdjustTimer = new QTimer(this);
|
|
|
|
m_quickAdjustTimer->setSingleShot(false);
|
|
|
|
connect(m_quickAdjustTimer, &QTimer::timeout, this, &Manager::quickAdjust);
|
|
|
|
|
|
|
|
int interval = QUICK_ADJUST_DURATION / (tempDiff / TEMPERATURE_STEP);
|
|
|
|
if (interval == 0) {
|
|
|
|
interval = 1;
|
|
|
|
}
|
|
|
|
m_quickAdjustTimer->start(interval);
|
|
|
|
} else {
|
|
|
|
resetSlowUpdateStartTimer();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::quickAdjust()
|
|
|
|
{
|
|
|
|
if (!m_quickAdjustTimer) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int nextTemp;
|
2019-09-26 11:41:05 +03:00
|
|
|
const int targetTemp = currentTargetTemp();
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
|
|
|
|
if (m_currentTemp < targetTemp) {
|
|
|
|
nextTemp = qMin(m_currentTemp + TEMPERATURE_STEP, targetTemp);
|
|
|
|
} else {
|
|
|
|
nextTemp = qMax(m_currentTemp - TEMPERATURE_STEP, targetTemp);
|
|
|
|
}
|
|
|
|
commitGammaRamps(nextTemp);
|
|
|
|
|
|
|
|
if (nextTemp == targetTemp) {
|
|
|
|
// stop timer, we reached the target temp
|
|
|
|
delete m_quickAdjustTimer;
|
|
|
|
m_quickAdjustTimer = nullptr;
|
|
|
|
resetSlowUpdateStartTimer();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::resetSlowUpdateStartTimer()
|
|
|
|
{
|
|
|
|
delete m_slowUpdateStartTimer;
|
|
|
|
m_slowUpdateStartTimer = nullptr;
|
|
|
|
|
|
|
|
if (!m_running || m_quickAdjustTimer) {
|
|
|
|
// only reenable the slow update start timer when quick adjust is not active anymore
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
[colorcorrection] Add "Constant" mode
Summary:
Currently, the Night Color manager supports three operation modes:
* Automatic: in this mode, screen color temperature is computed based on
the current position of the Sun. In order to calculate sunrise & sunset
times, the manager needs coordinates of the user, which are provided by
Plasma;
* Location: this mode is very similar to the Automatic, except one minor
detail: user needs to provide his/her/their location. This mode can be
very useful if coordinates provided by Plasma are incorrect;
* Timings: unfortunately we can't compute timings of the Sun for people
living near Earth poles. This mode allows the user to specify timings of
sunrise and sunset as well the transition time.
This change introduces another mode, called Constant. With this mode the
screen color temperature is constant throughout the day. The new mode
can be useful for people wishing constant screen color temperature or
just for people living near Earth's North or South poles.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: ngraham, davidedmundson, romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21948
2019-07-22 00:30:38 +03:00
|
|
|
// There is no need for starting the slow update timer. Screen color temperature
|
|
|
|
// will be constant all the time now.
|
|
|
|
if (m_mode == NightColorMode::Constant) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
// set up the next slow update
|
|
|
|
m_slowUpdateStartTimer = new QTimer(this);
|
|
|
|
m_slowUpdateStartTimer->setSingleShot(true);
|
|
|
|
connect(m_slowUpdateStartTimer, &QTimer::timeout, this, &Manager::resetSlowUpdateStartTimer);
|
|
|
|
|
2020-01-13 23:41:36 +03:00
|
|
|
updateTransitionTimings(false);
|
2020-01-07 18:11:56 +03:00
|
|
|
updateTargetTemperature();
|
|
|
|
|
2019-09-22 21:15:58 +03:00
|
|
|
const int diff = QDateTime::currentDateTime().msecsTo(m_next.first);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
if (diff <= 0) {
|
|
|
|
qCCritical(KWIN_COLORCORRECTION) << "Error in time calculation. Deactivating Night Color.";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_slowUpdateStartTimer->start(diff);
|
|
|
|
|
|
|
|
// start the current slow update
|
|
|
|
resetSlowUpdateTimer();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::resetSlowUpdateTimer()
|
|
|
|
{
|
|
|
|
delete m_slowUpdateTimer;
|
|
|
|
m_slowUpdateTimer = nullptr;
|
|
|
|
|
2019-09-26 11:41:05 +03:00
|
|
|
const QDateTime now = QDateTime::currentDateTime();
|
|
|
|
const bool isDay = daylight();
|
|
|
|
const int targetTemp = isDay ? m_dayTargetTemp : m_nightTargetTemp;
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
|
[colorcorrection] Fix division by zero
Summary:
m_currentTemp can be equal to targetTemp when resetSlowUpdateTimer is
called. resetSlowUpdateTimer doesn't handle that case, which results
in an FP exception being raised:
==20103==ERROR: AddressSanitizer: FPE on unknown address 0x7f40857d5ca6 (pc 0x7f40857d5ca6 bp 0x7ffccd95c330 sp 0x7ffccd95c220 T0)
#0 0x7f40857d5ca5 in KWin::ColorCorrect::Manager::resetSlowUpdateTimer() /home/jenkins/workspace/Plasma/kwin/kf5-qt5 SUSEQt5.12/colorcorrection/manager.cpp:417
#1 0x7f40857d521d in KWin::ColorCorrect::Manager::resetSlowUpdateStartTimer() /home/jenkins/workspace/Plasma/kwin/kf5-qt5 SUSEQt5.12/colorcorrection/manager.cpp:388
#2 0x7f40857d42d5 in KWin::ColorCorrect::Manager::resetQuickAdjustTimer() /home/jenkins/workspace/Plasma/kwin/kf5-qt5 SUSEQt5.12/colorcorrection/manager.cpp:324
#3 0x7f40857d3ac1 in KWin::ColorCorrect::Manager::resetAllTimers() /home/jenkins/workspace/Plasma/kwin/kf5-qt5 SUSEQt5.12/colorcorrection/manager.cpp:286
#4 0x7f40857d0311 in KWin::ColorCorrect::Manager::hardReset() /home/jenkins/workspace/Plasma/kwin/kf5-qt5 SUSEQt5.12/colorcorrection/manager.cpp:152
#5 0x7f40857d038d in KWin::ColorCorrect::Manager::reparseConfigAndReset() /home/jenkins/workspace/Plasma/kwin/kf5-qt5 SUSEQt5.12/colorcorrection/manager.cpp:159
#6 0x420e75 in ColorCorrectNightColorTest::testConfigRead() /home/jenkins/workspace/Plasma/kwin/kf5-qt5 SUSEQt5.12/autotests/integration/colorcorrect_nightcolor_test.cpp:126
#7 0x4326b4 in ColorCorrectNightColorTest::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) /home/jenkins/workspace/Plasma/kwin/kf5-qt5 SUSEQt5.12/build/autotests/integration/testColorCorrectNightColor_waylandonly_autogen/include/colorcorrect_nightcolor_test.moc:98
#8 0x7f407a80a94a in QMetaMethod::invoke(QObject*, Qt::ConnectionType, QGenericReturnArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument) const (/usr/lib64/libQt5Core.so.5+0x29694a)
#9 0x7f40840a8962 (/usr/lib64/libQt5Test.so.5+0x19962)
#10 0x7f40840a9352 (/usr/lib64/libQt5Test.so.5+0x1a352)
#11 0x7f40840a9910 (/usr/lib64/libQt5Test.so.5+0x1a910)
#12 0x7f40840a9cda in QTest::qRun() (/usr/lib64/libQt5Test.so.5+0x1acda)
#13 0x7f40840a9edb in QTest::qExec(QObject*, int, char**) (/usr/lib64/libQt5Test.so.5+0x1aedb)
#14 0x432428 in main /home/jenkins/workspace/Plasma/kwin/kf5-qt5 SUSEQt5.12/autotests/integration/colorcorrect_nightcolor_test.cpp:338
#15 0x7f407a095bca in __libc_start_main (/lib64/libc.so.6+0x26bca)
#16 0x413ea9 in _start (/home/jenkins/workspace/Plasma/kwin/kf5-qt5 SUSEQt5.12/build/bin/testColorCorrectNightColor_waylandonly+0x413ea9)
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23914
2019-09-12 21:38:33 +03:00
|
|
|
// We've reached the target color temperature or the transition time is zero.
|
|
|
|
if (m_prev.first == m_prev.second || m_currentTemp == targetTemp) {
|
|
|
|
commitGammaRamps(targetTemp);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_prev.first <= now && now <= m_prev.second) {
|
|
|
|
int availTime = now.msecsTo(m_prev.second);
|
|
|
|
m_slowUpdateTimer = new QTimer(this);
|
|
|
|
m_slowUpdateTimer->setSingleShot(false);
|
|
|
|
if (isDay) {
|
|
|
|
connect(m_slowUpdateTimer, &QTimer::timeout, this, [this]() {slowUpdate(m_dayTargetTemp);});
|
|
|
|
} else {
|
|
|
|
connect(m_slowUpdateTimer, &QTimer::timeout, this, [this]() {slowUpdate(m_nightTargetTemp);});
|
|
|
|
}
|
|
|
|
|
|
|
|
// calculate interval such as temperature is changed by TEMPERATURE_STEP K per timer timeout
|
2020-01-07 16:16:05 +03:00
|
|
|
int interval = availTime * TEMPERATURE_STEP / qAbs(targetTemp - m_currentTemp);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
if (interval == 0) {
|
|
|
|
interval = 1;
|
|
|
|
}
|
|
|
|
m_slowUpdateTimer->start(interval);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::slowUpdate(int targetTemp)
|
|
|
|
{
|
|
|
|
if (!m_slowUpdateTimer) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
int nextTemp;
|
|
|
|
if (m_currentTemp < targetTemp) {
|
|
|
|
nextTemp = qMin(m_currentTemp + TEMPERATURE_STEP, targetTemp);
|
|
|
|
} else {
|
|
|
|
nextTemp = qMax(m_currentTemp - TEMPERATURE_STEP, targetTemp);
|
|
|
|
}
|
|
|
|
commitGammaRamps(nextTemp);
|
|
|
|
if (nextTemp == targetTemp) {
|
|
|
|
// stop timer, we reached the target temp
|
|
|
|
delete m_slowUpdateTimer;
|
|
|
|
m_slowUpdateTimer = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-07 18:11:56 +03:00
|
|
|
void Manager::updateTargetTemperature()
|
|
|
|
{
|
|
|
|
const int targetTemperature = mode() != NightColorMode::Constant && daylight() ? m_dayTargetTemp : m_nightTargetTemp;
|
|
|
|
|
|
|
|
if (m_targetTemperature == targetTemperature) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_targetTemperature = targetTemperature;
|
|
|
|
|
|
|
|
emit targetTemperatureChanged();
|
|
|
|
}
|
|
|
|
|
2020-01-13 23:41:36 +03:00
|
|
|
void Manager::updateTransitionTimings(bool force)
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
{
|
2020-01-13 23:41:36 +03:00
|
|
|
if (m_mode == NightColorMode::Constant) {
|
|
|
|
m_next = DateTimes();
|
|
|
|
m_prev = DateTimes();
|
|
|
|
emit previousTransitionTimingsChanged();
|
|
|
|
emit scheduledTransitionTimingsChanged();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-09-26 11:41:05 +03:00
|
|
|
const QDateTime todayNow = QDateTime::currentDateTime();
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
|
|
|
|
if (m_mode == NightColorMode::Timings) {
|
2019-09-26 11:41:05 +03:00
|
|
|
const QDateTime morB = QDateTime(todayNow.date(), m_morning);
|
|
|
|
const QDateTime morE = morB.addSecs(m_trTime * 60);
|
|
|
|
const QDateTime eveB = QDateTime(todayNow.date(), m_evening);
|
|
|
|
const QDateTime eveE = eveB.addSecs(m_trTime * 60);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
|
2019-09-22 21:15:58 +03:00
|
|
|
if (morB <= todayNow && todayNow < eveB) {
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
m_next = DateTimes(eveB, eveE);
|
|
|
|
m_prev = DateTimes(morB, morE);
|
2019-09-22 21:15:58 +03:00
|
|
|
} else if (todayNow < morB) {
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
m_next = DateTimes(morB, morE);
|
|
|
|
m_prev = DateTimes(eveB.addDays(-1), eveE.addDays(-1));
|
|
|
|
} else {
|
|
|
|
m_next = DateTimes(morB.addDays(1), morE.addDays(1));
|
|
|
|
m_prev = DateTimes(eveB, eveE);
|
|
|
|
}
|
2020-01-13 23:41:36 +03:00
|
|
|
emit previousTransitionTimingsChanged();
|
|
|
|
emit scheduledTransitionTimingsChanged();
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
double lat, lng;
|
|
|
|
if (m_mode == NightColorMode::Automatic) {
|
|
|
|
lat = m_latAuto;
|
|
|
|
lng = m_lngAuto;
|
|
|
|
} else {
|
|
|
|
lat = m_latFixed;
|
|
|
|
lng = m_lngFixed;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!force) {
|
|
|
|
// first try by only switching the timings
|
|
|
|
if (daylight()) {
|
|
|
|
// next is morning
|
|
|
|
m_prev = m_next;
|
2019-09-22 21:15:58 +03:00
|
|
|
m_next = getSunTimings(todayNow.addDays(1), lat, lng, true);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
} else {
|
|
|
|
// next is evening
|
|
|
|
m_prev = m_next;
|
2019-09-22 21:15:58 +03:00
|
|
|
m_next = getSunTimings(todayNow, lat, lng, false);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (force || !checkAutomaticSunTimings()) {
|
|
|
|
// in case this fails, reset them
|
2019-09-22 21:15:58 +03:00
|
|
|
DateTimes morning = getSunTimings(todayNow, lat, lng, true);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
if (todayNow < morning.first) {
|
2019-09-22 21:15:58 +03:00
|
|
|
m_prev = getSunTimings(todayNow.addDays(-1), lat, lng, false);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
m_next = morning;
|
|
|
|
} else {
|
2019-09-22 21:15:58 +03:00
|
|
|
DateTimes evening = getSunTimings(todayNow, lat, lng, false);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
if (todayNow < evening.first) {
|
|
|
|
m_prev = morning;
|
|
|
|
m_next = evening;
|
|
|
|
} else {
|
|
|
|
m_prev = evening;
|
2019-09-22 21:15:58 +03:00
|
|
|
m_next = getSunTimings(todayNow.addDays(1), lat, lng, true);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-01-13 23:41:36 +03:00
|
|
|
|
|
|
|
emit previousTransitionTimingsChanged();
|
|
|
|
emit scheduledTransitionTimingsChanged();
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
}
|
|
|
|
|
2019-09-22 21:15:58 +03:00
|
|
|
DateTimes Manager::getSunTimings(const QDateTime &dateTime, double latitude, double longitude, bool morning) const
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
{
|
2019-09-22 21:15:58 +03:00
|
|
|
DateTimes dateTimes = calculateSunTimings(dateTime, latitude, longitude, morning);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
// At locations near the poles it is possible, that we can't
|
|
|
|
// calculate some or all sun timings (midnight sun).
|
|
|
|
// In this case try to fallback to sensible default values.
|
2019-09-26 11:41:05 +03:00
|
|
|
const bool beginDefined = !dateTimes.first.isNull();
|
|
|
|
const bool endDefined = !dateTimes.second.isNull();
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
if (!beginDefined || !endDefined) {
|
|
|
|
if (beginDefined) {
|
2019-09-22 21:15:58 +03:00
|
|
|
dateTimes.second = dateTimes.first.addMSecs( FALLBACK_SLOW_UPDATE_TIME );
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
} else if (endDefined) {
|
2019-09-22 21:15:58 +03:00
|
|
|
dateTimes.first = dateTimes.second.addMSecs( - FALLBACK_SLOW_UPDATE_TIME );
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
} else {
|
|
|
|
// Just use default values for morning and evening, but the user
|
|
|
|
// will probably deactivate Night Color anyway if he is living
|
|
|
|
// in a region without clear sun rise and set.
|
2019-09-22 21:15:58 +03:00
|
|
|
const QTime referenceTime = morning ? QTime(6, 0) : QTime(18, 0);
|
|
|
|
dateTimes.first = QDateTime(dateTime.date(), referenceTime);
|
|
|
|
dateTimes.second = dateTimes.first.addMSecs( FALLBACK_SLOW_UPDATE_TIME );
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
}
|
|
|
|
}
|
2019-09-22 21:15:58 +03:00
|
|
|
return dateTimes;
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Manager::checkAutomaticSunTimings() const
|
|
|
|
{
|
|
|
|
if (m_prev.first.isValid() && m_prev.second.isValid() &&
|
|
|
|
m_next.first.isValid() && m_next.second.isValid()) {
|
2019-09-26 11:41:05 +03:00
|
|
|
const QDateTime todayNow = QDateTime::currentDateTime();
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
return m_prev.first <= todayNow && todayNow < m_next.first &&
|
|
|
|
m_prev.first.msecsTo(m_next.first) < MSC_DAY * 23./24;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Manager::daylight() const
|
|
|
|
{
|
|
|
|
return m_prev.first.date() == m_next.first.date();
|
|
|
|
}
|
|
|
|
|
|
|
|
int Manager::currentTargetTemp() const
|
|
|
|
{
|
2020-01-07 18:09:55 +03:00
|
|
|
if (!m_running) {
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
return NEUTRAL_TEMPERATURE;
|
|
|
|
}
|
|
|
|
|
[colorcorrection] Add "Constant" mode
Summary:
Currently, the Night Color manager supports three operation modes:
* Automatic: in this mode, screen color temperature is computed based on
the current position of the Sun. In order to calculate sunrise & sunset
times, the manager needs coordinates of the user, which are provided by
Plasma;
* Location: this mode is very similar to the Automatic, except one minor
detail: user needs to provide his/her/their location. This mode can be
very useful if coordinates provided by Plasma are incorrect;
* Timings: unfortunately we can't compute timings of the Sun for people
living near Earth poles. This mode allows the user to specify timings of
sunrise and sunset as well the transition time.
This change introduces another mode, called Constant. With this mode the
screen color temperature is constant throughout the day. The new mode
can be useful for people wishing constant screen color temperature or
just for people living near Earth's North or South poles.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: ngraham, davidedmundson, romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21948
2019-07-22 00:30:38 +03:00
|
|
|
if (m_mode == NightColorMode::Constant) {
|
|
|
|
return m_nightTargetTemp;
|
|
|
|
}
|
|
|
|
|
2019-09-26 11:41:05 +03:00
|
|
|
const QDateTime todayNow = QDateTime::currentDateTime();
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
|
|
|
|
auto f = [this, todayNow](int target1, int target2) {
|
|
|
|
if (todayNow <= m_prev.second) {
|
|
|
|
double residueQuota = todayNow.msecsTo(m_prev.second) / (double)m_prev.first.msecsTo(m_prev.second);
|
|
|
|
|
|
|
|
double ret = (int)((1. - residueQuota) * (double)target2 + residueQuota * (double)target1);
|
|
|
|
// remove single digits
|
|
|
|
ret = ((int)(0.1 * ret)) * 10;
|
|
|
|
return (int)ret;
|
|
|
|
} else {
|
|
|
|
return target2;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
if (daylight()) {
|
|
|
|
return f(m_nightTargetTemp, m_dayTargetTemp);
|
|
|
|
} else {
|
|
|
|
return f(m_dayTargetTemp, m_nightTargetTemp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::commitGammaRamps(int temperature)
|
|
|
|
{
|
2018-03-30 16:03:37 +03:00
|
|
|
const auto outs = kwinApp()->platform()->outputs();
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
|
2018-03-30 16:03:37 +03:00
|
|
|
for (auto *o : outs) {
|
Backport Night Color feature to X11
Summary:
The color correction manager doesn't make any specific assumptions about
underlying platform, e.g. whether it's x11, etc. The platform just
has to be capable of setting gamma ramps. Given that, there are no any
significant technical blockers for making this feature work on x.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, neobrain, GB_2, filipf, davidedmundson, ngraham, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21345
2019-06-17 12:07:19 +03:00
|
|
|
int rampsize = o->gammaRampSize();
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
GammaRamp ramp(rampsize);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The gamma calculation below is based on the Redshift app:
|
|
|
|
* https://github.com/jonls/redshift
|
|
|
|
*/
|
Backport Night Color feature to X11
Summary:
The color correction manager doesn't make any specific assumptions about
underlying platform, e.g. whether it's x11, etc. The platform just
has to be capable of setting gamma ramps. Given that, there are no any
significant technical blockers for making this feature work on x.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, neobrain, GB_2, filipf, davidedmundson, ngraham, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21345
2019-06-17 12:07:19 +03:00
|
|
|
uint16_t *red = ramp.red();
|
|
|
|
uint16_t *green = ramp.green();
|
|
|
|
uint16_t *blue = ramp.blue();
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
|
|
|
|
// linear default state
|
|
|
|
for (int i = 0; i < rampsize; i++) {
|
|
|
|
uint16_t value = (double)i / rampsize * (UINT16_MAX + 1);
|
Backport Night Color feature to X11
Summary:
The color correction manager doesn't make any specific assumptions about
underlying platform, e.g. whether it's x11, etc. The platform just
has to be capable of setting gamma ramps. Given that, there are no any
significant technical blockers for making this feature work on x.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, neobrain, GB_2, filipf, davidedmundson, ngraham, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21345
2019-06-17 12:07:19 +03:00
|
|
|
red[i] = value;
|
|
|
|
green[i] = value;
|
|
|
|
blue[i] = value;
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// approximate white point
|
|
|
|
float whitePoint[3];
|
|
|
|
float alpha = (temperature % 100) / 100.;
|
|
|
|
int bbCIndex = ((temperature - 1000) / 100) * 3;
|
|
|
|
whitePoint[0] = (1. - alpha) * blackbodyColor[bbCIndex] + alpha * blackbodyColor[bbCIndex + 3];
|
|
|
|
whitePoint[1] = (1. - alpha) * blackbodyColor[bbCIndex + 1] + alpha * blackbodyColor[bbCIndex + 4];
|
|
|
|
whitePoint[2] = (1. - alpha) * blackbodyColor[bbCIndex + 2] + alpha * blackbodyColor[bbCIndex + 5];
|
|
|
|
|
|
|
|
for (int i = 0; i < rampsize; i++) {
|
Backport Night Color feature to X11
Summary:
The color correction manager doesn't make any specific assumptions about
underlying platform, e.g. whether it's x11, etc. The platform just
has to be capable of setting gamma ramps. Given that, there are no any
significant technical blockers for making this feature work on x.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, neobrain, GB_2, filipf, davidedmundson, ngraham, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21345
2019-06-17 12:07:19 +03:00
|
|
|
red[i] = qreal(red[i]) / (UINT16_MAX+1) * whitePoint[0] * (UINT16_MAX+1);
|
|
|
|
green[i] = qreal(green[i]) / (UINT16_MAX+1) * whitePoint[1] * (UINT16_MAX+1);
|
|
|
|
blue[i] = qreal(blue[i]) / (UINT16_MAX+1) * whitePoint[2] * (UINT16_MAX+1);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
}
|
|
|
|
|
2018-03-30 16:03:37 +03:00
|
|
|
if (o->setGammaRamp(ramp)) {
|
2020-01-07 18:11:56 +03:00
|
|
|
setCurrentTemperature(temperature);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
m_failedCommitAttempts = 0;
|
|
|
|
} else {
|
|
|
|
m_failedCommitAttempts++;
|
|
|
|
if (m_failedCommitAttempts < 10) {
|
2018-03-30 16:03:37 +03:00
|
|
|
qCWarning(KWIN_COLORCORRECTION).nospace() << "Committing Gamma Ramp failed for output " << o->name() <<
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
". Trying " << (10 - m_failedCommitAttempts) << " times more.";
|
|
|
|
} else {
|
2019-11-26 20:48:29 +03:00
|
|
|
// TODO: On multi monitor setups we could try to rollback earlier changes for already committed outputs
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
qCWarning(KWIN_COLORCORRECTION) << "Gamma Ramp commit failed too often. Deactivating color correction for now.";
|
|
|
|
m_failedCommitAttempts = 0; // reset so we can try again later (i.e. after suspend phase or config change)
|
2020-01-07 18:11:56 +03:00
|
|
|
setRunning(false);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
cancelAllTimers();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QHash<QString, QVariant> Manager::info() const
|
|
|
|
{
|
|
|
|
return QHash<QString, QVariant> {
|
2020-01-07 18:11:56 +03:00
|
|
|
{ QStringLiteral("Available"), isAvailable() },
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
|
|
|
|
{ QStringLiteral("ActiveEnabled"), true},
|
|
|
|
{ QStringLiteral("Active"), m_active},
|
|
|
|
|
|
|
|
{ QStringLiteral("ModeEnabled"), true},
|
|
|
|
{ QStringLiteral("Mode"), (int)m_mode},
|
|
|
|
|
|
|
|
{ QStringLiteral("NightTemperatureEnabled"), true},
|
|
|
|
{ QStringLiteral("NightTemperature"), m_nightTargetTemp},
|
|
|
|
|
|
|
|
{ QStringLiteral("Running"), m_running},
|
|
|
|
{ QStringLiteral("CurrentColorTemperature"), m_currentTemp},
|
|
|
|
|
|
|
|
{ QStringLiteral("LatitudeAuto"), m_latAuto},
|
|
|
|
{ QStringLiteral("LongitudeAuto"), m_lngAuto},
|
|
|
|
|
|
|
|
{ QStringLiteral("LocationEnabled"), true},
|
|
|
|
{ QStringLiteral("LatitudeFixed"), m_latFixed},
|
|
|
|
{ QStringLiteral("LongitudeFixed"), m_lngFixed},
|
|
|
|
|
|
|
|
{ QStringLiteral("TimingsEnabled"), true},
|
|
|
|
{ QStringLiteral("MorningBeginFixed"), m_morning.toString(Qt::ISODate)},
|
|
|
|
{ QStringLiteral("EveningBeginFixed"), m_evening.toString(Qt::ISODate)},
|
|
|
|
{ QStringLiteral("TransitionTime"), m_trTime},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Manager::changeConfiguration(QHash<QString, QVariant> data)
|
|
|
|
{
|
|
|
|
bool activeUpdate, modeUpdate, tempUpdate, locUpdate, timeUpdate;
|
|
|
|
activeUpdate = modeUpdate = tempUpdate = locUpdate = timeUpdate = false;
|
|
|
|
|
|
|
|
bool active = m_active;
|
|
|
|
NightColorMode mode = m_mode;
|
|
|
|
int nightT = m_nightTargetTemp;
|
|
|
|
|
|
|
|
double lat = m_latFixed;
|
|
|
|
double lng = m_lngFixed;
|
|
|
|
|
|
|
|
QTime mor = m_morning;
|
|
|
|
QTime eve = m_evening;
|
|
|
|
int trT = m_trTime;
|
|
|
|
|
|
|
|
QHash<QString, QVariant>::const_iterator iter1, iter2, iter3;
|
|
|
|
|
|
|
|
iter1 = data.constFind("Active");
|
|
|
|
if (iter1 != data.constEnd()) {
|
|
|
|
if (!iter1.value().canConvert<bool>()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
bool act = iter1.value().toBool();
|
|
|
|
activeUpdate = m_active != act;
|
|
|
|
active = act;
|
|
|
|
}
|
|
|
|
|
|
|
|
iter1 = data.constFind("Mode");
|
|
|
|
if (iter1 != data.constEnd()) {
|
|
|
|
if (!iter1.value().canConvert<int>()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
int mo = iter1.value().toInt();
|
[colorcorrection] Add "Constant" mode
Summary:
Currently, the Night Color manager supports three operation modes:
* Automatic: in this mode, screen color temperature is computed based on
the current position of the Sun. In order to calculate sunrise & sunset
times, the manager needs coordinates of the user, which are provided by
Plasma;
* Location: this mode is very similar to the Automatic, except one minor
detail: user needs to provide his/her/their location. This mode can be
very useful if coordinates provided by Plasma are incorrect;
* Timings: unfortunately we can't compute timings of the Sun for people
living near Earth poles. This mode allows the user to specify timings of
sunrise and sunset as well the transition time.
This change introduces another mode, called Constant. With this mode the
screen color temperature is constant throughout the day. The new mode
can be useful for people wishing constant screen color temperature or
just for people living near Earth's North or South poles.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: ngraham, davidedmundson, romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21948
2019-07-22 00:30:38 +03:00
|
|
|
if (mo < 0 || 3 < mo) {
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
NightColorMode moM;
|
|
|
|
switch (mo) {
|
|
|
|
case 0:
|
|
|
|
moM = NightColorMode::Automatic;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
moM = NightColorMode::Location;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
moM = NightColorMode::Timings;
|
[colorcorrection] Add "Constant" mode
Summary:
Currently, the Night Color manager supports three operation modes:
* Automatic: in this mode, screen color temperature is computed based on
the current position of the Sun. In order to calculate sunrise & sunset
times, the manager needs coordinates of the user, which are provided by
Plasma;
* Location: this mode is very similar to the Automatic, except one minor
detail: user needs to provide his/her/their location. This mode can be
very useful if coordinates provided by Plasma are incorrect;
* Timings: unfortunately we can't compute timings of the Sun for people
living near Earth poles. This mode allows the user to specify timings of
sunrise and sunset as well the transition time.
This change introduces another mode, called Constant. With this mode the
screen color temperature is constant throughout the day. The new mode
can be useful for people wishing constant screen color temperature or
just for people living near Earth's North or South poles.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: ngraham, davidedmundson, romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D21948
2019-07-22 00:30:38 +03:00
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
moM = NightColorMode::Constant;
|
|
|
|
break;
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
}
|
|
|
|
modeUpdate = m_mode != moM;
|
|
|
|
mode = moM;
|
|
|
|
}
|
|
|
|
|
|
|
|
iter1 = data.constFind("NightTemperature");
|
|
|
|
if (iter1 != data.constEnd()) {
|
|
|
|
if (!iter1.value().canConvert<int>()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
int nT = iter1.value().toInt();
|
|
|
|
if (nT < MIN_TEMPERATURE || NEUTRAL_TEMPERATURE < nT) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
tempUpdate = m_nightTargetTemp != nT;
|
|
|
|
nightT = nT;
|
|
|
|
}
|
|
|
|
|
|
|
|
iter1 = data.constFind("LatitudeFixed");
|
|
|
|
iter2 = data.constFind("LongitudeFixed");
|
|
|
|
if (iter1 != data.constEnd() && iter2 != data.constEnd()) {
|
|
|
|
if (!iter1.value().canConvert<double>() || !iter2.value().canConvert<double>()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
double la = iter1.value().toDouble();
|
|
|
|
double ln = iter2.value().toDouble();
|
|
|
|
if (!checkLocation(la, ln)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
locUpdate = m_latFixed != la || m_lngFixed != ln;
|
|
|
|
lat = la;
|
|
|
|
lng = ln;
|
|
|
|
}
|
|
|
|
|
|
|
|
iter1 = data.constFind("MorningBeginFixed");
|
|
|
|
iter2 = data.constFind("EveningBeginFixed");
|
|
|
|
iter3 = data.constFind("TransitionTime");
|
|
|
|
if (iter1 != data.constEnd() && iter2 != data.constEnd() && iter3 != data.constEnd()) {
|
|
|
|
if (!iter1.value().canConvert<QString>() || !iter2.value().canConvert<QString>() || !iter3.value().canConvert<int>()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
QTime mo = QTime::fromString(iter1.value().toString(), Qt::ISODate);
|
|
|
|
QTime ev = QTime::fromString(iter2.value().toString(), Qt::ISODate);
|
|
|
|
if (!mo.isValid() || !ev.isValid()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
int tT = iter3.value().toInt();
|
|
|
|
|
|
|
|
int diffME = mo.msecsTo(ev);
|
|
|
|
if (diffME <= 0 || qMin(diffME, MSC_DAY - diffME) <= tT * 60 * 1000 || tT < 1) {
|
|
|
|
// morning not strictly before evening, transition time too long or transition time out of bounds
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
timeUpdate = m_morning != mo || m_evening != ev || m_trTime != tT;
|
|
|
|
mor = mo;
|
|
|
|
eve = ev;
|
|
|
|
trT = tT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(activeUpdate || modeUpdate || tempUpdate || locUpdate || timeUpdate)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool resetNeeded = activeUpdate || modeUpdate || tempUpdate ||
|
|
|
|
(locUpdate && mode == NightColorMode::Location) ||
|
|
|
|
(timeUpdate && mode == NightColorMode::Timings);
|
|
|
|
|
|
|
|
if (resetNeeded) {
|
|
|
|
cancelAllTimers();
|
|
|
|
}
|
|
|
|
|
|
|
|
Settings *s = Settings::self();
|
|
|
|
if (activeUpdate) {
|
2020-01-07 18:11:56 +03:00
|
|
|
setEnabled(active);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
s->setActive(active);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (modeUpdate) {
|
2020-01-07 18:11:56 +03:00
|
|
|
setMode(mode);
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
s->setMode(mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tempUpdate) {
|
|
|
|
m_nightTargetTemp = nightT;
|
|
|
|
s->setNightTemperature(nightT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (locUpdate) {
|
|
|
|
m_latFixed = lat;
|
|
|
|
m_lngFixed = lng;
|
|
|
|
s->setLatitudeFixed(lat);
|
|
|
|
s->setLongitudeFixed(lng);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (timeUpdate) {
|
|
|
|
m_morning = mor;
|
|
|
|
m_evening = eve;
|
|
|
|
m_trTime = trT;
|
|
|
|
s->setMorningBeginFixed(mor.toString("hhmm"));
|
|
|
|
s->setEveningBeginFixed(eve.toString("hhmm"));
|
|
|
|
s->setTransitionTime(trT);
|
|
|
|
}
|
|
|
|
s->save();
|
|
|
|
|
|
|
|
if (resetNeeded) {
|
|
|
|
resetAllTimers();
|
|
|
|
}
|
|
|
|
emit configChange(info());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::autoLocationUpdate(double latitude, double longitude)
|
|
|
|
{
|
2019-09-26 11:47:59 +03:00
|
|
|
qCDebug(KWIN_COLORCORRECTION, "Received new location (lat: %f, lng: %f)", latitude, longitude);
|
|
|
|
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
if (!checkLocation(latitude, longitude)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// we tolerate small deviations with minimal impact on sun timings
|
|
|
|
if (qAbs(m_latAuto - latitude) < 2 && qAbs(m_lngAuto - longitude) < 1) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
cancelAllTimers();
|
|
|
|
m_latAuto = latitude;
|
|
|
|
m_lngAuto = longitude;
|
|
|
|
|
|
|
|
Settings *s = Settings::self();
|
|
|
|
s->setLatitudeAuto(latitude);
|
|
|
|
s->setLongitudeAuto(longitude);
|
|
|
|
s->save();
|
|
|
|
|
|
|
|
resetAllTimers();
|
|
|
|
emit configChange(info());
|
|
|
|
}
|
|
|
|
|
2020-01-07 18:11:56 +03:00
|
|
|
void Manager::setEnabled(bool enabled)
|
|
|
|
{
|
|
|
|
if (m_active == enabled) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_active = enabled;
|
2020-01-07 18:12:11 +03:00
|
|
|
m_skewNotifier->setActive(enabled);
|
2020-01-07 18:11:56 +03:00
|
|
|
emit enabledChanged();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::setRunning(bool running)
|
|
|
|
{
|
|
|
|
if (m_running == running) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_running = running;
|
|
|
|
emit runningChanged();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::setCurrentTemperature(int temperature)
|
|
|
|
{
|
|
|
|
if (m_currentTemp == temperature) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_currentTemp = temperature;
|
|
|
|
emit currentTemperatureChanged();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Manager::setMode(NightColorMode mode)
|
|
|
|
{
|
|
|
|
if (m_mode == mode) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_mode = mode;
|
|
|
|
emit modeChanged();
|
|
|
|
}
|
|
|
|
|
[colorcorrection] Night Color - blue light filter at nighttime
With Wayland KWin needs to provide certain services, which were provided
before that by the Xserver. One of these is gamma correction, which includes
the - by many people beloved - functionality to reduce the blue light at
nighttime. This patch provides the KWin part of that. It is self contained,
but in the end will work in tandem with a lib in Plasma Workspace and a KCM
in Plasma Desktop, which can be used to configure Night Color.
* Three modi:
** Automatic: The location and sun timings are determined automatically
(location data updates will be provided by the workspace)
** Location: The sun timings are determined by fixed location data
** Timings: The sun timings are set manually by the user
* Color temperature value changes are smoothly applied:
** Configuration changes, which lead to other current values are changed
in a quick way over a few seconds
** Changes on sunrise and sunset are applied slowly over the course of few
minutes till several hours depending on the configuration
* The current color value is set immediately at startup or after suspend
phases and VT switches. There is no flickering.
* All configuration is done via a DBus interface, changed values are tested
on correctness and applied atomically
* Self contained mechanism, speaks directly to the hardware by setting the
gamma ramps on the CRTC
* Currently working on DRM backend, extensible to other platform backends in
the future
* The code is written in a way to make the classes later easily extendable to
also provide normal color correction, as it's currently done by KGamma on X
Test Plan:
Manually with the workspace parts and added integration tests in KWin using
the virtual backend.
BUG:371494
Reviewers: #kwin, graesslin
Subscribers: kwin, plasma-devel, #kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D5928
2017-12-11 12:43:12 +03:00
|
|
|
}
|
|
|
|
}
|