mirror of
https://github.com/AvengeMedia/DankMaterialShell.git
synced 2025-12-07 05:55:37 -05:00
705 lines
25 KiB
QML
705 lines
25 KiB
QML
import QtQuick
|
|
import Quickshell
|
|
import Quickshell.Io
|
|
import qs.Common
|
|
pragma Singleton
|
|
pragma ComponentBehavior
|
|
|
|
Singleton {
|
|
id: root
|
|
|
|
property bool brightnessAvailable: devices.length > 0
|
|
property var devices: []
|
|
property var ddcDevices: []
|
|
property var deviceBrightness: ({})
|
|
property var ddcPendingInit: ({})
|
|
property string currentDevice: ""
|
|
property string lastIpcDevice: ""
|
|
property bool ddcAvailable: false
|
|
property var ddcInitQueue: []
|
|
property bool skipDdcRead: false
|
|
property int brightnessLevel: {
|
|
const deviceToUse = lastIpcDevice === "" ? getDefaultDevice() : (lastIpcDevice || currentDevice);
|
|
if (!deviceToUse) return 50;
|
|
|
|
const deviceInfo = getCurrentDeviceInfoByName(deviceToUse);
|
|
if (deviceInfo && deviceInfo.class === "ddc") {
|
|
if (ddcPendingInit[deviceToUse]) {
|
|
return deviceBrightness[deviceToUse] || 50;
|
|
}
|
|
return deviceBrightness[deviceToUse] || 50;
|
|
}
|
|
|
|
// For non-DDC devices, don't use cache - they're fast to read
|
|
return deviceBrightness[deviceToUse] || 50;
|
|
}
|
|
property int maxBrightness: 100
|
|
property bool brightnessInitialized: false
|
|
|
|
signal brightnessChanged()
|
|
signal deviceSwitched()
|
|
|
|
property bool nightModeActive: false
|
|
|
|
function setBrightnessInternal(percentage, device) {
|
|
const clampedValue = Math.max(1, Math.min(100, percentage));
|
|
const actualDevice = device === "" ? getDefaultDevice() : (device || currentDevice || getDefaultDevice());
|
|
|
|
// Update the device brightness cache
|
|
const deviceInfo = getCurrentDeviceInfoByName(actualDevice);
|
|
if (actualDevice && deviceInfo && deviceInfo.class === "ddc") {
|
|
// Always cache DDC values since we never read them again
|
|
var newBrightness = Object.assign({}, deviceBrightness);
|
|
newBrightness[actualDevice] = clampedValue;
|
|
deviceBrightness = newBrightness;
|
|
}
|
|
|
|
if (deviceInfo && deviceInfo.class === "ddc") {
|
|
// Use ddcutil for DDC devices
|
|
ddcBrightnessSetProcess.command = ["ddcutil", "setvcp", "-d", String(deviceInfo.ddcDisplay), "10", String(clampedValue)];
|
|
ddcBrightnessSetProcess.running = true;
|
|
} else {
|
|
// Use brightnessctl for regular devices
|
|
if (device)
|
|
brightnessSetProcess.command = ["brightnessctl", "-d", device, "set", clampedValue + "%"];
|
|
else
|
|
brightnessSetProcess.command = ["brightnessctl", "set", clampedValue + "%"];
|
|
brightnessSetProcess.running = true;
|
|
}
|
|
}
|
|
|
|
function setBrightness(percentage, device) {
|
|
setBrightnessInternal(percentage, device);
|
|
brightnessChanged();
|
|
}
|
|
|
|
function setCurrentDevice(deviceName, saveToSession = false) {
|
|
if (currentDevice === deviceName)
|
|
return ;
|
|
|
|
currentDevice = deviceName;
|
|
lastIpcDevice = deviceName;
|
|
|
|
// Only save to session if explicitly requested (user choice)
|
|
if (saveToSession) {
|
|
SessionData.setLastBrightnessDevice(deviceName);
|
|
}
|
|
|
|
deviceSwitched();
|
|
|
|
// Check if this is a DDC device
|
|
const deviceInfo = getCurrentDeviceInfoByName(deviceName);
|
|
if (deviceInfo && deviceInfo.class === "ddc") {
|
|
// For DDC devices, never read after initial - just use cached values
|
|
return;
|
|
} else {
|
|
// For regular devices, use brightnessctl
|
|
brightnessGetProcess.command = ["brightnessctl", "-m", "-d", deviceName, "get"];
|
|
brightnessGetProcess.running = true;
|
|
}
|
|
}
|
|
|
|
function refreshDevices() {
|
|
deviceListProcess.running = true;
|
|
}
|
|
|
|
function refreshDevicesInternal() {
|
|
const allDevices = [...devices, ...ddcDevices];
|
|
|
|
allDevices.sort((a, b) => {
|
|
if (a.class === "backlight" && b.class !== "backlight")
|
|
return -1;
|
|
if (a.class !== "backlight" && b.class === "backlight")
|
|
return 1;
|
|
|
|
if (a.class === "ddc" && b.class !== "ddc" && b.class !== "backlight")
|
|
return -1;
|
|
if (a.class !== "ddc" && b.class === "ddc" && a.class !== "backlight")
|
|
return 1;
|
|
|
|
return a.name.localeCompare(b.name);
|
|
});
|
|
|
|
devices = allDevices;
|
|
|
|
if (devices.length > 0 && !currentDevice) {
|
|
const lastDevice = SessionData.lastBrightnessDevice || "";
|
|
const deviceExists = devices.some(d => d.name === lastDevice);
|
|
if (deviceExists) {
|
|
setCurrentDevice(lastDevice, false);
|
|
} else {
|
|
const nonKbdDevice = devices.find(d => !d.name.includes("kbd")) || devices[0];
|
|
setCurrentDevice(nonKbdDevice.name, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
function getDeviceBrightness(deviceName) {
|
|
return deviceBrightness[deviceName] || 50;
|
|
}
|
|
|
|
function getDefaultDevice() {
|
|
for (const device of devices) {
|
|
if (device.class === "backlight") {
|
|
return device.name;
|
|
}
|
|
}
|
|
return devices.length > 0 ? devices[0].name : "";
|
|
}
|
|
|
|
function getCurrentDeviceInfo() {
|
|
const deviceToUse = lastIpcDevice === "" ? getDefaultDevice() : (lastIpcDevice || currentDevice);
|
|
if (!deviceToUse) return null;
|
|
|
|
for (const device of devices) {
|
|
if (device.name === deviceToUse) {
|
|
return device;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function isCurrentDeviceReady() {
|
|
const deviceToUse = lastIpcDevice === "" ? getDefaultDevice() : (lastIpcDevice || currentDevice);
|
|
if (!deviceToUse) return false;
|
|
|
|
if (ddcPendingInit[deviceToUse]) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function getCurrentDeviceInfoByName(deviceName) {
|
|
if (!deviceName) return null;
|
|
|
|
for (const device of devices) {
|
|
if (device.name === deviceName) {
|
|
return device;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function processNextDdcInit() {
|
|
if (ddcInitQueue.length === 0 || ddcInitialBrightnessProcess.running) {
|
|
return;
|
|
}
|
|
|
|
const displayId = ddcInitQueue.shift();
|
|
ddcInitialBrightnessProcess.command = ["ddcutil", "getvcp", "-d", String(displayId), "10", "--brief"];
|
|
ddcInitialBrightnessProcess.running = true;
|
|
}
|
|
|
|
|
|
function enableNightMode() {
|
|
if (nightModeActive) return;
|
|
|
|
// Test if gammastep exists before enabling
|
|
gammaStepTestProcess.running = true;
|
|
}
|
|
|
|
function updateNightModeTemperature(temperature) {
|
|
SessionData.setNightModeTemperature(temperature);
|
|
|
|
// If night mode is active, restart it with new temperature
|
|
if (nightModeActive) {
|
|
// Temporarily disable and re-enable to restart with new temp
|
|
nightModeActive = false;
|
|
Qt.callLater(() => {
|
|
if (SessionData.nightModeEnabled) {
|
|
nightModeActive = true;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
function disableNightMode() {
|
|
nightModeActive = false;
|
|
SessionData.setNightModeEnabled(false);
|
|
|
|
// Also kill any stray gammastep processes
|
|
Quickshell.execDetached(["pkill", "gammastep"]);
|
|
}
|
|
|
|
function toggleNightMode() {
|
|
if (nightModeActive) {
|
|
disableNightMode();
|
|
} else {
|
|
enableNightMode();
|
|
}
|
|
}
|
|
|
|
|
|
Component.onCompleted: {
|
|
ddcDetectionProcess.running = true;
|
|
refreshDevices();
|
|
|
|
// Check if night mode was enabled on startup
|
|
if (SessionData.nightModeEnabled) {
|
|
enableNightMode();
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: ddcDetectionProcess
|
|
|
|
command: ["which", "ddcutil"]
|
|
running: false
|
|
|
|
onExited: function(exitCode) {
|
|
ddcAvailable = (exitCode === 0);
|
|
if (ddcAvailable) {
|
|
console.log("BrightnessService: ddcutil detected");
|
|
ddcDisplayDetectionProcess.running = true;
|
|
} else {
|
|
console.log("BrightnessService: ddcutil not available");
|
|
}
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: ddcDisplayDetectionProcess
|
|
|
|
command: ["bash", "-c", "ddcutil detect --brief 2>/dev/null | grep '^Display [0-9]' | awk '{print \"{\\\"display\\\":\" $2 \",\\\"name\\\":\\\"ddc-\" $2 \"\\\",\\\"class\\\":\\\"ddc\\\"}\"}' | tr '\\n' ',' | sed 's/,$//' | sed 's/^/[/' | sed 's/$/]/' || echo '[]'"]
|
|
running: false
|
|
|
|
stdout: StdioCollector {
|
|
onStreamFinished: {
|
|
if (!text.trim()) {
|
|
console.log("BrightnessService: No DDC displays found");
|
|
ddcDevices = [];
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const parsedDevices = JSON.parse(text.trim());
|
|
const newDdcDevices = [];
|
|
|
|
for (const device of parsedDevices) {
|
|
if (device.display && device.class === "ddc") {
|
|
newDdcDevices.push({
|
|
"name": device.name,
|
|
"class": "ddc",
|
|
"current": 50,
|
|
"percentage": 50,
|
|
"max": 100,
|
|
"ddcDisplay": device.display
|
|
});
|
|
}
|
|
}
|
|
|
|
ddcDevices = newDdcDevices;
|
|
console.log("BrightnessService: Found", ddcDevices.length, "DDC displays");
|
|
|
|
// Queue initial brightness readings for DDC devices
|
|
ddcInitQueue = [];
|
|
for (const device of ddcDevices) {
|
|
ddcInitQueue.push(device.ddcDisplay);
|
|
// Mark DDC device as pending initialization
|
|
ddcPendingInit[device.name] = true;
|
|
}
|
|
|
|
// Start processing the queue
|
|
processNextDdcInit();
|
|
|
|
// Refresh device list to include DDC devices
|
|
refreshDevicesInternal();
|
|
|
|
// Retry setting last device now that DDC devices are available
|
|
const lastDevice = SessionData.lastBrightnessDevice || "";
|
|
if (lastDevice) {
|
|
const deviceExists = devices.some(d => d.name === lastDevice);
|
|
if (deviceExists && (!currentDevice || currentDevice !== lastDevice)) {
|
|
setCurrentDevice(lastDevice, false);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.warn("BrightnessService: Failed to parse DDC devices:", error);
|
|
ddcDevices = [];
|
|
}
|
|
}
|
|
}
|
|
|
|
onExited: function(exitCode) {
|
|
if (exitCode !== 0) {
|
|
console.warn("BrightnessService: Failed to detect DDC displays:", exitCode);
|
|
ddcDevices = [];
|
|
}
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: deviceListProcess
|
|
|
|
command: ["brightnessctl", "-m", "-l"]
|
|
onExited: function(exitCode) {
|
|
if (exitCode !== 0) {
|
|
console.warn("BrightnessService: Failed to list devices:", exitCode);
|
|
brightnessAvailable = false;
|
|
}
|
|
}
|
|
|
|
stdout: StdioCollector {
|
|
onStreamFinished: {
|
|
if (!text.trim()) {
|
|
console.warn("BrightnessService: No devices found");
|
|
return ;
|
|
}
|
|
const lines = text.trim().split("\n");
|
|
const newDevices = [];
|
|
for (const line of lines) {
|
|
const parts = line.split(",");
|
|
if (parts.length >= 5)
|
|
newDevices.push({
|
|
"name": parts[0],
|
|
"class": parts[1],
|
|
"current": parseInt(parts[2]),
|
|
"percentage": parseInt(parts[3]),
|
|
"max": parseInt(parts[4])
|
|
});
|
|
|
|
}
|
|
// Store brightnessctl devices separately, will be combined with DDC
|
|
const brightnessCtlDevices = newDevices;
|
|
devices = brightnessCtlDevices;
|
|
|
|
// If we have DDC devices, combine them
|
|
if (ddcDevices.length > 0) {
|
|
refreshDevicesInternal();
|
|
} else if (devices.length > 0 && !currentDevice) {
|
|
// Try to restore last selected device, fallback to first device
|
|
const lastDevice = SessionData.lastBrightnessDevice || "";
|
|
const deviceExists = devices.some(d => d.name === lastDevice);
|
|
if (deviceExists) {
|
|
setCurrentDevice(lastDevice, false);
|
|
} else {
|
|
const nonKbdDevice = devices.find(d => !d.name.includes("kbd")) || devices[0];
|
|
setCurrentDevice(nonKbdDevice.name, false);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
Process {
|
|
id: brightnessSetProcess
|
|
|
|
running: false
|
|
onExited: function(exitCode) {
|
|
if (exitCode !== 0)
|
|
console.warn("BrightnessService: Failed to set brightness:", exitCode);
|
|
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: ddcBrightnessSetProcess
|
|
|
|
running: false
|
|
onExited: function(exitCode) {
|
|
if (exitCode !== 0)
|
|
console.warn("BrightnessService: Failed to set DDC brightness:", exitCode);
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: ddcInitialBrightnessProcess
|
|
|
|
running: false
|
|
onExited: function(exitCode) {
|
|
if (exitCode !== 0)
|
|
console.warn("BrightnessService: Failed to get initial DDC brightness:", exitCode);
|
|
|
|
processNextDdcInit();
|
|
}
|
|
|
|
stdout: StdioCollector {
|
|
onStreamFinished: {
|
|
if (!text.trim())
|
|
return;
|
|
|
|
const parts = text.trim().split(" ");
|
|
if (parts.length >= 5) {
|
|
const current = parseInt(parts[3]) || 50;
|
|
const max = parseInt(parts[4]) || 100;
|
|
const brightness = Math.round((current / max) * 100);
|
|
|
|
const commandParts = ddcInitialBrightnessProcess.command;
|
|
if (commandParts && commandParts.length >= 4) {
|
|
const displayId = commandParts[3];
|
|
const deviceName = "ddc-" + displayId;
|
|
|
|
var newBrightness = Object.assign({}, deviceBrightness);
|
|
newBrightness[deviceName] = brightness;
|
|
deviceBrightness = newBrightness;
|
|
|
|
var newPending = Object.assign({}, ddcPendingInit);
|
|
delete newPending[deviceName];
|
|
ddcPendingInit = newPending;
|
|
|
|
console.log("BrightnessService: Initial DDC Device", deviceName, "brightness:", brightness + "%");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: brightnessGetProcess
|
|
|
|
running: false
|
|
onExited: function(exitCode) {
|
|
if (exitCode !== 0)
|
|
console.warn("BrightnessService: Failed to get brightness:", exitCode);
|
|
|
|
}
|
|
|
|
stdout: StdioCollector {
|
|
onStreamFinished: {
|
|
if (!text.trim())
|
|
return ;
|
|
|
|
const parts = text.trim().split(",");
|
|
if (parts.length >= 5) {
|
|
const current = parseInt(parts[2]);
|
|
const max = parseInt(parts[4]);
|
|
maxBrightness = max;
|
|
const brightness = Math.round((current / max) * 100);
|
|
|
|
// Update the device brightness cache
|
|
if (currentDevice) {
|
|
var newBrightness = deviceBrightness;
|
|
newBrightness[currentDevice] = brightness;
|
|
deviceBrightness = newBrightness;
|
|
}
|
|
|
|
brightnessInitialized = true;
|
|
console.log("BrightnessService: Device", currentDevice, "brightness:", brightness + "%");
|
|
brightnessChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
Process {
|
|
id: ddcBrightnessGetProcess
|
|
|
|
running: false
|
|
onExited: function(exitCode) {
|
|
if (exitCode !== 0)
|
|
console.warn("BrightnessService: Failed to get DDC brightness:", exitCode);
|
|
}
|
|
|
|
stdout: StdioCollector {
|
|
onStreamFinished: {
|
|
if (!text.trim())
|
|
return;
|
|
|
|
// Parse ddcutil getvcp output format: "VCP 10 C 50 100"
|
|
const parts = text.trim().split(" ");
|
|
if (parts.length >= 5) {
|
|
const current = parseInt(parts[3]) || 50;
|
|
const max = parseInt(parts[4]) || 100;
|
|
maxBrightness = max;
|
|
const brightness = Math.round((current / max) * 100);
|
|
|
|
// Update the device brightness cache
|
|
if (currentDevice) {
|
|
var newBrightness = deviceBrightness;
|
|
newBrightness[currentDevice] = brightness;
|
|
deviceBrightness = newBrightness;
|
|
}
|
|
|
|
brightnessInitialized = true;
|
|
console.log("BrightnessService: DDC Device", currentDevice, "brightness:", brightness + "%");
|
|
brightnessChanged();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: gammaStepTestProcess
|
|
|
|
command: ["which", "gammastep"]
|
|
running: false
|
|
|
|
onExited: function(exitCode) {
|
|
if (exitCode === 0) {
|
|
// gammastep exists, enable night mode
|
|
nightModeActive = true;
|
|
SessionData.setNightModeEnabled(true);
|
|
} else {
|
|
// gammastep not found
|
|
console.warn("BrightnessService: gammastep not found");
|
|
ToastService.showWarning("Night mode failed: gammastep not found");
|
|
}
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: gammaStepProcess
|
|
|
|
command: {
|
|
const temperature = SessionData.nightModeTemperature || 4500;
|
|
return ["gammastep", "-m", "wayland", "-O", String(temperature)];
|
|
}
|
|
running: nightModeActive
|
|
|
|
onExited: function(exitCode) {
|
|
// If process exits with non-zero code while we think it should be running
|
|
if (nightModeActive && exitCode !== 0) {
|
|
console.warn("BrightnessService: Night mode process crashed with exit code:", exitCode);
|
|
nightModeActive = false;
|
|
SessionData.setNightModeEnabled(false);
|
|
ToastService.showWarning("Night mode failed: process crashed");
|
|
}
|
|
}
|
|
}
|
|
|
|
// IPC Handler for external control
|
|
IpcHandler {
|
|
function set(percentage: string, device: string) : string {
|
|
if (!root.brightnessAvailable)
|
|
return "Brightness control not available";
|
|
|
|
const value = parseInt(percentage);
|
|
const clampedValue = Math.max(1, Math.min(100, value));
|
|
const targetDevice = device || "";
|
|
root.lastIpcDevice = targetDevice;
|
|
if (targetDevice && targetDevice !== root.currentDevice) {
|
|
root.setCurrentDevice(targetDevice, false);
|
|
}
|
|
root.setBrightness(clampedValue, targetDevice);
|
|
if (targetDevice)
|
|
return "Brightness set to " + clampedValue + "% on " + targetDevice;
|
|
else
|
|
return "Brightness set to " + clampedValue + "%";
|
|
}
|
|
|
|
function increment(step: string, device: string) : string {
|
|
if (!root.brightnessAvailable)
|
|
return "Brightness control not available";
|
|
|
|
const targetDevice = device || "";
|
|
const actualDevice = targetDevice === "" ? root.getDefaultDevice() : targetDevice;
|
|
const currentLevel = actualDevice ? root.getDeviceBrightness(actualDevice) : root.brightnessLevel;
|
|
const stepValue = parseInt(step || "10");
|
|
const newLevel = Math.max(1, Math.min(100, currentLevel + stepValue));
|
|
root.lastIpcDevice = targetDevice;
|
|
if (targetDevice && targetDevice !== root.currentDevice) {
|
|
root.setCurrentDevice(targetDevice, false);
|
|
}
|
|
root.setBrightness(newLevel, targetDevice);
|
|
if (targetDevice)
|
|
return "Brightness increased to " + newLevel + "% on " + targetDevice;
|
|
else
|
|
return "Brightness increased to " + newLevel + "%";
|
|
}
|
|
|
|
function decrement(step: string, device: string) : string {
|
|
if (!root.brightnessAvailable)
|
|
return "Brightness control not available";
|
|
|
|
const targetDevice = device || "";
|
|
const actualDevice = targetDevice === "" ? root.getDefaultDevice() : targetDevice;
|
|
const currentLevel = actualDevice ? root.getDeviceBrightness(actualDevice) : root.brightnessLevel;
|
|
const stepValue = parseInt(step || "10");
|
|
const newLevel = Math.max(1, Math.min(100, currentLevel - stepValue));
|
|
root.lastIpcDevice = targetDevice;
|
|
if (targetDevice && targetDevice !== root.currentDevice) {
|
|
root.setCurrentDevice(targetDevice, false);
|
|
}
|
|
root.setBrightness(newLevel, targetDevice);
|
|
if (targetDevice)
|
|
return "Brightness decreased to " + newLevel + "% on " + targetDevice;
|
|
else
|
|
return "Brightness decreased to " + newLevel + "%";
|
|
}
|
|
|
|
function status() : string {
|
|
if (!root.brightnessAvailable)
|
|
return "Brightness control not available";
|
|
|
|
return "Device: " + root.currentDevice + " - Brightness: " + root.brightnessLevel + "%";
|
|
}
|
|
|
|
function list() : string {
|
|
if (!root.brightnessAvailable)
|
|
return "No brightness devices available";
|
|
|
|
let result = "Available devices:\n";
|
|
for (const device of root.devices) {
|
|
result += device.name + " (" + device.class + ")\n";
|
|
}
|
|
return result;
|
|
}
|
|
|
|
target: "brightness"
|
|
}
|
|
|
|
// IPC Handler for night mode control
|
|
IpcHandler {
|
|
function toggle() : string {
|
|
root.toggleNightMode();
|
|
return root.nightModeActive ? "Night mode enabled" : "Night mode disabled";
|
|
}
|
|
|
|
function enable() : string {
|
|
root.enableNightMode();
|
|
return "Night mode enabled";
|
|
}
|
|
|
|
function disable() : string {
|
|
root.disableNightMode();
|
|
return "Night mode disabled";
|
|
}
|
|
|
|
function status() : string {
|
|
return root.nightModeActive ? "Night mode is enabled" : "Night mode is disabled";
|
|
}
|
|
|
|
function temperature(value: string) : string {
|
|
if (!value) {
|
|
return "Current temperature: " + SessionData.nightModeTemperature + "K";
|
|
}
|
|
|
|
const temp = parseInt(value);
|
|
if (isNaN(temp)) {
|
|
return "Invalid temperature. Use a value between 2500 and 6000 (in steps of 500)";
|
|
}
|
|
|
|
// Validate temperature is in valid range and steps
|
|
if (temp < 2500 || temp > 6000) {
|
|
return "Temperature must be between 2500K and 6000K";
|
|
}
|
|
|
|
// Round to nearest 500
|
|
const rounded = Math.round(temp / 500) * 500;
|
|
|
|
SessionData.setNightModeTemperature(rounded);
|
|
|
|
// If night mode is active, restart it with new temperature
|
|
if (root.nightModeActive) {
|
|
root.nightModeActive = false;
|
|
Qt.callLater(() => {
|
|
root.nightModeActive = true;
|
|
});
|
|
}
|
|
|
|
if (rounded !== temp) {
|
|
return "Night mode temperature set to " + rounded + "K (rounded from " + temp + "K)";
|
|
} else {
|
|
return "Night mode temperature set to " + rounded + "K";
|
|
}
|
|
}
|
|
|
|
target: "night"
|
|
}
|
|
|
|
}
|