repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by admin
quickshell/nuguland/features/brightness/fixtures/services/Brightness.qml
Rawimport QtQuick
Item {
// Inputs the registry forwards to the production service.
property var osdService: null
property var niriService: null
property var privilegeService: null
property var ambientLightService: null
property real level: 0.5
property int writes: 0
property bool available: true
property var snapshotOverride: null
property int setups: 0
property int cancellations: 0
property int retries: 0
property string lastDisplay: ""
// The registry sets this while the popup is open; it gates sensor discovery.
property bool panelOpen: false
readonly property bool setupExpanded: !!(snapshotOverride && snapshotOverride.setup && snapshotOverride.setup.expanded)
readonly property bool sensorWanted: panelOpen || !!(snapshotOverride && snapshotOverride.adaptive && snapshotOverride.adaptive.enabled && snapshotOverride.setup && snapshotOverride.setup.ready)
// The production service's panel properties, read from the suite's state
// (or the base display), so the panel binds identically to both.
readonly property var current: stateObject()
readonly property var displays: current.displays || []
readonly property string globalMode: current.global ? String(current.global.mode) : "none"
readonly property real globalLevel: current.global ? Number(current.global.level || 0) : 0
readonly property var globalLevels: current.global ? current.global.levels || [] : []
readonly property bool setupNeeded: !!(current.setup && current.setup.needed)
readonly property bool setupAvailable: !!(current.setup && current.setup.available)
readonly property bool setupRunning: !!(current.setup && current.setup.running)
readonly property bool setupReady: !!(current.setup && current.setup.ready)
readonly property var setupStages: current.setup && current.setup.stages || []
readonly property string setupError: String(current.setup && current.setup.error || "")
readonly property bool cancelRequested: !!(current.setup && current.setup.cancelRequested)
// A state without adaptive has no light sensor route.
readonly property bool adaptiveRoute: !!current.adaptive
readonly property bool adaptiveEnabled: !!(current.adaptive && current.adaptive.enabled)
readonly property bool adaptiveAvailable: !!(current.adaptive && current.adaptive.available)
readonly property bool adaptiveActive: !!(current.adaptive && current.adaptive.active)
readonly property int currentBucket: current.adaptive && typeof current.adaptive.currentBucket === "number" ? current.adaptive.currentBucket : -1
readonly property var adaptiveRaw: current.adaptive && typeof current.adaptive.raw === "number" ? current.adaptive.raw : null
readonly property var adaptiveThresholds: current.adaptive && current.adaptive.thresholds || []
readonly property string adaptiveError: String(current.adaptive && current.adaptive.error || "")
readonly property string persistenceError: String(current.adaptive && current.adaptive.persistenceError || "")
function copyState() {
return snapshotOverride ? JSON.parse(JSON.stringify(snapshotOverride)) : null;
}
function updateGlobal(state) {
const levels = state.displays.filter(row => row.controllable).map(row => row.level);
state.global = {
mode: levels.length === 0 ? "none" : levels.every(value => value === levels[0]) ? "synced" : "mixed",
level: levels.length ? levels.reduce((sum, value) => sum + value, 0) / levels.length : 0,
levels: levels
};
}
function learnAdaptive(state, row) {
const adaptive = state.adaptive;
if (!adaptive || !adaptive.enabled || !adaptive.available || !adaptive.active || adaptive.currentBucket < 0 || adaptive.currentBucket > 3)
return;
const buckets = adaptive.buckets || [];
if (!buckets[adaptive.currentBucket])
return;
const targets = Object.assign({}, buckets[adaptive.currentBucket].targets || {});
targets[row.id] = row.level;
buckets[adaptive.currentBucket] = Object.assign({}, buckets[adaptive.currentBucket], {
targets: targets
});
adaptive.buckets = buckets;
}
function applyAdaptiveTargets(state, bucket) {
const targets = ((state.adaptive.buckets || [])[bucket] || {}).targets || {};
state.displays = state.displays.map(row => row.controllable && typeof targets[row.id] === "number" ? Object.assign({}, row, {
level: targets[row.id]
}) : row);
updateGlobal(state);
}
// Suite surface: synthetic boundary changes, never native setup or hardware access.
// A full state replaces the base display; null restores it.
function setState(state) {
snapshotOverride = state;
}
// An external writer changes the base display's level.
function externalUpdate() {
level = 0.25;
}
function setAvailable(value) {
available = !!value;
}
// Setup reaches `stage` with its predecessors done; "ready" completes it.
function advanceSetup(stage) {
fixtureEvent(String(stage));
}
// The ambient sensor reports `bucket` (0 dark … 3 sunlight).
function setAmbient(bucket) {
fixtureEvent("ambient:" + bucket);
}
function setSensorAvailable(value) {
fixtureEvent(value ? "sensor-available" : "sensor-unavailable");
}
function setDdcReady(value) {
fixtureEvent(value ? "ddc-ready" : "ddc-not-ready");
}
// `features.brightness.service`: the state the panel reads plus intent counters.
function fixtureState() {
return Object.assign({}, stateObject(), {
"level": level,
"writes": writes,
"setups": setups,
"cancellations": cancellations,
"retries": retries,
"lastDisplay": lastDisplay,
"sensorMonitoring": !!ambientLightService && ambientLightService.monitoring
});
}
function fixtureEvent(event) {
const state = copyState();
if (!state)
return;
const setup = state.setup || {};
if (event === "ready") {
setup.stages = (setup.stages || []).map(stage => ({
id: stage.id,
status: "done",
error: ""
}));
setup.ready = true;
setup.needed = false;
setup.expanded = false;
setup.running = false;
setup.error = "";
state.setup = setup;
state.displays = state.displays.map(row => Object.assign({}, row, {
controllable: true,
level: 0.5,
issue: ""
}));
updateGlobal(state);
} else if (event.startsWith("ambient:")) {
const bucket = Number(event.slice("ambient:".length));
if (state.adaptive && Number.isInteger(bucket) && bucket >= 0 && bucket < 4) {
state.adaptive.currentBucket = bucket;
state.adaptive.raw = [10, 50, 200, 500][bucket];
state.adaptive.active = !!state.adaptive.enabled && !!state.adaptive.available;
state.adaptive.error = "";
if (state.adaptive.active)
applyAdaptiveTargets(state, bucket);
}
} else if (event === "sensor-unavailable" || event === "ddc-not-ready") {
if (state.adaptive) {
state.adaptive.available = false;
state.adaptive.active = false;
}
if (event === "ddc-not-ready") {
state.setup = Object.assign({}, setup, {
ready: false,
needed: true
});
state.displays = state.displays.map(row => Object.assign({}, row, {
controllable: false,
issue: "needs setup"
}));
updateGlobal(state);
}
} else if (event === "sensor-available" || event === "ddc-ready") {
if (state.adaptive) {
state.adaptive.available = true;
state.adaptive.active = !!state.adaptive.enabled && state.adaptive.currentBucket >= 0;
}
if (event === "ddc-ready")
state.setup = Object.assign({}, setup, {
ready: true,
needed: false
});
} else {
const index = (setup.stages || []).findIndex(stage => stage.id === event);
setup.stages = (setup.stages || []).map((stage, i) => ({
id: stage.id,
status: i < index ? "done" : i === index ? "running" : "waiting",
error: ""
}));
state.setup = setup;
}
snapshotOverride = state;
}
function stateJson() {
return JSON.stringify(stateObject());
}
// The typed properties read this; callers never mutate it.
function stateObject() {
if (snapshotOverride)
return snapshotOverride;
return {
global: {
mode: available ? "synced" : "none",
level: available ? level : 0,
levels: available ? [level] : []
},
setup: {
needed: false,
available: false
},
displays: [
{
id: "fixture-display",
name: "fixture display",
level: level,
controllable: available,
issue: available ? "" : "unavailable"
}
]
};
}
function setAll(value) {
if (snapshotOverride) {
const state = copyState();
state.displays = state.displays.map(row => {
const next = row.controllable ? Object.assign({}, row, {
level: value
}) : row;
if (next !== row)
learnAdaptive(state, next);
return next;
});
updateGlobal(state);
snapshotOverride = state;
writes++;
return stateJson();
}
if (available) {
level = value;
writes++;
}
return stateJson();
}
function setDisplay(id, value) {
lastDisplay = id;
if (!snapshotOverride)
return setAll(value);
const state = copyState();
state.displays = state.displays.map(row => {
const next = row.id === id && row.controllable ? Object.assign({}, row, {
level: value
}) : row;
if (next !== row)
learnAdaptive(state, next);
return next;
});
updateGlobal(state);
snapshotOverride = state;
writes++;
return stateJson();
}
function toggleAdaptive() {
const state = copyState();
if (!state || !state.adaptive || !state.adaptive.available)
return stateJson();
state.adaptive.enabled = !state.adaptive.enabled;
state.adaptive.active = state.adaptive.enabled && state.adaptive.currentBucket >= 0;
snapshotOverride = state;
return stateJson();
}
function setAdaptiveThreshold(index, value) {
const state = copyState();
const adaptive = state && state.adaptive;
if (!adaptive || !Number.isInteger(index) || index < 0 || index > 2 || !Number.isSafeInteger(value) || value <= 0)
return adaptiveThresholds[index] === value;
const thresholds = (adaptive.thresholds || []).slice();
if (thresholds.length !== 3)
return adaptiveThresholds[index] === value;
const minimum = index === 0 ? 1 : thresholds[index - 1] + 1;
const maximum = index === 2 ? Number.MAX_SAFE_INTEGER : thresholds[index + 1] - 1;
thresholds[index] = Math.max(minimum, Math.min(maximum, value));
adaptive.thresholds = thresholds;
snapshotOverride = state;
return thresholds[index] === value;
}
function setupDdc() {
if (!snapshotOverride || snapshotOverride.setup.running)
return stateJson();
setups++;
const state = copyState();
state.setup.expanded = true;
state.setup.running = true;
state.setup.error = "";
state.setup.cancelRequested = false;
state.setup.privilegedEntered = false;
snapshotOverride = state;
fixtureEvent("preflight");
return stateJson();
}
function cancelSetup() {
if (!setupRunning || cancelRequested)
return stateJson();
cancellations++;
const state = copyState();
if (state.setup.privilegedEntered) {
state.setup.cancelRequested = true;
state.setup.error = "cancel requested; waiting for package setup";
snapshotOverride = state;
return stateJson();
}
return finishCancellation();
}
function finishCancellation() {
const state = copyState();
state.setup.running = false;
state.setup.error = "cancelled";
state.setup.stages = state.setup.stages.map(stage => stage.status === "running" ? {
id: stage.id,
status: "failed",
error: "cancelled"
} : stage);
snapshotOverride = state;
return stateJson();
}
function retrySetup() {
retries++;
return setupDdc();
}
function toggleSetup() {
const state = copyState();
state.setup.expanded = !state.setup.expanded;
snapshotOverride = state;
return stateJson();
}
}