Differential D5931 Diff 14743 libcolorcorrect/compositorcoloradaptor.h

Changeset View

Standalone View

View Options

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