repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by admin
quickshell/nuguland/features/brightness/Brightness.qml
Rawimport QtQuick
import Quickshell
import Quickshell.Io
import "../.."
import "../osd"
import "brightness.js" as Brightness
import "adaptive-brightness.js" as Adaptive
Item {
id: root
property Osd osdService
property Niri niriService
property Privilege privilegeService
property AmbientLight ambientLightService: null
property var adaptiveConfig: Adaptive.normalizeConfig(null)
property bool persistenceReady: false
property string persistenceError: ""
property int currentBucket: -1
property var adaptiveRaw: null
property var adaptiveSmoothed: null
property real adaptiveReadAt: 0
property string adaptiveSignature: ""
property string adaptiveError: ""
property bool adaptiveUnsafe: false
property int adaptiveGeneration: 0
property var adaptiveTransitions: ({})
property int adaptiveTransitionStep: 0
property bool adaptiveReapplyNeeded: false
readonly property bool adaptiveTransitioning: Object.keys(adaptiveTransitions).length > 0
property int adaptiveSampleEpoch: 0
property int adaptiveRequestedEpoch: -1
property bool adaptiveReadPending: false
// A sample older than this stops adaptation; motion eases over this many ticks.
readonly property int adaptiveSampleLifetime: 10000
readonly property int adaptiveSteps: 20
readonly property bool adaptiveEnabled: adaptiveConfig.enabled
readonly property var adaptiveThresholds: adaptiveConfig.thresholds
readonly property var adaptiveBuckets: Adaptive.buckets(adaptiveConfig)
readonly property var adaptiveRows: Brightness.displayRows({
"present": backlightPresent(),
"level": levelFraction()
}, outputRows(), ddcDisplays)
// Adaptive could run as soon as a sensor appears.
readonly property bool adaptiveEligible: setupReady && !setupRunning && adaptiveRows.some(row => row.kind === "ddc" && row.controllable)
readonly property bool adaptiveAvailable: !!ambientLightService && ambientLightService.found && adaptiveEligible
// Set by the registry while the popup is open.
property bool panelOpen: false
// Sensor discovery only while someone sees its state or adaptive mode needs it.
readonly property bool sensorWanted: panelOpen || (adaptiveEnabled && adaptiveEligible)
readonly property bool adaptiveSampling: persistenceReady && adaptiveEnabled && adaptiveAvailable && !adaptiveUnsafe
readonly property bool adaptiveActive: adaptiveSampling && currentBucket >= 0
onAdaptiveSamplingChanged: {
resetAdaptive();
}
onAmbientLightServiceChanged: resetAdaptive()
// Connector removal must invalidate queued work even when another DDC row remains.
readonly property string adaptiveTopology: adaptiveRows.filter(row => row.controllable).map(row => row.id).sort().join("|")
onAdaptiveTopologyChanged: resetAdaptive()
function resetAdaptive() {
adaptiveSampleEpoch++;
adaptiveGeneration++;
adaptiveTransitions = ({});
adaptiveTransitionStep = 0;
adaptiveReapplyNeeded = false;
writeQueue = writeQueue.filter(write => write.source !== "adaptive");
currentBucket = -1;
adaptiveRaw = null;
adaptiveSmoothed = null;
adaptiveReadAt = 0;
adaptiveSignature = "";
}
function saveAdaptive() {
if (persistenceReady)
adaptiveFile.setText(JSON.stringify(adaptiveConfig));
}
function loadAdaptive(text) {
try {
adaptiveConfig = Adaptive.normalizeConfig(JSON.parse(text));
} catch (error) {
persistenceError = "invalid adaptive settings";
}
persistenceReady = true;
}
function setAdaptiveEnabled(enabled) {
if (typeof enabled !== "boolean")
return stateJson();
resetAdaptive();
adaptiveUnsafe = false;
adaptiveError = "";
adaptiveConfig = Object.assign({}, adaptiveConfig, {
"enabled": enabled
});
saveAdaptive();
// Explicit retry also works when already enabled.
Qt.callLater(sampleAdaptive);
return stateJson();
}
function toggleAdaptive() {
return setAdaptiveEnabled(!adaptiveEnabled);
}
// True when the confirmed threshold now equals `value`; edits clamp between neighbours.
function setAdaptiveThreshold(index, value) {
const thresholds = Adaptive.editThreshold(adaptiveThresholds, index, value);
if (!thresholds)
return adaptiveThresholds[index] === value;
adaptiveConfig = Object.assign({}, adaptiveConfig, {
"thresholds": thresholds
});
saveAdaptive();
// Never change intent-time learning scope while editing an inactive bucket.
// Reclassify on the next terminal sample, not against old measurements.
adaptiveGeneration++;
adaptiveTransitions = ({});
adaptiveReapplyNeeded = true;
writeQueue = writeQueue.filter(write => write.source !== "adaptive");
return thresholds[index] === value;
}
function sampleAdaptive() {
if (adaptiveSampling && ambientLightService && !ambientLightService.busy) {
adaptiveRequestedEpoch = adaptiveSampleEpoch;
adaptiveReadPending = true;
ambientLightService.requestRead();
}
}
function acceptAdaptiveSample() {
const sensor = ambientLightService;
if (!sensor)
return;
if (sensor.restoreError || sensor.verificationError || sensor.cleanupError || sensor.restorationStatus === "unverified" || sensor.restorationStatus === "mismatch") {
adaptiveUnsafe = true;
adaptiveError = "sensor cleanup failed; toggle to retry";
resetAdaptive();
return;
}
const obsolete = adaptiveReadPending && adaptiveRequestedEpoch !== adaptiveSampleEpoch;
adaptiveReadPending = false;
if (!adaptiveSampling || obsolete)
return;
const timestamp = Date.parse(sensor.readAt);
if (sensor.status !== "ready" || sensor.errorCode || !isFinite(sensor.rawCount) || sensor.rawCount < 0 || !isFinite(timestamp) || Date.now() - timestamp >= adaptiveSampleLifetime || timestamp > Date.now()) {
adaptiveError = "sensor read failed";
resetAdaptive();
return;
}
const settings = sensor.effectiveSettings;
const signature = JSON.stringify([settings.channel, settings.frequencyPercent, settings.integrationTime]);
if (signature !== adaptiveSignature) {
resetAdaptive();
adaptiveSignature = signature;
}
adaptiveError = "";
adaptiveRaw = sensor.rawCount;
adaptiveReadAt = timestamp;
adaptiveSmoothed = Adaptive.smooth(adaptiveSmoothed, adaptiveRaw);
const next = Adaptive.bucket(adaptiveSmoothed, adaptiveThresholds, currentBucket);
if (next !== currentBucket || adaptiveReapplyNeeded) {
adaptiveReapplyNeeded = false;
currentBucket = next;
adaptiveGeneration++;
writeQueue = writeQueue.filter(write => write.source !== "adaptive");
applyAdaptive();
}
}
function applyAdaptive() {
if (!adaptiveActive)
return;
const transitions = {};
for (const row of adaptiveRows) {
if (!row.controllable)
continue;
// Do not fight a drag or a pending manual intent, even across buckets.
if ((writePending && activeWrite.id === row.id && activeWrite.source === "manual") || writeQueue.some(write => write.id === row.id && write.source === "manual"))
continue;
const actual = deviceLevel(row, Adaptive.target(adaptiveConfig, row.id, currentBucket));
if (Math.abs(row.level - actual) < 0.000001 && !(writePending && activeWrite.id === row.id && activeWrite.source === "adaptive"))
continue;
transitions[row.id] = {
"from": row.level,
"target": actual,
"bucket": currentBucket,
"generation": adaptiveGeneration
};
}
adaptiveTransitions = transitions;
adaptiveTransitionStep = 0;
}
// The nearest level the device can show; a backlight never turns fully off.
function deviceLevel(row, level) {
const maximum = row.kind === "ddc" ? ddcDisplays[row.id.slice(4)].maximum : nativeMax();
return Math.max(row.kind === "ddc" ? 0 : 1, Math.round(level * maximum)) / maximum;
}
function cancelAdaptiveDisplay(id) {
const transitions = Object.assign({}, adaptiveTransitions);
delete transitions[id];
adaptiveTransitions = transitions;
writeQueue = writeQueue.filter(write => write.id !== id || write.source !== "adaptive");
}
function advanceAdaptive() {
if (!adaptiveActive || writePending || writeQueue.length)
return;
if (Date.now() - adaptiveReadAt >= adaptiveSampleLifetime) {
adaptiveError = "sensor sample stale";
resetAdaptive();
return;
}
adaptiveTransitionStep = Math.min(adaptiveSteps, adaptiveTransitionStep + 1);
for (const id of Object.keys(adaptiveTransitions)) {
const transition = adaptiveTransitions[id];
const row = adaptiveRows.find(display => display.id === id && display.controllable);
if (!row) {
cancelAdaptiveDisplay(id);
continue;
}
const level = deviceLevel(row, Adaptive.easedLevel(transition.from, transition.target, adaptiveTransitionStep / adaptiveSteps));
if (Math.abs(row.level - level) >= 0.000001)
enqueueWrite(id, level, "adaptive", transition.bucket, transition.generation);
else if (adaptiveTransitionStep === adaptiveSteps)
cancelAdaptiveDisplay(id);
}
}
property var setupStages: Brightness.initialStages()
property bool setupRunning: false
property bool setupExpanded: false
property bool setupReady: false
property bool cancelRequested: false
property string stopReason: ""
property int setupEpoch: 0
property string setupStage: ""
property string setupError: ""
property var preflight: ({})
property string retryStage: ""
property var readQueue: []
property string readingName: ""
property string operation: ""
property bool operationPending: false
property string operationOutput: ""
property bool privilegedEntered: false
property var writeQueue: []
property var activeWrite: ({})
property bool writePending: false
property string writeOutput: ""
property string devicePath: "/sys/class/backlight/intel_backlight"
property var ddcDisplays: ({})
property var lastAction: ({})
property var lastOsd: ({})
// Last confirmed native write; failures never replace the previous level.
property real liveLevel: -1
property string nativeError: ""
// Panel state; stateObject() reuses it for IPC.
readonly property var displays: Brightness.displayRows({
"present": backlightPresent(),
"level": Math.round(levelFraction() * 100) / 100,
"error": nativeError
}, outputRows(), ddcDisplays)
readonly property var globalState: Brightness.globalState(displays)
readonly property string globalMode: globalState.mode
readonly property real globalLevel: globalState.level
readonly property var globalLevels: globalState.levels
// Internal panels use backlight; only external displays need DDC setup.
readonly property bool setupNeeded: displays.some(row => row.kind === "ddc" && !row.controllable)
readonly property bool setupAvailable: !setupRunning && !writePending && writeQueue.length === 0
// Adaptive's heading row needs a light sensor route.
readonly property bool adaptiveRoute: ambientLightService !== null
function intText(text, fallback) {
const n = parseInt(String(text || "").trim(), 10);
return isFinite(n) ? n : fallback;
}
function backlightPresent() {
const maximum = String(maxFile.text() || "").trim();
const current = String(brightnessFile.text() || "").trim();
return /^\d+$/.test(maximum) && /^\d+$/.test(current) && Number(maximum) > 0 && Number(current) <= Number(maximum);
}
function nativeMax() {
return Math.max(1, intText(maxFile.text(), 1));
}
function nativeBrightness() {
return Math.max(1, intText(brightnessFile.text(), nativeMax()));
}
function levelFraction() {
if (!backlightPresent())
return 0;
if (liveLevel >= 0)
return Brightness.clampLevel(liveLevel);
return Brightness.clampLevel(nativeBrightness() / nativeMax());
}
function outputRows() {
return niriService ? niriService.outputList() : [];
}
// Without an OSD service, or on an unreadable reply, report the requested event.
function triggerOsd(value) {
const text = String(Brightness.levelPercent(value));
const requested = {
"event": "brightness",
"value": text
};
if (!osdService)
return requested;
try {
return osdService.trigger("brightness", text);
} catch (error) {
return requested;
}
}
function stateObject() {
return {
"level": globalLevel,
"adaptive": {
"enabled": adaptiveEnabled,
"available": adaptiveAvailable,
"active": adaptiveActive,
"transitioning": adaptiveTransitioning,
"currentBucket": currentBucket,
"raw": adaptiveRaw,
"smoothed": adaptiveSmoothed,
"thresholds": adaptiveThresholds,
"buckets": adaptiveBuckets,
"error": adaptiveError,
"persistenceError": persistenceError
},
"displays": displays,
"global": {
"mode": globalMode,
"level": globalLevel,
"levels": globalLevels
},
"setup": {
"needed": setupNeeded,
"available": setupAvailable,
"running": setupRunning,
"expanded": setupExpanded,
"ready": setupReady,
"stage": setupStage,
"stages": setupStages,
"error": setupError,
"cancelRequested": cancelRequested
},
"compact": {
"label": "brightness",
"role": Brightness.levelRole(globalLevel)
},
"pendingWrites": (writePending ? [activeWrite.id] : []).concat(writeQueue.map(write => write.id)),
"lastAction": lastAction,
"lastOsd": lastOsd
};
}
function stateJson() {
return JSON.stringify(stateObject());
}
function stage(id, status, error) {
setupStage = id;
setupStages = Brightness.stageState(setupStages, id, status, error || "");
}
function failSetup(message) {
setupError = Brightness.diagnostic(message);
const current = setupStages.find(item => item.id === setupStage);
// Cancellation between stages must not erase completed work.
if (!current || current.status !== "done")
stage(setupStage, "failed", setupError);
setupRunning = false;
}
function runOperation(kind, command) {
operation = kind;
operationOutput = "";
operationPending = true;
setupProcess.command = command;
setupProcess.running = true;
}
function deferSetup(next) {
const epoch = setupEpoch;
Qt.callLater(() => {
if (setupRunning && !cancelRequested && epoch === setupEpoch)
next();
});
}
function beginAuthorization() {
if (!setupRunning || cancelRequested)
return;
stage("authorization", "running");
if (!privilegeService || !privilegeService.polkitAgent || !privilegeService.polkitAgent.isRegistered) {
failSetup("authorization unavailable");
return;
}
if (privilegeService.polkitAgent.isActive) {
failSetup("authorization busy");
return;
}
// pkexec delegates to this registered native PolkitAgent automatically.
// No secret handoff, second agent, global authorized flag or detached job.
privilegedEntered = false;
runOperation("privileged", Brightness.privilegedCommand(!preflight.installed));
authorizationDeadline.restart();
}
function beginDetection() {
stage("detection", "running");
runOperation("detect", Brightness.ddcCommand("detect"));
}
function beginReads() {
stage("reading", "running");
readQueue = Object.keys(ddcDisplays).filter(name => !ddcDisplays[name].controllable);
readNext();
}
function readNext() {
if (cancelRequested) {
failSetup(stopReason || "cancelled");
return;
}
if (readQueue.length === 0) {
const failedRead = Object.keys(ddcDisplays).some(name => !ddcDisplays[name].controllable && !!ddcDisplays[name].error);
if (failedRead) {
failSetup("read failed");
return;
}
stage("reading", "done");
stage("verification", "running");
const rows = displays.filter(row => row.kind === "ddc");
if (!rows.length || !rows.some(row => row.controllable)) {
failSetup("read failed");
} else if (rows.some(row => !row.controllable)) {
failSetup("some displays unavailable");
} else {
stage("verification", "done");
stage("ready", "done");
setupReady = true;
setupRunning = false;
setupExpanded = false;
}
return;
}
readingName = readQueue[0];
readQueue = readQueue.slice(1);
runOperation("read", Brightness.ddcCommand("read", ddcDisplays[readingName].bus));
}
function consumeOutput(data) {
operationOutput = (operationOutput + data + "\n").slice(0, 65536);
if (operation === "privileged" && data === "nugu:authorized") {
authorizationDeadline.stop();
if (cancelRequested) {
setupProcess.write("cancel\n");
return;
}
privilegedEntered = true;
stage("authorization", "done");
stage("installation", "running");
installationDeadline.restart();
setupProcess.write("continue\n");
}
}
function authorizationExpired() {
if (operationPending && operation === "privileged" && !privilegedEntered) {
cancelRequested = true;
stopReason = "timeout";
setupError = stopReason;
setupProcess.write("cancel\n");
setupProcess.running = false;
}
}
function installationExpired() {
if (operationPending && operation === "privileged" && privilegedEntered) {
cancelRequested = true;
stopReason = "timeout";
setupError = stopReason;
stage("installation", "failed", stopReason);
// Keep ownership until the package process actually exits. Its INT
// deadline permits pacman cleanup; never SIGKILL a package transaction.
}
}
function finishOperation(code) {
if (!operationPending)
return;
operationPending = false;
authorizationDeadline.stop();
installationDeadline.stop();
const kind = operation;
if (cancelRequested) {
failSetup(stopReason || "cancelled");
return;
}
if (kind === "preflight" || kind === "refresh" || kind === "retry-preflight") {
if (code !== 0) {
failSetup(Brightness.processError(code, "preflight failed"));
return;
}
preflight = Brightness.parsePreflight(operationOutput);
if (kind === "preflight" || kind === "retry-preflight") {
stage("preflight", "done");
if (preflight.needsPrivilege) {
deferSetup(beginAuthorization);
return;
}
stage("authorization", "done");
stage("installation", "done");
if (kind === "retry-preflight" && retryStage === "reading") {
deferSetup(beginReads);
return;
}
}
deferSetup(beginDetection);
} else if (kind === "privileged") {
if (code !== 0) {
failSetup(Brightness.processError(code, privilegedEntered ? "installation failed" : "authorization denied"));
return;
}
stage("installation", "done");
// New device nodes/ACLs and DRM links may have appeared.
deferSetup(() => runOperation("refresh", Brightness.preflightCommand()));
} else if (kind === "detect") {
// ddcutil may return nonzero for one invalid display. Keep successful buses.
const found = Brightness.parseDetection(operationOutput, preflight.connectors);
for (const name of Object.keys(found)) {
const previous = ddcDisplays[name];
if (previous && previous.bus === found[name].bus && previous.controllable)
found[name] = previous;
}
ddcDisplays = found;
if (!Object.keys(found).length) {
failSetup(Brightness.processError(code, code === 0 ? "no mapped displays" : "detection failed"));
return;
}
stage("detection", "done");
deferSetup(beginReads);
} else if (kind === "read") {
const reading = code === 0 ? Brightness.parseBrightness(operationOutput) : null;
const copy = Object.assign({}, ddcDisplays);
copy[readingName] = Object.assign({}, copy[readingName], reading || {}, {
"controllable": !!reading,
"error": reading ? "" : Brightness.processError(code, "read failed")
});
ddcDisplays = copy;
deferSetup(readNext);
}
}
function setupDdc() {
if (setupRunning || writePending || writeQueue.length)
return stateJson();
setupEpoch++;
setupExpanded = true;
setupRunning = true;
setupReady = false;
cancelRequested = false;
stopReason = "";
setupError = "";
setupStages = Brightness.initialStages();
stage("preflight", "running");
lastAction = {
"kind": "setup-ddc"
};
runOperation("preflight", Brightness.preflightCommand());
return stateJson();
}
function retrySetup() {
if (setupRunning || writePending || writeQueue.length)
return stateJson();
const failed = setupStage;
setupEpoch++;
setupRunning = true;
cancelRequested = false;
stopReason = "";
setupError = "";
retryStage = failed;
// Retained package/session changes are facts to re-read, not assumptions
// from the original attempt. Never authorize from a stale preflight.
stage("preflight", "running");
runOperation("retry-preflight", Brightness.preflightCommand());
return stateJson();
}
function cancelSetup() {
if (!setupRunning)
return stateJson();
setupEpoch++;
cancelRequested = true;
stopReason = "cancelled";
if (operationPending && operation === "privileged" && !privilegedEntered) {
setupProcess.write("cancel\n");
setupProcess.running = false;
} else if (operationPending && operation === "privileged") {
// A root transaction cannot safely be killed by this unprivileged owner.
// Keep tracking until exit; never claim rollback or release the busy guard.
setupError = "cancel requested; waiting for package setup";
} else if (!operationPending) {
failSetup(stopReason || "cancelled");
}
// Unprivileged commands already have short process-group deadlines.
return stateJson();
}
function toggleSetup() {
setupExpanded = !setupExpanded;
return stateJson();
}
function setDisplay(id, level) {
const row = displays.find(display => display.id === String(id));
if (setupRunning || !row || !row.controllable)
return stateJson();
cancelAdaptiveDisplay(String(id));
enqueueWrite(String(id), Brightness.clampLevel(level), "manual", adaptiveActive ? currentBucket : -1);
return stateJson();
}
function enqueueWrite(id, level, source, bucket, generation) {
const request = {
"id": id,
"level": level,
"source": source,
"bucket": bucket,
"generation": generation === undefined ? adaptiveGeneration : generation
};
// Coalesce slider motion per display; manual always replaces queued auto.
writeQueue = writeQueue.filter(write => write.id !== request.id).concat([request]);
startWrite();
}
function startWrite() {
if (writePending || !writeQueue.length)
return;
activeWrite = writeQueue[0];
writeQueue = writeQueue.slice(1);
const row = adaptiveRows.find(display => display.id === activeWrite.id);
if (setupRunning || !row || !row.controllable || (activeWrite.source === "adaptive" && (!adaptiveActive || activeWrite.generation !== adaptiveGeneration || Date.now() - adaptiveReadAt >= adaptiveSampleLifetime))) {
Qt.callLater(startWrite);
return;
}
let command;
if (activeWrite.id === "backlight") {
// Paths/values are positional arguments, never interpolated shell source.
const native = Math.max(1, Math.round(activeWrite.level * nativeMax()));
command = Brightness.timedCommand(5, ["/usr/bin/sh", "-c", "printf '%s\\n' \"$2\" > \"$1/brightness\" && /usr/bin/cat \"$1/brightness\"", "nugu-backlight", devicePath, String(native)]);
} else {
const state = ddcDisplays[activeWrite.id.slice(4)];
command = state && state.controllable ? Brightness.ddcCommand("write", state.bus, activeWrite.level, state.maximum) : [];
}
if (!command.length) {
finishWrite(1);
return;
}
writeOutput = "";
writePending = true;
writeProcess.command = command;
writeProcess.running = true;
}
function finishWrite(code) {
writePending = false;
const readback = String(writeOutput).trim();
const native = /^\d+$/.test(readback) ? Number(readback) : -1;
const success = code === 0 && (activeWrite.id !== "backlight" || (native >= 0 && native <= nativeMax()));
const error = success ? "" : Brightness.processError(code, "write failed");
if (activeWrite.id === "backlight") {
if (success)
liveLevel = native / nativeMax();
nativeError = error;
} else {
const name = String(activeWrite.id).slice(4);
const copy = Object.assign({}, ddcDisplays);
if (copy[name]) {
copy[name] = Object.assign({}, copy[name], {
"error": error
});
if (success)
copy[name].level = Math.round(activeWrite.level * copy[name].maximum) / copy[name].maximum;
}
ddcDisplays = copy;
}
lastAction = {
"kind": "set-display",
"id": activeWrite.id,
"source": activeWrite.source,
"level": activeWrite.level,
"success": success,
"error": error
};
const confirmed = activeWrite.id === "backlight" ? liveLevel : (ddcDisplays[activeWrite.id.slice(4)] || {}).level;
if (activeWrite.source === "adaptive") {
const transition = adaptiveTransitions[activeWrite.id];
if (!success || (transition && activeWrite.generation === transition.generation && adaptiveTransitionStep === adaptiveSteps)) {
if (success && Math.abs(confirmed - transition.target) >= 0.000001) {
adaptiveError = "adaptive target not confirmed";
if (activeWrite.id === "backlight")
nativeError = adaptiveError;
}
cancelAdaptiveDisplay(activeWrite.id);
} else if (transition && activeWrite.generation !== transition.generation) {
// Retargeting cannot undo an in-flight command. Rebase only after its ACK.
const transitions = Object.assign({}, adaptiveTransitions);
transitions[activeWrite.id] = Object.assign({}, transition, {
"from": confirmed
});
adaptiveTransitions = transitions;
}
}
if (success && activeWrite.source === "manual" && activeWrite.bucket >= 0 && typeof confirmed === "number") {
adaptiveConfig = Adaptive.learn(adaptiveConfig, activeWrite.id, activeWrite.bucket, confirmed);
saveAdaptive();
}
if (success && activeWrite.source !== "adaptive")
lastOsd = triggerOsd(confirmed);
Qt.callLater(startWrite);
}
function setAll(level) {
const value = Brightness.clampLevel(level);
const rows = displays;
for (let i = 0; i < rows.length; i++) {
if (rows[i].controllable)
setDisplay(rows[i].id, value);
}
lastAction = {
"kind": "set-all",
"level": Math.round(value * 100) / 100
};
return stateJson();
}
function increase() {
return setAll(globalLevel + 0.05);
}
function decrease() {
return setAll(globalLevel - 0.05);
}
Process {
id: setupProcess
stdinEnabled: true
stdout: SplitParser {
onRead: data => root.consumeOutput(data)
}
stderr: SplitParser {}
onExited: (exitCode, exitStatus) => root.finishOperation(exitStatus === 0 ? exitCode : 128 + exitCode)
onRunningChanged: {
if (!running)
Qt.callLater(() => {
// QProcess FailedToStart does not emit exited.
if (root.operationPending && !setupProcess.running)
root.finishOperation(127);
});
}
}
Timer {
id: authorizationDeadline
interval: 120000
onTriggered: root.authorizationExpired()
}
Timer {
id: installationDeadline
interval: 370000
onTriggered: root.installationExpired()
}
Process {
id: writeProcess
// Only backlight's strict numeric readback is consumed; never exposed raw.
stdout: SplitParser {
onRead: data => root.writeOutput = (root.writeOutput + data + "\n").slice(0, 128)
}
stderr: SplitParser {}
onExited: (exitCode, exitStatus) => root.finishWrite(exitStatus === 0 ? exitCode : 128 + exitCode)
onRunningChanged: {
if (!running)
Qt.callLater(() => {
if (root.writePending && !writeProcess.running)
root.finishWrite(127);
});
}
}
Connections {
target: root.ambientLightService
function onSampleFinished() {
root.acceptAdaptiveSample();
}
}
Timer {
id: adaptiveTransitionTimer
interval: 100
repeat: true
running: root.adaptiveActive && root.adaptiveTransitioning
onTriggered: root.advanceAdaptive()
}
Timer {
interval: 2000
repeat: true
triggeredOnStart: true
running: root.adaptiveSampling
onTriggered: root.sampleAdaptive()
}
Timer {
interval: 500
repeat: true
running: root.adaptiveSampling
onTriggered: {
if (root.adaptiveReadAt > 0 && Date.now() - root.adaptiveReadAt >= root.adaptiveSampleLifetime) {
root.resetAdaptive();
root.adaptiveError = "sensor sample stale";
}
}
}
FileView {
id: adaptiveFile
path: Quickshell.statePath("adaptive-brightness.json")
atomicWrites: true
blockWrites: true
printErrors: false
onLoaded: root.loadAdaptive(adaptiveFile.text())
onLoadFailed: error => {
if (error !== FileViewError.FileNotFound)
root.persistenceError = "adaptive settings could not be read";
root.persistenceReady = true;
}
onSaveFailed: root.persistenceError = "adaptive settings could not be saved"
}
FileView {
id: brightnessFile
path: `${root.devicePath}/brightness`
blockLoading: true
blockAllReads: true
printErrors: false
}
FileView {
id: maxFile
path: `${root.devicePath}/max_brightness`
blockLoading: true
blockAllReads: true
printErrors: false
}
}