Differential D5931 Diff 23750 libcolorcorrect/compositorcoloradaptor.h

Changeset View

Standalone View

libcolorcorrect/compositorcoloradaptor.h

This file was added.

		1		/********************************************************************
		2		Copyright 2017 Roman Gilg <subdiff@gmail.com>
		3
		4		This program is free software; you can redistribute it and/or modify
		5		it under the terms of the GNU General Public License as published by
		6		the Free Software Foundation; either version 2 of the License, or
		7		(at your option) any later version.
		8
		9		This program is distributed in the hope that it will be useful,
		10		but WITHOUT ANY WARRANTY; without even the implied warranty of
		11		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		12		GNU General Public License for more details.
		13
		14		You should have received a copy of the GNU General Public License
		15		along with this program. If not, see <http://www.gnu.org/licenses/>.
		16		*********************************************************************/
		17		#ifndef COLORCORRECT_COMPOSITORADAPTOR_H
		18		#define COLORCORRECT_COMPOSITORADAPTOR_H
		19
		20		#include <QObject>
		21		#include <QTime>
		22		#include <QHash>
		23		#include <QString>
		24
		25		#include "colorcorrect_export.h"
		26		#include "colorcorrectconstants.h"
		27
		28		class QDBusInterface;
		29
		30		namespace ColorCorrect
		31		{
		32
		33		class COLORCORRECT_EXPORT CompositorAdaptor : public QObject
		34		{
		35		Q_OBJECT
		36
		37		Q_PROPERTY(int error READ error NOTIFY errorChanged)
		38		Q_PROPERTY(QString errorText READ errorText NOTIFY errorTextChanged)
		39
		40		Q_PROPERTY(bool nightColorAvailable READ nightColorAvailable CONSTANT)
		41		Q_PROPERTY(int minimalTemperature READ minimalTemperature CONSTANT)
		42		Q_PROPERTY(int neutralTemperature READ neutralTemperature CONSTANT)
		43
		44		Q_PROPERTY(bool activeEnabled READ activeEnabled NOTIFY activeEnabledChanged)
		45		Q_PROPERTY(bool active READ active NOTIFY activeChanged)
		46		Q_PROPERTY(bool activeStaged READ activeStaged WRITE setActiveStaged NOTIFY activeStagedChanged)
		47		Q_PROPERTY(bool activeDefault READ activeDefault CONSTANT)
		48
		49		Q_PROPERTY(bool modeEnabled READ modeEnabled NOTIFY modeEnabledChanged)
		50		Q_PROPERTY(int mode READ mode NOTIFY modeChanged)
		51		Q_PROPERTY(int modeStaged READ modeStaged WRITE setModeStaged NOTIFY modeStagedChanged)
		52		Q_PROPERTY(int modeDefault READ modeDefault CONSTANT)
		53
		54		Q_PROPERTY(bool nightTemperatureEnabled READ nightTemperatureEnabled NOTIFY nightTemperatureEnabledChanged)
		55		Q_PROPERTY(int nightTemperature READ nightTemperature NOTIFY nightTemperatureChanged)
		56		Q_PROPERTY(int nightTemperatureStaged READ nightTemperatureStaged WRITE setNightTemperatureStaged NOTIFY nightTemperatureStagedChanged)
		57		Q_PROPERTY(int nightTemperatureDefault READ nightTemperatureDefault CONSTANT)
		58
		59		Q_PROPERTY(int curColorT READ curColorT WRITE setCurColorT NOTIFY curColorTChanged)
		60
		61		Q_PROPERTY(double latitudeAuto READ latitudeAuto NOTIFY latitudeAutoChanged)
		62		Q_PROPERTY(double longitudeAuto READ longitudeAuto NOTIFY longitudeAutoChanged)
		63
		64		Q_PROPERTY(bool locationEnabled READ locationEnabled NOTIFY locationEnabledChanged)
		65		Q_PROPERTY(double latitudeFixed READ latitudeFixed NOTIFY latitudeFixedChanged)
		66		Q_PROPERTY(double longitudeFixed READ longitudeFixed NOTIFY longitudeFixedChanged)
		67		Q_PROPERTY(double latitudeFixedStaged READ latitudeFixedStaged WRITE setLatitudeFixedStaged NOTIFY latitudeFixedStagedChanged)
		68		Q_PROPERTY(double longitudeFixedStaged READ longitudeFixedStaged WRITE setLongitudeFixedStaged NOTIFY longitudeFixedStagedChanged)
		69		Q_PROPERTY(double latitudeFixedDefault READ latitudeFixedDefault CONSTANT)
		70		Q_PROPERTY(double longitudeFixedDefault READ longitudeFixedDefault CONSTANT)
		71
		72		Q_PROPERTY(bool timingsEnabled READ timingsEnabled NOTIFY timingsEnabledChanged)
		73
		74		Q_PROPERTY(QTime morningBeginFixed READ morningBeginFixed NOTIFY morningBeginFixedChanged)
		75		Q_PROPERTY(QTime morningBeginFixedStaged READ morningBeginFixedStaged WRITE setMorningBeginFixedStaged NOTIFY morningBeginFixedStagedChanged)
		76		Q_PROPERTY(QTime eveningBeginFixed READ eveningBeginFixed NOTIFY eveningBeginFixedChanged)
		77		Q_PROPERTY(QTime eveningBeginFixedStaged READ eveningBeginFixedStaged WRITE setEveningBeginFixedStaged NOTIFY eveningBeginFixedStagedChanged)
		78		Q_PROPERTY(int transitionTime READ transitionTime NOTIFY transitionTimeChanged)
		79		Q_PROPERTY(int transitionTimeStaged READ transitionTimeStaged WRITE setTransitionTimeStaged NOTIFY transitionTimeStagedChanged)
		80		Q_PROPERTY(QTime morningBeginFixedDefault READ morningBeginFixedDefault CONSTANT)
		81		Q_PROPERTY(QTime eveningBeginFixedDefault READ eveningBeginFixedDefault CONSTANT)
		82		Q_PROPERTY(int transitionTimeDefault READ transitionTimeDefault CONSTANT)
		83
		84		public:
		85		enum class ErrorCode {
		86		// no error
		87		ErrorCodeSuccess = 0,
		88		// couldn't establish connection to compositor
		89		ErrorCodeConnectionFailed,
		90		// rendering backend doesn't support hardware color correction
		91		ErrorCodeBackendNoSupport,
		92		// it's an X session - no native color correction in general on X
		93		ErrorCodeXSession
		94		};
		95		Q_ENUMS(ErrorCode)
		96
		97		enum class Mode {
		98		ModeAutomatic,
		99		ModeLocation,
		100		ModeTimings
		101		};
		102		Q_ENUMS(Mode)
		103
		104		explicit CompositorAdaptor(QObject *parent = nullptr);
		105		virtual ~CompositorAdaptor() = default;
		106
		107		int error() {
		108		return (int)m_error;
		109		}
		110		void setError(ErrorCode error);
		111
		112		QString errorText() {
		113		return m_errorText;
		114		}
		115
		116		/*
		117		* General
		118		*/
		119		bool nightColorAvailable() const {
		120		return m_nightColorAvailable;
		121		}
		122		int minimalTemperature() {
		123		return MIN_TEMPERATURE;
		124		}
		125		int neutralTemperature() {
		126		return NEUTRAL_TEMPERATURE;
		127		}
		128
		129		bool activeEnabled() const {
		130		return m_activeEnabled;
		131		}
		132		bool active() const {
		133		return m_active;
		134		}
		135		bool activeStaged() const {
		136		return m_activeStaged;
		137		}
		138		void setActiveStaged(bool set) {
		139		if (m_activeStaged == set) {
		140		return;
		141		}
		142		m_activeStaged = set;
		143		emit activeStagedChanged();
		144		}
		145		bool activeDefault() {
		146		return true;
		147		}
		148
		149		bool modeEnabled() const {
		150		return m_modeEnabled;
		151		}
		152		int mode() const {
		153		return (int)m_mode;
		154		}
		155		int modeStaged() const {
		156		return (int)m_modeStaged;
		157		}
		158		void setModeStaged(int mode) {
		159		if (mode < 0 \|\| 2 < mode \|\| (int)m_modeStaged == mode) {
		160		return;
		161		}
		162		m_modeStaged = (Mode)mode;
		163		emit modeStagedChanged();
		164		}
		165		int modeDefault() {
		166		return (int)Mode::ModeAutomatic;
		167		}
		168		/*
		169		* Color Temperature
		170		*/
		171		bool nightTemperatureEnabled() const {
		172		return m_nightTemperatureEnabled;
		173		}
		174		int nightTemperature() const {
		175		return m_nightTemperature;
		176		}
		177		int nightTemperatureStaged() const {
		178		return m_nightTemperatureStaged;
		179		}
		180		void setNightTemperatureStaged(int val) {
		181		if (m_nightTemperatureStaged == val) {
		182		return;
		183		}
		184		m_nightTemperatureStaged = val;
		185		emit nightTemperatureStagedChanged();
		186		}
		187		int nightTemperatureDefault() {
		188		return DEFAULT_NIGHT_TEMPERATURE;
		189		}
		190		int curColorT() {
		191		return m_curColorT;
		192		}
		193		void setCurColorT(int val) {
		194		if (m_nightTemperature == val) {
		195		return;
		196		}
		197		m_curColorT = val;
		198		emit curColorTChanged();
		199		}
		200		/*
		201		* Location
		202		*/
		203		bool locationEnabled() const {
		204		return m_locationEnabled;
		205		}
		206
		207		double latitudeAuto() const {
		208		return m_latitudeAuto;
		209		}
		210		double longitudeAuto() const {
		211		return m_longitudeAuto;
		212		}
		213
		214		double latitudeFixed() const {
		215		return m_latitudeFixed;
		216		}
		217		double latitudeFixedStaged() const {
		218		return m_latitudeFixedStaged;
		219		}
		220		void setLatitudeFixedStaged(double val) {
		221		if (m_latitudeFixedStaged == val) {
		222		return;
		223		}
		224		m_latitudeFixedStaged = val;
		225		emit latitudeFixedStagedChanged();
		226		}
		227
		228		double longitudeFixed() const {
		229		return m_longitudeFixed;
		230		}
		231		double longitudeFixedStaged() const {
		232		return m_longitudeFixedStaged;
		233		}
		234		void setLongitudeFixedStaged(double val) {
		235		if (m_longitudeFixedStaged == val) {
		236		return;
		237		}
		238		m_longitudeFixedStaged = val;
		239		emit longitudeFixedStagedChanged();
		240		}
		241		double latitudeFixedDefault() {
		242		return 0.;
		243		}
		244		double longitudeFixedDefault() {
		245		return 0.;
		246		}
		247		/*
		248		* Timings
		249		*/
		250		bool timingsEnabled() const {
		251		return m_timingsEnabled;
		252		}
		253
		254		QTime morningBeginFixed() const {
		255		return m_morningBeginFixed;
		256		}
		257		QTime morningBeginFixedStaged() const {
		258		return m_morningBeginFixedStaged;
		259		}
		260		void setMorningBeginFixedStaged(QTime time) {
		261		if (m_morningBeginFixedStaged == time) {
		262		return;
		263		}
		264		m_morningBeginFixedStaged = time;
		265		emit morningBeginFixedStagedChanged();
		266		}
		267
		268		QTime eveningBeginFixed() const {
		269		return m_eveningBeginFixed;
		270		}
		271		QTime eveningBeginFixedStaged() const {
		272		return m_eveningBeginFixedStaged;
		273		}
		274		void setEveningBeginFixedStaged(QTime time) {
		275		if (m_eveningBeginFixedStaged == time) {
		276		return;
		277		}
		278		m_eveningBeginFixedStaged = time;
		279		emit eveningBeginFixedStagedChanged();
		280		}
		281		// saved in minutes
		282		int transitionTime() const {
		283		return m_transitionTime;
		284		}
		285		int transitionTimeStaged() const {
		286		return m_transitionTimeStaged;
		287		}
		288		void setTransitionTimeStaged(int time) {
		289		if (m_transitionTimeStaged == time) {
		290		return;
		291		}
		292		m_transitionTimeStaged = time;
		293		emit transitionTimeStagedChanged();
		294		}
		295		QTime morningBeginFixedDefault() {
		296		return QTime(6,0,0);
		297		}
		298		QTime eveningBeginFixedDefault() {
		299		return QTime(18,0,0);
		300		}
		301		int transitionTimeDefault() {
		302		return FALLBACK_SLOW_UPDATE_TIME;
		303		}
		304
		305		/**
		306		* @brief Reloads data and resets staged values.
		307		*
		308		* Reloads current data from compositor, also resets all staged values.
		309		* For data updates without resetting staged values, don't use this method
		310		* and instead connect to the compDataUpdated signal.
		311		*
		312		* @return void
		313		* @see compDataUpdated
		314		* @since 5.12
		315		**/
		316		Q_INVOKABLE void reloadData();
		317		/**
		318		* @brief Send subset of staged values.
		319		*
		320		* Send a relevant subset of staged values to the compositor in order
		321		* to trigger a configuration change. If active will be set to false, no
		322		* other data will be sent. Otherwise additionally staged temperature and
		323		* mode values will be sent and for the requested mode relevant data, i.e.
		324		* in Automatic mode no other data, in Location mode staged latitude or
		325		* longitude values and in Timings mode the morning and evening begin, as
		326		* well as the transition time.
		327		*
		328		* Returns true, if the configuration was succesfully applied.
		329		*
		330		* @return bool
		331		* @see sendConfigurationAll
		332		* @since 5.12
		333		**/
		334		Q_INVOKABLE bool sendConfiguration();
		335		/**
		336		* @brief Send all staged values.
		337		*
		338		* Send all currently staged values to the compositor in order
		339		* to trigger a configuration change.
		340		*
		341		* Returns true, if the configuration was succesfully applied.
		342		*
		343		* @return bool
		344		* @see sendConfiguration
		345		* @since 5.12
		346		**/
		347		Q_INVOKABLE bool sendConfigurationAll();
		348		/**
		349		* @brief Send automatic location data.
		350		*
		351		* Updated auto location data is provided by the workspace. This is
		352		* in general already done by the KDE Daemon.
		353		*
		354		* @return void
		355		* @since 5.12
		356		**/
		357		Q_INVOKABLE void sendAutoLocationUpdate(double latitude, double longitude);
		358		/**
		359		* @brief Check changes in subset of staged values.
		360		*
		361		* Compares staged to current values relative to chosen activation state and mode,
		362		* returns true if there is a difference.
		363		*
		364		* @return bool
		365		* @see checkStagedAll
		366		* @since 5.12
		367		**/
		368		Q_INVOKABLE bool checkStaged();
		369		/**
		370		* @brief Check changes in staged values.
		371		*
		372		* Compares every staged to its current value, returns true if there is a difference.
		373		*
		374		* @return bool
		375		* @see checkStaged
		376		* @since 5.12
		377		**/
		378		Q_INVOKABLE bool checkStagedAll();
		379
		380		private Q_SLOTS:
		381		void compDataUpdated(QHash<QString, QVariant> data);
		382
		383		Q_SIGNALS:
		384		void errorChanged();
		385		void errorTextChanged();
		386
		387		void activeEnabledChanged();
		388		void activeChanged();
		389		void activeStagedChanged();
		390		void modeEnabledChanged();
		391		void modeChanged();
		392		void modeStagedChanged();
		393
		394		void curColorTChanged();
		395		void nightTemperatureEnabledChanged();
		396		void nightTemperatureChanged();
		397		void nightTemperatureStagedChanged();
		398
		399		void latitudeAutoChanged();
		400		void longitudeAutoChanged();
		401
		402		void locationEnabledChanged();
		403		void latitudeFixedChanged();
		404		void latitudeFixedStagedChanged();
		405		void longitudeFixedChanged();
		406		void longitudeFixedStagedChanged();
		407
		408		void timingsEnabledChanged();
		409		void morningBeginFixedChanged();
		410		void eveningBeginFixedChanged();
		411		void morningBeginFixedStagedChanged();
		412		void eveningBeginFixedStagedChanged();
		413
		414		void transitionTimeChanged();
		415		void transitionTimeStagedChanged();
		416
		417		void dataUpdated();
		418		void stagedDataReset();
		419
		420
		421		private:
		422		bool resetData(QHash<QString, QVariant> data);
		423		void resetDataAndStaged(QHash<QString, QVariant> data);
		424		QDBusInterface *m_iface;
		425
		426		QHash<QString, QVariant> getData();
		427
		428		ErrorCode m_error = ErrorCode::ErrorCodeSuccess;
		429		QString m_errorText = "";
		430
		431		bool m_nightColorAvailable = false;
		432
		433		bool m_activeEnabled = true;
		434		bool m_active = false;
		435		bool m_activeStaged = false;
		436
		437		bool m_modeEnabled = true;
		438		Mode m_mode = Mode::ModeAutomatic;
		439		Mode m_modeStaged = Mode::ModeAutomatic;
		440
		441		bool m_nightTemperatureEnabled = true;
		442		int m_nightTemperature = DEFAULT_NIGHT_TEMPERATURE;
		443		int m_nightTemperatureStaged = DEFAULT_NIGHT_TEMPERATURE;
		444		int m_curColorT;
		445
		446		double m_latitudeAuto;
		447		double m_longitudeAuto;
		448
		449		bool m_locationEnabled = true;
		450		double m_latitudeFixed = 0;
		451		double m_longitudeFixed = 0;
		452		double m_latitudeFixedStaged = 0;
		453		double m_longitudeFixedStaged = 0;
		454
		455		bool m_timingsEnabled = true;
		456
		457		QTime m_morningBeginFixed = QTime(6,0,0);
		458		QTime m_eveningBeginFixed = QTime(18,0,0);
		459		QTime m_morningBeginFixedStaged = QTime(6,0,0);
		460		QTime m_eveningBeginFixedStaged = QTime(18,0,0);
		461
		462		int m_transitionTime = FALLBACK_SLOW_UPDATE_TIME;
		463		int m_transitionTimeStaged = FALLBACK_SLOW_UPDATE_TIME;
		464		};
		465
		466		}
		467
		468		#endif // COLORCORRECT_COMPOSITORADAPTOR_H