diff --git a/applets/nightcolor/package/contents/ui/main.qml b/applets/nightcolor/package/contents/ui/main.qml --- a/applets/nightcolor/package/contents/ui/main.qml +++ b/applets/nightcolor/package/contents/ui/main.qml @@ -30,7 +30,7 @@ Plasmoid.status: { // Display the applet in the system tray when Night Color is active. - if (monitor.enabled && monitor.targetTemperature != 6500) { + if (monitor.enabled && monitor.targetTemperature != Monitor.NeutralTemperature) { return PlasmaCore.Types.ActiveStatus; } if (inhibitor.state != Inhibitor.Uninhibited) { @@ -53,6 +53,14 @@ if (!monitor.running) { return i18n("Night Color is not running"); } + if (monitor.operationMode != Monitor.ConstantMode) { + if (monitor.currentTemperature == Monitor.NeutralTemperature) { + // TODO: Show a better message... + return i18nc("Night Color is not active. The next transition will occur at (time)", + "Night Color is not active. The next transition will occur at %1", + monitor.scheduledTransitionDateTime.toLocaleTimeString(Qt.locale(), Locale.ShortFormat)); + } + } return i18n("Night Color is active (%1K)", monitor.currentTemperature); } diff --git a/applets/nightcolor/plugin/monitor.h b/applets/nightcolor/plugin/monitor.h --- a/applets/nightcolor/plugin/monitor.h +++ b/applets/nightcolor/plugin/monitor.h @@ -17,6 +17,7 @@ #pragma once +#include #include class MonitorPrivate; @@ -53,10 +54,62 @@ */ Q_PROPERTY(int targetTemperature READ targetTemperature NOTIFY targetTemperatureChanged) + /** + * This property holds a value to specify the operation mode of Night Color. + */ + Q_PROPERTY(OperationMode operationMode READ operationMode NOTIFY operationModeChanged) + + /** + * This property holds a datetime that specifies when the previous screen color temperature + * transition had started. Notice that if Night Color operates in the constant mode, this + * property holds an invalid datetime. + */ + Q_PROPERTY(QDateTime previousTransitionDateTime READ previousTransitionDateTime NOTIFY previousTransitionDateTimeChanged) + + /** + * This property holds a value to indicate the duration of the previous color temperature + * transition, in milliseconds. Notice that if Night Color operates in the constant mode, + * this property holds a value of 0. + */ + Q_PROPERTY(quint32 previousTransitionDuration READ previousTransitionDuration NOTIFY previousTransitionDurationChanged) + + /** + * This property holds a datetime to indicate when the next screen color temperature transition + * will start. Notice that if Night Color operates in the constant mode, this property holds + * an invalid datetime. + */ + Q_PROPERTY(QDateTime scheduledTransitionDateTime READ scheduledTransitionDateTime NOTIFY scheduledTransitionDateTimeChanged) + + /** + * This property holds a value to indicate the duration of the next screen color temperature + * transition, in milliseconds. Notice that if Night Color operates in the constant mode, this + * property holds a value of 0. + */ + Q_PROPERTY(quint32 scheduledTransitionDuration READ scheduledTransitionDuration NOTIFY scheduledTransitionDurationChanged) + public: explicit Monitor(QObject *parent = nullptr); ~Monitor() override; + /** + * This enum type is used to specify the operation mode of Night Color. + */ + enum OperationMode { + AutomaticMode, + LocationMode, + ManualMode, + ConstantMode, + }; + Q_ENUM(OperationMode) + + /** + * This enum type is used to specify some well known temperature values. + */ + enum TemperatureConstant { + NeutralTemperature = 6500, + }; + Q_ENUM(TemperatureConstant) + /** * Returns @c true if Night Color is available; otherwise @c false. */ @@ -82,6 +135,31 @@ */ int targetTemperature() const; + /** + * Returns the current operation mode of Night Color. + */ + OperationMode operationMode() const; + + /** + * Returns the datetime that specifies when the previous color temperature transition had started. + */ + QDateTime previousTransitionDateTime() const; + + /** + * Returns the duration of the previous color temperature transition, in milliseconds. + */ + quint32 previousTransitionDuration() const; + + /** + * Returns the datetime that specifies when the next color temperature transition will start. + */ + QDateTime scheduledTransitionDateTime() const; + + /** + * Returns the duration of the next color temperature transition, in milliseconds. + */ + quint32 scheduledTransitionDuration() const; + Q_SIGNALS: /** * This signal is emitted when Night Color becomes (un)available. @@ -108,6 +186,31 @@ */ void targetTemperatureChanged(); + /** + * Emitted whenever the operation mode has changed. + */ + void operationModeChanged(); + + /** + * Emitted whenever the datetime of the previous color temperature transition has changed. + */ + void previousTransitionDateTimeChanged(); + + /** + * Emitted whenever the duration of the previous color temperature transition has changed. + */ + void previousTransitionDurationChanged(); + + /** + * Emitted whenever the datetime of the next color temperature transition has changed. + */ + void scheduledTransitionDateTimeChanged(); + + /** + * Emitted whenever the duration of the next color temperature transition has changed. + */ + void scheduledTransitionDurationChanged(); + private: MonitorPrivate *d; }; diff --git a/applets/nightcolor/plugin/monitor.cpp b/applets/nightcolor/plugin/monitor.cpp --- a/applets/nightcolor/plugin/monitor.cpp +++ b/applets/nightcolor/plugin/monitor.cpp @@ -109,8 +109,80 @@ return m_targetTemperature; } +int MonitorPrivate::operationMode() const +{ + return m_operationMode; +} + +void MonitorPrivate::setOperationMode(int mode) +{ + if (m_operationMode == mode) { + return; + } + m_operationMode = mode; + emit operationModeChanged(); +} + +QDateTime MonitorPrivate::previousTransitionDateTime() const +{ + return m_previousTransitionDateTime; +} + +void MonitorPrivate::setPreviousTransitionDateTime(const QDateTime &dateTime) +{ + if (m_previousTransitionDateTime == dateTime) { + return; + } + m_previousTransitionDateTime = dateTime; + emit previousTransitionDateTimeChanged(); +} + +quint32 MonitorPrivate::previousTransitionDuration() const +{ + return m_previousTransitionDuration; +} + +void MonitorPrivate::setPreviousTransitionDuration(quint32 milliseconds) +{ + if (m_previousTransitionDuration == milliseconds) { + return; + } + m_previousTransitionDuration = milliseconds; + emit previousTransitionDurationChanged(); +} + +QDateTime MonitorPrivate::scheduledTransitionDateTime() const +{ + return m_scheduledTransitionDateTime; +} + +void MonitorPrivate::setScheduledTransitionDateTime(const QDateTime &dateTime) +{ + if (m_scheduledTransitionDateTime == dateTime) { + return; + } + m_scheduledTransitionDateTime = dateTime; + emit scheduledTransitionDateTimeChanged(); +} + +quint32 MonitorPrivate::scheduledTransitionDuration() const +{ + return m_scheduledTransitionDuration; +} + +void MonitorPrivate::setScheduledTransitionDuration(quint32 milliseconds) +{ + if (m_scheduledTransitionDuration == milliseconds) { + return; + } + m_scheduledTransitionDuration = milliseconds; + emit scheduledTransitionDurationChanged(); +} + void MonitorPrivate::updateProperties(const QVariantMap &properties) { + // TODO: Find the most optimal way to update our properties. + const QVariant available = properties.value(QStringLiteral("available")); if (available.isValid()) { setAvailable(available.toBool()); @@ -135,6 +207,35 @@ if (targetTemperature.isValid()) { setTargetTemperature(targetTemperature.toInt()); } + + const QVariant operationMode = properties.value(QStringLiteral("mode")); + if (operationMode.isValid()) { + setOperationMode(operationMode.toInt()); + } + + const QVariant previousTransitionTimestamp = properties.value(QStringLiteral("previousTransitionDateTime")); + if (previousTransitionTimestamp.isValid()) { + const quint64 unixTimestamp = previousTransitionTimestamp.value(); + const QDateTime dateTime = QDateTime::fromSecsSinceEpoch(qint64(unixTimestamp)); + setPreviousTransitionDateTime(dateTime); + } + + const QVariant previousTransitionDuration = properties.value(QStringLiteral("previousTransitionDuration")); + if (previousTransitionDuration.isValid()) { + setPreviousTransitionDuration(previousTransitionDuration.value()); + } + + const QVariant scheduledTransitionTimestamp = properties.value(QStringLiteral("scheduledTransitionDateTime")); + if (scheduledTransitionTimestamp.isValid()) { + const quint64 unixTimestamp = scheduledTransitionTimestamp.value(); + const QDateTime dateTime = QDateTime::fromSecsSinceEpoch(qint64(unixTimestamp)); + setScheduledTransitionDateTime(dateTime); + } + + const QVariant scheduledTransitionDuration = properties.value(QStringLiteral("scheduledTransitionDuration")); + if (scheduledTransitionDuration.isValid()) { + setScheduledTransitionDuration(scheduledTransitionDuration.value()); + } } void MonitorPrivate::setCurrentTemperature(int temperature) @@ -206,6 +307,11 @@ connect(d, &MonitorPrivate::runningChanged, this, &Monitor::runningChanged); connect(d, &MonitorPrivate::currentTemperatureChanged, this, &Monitor::currentTemperatureChanged); connect(d, &MonitorPrivate::targetTemperatureChanged, this, &Monitor::targetTemperatureChanged); + connect(d, &MonitorPrivate::operationModeChanged, this, &Monitor::operationModeChanged); + connect(d, &MonitorPrivate::previousTransitionDateTimeChanged, this, &Monitor::previousTransitionDateTimeChanged); + connect(d, &MonitorPrivate::previousTransitionDurationChanged, this, &Monitor::previousTransitionDurationChanged); + connect(d, &MonitorPrivate::scheduledTransitionDateTimeChanged, this, &Monitor::scheduledTransitionDateTimeChanged); + connect(d, &MonitorPrivate::scheduledTransitionDurationChanged, this, &Monitor::scheduledTransitionDurationChanged); } Monitor::~Monitor() @@ -236,3 +342,28 @@ { return d->targetTemperature(); } + +Monitor::OperationMode Monitor::operationMode() const +{ + return OperationMode(d->operationMode()); +} + +QDateTime Monitor::previousTransitionDateTime() const +{ + return d->previousTransitionDateTime(); +} + +quint32 Monitor::previousTransitionDuration() const +{ + return d->previousTransitionDuration(); +} + +QDateTime Monitor::scheduledTransitionDateTime() const +{ + return d->scheduledTransitionDateTime(); +} + +quint32 Monitor::scheduledTransitionDuration() const +{ + return d->scheduledTransitionDuration(); +} diff --git a/applets/nightcolor/plugin/monitor_p.h b/applets/nightcolor/plugin/monitor_p.h --- a/applets/nightcolor/plugin/monitor_p.h +++ b/applets/nightcolor/plugin/monitor_p.h @@ -17,6 +17,7 @@ #pragma once +#include #include class MonitorPrivate : public QObject @@ -32,13 +33,23 @@ bool isAvailable() const; bool isEnabled() const; bool isRunning() const; + int operationMode() const; + QDateTime previousTransitionDateTime() const; + quint32 previousTransitionDuration() const; + QDateTime scheduledTransitionDateTime() const; + quint32 scheduledTransitionDuration() const; Q_SIGNALS: void currentTemperatureChanged(); void targetTemperatureChanged(); void availableChanged(); void enabledChanged(); void runningChanged(); + void operationModeChanged(); + void previousTransitionDateTimeChanged(); + void previousTransitionDurationChanged(); + void scheduledTransitionDateTimeChanged(); + void scheduledTransitionDurationChanged(); private Q_SLOTS: void handleServiceRegistered(); @@ -54,10 +65,20 @@ void setAvailable(bool available); void setEnabled(bool enabled); void setRunning(bool running); + void setOperationMode(int mode); + void setPreviousTransitionDateTime(const QDateTime &dateTime); + void setPreviousTransitionDuration(quint32 milliseconds); + void setScheduledTransitionDateTime(const QDateTime &dateTime); + void setScheduledTransitionDuration(quint32 milliseconds); + QDateTime m_previousTransitionDateTime; + QDateTime m_scheduledTransitionDateTime; int m_currentTemperature = 0; int m_targetTemperature = 0; + int m_operationMode = 0; bool m_isAvailable = false; bool m_isEnabled = false; bool m_isRunning = false; + quint32 m_previousTransitionDuration = 0; + quint32 m_scheduledTransitionDuration = 0; };