mirror of
https://github.com/AvengeMedia/DankMaterialShell.git
synced 2026-10-16 16:24:00 -04:00
bbedward
f482642880
scrollbar: interface style toggle and no scrollbars in the dash dash: never allow scrollbars cc: widget sheet cards, header close button and content-sized dialogs
2499 lines
111 KiB
QML
2499 lines
111 KiB
QML
pragma Singleton
|
|
pragma ComponentBehavior: Bound
|
|
|
|
import QtCore
|
|
import QtQuick
|
|
import "../DankCommon/Common/Shape.js" as Shape
|
|
import "../DankCommon/Common/Surface.js" as Surface
|
|
import "../DankCommon/Common/Contrast.js" as Contrast
|
|
import "../DankCommon/Common/Accents.js" as Accents
|
|
import "../DankCommon/Common/Tonal.js" as Tonal
|
|
import Quickshell
|
|
import Quickshell.Io
|
|
import qs.Common
|
|
import qs.DankCommon.Common as DankCommon
|
|
import qs.Services
|
|
import qs.Modules.Greetd
|
|
import "StockThemes.js" as StockThemes
|
|
import "GSettings.js" as GSettings
|
|
|
|
Singleton {
|
|
id: root
|
|
readonly property var log: Log.scoped("Theme")
|
|
|
|
readonly property string stateDir: Paths.strip(StandardPaths.writableLocation(StandardPaths.GenericCacheLocation).toString()) + "/DankMaterialShell"
|
|
readonly property bool envDisableMatugen: Quickshell.env("DMS_DISABLE_MATUGEN") === "1" || Quickshell.env("DMS_DISABLE_MATUGEN") === "true"
|
|
readonly property string defaultFontFamily: "Google Sans Flex"
|
|
readonly property string defaultMonoFontFamily: "Fira Code"
|
|
readonly property string defaultDisplayFontFamily: "DM Serif Display"
|
|
|
|
readonly property real popupDistance: {
|
|
if (typeof SettingsData === "undefined")
|
|
return 4;
|
|
const defaultBar = SettingsData.getPrimaryBarConfig();
|
|
if (!defaultBar)
|
|
return 4;
|
|
const useAuto = defaultBar.popupGapsAuto ?? true;
|
|
const manualValue = defaultBar.popupGapsManual ?? 4;
|
|
const spacing = defaultBar.spacing ?? 4;
|
|
return useAuto ? Math.max(4, spacing) : manualValue;
|
|
}
|
|
|
|
property string currentTheme: "purple"
|
|
property string currentThemeCategory: "generic"
|
|
property bool isLightMode: typeof SessionData !== "undefined" ? SessionData.isLightMode : false
|
|
property bool colorsFileLoadFailed: false
|
|
|
|
readonly property string dynamic: "dynamic"
|
|
readonly property string custom: "custom"
|
|
|
|
readonly property string homeDir: Paths.strip(StandardPaths.writableLocation(StandardPaths.HomeLocation))
|
|
readonly property string configDir: Paths.strip(StandardPaths.writableLocation(StandardPaths.ConfigLocation))
|
|
readonly property string shellDir: Paths.strip(Qt.resolvedUrl(".").toString()).replace("/Common/", "")
|
|
readonly property string wallpaperPath: {
|
|
if (typeof SessionData === "undefined")
|
|
return "";
|
|
|
|
var monitors = SessionData.monitorWallpapers;
|
|
if (SessionData.perMonitorWallpaper) {
|
|
var screens = Quickshell.screens;
|
|
if (screens.length > 0) {
|
|
var s = screens[0];
|
|
return monitors[s.name] || (s.model ? monitors[s.model] : "") || SessionData.wallpaperPath;
|
|
}
|
|
}
|
|
|
|
return SessionData.wallpaperPath;
|
|
}
|
|
readonly property string rawWallpaperPath: {
|
|
if (typeof SessionData === "undefined")
|
|
return "";
|
|
|
|
var monitors = SessionData.monitorWallpapers;
|
|
if (SessionData.perMonitorWallpaper) {
|
|
var screens = Quickshell.screens;
|
|
if (screens.length > 0) {
|
|
var targetMonitor = (typeof SettingsData !== "undefined" && SettingsData.matugenTargetMonitor && SettingsData.matugenTargetMonitor !== "") ? SettingsData.matugenTargetMonitor : screens[0].name;
|
|
|
|
var targetMonitorExists = false;
|
|
for (var i = 0; i < screens.length; i++) {
|
|
if (screens[i].name === targetMonitor) {
|
|
targetMonitorExists = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!targetMonitorExists)
|
|
targetMonitor = screens[0].name;
|
|
|
|
var s = null;
|
|
for (var j = 0; j < screens.length; j++) {
|
|
if (screens[j].name === targetMonitor) {
|
|
s = screens[j];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (s)
|
|
return monitors[s.name] || (s.model ? monitors[s.model] : "") || SessionData.wallpaperPath;
|
|
return monitors[targetMonitor] || SessionData.wallpaperPath;
|
|
}
|
|
}
|
|
|
|
return SessionData.wallpaperPath;
|
|
}
|
|
|
|
property bool matugenAvailable: false
|
|
property var workerRunning: false
|
|
property var pendingThemeRequest: null
|
|
|
|
signal matugenCompleted(string mode, string result)
|
|
property var matugenColors: ({})
|
|
property var _pendingGenerateParams: null
|
|
property int _colorsRetryCount: 0
|
|
property double _lastGenerateMs: 0
|
|
property string _matugenRunKey: ""
|
|
|
|
property bool blurLayersActive: false
|
|
property bool matugenToastSuppressed: false
|
|
|
|
signal screenTransitionNeeded
|
|
signal themeGenerationStarting
|
|
|
|
readonly property var dank16: {
|
|
const raw = matugenColors?.dank16;
|
|
if (!raw)
|
|
return null;
|
|
|
|
const dark = {};
|
|
const light = {};
|
|
const def = {};
|
|
|
|
for (let i = 0; i < 16; i++) {
|
|
const key = "color" + i;
|
|
const c = raw[key];
|
|
if (!c)
|
|
continue;
|
|
dark[key] = c.dark;
|
|
light[key] = c.light;
|
|
def[key] = c.default;
|
|
}
|
|
|
|
return {
|
|
dark,
|
|
light,
|
|
"default": def
|
|
};
|
|
}
|
|
property var customThemeData: null
|
|
property var customThemeRawData: null
|
|
readonly property var currentThemeVariants: customThemeRawData?.variants || null
|
|
readonly property string currentThemeId: customThemeRawData?.id || ""
|
|
readonly property string currentThemeLabel: {
|
|
if (currentTheme === dynamic)
|
|
return I18n.tr("Dynamic", "dynamic theme name");
|
|
const name = getThemeColors(currentThemeName)?.name || customThemeRawData?.name;
|
|
if (name)
|
|
return name;
|
|
const file = typeof SettingsData !== "undefined" ? SettingsData.customThemeFile : "";
|
|
return file ? file.split("/").pop() : "";
|
|
}
|
|
|
|
Component.onCompleted: {
|
|
Quickshell.execDetached(["mkdir", "-p", stateDir]);
|
|
Proc.runCommand("matugenCheck", ["sh", "-c", "command -v matugen"], (output, code) => {
|
|
matugenAvailable = (code === 0) && !envDisableMatugen;
|
|
generateSystemThemesFromCurrentTheme();
|
|
}, 0);
|
|
if (typeof SessionData !== "undefined") {
|
|
SessionData.isLightModeChanged.connect(root.onLightModeChanged);
|
|
}
|
|
|
|
if (typeof SettingsData !== "undefined" && SettingsData.currentThemeName) {
|
|
switchTheme(SettingsData.currentThemeName, false, false);
|
|
const currentIsLight = (typeof SessionData !== "undefined") ? SessionData.isLightMode : false;
|
|
SettingsData.updateCosmicThemeMode(currentIsLight);
|
|
}
|
|
}
|
|
|
|
function getMatugenColor(path, fallback) {
|
|
const colorMode = (typeof SessionData !== "undefined" && SessionData.isLightMode) ? "light" : "dark";
|
|
return getMatugenColorForMode(colorMode, path, fallback);
|
|
}
|
|
|
|
function getMatugenColorForMode(colorMode, path, fallback) {
|
|
let cur = matugenColors && matugenColors.colors && matugenColors.colors[colorMode];
|
|
for (const part of path.split(".")) {
|
|
if (!cur || typeof cur !== "object" || !(part in cur))
|
|
return fallback;
|
|
cur = cur[part];
|
|
}
|
|
return cur || fallback;
|
|
}
|
|
|
|
function extractCurrentTheme(themeName) {
|
|
var name = themeName || "Extracted Theme";
|
|
var dark = {};
|
|
var light = {};
|
|
|
|
if (currentTheme === dynamic) {
|
|
dark = buildExtractedDynamicMode("dark", name + " Dark");
|
|
light = buildExtractedDynamicMode("light", name + " Light");
|
|
} else if (currentTheme === custom && customThemeRawData) {
|
|
var rawDark = customThemeRawData.dark || null;
|
|
var rawLight = customThemeRawData.light || null;
|
|
if (rawDark) {
|
|
dark = JSON.parse(JSON.stringify(rawDark));
|
|
if (!dark.name)
|
|
dark.name = name + " Dark";
|
|
} else if (rawLight) {
|
|
dark = buildExtractedDynamicMode("dark", name + " Dark");
|
|
} else {
|
|
dark = currentThemeData ? JSON.parse(JSON.stringify(currentThemeData)) : {};
|
|
dark.name = name + " Dark";
|
|
}
|
|
if (rawLight) {
|
|
light = JSON.parse(JSON.stringify(rawLight));
|
|
if (!light.name)
|
|
light.name = name + " Light";
|
|
} else if (rawDark) {
|
|
light = buildExtractedDynamicMode("light", name + " Light");
|
|
} else {
|
|
light = currentThemeData ? JSON.parse(JSON.stringify(currentThemeData)) : {};
|
|
light.name = name + " Light";
|
|
}
|
|
} else {
|
|
var darkTheme = StockThemes.getThemeByName(currentTheme, false);
|
|
var lightTheme = StockThemes.getThemeByName(currentTheme, true);
|
|
dark = darkTheme ? JSON.parse(JSON.stringify(darkTheme)) : {};
|
|
light = lightTheme ? JSON.parse(JSON.stringify(lightTheme)) : {};
|
|
dark.name = name + " Dark";
|
|
light.name = name + " Light";
|
|
}
|
|
|
|
return JSON.stringify({
|
|
dark: dark,
|
|
light: light
|
|
}, null, 2);
|
|
}
|
|
|
|
function buildExtractedDynamicMode(colorMode, name) {
|
|
return {
|
|
"name": name,
|
|
"primary": getMatugenColorForMode(colorMode, "primary", "#42a5f5"),
|
|
"primaryText": getMatugenColorForMode(colorMode, "on_primary", "#ffffff"),
|
|
"primaryContainer": getMatugenColorForMode(colorMode, "primary_container", "#1976d2"),
|
|
"onPrimaryContainer": getMatugenColorForMode(colorMode, "on_primary_container"),
|
|
"secondary": getMatugenColorForMode(colorMode, "secondary", "#8ab4f8"),
|
|
"secondaryContainer": getMatugenColorForMode(colorMode, "secondary_container"),
|
|
"onSecondaryContainer": getMatugenColorForMode(colorMode, "on_secondary_container"),
|
|
"tertiary": getMatugenColorForMode(colorMode, "tertiary", "#efb8c8"),
|
|
"tertiaryContainer": getMatugenColorForMode(colorMode, "tertiary_container", getMatugenColorForMode(colorMode, "surface_container_high", "#292b2f")),
|
|
"onTertiaryContainer": getMatugenColorForMode(colorMode, "on_tertiary_container"),
|
|
"surface": getMatugenColorForMode(colorMode, "surface", "#1a1c1e"),
|
|
"surfaceText": getMatugenColorForMode(colorMode, "on_background", "#e3e8ef"),
|
|
"surfaceVariant": getMatugenColorForMode(colorMode, "surface_variant", "#44464f"),
|
|
"surfaceVariantText": getMatugenColorForMode(colorMode, "on_surface_variant", "#c4c7c5"),
|
|
"surfaceTint": getMatugenColorForMode(colorMode, "surface_tint", "#8ab4f8"),
|
|
"background": getMatugenColorForMode(colorMode, "background", "#1a1c1e"),
|
|
"backgroundText": getMatugenColorForMode(colorMode, "on_background", "#e3e8ef"),
|
|
"outline": getMatugenColorForMode(colorMode, "outline", "#8e918f"),
|
|
"surfaceContainerLowest": getMatugenColorForMode(colorMode, "surface_container_lowest", "#0e1013"),
|
|
"surfaceContainerLow": getMatugenColorForMode(colorMode, "surface_container_low", "#181a1d"),
|
|
"surfaceContainer": getMatugenColorForMode(colorMode, "surface_container", "#1e2023"),
|
|
"surfaceContainerHigh": getMatugenColorForMode(colorMode, "surface_container_high", "#292b2f"),
|
|
"surfaceContainerHighest": getMatugenColorForMode(colorMode, "surface_container_highest", "#343740"),
|
|
"error": getMatugenColorForMode(colorMode, "error", "#F2B8B5"),
|
|
"errorText": getMatugenColorForMode(colorMode, "on_error"),
|
|
"errorContainer": getMatugenColorForMode(colorMode, "error_container"),
|
|
"errorContainerText": getMatugenColorForMode(colorMode, "on_error_container"),
|
|
"warning": "#FF9800",
|
|
"info": "#2196F3",
|
|
"success": "#4CAF50"
|
|
};
|
|
}
|
|
|
|
readonly property var currentThemeData: {
|
|
if (currentTheme === "custom") {
|
|
return customThemeData || StockThemes.getThemeByName("purple", isLightMode);
|
|
} else if (currentTheme === dynamic) {
|
|
return buildExtractedDynamicMode(isLightMode ? "light" : "dark", "Dynamic");
|
|
} else {
|
|
return StockThemes.getThemeByName(currentTheme, isLightMode);
|
|
}
|
|
}
|
|
|
|
readonly property var availableMatugenSchemes: {
|
|
const schemes = _matugenSchemeDefs;
|
|
const seen = {};
|
|
for (let i = 0; i < schemes.length; i++) {
|
|
const label = schemes[i].label;
|
|
if (seen[label] === undefined) {
|
|
seen[label] = true;
|
|
continue;
|
|
}
|
|
// duplicate translations otherwise collapse the label-keyed dropdown onto one scheme (#3154)
|
|
schemes[i].label = label + " (" + schemes[i].value.replace("scheme-", "") + ")";
|
|
}
|
|
return schemes;
|
|
}
|
|
|
|
readonly property var _matugenSchemeDefs: [({
|
|
"value": "scheme-tonal-spot",
|
|
"spec2025": true,
|
|
"label": I18n.tr("Tonal Spot", "matugen color scheme option"),
|
|
"description": I18n.tr("Balanced palette with focused accents (default).")
|
|
}), ({
|
|
"value": "scheme-vibrant",
|
|
"spec2025": true,
|
|
"label": I18n.tr("Vibrant", "matugen color scheme option"),
|
|
"description": I18n.tr("Lively palette with saturated accents.")
|
|
}), ({
|
|
"value": "scheme-content",
|
|
"label": I18n.tr("Content", "matugen color scheme option"),
|
|
"description": I18n.tr("Derives colors that closely match the underlying image.")
|
|
}), ({
|
|
"value": "scheme-expressive",
|
|
"spec2025": true,
|
|
"label": I18n.tr("Expressive", "matugen color scheme option"),
|
|
"description": I18n.tr("Vibrant palette with playful saturation.")
|
|
}), ({
|
|
"value": "scheme-fidelity",
|
|
"label": I18n.tr("Fidelity", "matugen color scheme option"),
|
|
"description": I18n.tr("High-fidelity palette that preserves source hues.")
|
|
}), ({
|
|
"value": "scheme-fruit-salad",
|
|
"label": I18n.tr("Fruit Salad", "matugen color scheme option"),
|
|
"description": I18n.tr("Colorful mix of bright contrasting accents.")
|
|
}), ({
|
|
"value": "scheme-monochrome",
|
|
"label": I18n.tr("Monochrome", "matugen color scheme option"),
|
|
"description": I18n.tr("Minimal palette built around a single hue.")
|
|
}), ({
|
|
"value": "scheme-neutral",
|
|
"spec2025": true,
|
|
"label": I18n.tr("Neutral", "matugen color scheme option"),
|
|
"description": I18n.tr("Muted palette with subdued, calming tones.")
|
|
}), ({
|
|
"value": "scheme-rainbow",
|
|
"label": I18n.tr("Rainbow", "matugen color scheme option"),
|
|
"description": I18n.tr("Diverse palette spanning the full spectrum.")
|
|
}), ({
|
|
"value": "scheme-smart",
|
|
"label": I18n.tr("Smart", "matugen color scheme option"),
|
|
"description": I18n.tr("Automatically picks the scheme variant based on the wallpaper.")
|
|
})]
|
|
|
|
function getMatugenScheme(value) {
|
|
const schemes = availableMatugenSchemes;
|
|
for (var i = 0; i < schemes.length; i++) {
|
|
if (schemes[i].value === value)
|
|
return schemes[i];
|
|
}
|
|
return schemes[0];
|
|
}
|
|
|
|
readonly property var availableSourceModes: [({
|
|
"value": "dominant",
|
|
"label": I18n.tr("Dominant", "matugen source color option")
|
|
}), ({
|
|
"value": "colorful",
|
|
"label": I18n.tr("Colorful", "matugen source color option")
|
|
}), ({
|
|
"value": "darkness",
|
|
"label": I18n.tr("Darkest", "matugen source color option")
|
|
}), ({
|
|
"value": "lightness",
|
|
"label": I18n.tr("Lightest", "matugen source color option")
|
|
}), ({
|
|
"value": "saturation",
|
|
"label": I18n.tr("Most Saturated", "matugen source color option")
|
|
}), ({
|
|
"value": "less-saturation",
|
|
"label": I18n.tr("Least Saturated", "matugen source color option")
|
|
}), ({
|
|
"value": "value",
|
|
"label": I18n.tr("Most Vivid", "matugen source color option")
|
|
})]
|
|
|
|
function getSourceMode(value) {
|
|
const modes = availableSourceModes;
|
|
for (var i = 0; i < modes.length; i++) {
|
|
if (modes[i].value === value)
|
|
return modes[i];
|
|
}
|
|
return modes[0];
|
|
}
|
|
|
|
property color primary: currentThemeData.primary
|
|
property color primaryText: currentThemeData.primaryText
|
|
property color secondary: currentThemeData.secondary
|
|
property color tertiary: currentThemeData.tertiary || currentThemeData.secondary
|
|
property color surface: currentThemeData.surface
|
|
property color surfaceText: currentThemeData.surfaceText
|
|
property color surfaceVariant: currentThemeData.surfaceVariant
|
|
property color surfaceVariantText: currentThemeData.surfaceVariantText
|
|
property color surfaceTint: currentThemeData.surfaceTint
|
|
property color background: currentThemeData.background
|
|
property color backgroundText: currentThemeData.backgroundText
|
|
property color outline: currentThemeData.outline
|
|
property color outlineVariant: currentThemeData.outlineVariant || withAlpha(outline, 0.6)
|
|
property color surfaceContainerLowest: currentThemeData.surfaceContainerLowest || blend(surfaceContainer, surface, 1.2)
|
|
property color surfaceContainerLow: currentThemeData.surfaceContainerLow || blend(surface, surfaceContainer, 0.667)
|
|
property color surfaceContainer: currentThemeData.surfaceContainer
|
|
property color surfaceContainerHigh: currentThemeData.surfaceContainerHigh
|
|
property color surfaceContainerHighest: currentThemeData.surfaceContainerHighest || surfaceContainerHigh
|
|
property color surfaceBright: currentThemeData.surfaceBright || (isLightMode ? surface : surfaceContainerHighest)
|
|
property color surfaceDim: currentThemeData.surfaceDim || (isLightMode ? surfaceContainer : background)
|
|
readonly property color hostSurface: typeof SettingsData === "undefined" ? surface : surfaceRoleColor(SettingsData.hostSurfaceColor, SettingsData.hostSurfaceCustomColor, surface)
|
|
readonly property color cardSurface: typeof SettingsData === "undefined" ? surfaceContainer : surfaceRoleColor(SettingsData.cardSurfaceColor, SettingsData.cardSurfaceCustomColor, surfaceContainer)
|
|
readonly property color chipSurface: typeof SettingsData === "undefined" ? surfaceContainerHigh : surfaceRoleColor(SettingsData.chipSurfaceColor, SettingsData.chipSurfaceCustomColor, surfaceContainerHigh)
|
|
readonly property color chipSurfaceNested: typeof SettingsData === "undefined" ? surfaceContainerHighest : surfaceRoleColor(SettingsData.chipSurfaceNestedColor, SettingsData.chipSurfaceNestedCustomColor, surfaceContainerHighest)
|
|
readonly property real containerSaturation: typeof SettingsData === "undefined" ? 1 : SettingsData.containerSaturation / 100
|
|
readonly property real containerTint: (currentThemeData.containerTint ?? Tonal.defaultTint(surfaceContainer)) * containerSaturation
|
|
property color primaryContainer: currentThemeData.softPrimaryContainer || Tonal.softContainer(primary, surfaceContainer, containerTint)
|
|
property color secondaryContainer: currentThemeData.secondaryContainer || blend(surfaceContainerHigh, secondary, 0.35)
|
|
property color tertiaryContainer: currentThemeData.tertiaryContainer || blend(surfaceContainerHigh, tertiary, 0.35)
|
|
readonly property real selectedContainerTint: currentThemeData.selectedContainerTint ?? 0.2
|
|
readonly property bool themedSelectedContainer: !!currentThemeData.secondaryContainer && Contrast.isTonal(secondaryContainer, onSecondaryContainer) && Contrast.isTonal(secondaryContainer, surfaceText)
|
|
readonly property color selectedContainer: currentThemeData.selectedContainer || (themedSelectedContainer ? secondaryContainer : Contrast.subtleTint(surfaceContainerHigh, primary, surfaceText, selectedContainerTint))
|
|
readonly property color accentOnSelectedContainer: currentThemeData.accentOnSelectedContainer || (Contrast.ratio(primary, selectedContainer) >= 3 ? primary : onSelectedContainer)
|
|
readonly property color accentOnPrimaryContainer: currentThemeData.accentOnPrimaryContainer || (Contrast.ratio(primary, primaryContainer) >= 3 ? primary : onPrimaryContainer)
|
|
readonly property var accents: Accents.derive(primary, isLightMode, currentThemeData.accents ?? null)
|
|
property color inverseSurface: currentThemeData.inverseSurface || surfaceText
|
|
property color inverseOnSurface: currentThemeData.inverseOnSurface || surface
|
|
|
|
// on<Role> next to a <role> property parses as a signal handler; only Binding elements assign them.
|
|
property color onSurface
|
|
property color onSurfaceVariant
|
|
property color onPrimary
|
|
property color onPrimaryContainer
|
|
property color onSecondaryContainer
|
|
property color onError
|
|
property color onErrorContainer
|
|
property color onTertiaryContainer
|
|
property color onSelectedContainer
|
|
property color onSurface_12: withAlpha(onSurface, 0.12)
|
|
property color onSurface_38: withAlpha(onSurface, 0.38)
|
|
property color onSurfaceVariant_30: withAlpha(onSurfaceVariant, 0.30)
|
|
property color onSurfaceVariant_40
|
|
readonly property list<QtObject> roleBindings: [
|
|
Binding {
|
|
target: root
|
|
property: "onSurfaceVariant_40"
|
|
value: root.withAlpha(root.onSurfaceVariant, 0.4)
|
|
},
|
|
Binding {
|
|
target: root
|
|
property: "onError"
|
|
value: root.currentThemeData.errorText || root.getMatugenColor("on_error", root.surface)
|
|
},
|
|
Binding {
|
|
target: root
|
|
property: "onErrorContainer"
|
|
value: root.currentThemeData.errorContainerText || root.getMatugenColor("on_error_container", root.blend(root.surfaceText, root.error, 0.5))
|
|
},
|
|
Binding {
|
|
target: root
|
|
property: "onSurface"
|
|
value: root.surfaceText
|
|
},
|
|
Binding {
|
|
target: root
|
|
property: "onSurfaceVariant"
|
|
value: root.surfaceVariantText
|
|
},
|
|
Binding {
|
|
target: root
|
|
property: "onPrimary"
|
|
value: root.primaryText
|
|
},
|
|
Binding {
|
|
target: root
|
|
property: "onPrimaryContainer"
|
|
value: {
|
|
const explicit = root.currentThemeData.onPrimaryContainer || root.currentThemeData.primaryContainerText;
|
|
if (!explicit)
|
|
return Contrast.readableOn(root.primaryContainer, root.onContainerCandidates);
|
|
if (root.currentThemeData.softPrimaryContainer)
|
|
return explicit;
|
|
return Contrast.readableOn(root.primaryContainer, [Qt.color(explicit)].concat(root.onContainerCandidates));
|
|
}
|
|
},
|
|
Binding {
|
|
target: root
|
|
property: "onSecondaryContainer"
|
|
value: root.currentThemeData.onSecondaryContainer || Contrast.readableOn(root.secondaryContainer, root.onContainerCandidates)
|
|
},
|
|
Binding {
|
|
target: root
|
|
property: "onTertiaryContainer"
|
|
value: root.currentThemeData.onTertiaryContainer || Contrast.readableOn(root.tertiaryContainer, root.onContainerCandidates)
|
|
},
|
|
Binding {
|
|
target: root
|
|
property: "onSelectedContainer"
|
|
value: root.currentThemeData.onSelectedContainer || (root.currentThemeData.selectedContainer ? Contrast.readableOn(root.selectedContainer, root.onContainerCandidates) : root.themedSelectedContainer ? root.onSecondaryContainer : root.surfaceText)
|
|
}
|
|
]
|
|
readonly property var onContainerCandidates: [surfaceText, surface, contrastLight, contrastDark]
|
|
readonly property real tonalTintAlpha: 0.16
|
|
|
|
property color error: currentThemeData.error || "#F2B8B5"
|
|
property color errorContainer: currentThemeData.errorContainer || getMatugenColor("error_container", blend(surfaceContainerHigh, error, 0.35))
|
|
property color warning: currentThemeData.warning || "#FF9800"
|
|
property color info: currentThemeData.info || "#2196F3"
|
|
property color tempWarning: "#ff9933"
|
|
property color tempDanger: "#ff5555"
|
|
property color success: currentThemeData.success || "#4CAF50"
|
|
|
|
property color primaryHover: withAlpha(primary, 0.12)
|
|
property color primaryHoverLight: withAlpha(primary, transparentBlurLayers ? 0.12 : 0.08)
|
|
property color primaryPressed: withAlpha(primary, transparentBlurLayers ? 0.24 : 0.16)
|
|
property color primarySelected: withAlpha(primary, 0.3)
|
|
property color primaryBackground: withAlpha(primary, 0.04)
|
|
|
|
property color secondaryHover: withAlpha(secondary, 0.08)
|
|
|
|
property color surfaceHover: withAlpha(surfaceVariant, 0.08)
|
|
property color surfacePressed: withAlpha(surfaceVariant, 0.12)
|
|
property color surfaceSelected: withAlpha(surfaceVariant, 0.15)
|
|
property color surfaceLight: withAlpha(surfaceVariant, transparentBlurLayers ? 0.3 : 0.1)
|
|
property color surfaceVariantAlpha: withAlpha(surfaceVariant, 0.2)
|
|
|
|
readonly property bool foregroundLayers: typeof SettingsData === "undefined" || (SettingsData.blurForegroundLayers ?? true)
|
|
readonly property bool blurForegroundLayers: blurLayersActive && foregroundLayers
|
|
readonly property bool transparentBlurLayers: blurLayersActive && !foregroundLayers
|
|
readonly property real foregroundLayerTransparency: typeof SettingsData === "undefined" ? 1.0 : (SettingsData.foregroundLayerTransparency ?? 1.0)
|
|
readonly property bool notificationForegroundLayers: typeof SettingsData === "undefined" || (SettingsData.notificationForegroundLayers ?? true)
|
|
readonly property color readableSurface: withAlpha(hostSurface, popupTransparency)
|
|
readonly property color readableSurfaceHigh: withAlpha(cardSurface, popupTransparency)
|
|
readonly property color floatingSurface: readableSurface
|
|
readonly property color floatingSurfaceHigh: foregroundColor(cardSurface)
|
|
readonly property bool floatingWindowSynced: typeof SettingsData === "undefined" || (SettingsData.floatingWindowSyncGlobal ?? true)
|
|
readonly property real floatingWindowTransparency: {
|
|
if (typeof SettingsData === "undefined" || floatingWindowSynced)
|
|
return popupTransparency;
|
|
return SettingsData.floatingWindowTransparency ?? 1.0;
|
|
}
|
|
readonly property bool floatingWindowForegroundLayers: floatingWindowSynced ? foregroundLayers : (SettingsData.floatingWindowForegroundLayers ?? true)
|
|
readonly property real floatingWindowForegroundTransparency: {
|
|
if (typeof SettingsData === "undefined" || floatingWindowSynced)
|
|
return foregroundLayerTransparency;
|
|
return SettingsData.floatingWindowForegroundTransparency ?? 1.0;
|
|
}
|
|
readonly property real foregroundAlpha: Surface.foregroundAlpha(foregroundLayers || !blurLayersActive, foregroundLayerTransparency)
|
|
readonly property real floatingWindowForegroundAlpha: Surface.foregroundAlpha(floatingWindowForegroundLayers, floatingWindowForegroundTransparency)
|
|
|
|
function isFloatingWindow(item) {
|
|
return Surface.isFloatingWindow(item);
|
|
}
|
|
|
|
function accent(name) {
|
|
return accents[name] ?? null;
|
|
}
|
|
|
|
function foregroundColor(baseColor, floatingWindow = false) {
|
|
return blendAlpha(baseColor, floatingWindow ? floatingWindowForegroundAlpha : foregroundAlpha);
|
|
}
|
|
|
|
readonly property color floatingWindowSurface: withAlpha(hostSurface, floatingWindowTransparency)
|
|
readonly property color floatingWindowSurfaceHigh: foregroundColor(cardSurface, true)
|
|
readonly property color floatingWindowNestedSurface: floatingWindowSurfaceHigh
|
|
readonly property color notepadWindowSurface: withAlpha(hostSurface, notepadTransparency)
|
|
readonly property color nestedSurface: floatingSurfaceHigh
|
|
readonly property color notificationFloatingSurface: notificationForegroundLayers ? readableSurface : withAlpha(readableSurface, 0)
|
|
readonly property color notificationFloatingSurfaceHigh: notificationForegroundLayers ? readableSurfaceHigh : withAlpha(readableSurfaceHigh, 0)
|
|
readonly property color notificationNestedSurface: notificationFloatingSurfaceHigh
|
|
readonly property real blurLayerOutlineOpacity: Math.max(0, Math.min(1, typeof SettingsData === "undefined" ? 0 : (SettingsData.blurLayerOutlineOpacity ?? 0)))
|
|
readonly property real layerOutlineOpacity: blurLayerOutlineOpacity
|
|
readonly property int layerOutlineWidth: layerOutlineOpacity > 0 ? 1 : 0
|
|
readonly property real floatingWindowFieldAlpha: floatingWindowForegroundAlpha
|
|
readonly property color floatingWindowFieldColor: withAlpha(chipSurface, floatingWindowFieldAlpha)
|
|
readonly property real popupFieldAlpha: foregroundAlpha
|
|
readonly property color popupFieldColor: withAlpha(chipSurface, popupFieldAlpha)
|
|
readonly property color popupFieldBorderColor: withAlpha(outline, blurLayersActive ? 0.16 : layerOutlineOpacity)
|
|
readonly property color popupFieldFocusedBorderColor: withAlpha(primary, blurLayersActive ? 0.72 : 1.0)
|
|
readonly property color floatingWindowFieldBorderColor: popupFieldBorderColor
|
|
readonly property color floatingWindowFieldFocusedBorderColor: popupFieldFocusedBorderColor
|
|
property color surfaceTextHover: withAlpha(surfaceText, 0.08)
|
|
property color surfaceTextAlpha: withAlpha(surfaceText, 0.3)
|
|
|
|
function surfaceRoleColor(mode, customColor, fallback) {
|
|
switch (mode ?? "default") {
|
|
case "default":
|
|
return fallback;
|
|
case "custom":
|
|
return Qt.color(customColor);
|
|
default:
|
|
return roleColor(mode);
|
|
}
|
|
}
|
|
|
|
readonly property real avatarRingWidth: SettingsData.avatarRing === "none" ? 0 : outlineWidth
|
|
readonly property color avatarRingColor: SettingsData.avatarRing === "outline" ? surfaceVariant : roleColor(SettingsData.avatarRing)
|
|
|
|
function roleColor(mode) {
|
|
switch (mode) {
|
|
case "primary":
|
|
case "pri":
|
|
return primary;
|
|
case "primaryContainer":
|
|
return primaryContainer;
|
|
case "secondary":
|
|
case "sec":
|
|
return secondary;
|
|
case "secondaryContainer":
|
|
return secondaryContainer;
|
|
case "tertiary":
|
|
case "ter":
|
|
return tertiary;
|
|
case "tertiaryContainer":
|
|
return tertiaryContainer;
|
|
case "surfaceText":
|
|
return surfaceText;
|
|
case "surfaceVariant":
|
|
return surfaceVariant;
|
|
case "s":
|
|
return surface;
|
|
case "scll":
|
|
return surfaceContainerLowest;
|
|
case "scl":
|
|
return surfaceContainerLow;
|
|
case "sc":
|
|
return surfaceContainer;
|
|
case "sch":
|
|
return surfaceContainerHigh;
|
|
case "schh":
|
|
return surfaceContainerHighest;
|
|
case "sth":
|
|
return surfaceTextHover;
|
|
case "error":
|
|
case "err":
|
|
return error;
|
|
default:
|
|
return withAlpha(surface, 0);
|
|
}
|
|
}
|
|
property color surfaceTextLight: withAlpha(surfaceText, 0.06)
|
|
property color surfaceTextSecondary: withAlpha(surfaceText, 0.6)
|
|
property color surfaceTextMedium: withAlpha(surfaceText, 0.7)
|
|
|
|
property color outlineButton: withAlpha(outline, 0.5)
|
|
property color outlineLight: withAlpha(outline, Math.min(1, layerOutlineOpacity * 0.625))
|
|
property color outlineMedium: withAlpha(outline, layerOutlineOpacity)
|
|
property color outlineStrong: withAlpha(outline, Math.min(1, layerOutlineOpacity * 1.5))
|
|
property color outlineHeavy: withAlpha(outline, 0.2)
|
|
|
|
property color errorHover: withAlpha(error, 0.12)
|
|
property color errorPressed: withAlpha(error, 0.16)
|
|
property color errorSelected: withAlpha(error, 0.3)
|
|
property color warningHover: withAlpha(warning, 0.12)
|
|
|
|
readonly property color ccTileActiveBg: {
|
|
switch (SettingsData.controlCenterTileColorMode) {
|
|
case "primaryContainer":
|
|
return primaryContainer;
|
|
case "secondary":
|
|
return secondary;
|
|
case "surfaceVariant":
|
|
return surfaceVariant;
|
|
default:
|
|
return primary;
|
|
}
|
|
}
|
|
|
|
readonly property color ccPillInactiveBg: transparentBlurLayers ? withAlpha(cardSurface, 0.08) : nestedSurface
|
|
readonly property color ccIconBoxInactiveBg: transparentBlurLayers ? withAlpha(chipSurfaceNested, 0.16) : foregroundColor(chipSurfaceNested)
|
|
|
|
readonly property color ccTileActiveText: {
|
|
switch (SettingsData.controlCenterTileColorMode) {
|
|
case "primaryContainer":
|
|
return onPrimaryContainer;
|
|
case "secondary":
|
|
return surfaceText;
|
|
case "surfaceVariant":
|
|
return surfaceText;
|
|
default:
|
|
return primaryText;
|
|
}
|
|
}
|
|
|
|
readonly property color buttonBg: {
|
|
switch (SettingsData.buttonColorMode) {
|
|
case "primaryContainer":
|
|
return primaryContainer;
|
|
case "secondary":
|
|
return secondary;
|
|
case "surfaceVariant":
|
|
return surfaceVariant;
|
|
default:
|
|
return primary;
|
|
}
|
|
}
|
|
|
|
readonly property color buttonText: {
|
|
switch (SettingsData.buttonColorMode) {
|
|
case "primaryContainer":
|
|
return onPrimaryContainer;
|
|
case "secondary":
|
|
return surfaceText;
|
|
case "surfaceVariant":
|
|
return surfaceText;
|
|
default:
|
|
return primaryText;
|
|
}
|
|
}
|
|
|
|
readonly property color buttonHover: {
|
|
switch (SettingsData.buttonColorMode) {
|
|
case "primaryContainer":
|
|
return withAlpha(primary, 0.12);
|
|
case "secondary":
|
|
return withAlpha(surfaceText, 0.12);
|
|
case "surfaceVariant":
|
|
return withAlpha(surfaceText, 0.12);
|
|
default:
|
|
return primaryHover;
|
|
}
|
|
}
|
|
|
|
readonly property color buttonPressed: {
|
|
switch (SettingsData.buttonColorMode) {
|
|
case "primaryContainer":
|
|
return withAlpha(primary, 0.16);
|
|
case "secondary":
|
|
return withAlpha(surfaceText, 0.16);
|
|
case "surfaceVariant":
|
|
return withAlpha(surfaceText, 0.16);
|
|
default:
|
|
return primaryPressed;
|
|
}
|
|
}
|
|
|
|
property color shadowMedium: Qt.rgba(0, 0, 0, 0.08)
|
|
property color shadowStrong: Qt.rgba(0, 0, 0, 0.3)
|
|
|
|
readonly property bool elevationEnabled: typeof SettingsData !== "undefined" && (SettingsData.m3ElevationEnabled ?? true)
|
|
readonly property real elevationBlurMax: typeof SettingsData !== "undefined" && SettingsData.m3ElevationIntensity !== undefined ? Math.min(128, Math.max(32, SettingsData.m3ElevationIntensity * 2)) : 64
|
|
|
|
readonly property real _elevMult: typeof SettingsData !== "undefined" && SettingsData.m3ElevationIntensity !== undefined ? SettingsData.m3ElevationIntensity / 12 : 1
|
|
readonly property real _opMult: typeof SettingsData !== "undefined" && SettingsData.m3ElevationOpacity !== undefined ? SettingsData.m3ElevationOpacity / 60 : 1
|
|
function normalizeElevationDirection(direction) {
|
|
switch (direction) {
|
|
case "top":
|
|
case "topLeft":
|
|
case "topRight":
|
|
case "bottom":
|
|
case "bottomLeft":
|
|
case "bottomRight":
|
|
case "left":
|
|
case "right":
|
|
case "autoBar":
|
|
return direction;
|
|
default:
|
|
return "top";
|
|
}
|
|
}
|
|
|
|
readonly property string elevationLightDirection: {
|
|
if (typeof SettingsData === "undefined" || !SettingsData.m3ElevationLightDirection)
|
|
return "top";
|
|
switch (SettingsData.m3ElevationLightDirection) {
|
|
case "autoBar":
|
|
case "top":
|
|
case "topLeft":
|
|
case "topRight":
|
|
case "bottom":
|
|
return SettingsData.m3ElevationLightDirection;
|
|
default:
|
|
return "top";
|
|
}
|
|
}
|
|
readonly property real _elevDiagRatio: 0.55
|
|
readonly property string _globalElevationDirForTokens: {
|
|
const normalized = normalizeElevationDirection(elevationLightDirection);
|
|
return normalized === "autoBar" ? "top" : normalized;
|
|
}
|
|
readonly property real _elevDirX: {
|
|
switch (_globalElevationDirForTokens) {
|
|
case "topLeft":
|
|
case "bottomLeft":
|
|
case "left":
|
|
return 1;
|
|
case "topRight":
|
|
case "bottomRight":
|
|
case "right":
|
|
return -1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
readonly property real _elevDirY: {
|
|
switch (_globalElevationDirForTokens) {
|
|
case "bottom":
|
|
case "bottomLeft":
|
|
case "bottomRight":
|
|
return -1;
|
|
case "left":
|
|
case "right":
|
|
return 0;
|
|
default:
|
|
return 1;
|
|
}
|
|
}
|
|
readonly property real _elevDirXScale: (_globalElevationDirForTokens === "left" || _globalElevationDirForTokens === "right") ? 1 : _elevDiagRatio
|
|
|
|
readonly property var elevationLevel1: ({
|
|
blurPx: 4 * _elevMult,
|
|
offsetX: 1 * _elevMult * _elevDirXScale * _elevDirX,
|
|
offsetY: 1 * _elevMult * _elevDirY,
|
|
spreadPx: 0,
|
|
alpha: 0.2 * _opMult
|
|
})
|
|
readonly property var elevationLevel2: ({
|
|
blurPx: 8 * _elevMult,
|
|
offsetX: 4 * _elevMult * _elevDirXScale * _elevDirX,
|
|
offsetY: 4 * _elevMult * _elevDirY,
|
|
spreadPx: 0,
|
|
alpha: 0.25 * _opMult
|
|
})
|
|
readonly property var elevationLevel3: ({
|
|
blurPx: 12 * _elevMult,
|
|
offsetX: 6 * _elevMult * _elevDirXScale * _elevDirX,
|
|
offsetY: 6 * _elevMult * _elevDirY,
|
|
spreadPx: 0,
|
|
alpha: 0.3 * _opMult
|
|
})
|
|
readonly property var elevationLevel4: ({
|
|
blurPx: 16 * _elevMult,
|
|
offsetX: 8 * _elevMult * _elevDirXScale * _elevDirX,
|
|
offsetY: 8 * _elevMult * _elevDirY,
|
|
spreadPx: 0,
|
|
alpha: 0.3 * _opMult
|
|
})
|
|
readonly property var elevationLevel5: ({
|
|
blurPx: 20 * _elevMult,
|
|
offsetX: 10 * _elevMult * _elevDirXScale * _elevDirX,
|
|
offsetY: 10 * _elevMult * _elevDirY,
|
|
spreadPx: 0,
|
|
alpha: 0.3 * _opMult
|
|
})
|
|
|
|
function elevationOffsetMagnitude(level, fallback, direction) {
|
|
if (!level) {
|
|
return fallback !== undefined ? Math.abs(fallback) : 0;
|
|
}
|
|
const yMag = Math.abs(level.offsetY !== undefined ? level.offsetY : 0);
|
|
if (yMag > 0)
|
|
return yMag;
|
|
const xMag = Math.abs(level.offsetX !== undefined ? level.offsetX : 0);
|
|
if (xMag > 0) {
|
|
if (direction === "left" || direction === "right")
|
|
return xMag;
|
|
return xMag / _elevDiagRatio;
|
|
}
|
|
return fallback !== undefined ? Math.abs(fallback) : 0;
|
|
}
|
|
|
|
function elevationOffsetXFor(level, direction, fallback) {
|
|
const dir = normalizeElevationDirection(direction || elevationLightDirection);
|
|
const mag = elevationOffsetMagnitude(level, fallback, dir);
|
|
switch (dir) {
|
|
case "topLeft":
|
|
case "bottomLeft":
|
|
return mag * _elevDiagRatio;
|
|
case "topRight":
|
|
case "bottomRight":
|
|
return -mag * _elevDiagRatio;
|
|
case "left":
|
|
return mag;
|
|
case "right":
|
|
return -mag;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
function elevationOffsetYFor(level, direction, fallback) {
|
|
const dir = normalizeElevationDirection(direction || elevationLightDirection);
|
|
const mag = elevationOffsetMagnitude(level, fallback, dir);
|
|
switch (dir) {
|
|
case "bottom":
|
|
case "bottomLeft":
|
|
case "bottomRight":
|
|
return -mag;
|
|
case "left":
|
|
case "right":
|
|
return 0;
|
|
default:
|
|
return mag;
|
|
}
|
|
}
|
|
|
|
function elevationOffsetX(level, fallback) {
|
|
return elevationOffsetXFor(level, elevationLightDirection, fallback);
|
|
}
|
|
|
|
function elevationOffsetY(level, fallback) {
|
|
return elevationOffsetYFor(level, elevationLightDirection, fallback);
|
|
}
|
|
|
|
function elevationRenderPadding(level, direction, fallbackOffset, extraPadding, minPadding) {
|
|
const dir = direction !== undefined ? direction : elevationLightDirection;
|
|
const blur = (level && level.blurPx !== undefined) ? Math.max(0, level.blurPx) : 0;
|
|
const spread = (level && level.spreadPx !== undefined) ? Math.max(0, level.spreadPx) : 0;
|
|
const fallback = fallbackOffset !== undefined ? fallbackOffset : 0;
|
|
const extra = extraPadding !== undefined ? extraPadding : 8;
|
|
const minPad = minPadding !== undefined ? minPadding : 16;
|
|
const offsetX = Math.abs(elevationOffsetXFor(level, dir, fallback));
|
|
const offsetY = Math.abs(elevationOffsetYFor(level, dir, fallback));
|
|
return Math.max(minPad, blur + spread + Math.max(offsetX, offsetY) + extra);
|
|
}
|
|
|
|
function elevationShadowColor(level) {
|
|
const alpha = (level && level.alpha !== undefined) ? level.alpha : 0.3;
|
|
let r = 0;
|
|
let g = 0;
|
|
let b = 0;
|
|
|
|
if (typeof SettingsData !== "undefined") {
|
|
const mode = SettingsData.m3ElevationColorMode || "default";
|
|
if (mode === "default") {
|
|
r = 0;
|
|
g = 0;
|
|
b = 0;
|
|
} else if (mode === "text") {
|
|
r = surfaceText.r;
|
|
g = surfaceText.g;
|
|
b = surfaceText.b;
|
|
} else if (mode === "primary") {
|
|
r = primary.r;
|
|
g = primary.g;
|
|
b = primary.b;
|
|
} else if (mode === "surfaceVariant") {
|
|
r = surfaceVariant.r;
|
|
g = surfaceVariant.g;
|
|
b = surfaceVariant.b;
|
|
} else if (mode === "custom" && SettingsData.m3ElevationCustomColor) {
|
|
const c = Qt.color(SettingsData.m3ElevationCustomColor);
|
|
r = c.r;
|
|
g = c.g;
|
|
b = c.b;
|
|
}
|
|
}
|
|
return Qt.rgba(r, g, b, alpha);
|
|
}
|
|
function elevationAmbient(level) {
|
|
const blur = (level && level.blurPx !== undefined) ? Math.max(0, level.blurPx) : 0;
|
|
const alpha = ((level && level.alpha !== undefined) ? level.alpha : 0.3) * 0.5;
|
|
return {
|
|
blurPx: blur * 1.75,
|
|
spreadPx: 1,
|
|
alpha: alpha
|
|
};
|
|
}
|
|
|
|
readonly property int currentAnimationBaseDuration: typeof SettingsData !== "undefined" ? SettingsData.animationDuration : 250
|
|
readonly property int currentAnimationSpeed: currentAnimationBaseDuration > 0 ? SettingsData.AnimationSpeed.Custom : SettingsData.AnimationSpeed.None
|
|
|
|
readonly property int shorterDuration: Math.round(currentAnimationBaseDuration * 0.2)
|
|
readonly property int shortDuration: Math.round(currentAnimationBaseDuration * 0.3)
|
|
readonly property bool snapListModelChanges: shortDuration <= 0
|
|
readonly property int mediumDuration: Math.round(currentAnimationBaseDuration * 0.6)
|
|
readonly property int longDuration: currentAnimationBaseDuration
|
|
readonly property int extraLongDuration: currentAnimationBaseDuration * 2
|
|
readonly property int standardEasing: Easing.OutCubic
|
|
readonly property int emphasizedEasing: Easing.OutQuart
|
|
|
|
readonly property var expressiveCurves: {
|
|
"emphasized": [0.05, 0, 2 / 15, 0.06, 1 / 6, 0.4, 5 / 24, 0.82, 0.25, 1, 1, 1],
|
|
"emphasizedAccel": [0.3, 0, 0.8, 0.15, 1, 1],
|
|
"emphasizedDecel": [0.05, 0.7, 0.1, 1, 1, 1],
|
|
"standard": [0.2, 0, 0, 1, 1, 1],
|
|
"standardAccel": [0.3, 0, 1, 1, 1, 1],
|
|
"standardDecel": [0, 0, 0, 1, 1, 1],
|
|
"expressiveFastSpatial": [0.42, 1.67, 0.21, 0.9, 1, 1],
|
|
"expressiveDefaultSpatial": [0.38, 1.21, 0.22, 1, 1, 1],
|
|
"expressiveSlowSpatial": [0.39, 1.29, 0.35, 0.98, 1, 1],
|
|
"expressiveFastEffects": [0.31, 0.94, 0.34, 1, 1, 1],
|
|
"expressiveEffects": [0.34, 0.8, 0.34, 1, 1, 1],
|
|
"expressiveSlowEffects": [0.34, 0.88, 0.34, 1, 1, 1]
|
|
}
|
|
|
|
// Theme is the canonical access point for animation variant state. The
|
|
// aliases below forward to AnimVariants.qml so consumers don't need two
|
|
// imports. ~200 call sites read through Theme.variantEnterCurve /
|
|
// Theme.isConnectedEffect / etc. — do NOT migrate to AnimVariants directly.
|
|
readonly property list<real> variantEnterCurve: AnimVariants.variantEnterCurve
|
|
readonly property list<real> variantExitCurve: AnimVariants.variantExitCurve
|
|
readonly property list<real> variantModalEnterCurve: AnimVariants.variantModalEnterCurve
|
|
readonly property list<real> variantModalExitCurve: AnimVariants.variantModalExitCurve
|
|
readonly property list<real> variantPopoutEnterCurve: AnimVariants.variantPopoutEnterCurve
|
|
readonly property list<real> variantPopoutExitCurve: AnimVariants.variantPopoutExitCurve
|
|
readonly property list<real> variantPopoutResizeCurve: AnimVariants.variantPopoutResizeCurve
|
|
readonly property real variantEnterDurationFactor: AnimVariants.variantEnterDurationFactor
|
|
readonly property real variantExitDurationFactor: AnimVariants.variantExitDurationFactor
|
|
readonly property real variantOpacityDurationScale: AnimVariants.variantOpacityDurationScale
|
|
readonly property bool isDirectionalEffect: AnimVariants.isDirectionalEffect
|
|
readonly property bool isFluidEffect: AnimVariants.isFluidEffect
|
|
readonly property bool isDepthEffect: AnimVariants.isDepthEffect
|
|
readonly property bool isConnectedEffect: AnimVariants.isConnectedEffect
|
|
readonly property real connectedCornerRadius: {
|
|
if (typeof SettingsData === "undefined")
|
|
return 12;
|
|
return FrameTransitionState.effectiveConnectedFrameModeActive ? SettingsData.frameRounding : windowRadius;
|
|
}
|
|
readonly property color connectedSurfaceColor: {
|
|
if (typeof SettingsData === "undefined")
|
|
return withAlpha(hostSurface, popupTransparency);
|
|
return isConnectedEffect ? frameSurfaceColor : withAlpha(hostSurface, popupTransparency);
|
|
}
|
|
readonly property color frameSurfaceColor: typeof SettingsData === "undefined" ? withAlpha(hostSurface, popupTransparency) : withAlpha(SettingsData.frameSurfaceBase, SettingsData.frameSurfaceOpacity)
|
|
readonly property real connectedSurfaceRadius: isConnectedEffect ? connectedCornerRadius : windowRadius
|
|
readonly property bool connectedSurfaceBlurEnabled: (typeof SettingsData === "undefined") ? true : (!isConnectedEffect || SettingsData.frameBlurEnabled)
|
|
readonly property real effectScaleCollapsed: AnimVariants.effectScaleCollapsed
|
|
readonly property real effectAnimOffset: AnimVariants.effectAnimOffset
|
|
function variantDuration(baseDuration, entering) {
|
|
return AnimVariants.variantDuration(baseDuration, entering);
|
|
}
|
|
function variantExitCleanupPadding() {
|
|
return AnimVariants.variantExitCleanupPadding();
|
|
}
|
|
function variantCloseInterval(baseDuration) {
|
|
return AnimVariants.variantCloseInterval(baseDuration);
|
|
}
|
|
|
|
readonly property var expressiveDurations: {
|
|
if (typeof SettingsData === "undefined") {
|
|
return {
|
|
"fast": 200,
|
|
"normal": 400,
|
|
"large": 600,
|
|
"extraLarge": 1000,
|
|
"expressiveFastSpatial": 350,
|
|
"expressiveDefaultSpatial": 500,
|
|
"expressiveSlowSpatial": 650,
|
|
"expressiveFastEffects": 150,
|
|
"expressiveEffects": 200,
|
|
"expressiveSlowEffects": 300
|
|
};
|
|
}
|
|
|
|
const baseDuration = currentAnimationBaseDuration;
|
|
return {
|
|
"fast": baseDuration * 0.4,
|
|
"normal": baseDuration * 0.8,
|
|
"large": baseDuration * 1.2,
|
|
"extraLarge": baseDuration * 2.0,
|
|
"expressiveFastSpatial": baseDuration * 0.7,
|
|
"expressiveDefaultSpatial": baseDuration,
|
|
"expressiveSlowSpatial": baseDuration * 1.3,
|
|
"expressiveFastEffects": baseDuration * 0.3,
|
|
"expressiveEffects": baseDuration * 0.4,
|
|
"expressiveSlowEffects": baseDuration * 0.6
|
|
};
|
|
}
|
|
|
|
// Expressive spatial spring presets ([stiffness, damping], unit mass) tuned to a
|
|
// 500ms reference transition; runtime values scale via springPreset().
|
|
readonly property real morphSettleEpsilon: 0.02
|
|
readonly property real morphLayerEpsilon: 0.002
|
|
|
|
readonly property var springSpecs: {
|
|
"expressive": [560, 37],
|
|
"fast": [220, 23],
|
|
"default": [300, 24]
|
|
}
|
|
|
|
// Damping multipliers for the user-facing spring bounce setting:
|
|
// crisp settles without overshoot, playful adds visible bounce.
|
|
readonly property var springDampingScales: [1.22, 1.0, 0.82]
|
|
|
|
// Must stay under the 16px shadow motion padding every fluid surface reserves.
|
|
readonly property var fluidOvershootLimits: [0, 4, 10]
|
|
readonly property real fluidOvershootLimit: {
|
|
if (typeof SettingsData === "undefined" || springMotionDisabled)
|
|
return 0;
|
|
return fluidOvershootLimits[Math.round(SettingsData.springBounce)] ?? 4;
|
|
}
|
|
|
|
function tunedSpring(spec, baseDuration) {
|
|
const f = Math.max(0.05, baseDuration / 500);
|
|
const bounce = typeof SettingsData !== "undefined" && SettingsData.springBounce >= 0 && SettingsData.springBounce < springDampingScales.length ? springDampingScales[Math.round(SettingsData.springBounce)] : 1;
|
|
return {
|
|
"stiffness": spec[0] / (f * f),
|
|
"damping": spec[1] / f * bounce,
|
|
"mass": 1
|
|
};
|
|
}
|
|
|
|
function springPreset(name, baseDuration) {
|
|
return tunedSpring(springSpecs[name] ?? springSpecs["default"], baseDuration);
|
|
}
|
|
|
|
readonly property bool springMotionDisabled: currentAnimationBaseDuration <= 0
|
|
|
|
readonly property int notificationAnimationBaseDuration: typeof SettingsData !== "undefined" ? SettingsData.notificationAnimationDuration : 200
|
|
|
|
readonly property int notificationEnterDuration: Math.round(notificationAnimationBaseDuration * 0.875)
|
|
readonly property int notificationExitDuration: Math.round(notificationAnimationBaseDuration * 0.75)
|
|
readonly property int notificationStackShiftDuration: notificationAnimationBaseDuration
|
|
readonly property int notificationStackStaggerDuration: Math.round(notificationAnimationBaseDuration * 0.5)
|
|
|
|
readonly property int notificationExpandDuration: {
|
|
const base = notificationAnimationBaseDuration;
|
|
return base === 0 ? 0 : Math.round(base * 1.0);
|
|
}
|
|
|
|
readonly property int notificationCollapseDuration: {
|
|
const base = notificationAnimationBaseDuration;
|
|
return base === 0 ? 0 : Math.round(base * 0.85);
|
|
}
|
|
|
|
readonly property int notificationInlineExpandDuration: Math.round(notificationAnimationBaseDuration * 0.925)
|
|
readonly property int notificationInlineCollapseDuration: Math.round(notificationAnimationBaseDuration * 0.75)
|
|
|
|
readonly property real notificationExpandedIconSizeNormal: avatarSize
|
|
readonly property real notificationExpandedIconSizeCompact: avatarSize
|
|
readonly property real notificationButtonCornerRadius: cornerRadiusFull
|
|
readonly property real notificationHoverRevealMargin: spacingXL
|
|
readonly property real notificationContentSpacing: spacingXS
|
|
readonly property real notificationCardPadding: spacingM
|
|
readonly property real notificationCardPaddingCompact: spacingS
|
|
|
|
readonly property real stateLayerHover: 0.08
|
|
readonly property real stateLayerFocus: 0.12
|
|
readonly property real stateLayerPressed: 0.12
|
|
readonly property real stateLayerDrag: 0.16
|
|
|
|
readonly property int popoutAnimationDuration: {
|
|
if (typeof SettingsData === "undefined")
|
|
return 150;
|
|
if (SettingsData.syncComponentAnimationSpeeds)
|
|
return Math.min(currentAnimationBaseDuration, 1000);
|
|
return SettingsData.popoutAnimationDuration;
|
|
}
|
|
|
|
readonly property int modalAnimationDuration: {
|
|
if (typeof SettingsData === "undefined")
|
|
return 150;
|
|
if (SettingsData.syncComponentAnimationSpeeds)
|
|
return Math.min(currentAnimationBaseDuration, 1000);
|
|
return SettingsData.modalAnimationDuration;
|
|
}
|
|
|
|
readonly property real radiusStrength: typeof SettingsData !== "undefined" ? SettingsData.radiusStrength : 50
|
|
readonly property real fixedRadius: typeof SettingsData !== "undefined" && SettingsData.radiusMode === "fixed" ? SettingsData.fixedRadius : -1
|
|
readonly property real shapeScale: fixedRadius >= 0 ? fixedRadius / Shape.corners.m : Shape.scaleForStrength(radiusStrength)
|
|
readonly property real cornerRadius: cornerRadiusM
|
|
readonly property real cornerRadiusXXS: Shape.radius("xxs", shapeScale, fixedRadius)
|
|
readonly property real cornerRadiusXS: Shape.radius("xs", shapeScale, fixedRadius)
|
|
readonly property real cornerRadiusS: Shape.radius("s", shapeScale, fixedRadius)
|
|
readonly property real cornerRadiusM: Shape.radius("m", shapeScale, fixedRadius)
|
|
readonly property real cornerRadiusL: Shape.radius("l", shapeScale, fixedRadius)
|
|
readonly property real cornerRadiusLIncreased: Shape.radius("lIncreased", shapeScale, fixedRadius)
|
|
readonly property real cornerRadiusXL: Shape.radius("xl", shapeScale, fixedRadius)
|
|
readonly property real cornerRadiusXLIncreased: Shape.radius("xlIncreased", shapeScale, fixedRadius)
|
|
readonly property real cornerRadiusXXL: Shape.radius("xxl", shapeScale, fixedRadius)
|
|
readonly property real cornerRadiusFull: fixedRadius >= 0 ? fixedRadius : (shapeScale > 0 ? 9999 : 0)
|
|
readonly property real cornerRadiusSmall: cornerRadiusS
|
|
readonly property real cornerRadiusLarge: cornerRadiusL
|
|
readonly property int compositorRadiusOverride: {
|
|
if (typeof SettingsData === "undefined")
|
|
return -1;
|
|
if (!CompositorService.supportsLayoutConfig)
|
|
return -1;
|
|
const override = SettingsData[CompositorService.configKey + "LayoutRadiusOverride"];
|
|
return override === undefined ? -1 : override;
|
|
}
|
|
readonly property real windowRadius: compositorRadiusOverride >= 0 ? compositorRadiusOverride : cornerRadiusL
|
|
|
|
function scaledRadius(radius, limit) {
|
|
return Shape.scaledRadius(radius, limit, shapeScale, fixedRadius);
|
|
}
|
|
|
|
function fullRadius(width, height) {
|
|
return Shape.fullRadius(width, height, shapeScale, fixedRadius);
|
|
}
|
|
|
|
function buttonRadius(width, height, sizeHeight, pressed, round) {
|
|
return Shape.buttonRadius(width, height, sizeHeight, pressed, round, shapeScale, fixedRadius);
|
|
}
|
|
|
|
readonly property real groupedListGap: spacingXXS
|
|
readonly property real groupedListInnerRadius: cornerRadiusXS
|
|
readonly property real groupedListOuterRadius: cornerRadiusL
|
|
|
|
property string fontFamily: {
|
|
if (typeof SettingsData === "undefined")
|
|
return DankCommon.Fonts.sans;
|
|
if (SettingsData.isGreeterMode && SettingsData.lockScreenFontFamily !== "")
|
|
return resolvedFontFamily(SettingsData.lockScreenFontFamily);
|
|
return resolvedFontFamily(SettingsData.fontFamily);
|
|
}
|
|
|
|
property string monoFontFamily: typeof SettingsData !== "undefined" ? resolvedMonoFontFamily(SettingsData.monoFontFamily) : DankCommon.Fonts.mono
|
|
property string displayFontFamily: typeof SettingsData !== "undefined" ? resolvedDisplayFontFamily(SettingsData.displayFontFamily) : DankCommon.Fonts.display
|
|
|
|
readonly property var fontChoices: [
|
|
{
|
|
"value": "ui",
|
|
"text": I18n.tr("Default")
|
|
},
|
|
{
|
|
"value": "display",
|
|
"text": I18n.tr("Display", "Display font role option")
|
|
}
|
|
].concat(DankCommon.Fonts.bundledFamilies.map(family => ({
|
|
"value": family,
|
|
"text": family
|
|
})))
|
|
|
|
function resolvedFontFamily(family) {
|
|
if (family === defaultFontFamily)
|
|
return DankCommon.Fonts.sans;
|
|
return family;
|
|
}
|
|
|
|
function resolvedMonoFontFamily(family) {
|
|
if (family === defaultMonoFontFamily)
|
|
return DankCommon.Fonts.mono;
|
|
return family;
|
|
}
|
|
|
|
function resolvedDisplayFontFamily(family) {
|
|
if (family === defaultDisplayFontFamily)
|
|
return DankCommon.Fonts.display;
|
|
return family;
|
|
}
|
|
|
|
property int fontWeight: typeof SettingsData !== "undefined" ? SettingsData.fontWeight : Font.Normal
|
|
readonly property int fontWeightMedium: shiftedFontWeight(Font.Medium)
|
|
readonly property int fontWeightBold: shiftedFontWeight(Font.Bold)
|
|
|
|
function shiftedFontWeight(weight) {
|
|
return Math.max(Font.Thin, Math.min(Font.Black, weight + fontWeight - Font.Normal));
|
|
}
|
|
|
|
property real fontScale: typeof SettingsData !== "undefined" ? SettingsData.fontScale : 1.0
|
|
|
|
property real spacingXXS: 2
|
|
property real spacingXS: 4
|
|
property real spacingS: 8
|
|
property real spacingM: 12
|
|
property real spacingL: 16
|
|
property real spacingXL: 24
|
|
property real fontSizeSmall: Math.round(fontScale * 12)
|
|
property real fontSizeMedium: Math.round(fontScale * 14)
|
|
property real fontSizeLarge: Math.round(fontScale * 16)
|
|
property real fontSizeXLarge: Math.round(fontScale * 20)
|
|
property real fontSizeXXLarge: Math.round(fontScale * 28)
|
|
property real fontSizeDisplay: Math.round(fontScale * 36)
|
|
property real fontSizeDisplayLarge: Math.round(fontScale * 57)
|
|
property real barHeight: 48
|
|
property real iconSize: 24
|
|
property real iconSizeSmall: 16
|
|
property real iconSizeLarge: 32
|
|
readonly property real iconSizeMedium: 20
|
|
readonly property int smallBreakpoint: 480
|
|
readonly property int mediumBreakpoint: 768
|
|
readonly property real iconButtonSize: 40
|
|
readonly property real minimumTouchTargetSize: 48
|
|
readonly property real listItemHeight: 56
|
|
readonly property real listItemTwoLineHeight: 72
|
|
readonly property real avatarSize: 36
|
|
readonly property real sliderTrackHeight: 16
|
|
readonly property real sliderHandleWidth: 4
|
|
readonly property real sliderHandleWidthPressed: 2
|
|
readonly property real sliderHandleHeight: 28
|
|
readonly property real sliderHandleGap: 6
|
|
readonly property real sliderTrackHeightS: 24
|
|
readonly property real sliderHandleHeightS: 36
|
|
readonly property real sliderTrackHeightM: 40
|
|
readonly property real sliderHandleHeightM: 52
|
|
readonly property real sliderTrackHeightL: 56
|
|
readonly property real sliderHandleHeightL: 68
|
|
readonly property real sliderTrackHeightXL: 96
|
|
readonly property real sliderHandleHeightXL: 108
|
|
readonly property real switchTrackWidth: 52
|
|
readonly property real switchTrackHeight: 32
|
|
readonly property real switchOutlineWidth: 2
|
|
readonly property real switchThumbUnselected: 16
|
|
readonly property real switchThumbSelected: 24
|
|
readonly property real switchThumbPressed: 28
|
|
readonly property real sliderStopSize: 4
|
|
readonly property real sliderTickSize: 3
|
|
readonly property real menuItemHeight: 40
|
|
readonly property real outlineWidth: 1
|
|
readonly property real outlineWidthFocused: 2
|
|
readonly property real dividerWidth: 1
|
|
readonly property real focusRingWidth: SettingsData.focusRingEnabled ? SettingsData.focusRingWidth : 0
|
|
readonly property real focusRingOffset: 3
|
|
readonly property color focusRingColor: {
|
|
switch (SettingsData.focusRingColor) {
|
|
case "secondary":
|
|
return secondary;
|
|
case "outline":
|
|
return outline;
|
|
case "surfaceText":
|
|
return surfaceText;
|
|
default:
|
|
return primary;
|
|
}
|
|
}
|
|
readonly property color lockScreenContentColor: "#ffffff"
|
|
readonly property real lockScreenScrimAlpha: 0.4
|
|
readonly property real lockScreenBlur: 0.8
|
|
readonly property int lockScreenBlurMax: 32
|
|
readonly property color screenOffColor: "#000000"
|
|
readonly property real scrimAlpha: 0.55
|
|
readonly property color scrimColor: currentThemeData.scrim || "#000000"
|
|
readonly property real buttonHeightXXS: 28
|
|
readonly property real buttonHeightXS: 32
|
|
readonly property real buttonHeightS: 40
|
|
readonly property real buttonHeightM: 56
|
|
readonly property real buttonMinWidth: 58
|
|
readonly property real pressScale: 0.98
|
|
readonly property real iconEnterScale: 0.6
|
|
readonly property real osdHeight: 60
|
|
readonly property real osdLevelWidth: 264
|
|
readonly property real osdLevelVerticalHeight: 352
|
|
readonly property real osdMediaWidth: 308
|
|
readonly property real dialogMaxWidth: 560
|
|
readonly property real bottomSheetHandleWidth: 36
|
|
readonly property real bottomSheetHandleHeight: 4
|
|
readonly property real popupEnterScale: 0.92
|
|
readonly property real fabEnterScale: 0.2
|
|
readonly property real pendingOpacity: 0.6
|
|
readonly property real spinnerStrokeWidth: 2
|
|
readonly property real tabMinWidth: 64
|
|
readonly property real tabIndicatorHeight: 3
|
|
readonly property real navigationHeight: 64
|
|
readonly property real navigationRailWidth: 96
|
|
readonly property real navigationItemMinWidth: 80
|
|
readonly property real navigationIndicatorWidth: 56
|
|
readonly property real navigationIndicatorHeight: 32
|
|
readonly property real navigationVerticalPadding: 6
|
|
readonly property real tabIndicatorMinWidth: 24
|
|
readonly property real tabIndicatorInset: 2
|
|
readonly property real launcherTileSize: 120
|
|
readonly property real launcherImageRatio: 0.75
|
|
readonly property int launcherMaxVisibleRows: 8
|
|
readonly property real launcherWidthMicro: 500
|
|
readonly property real launcherWidthDefault: 620
|
|
readonly property real launcherWidthWide: 720
|
|
readonly property real launcherWidthLarge: 860
|
|
readonly property real launcherHeightDefault: 600
|
|
readonly property real launcherScreenMargin: 100
|
|
|
|
readonly property real fieldDefaultWidth: 200
|
|
readonly property real fieldHeight: Math.round(fontSizeMedium * 3)
|
|
readonly property real fieldHeightLarge: 48
|
|
readonly property real outlinedFieldLabelLineHeight: 16
|
|
readonly property real textFieldSpatialStiffness: 800
|
|
readonly property real textFieldSpatialDampingRatio: 1
|
|
readonly property real textFieldFastEffectsStiffness: 3800
|
|
readonly property real textFieldSlowEffectsStiffness: 800
|
|
readonly property real textEditHeight: Math.round(fontSizeMedium * 8)
|
|
readonly property real tooltipMaxWidth: 500
|
|
readonly property int tooltipDelay: 400
|
|
readonly property real scrollbarThickness: 6
|
|
readonly property real scrollbarGap: spacingXS
|
|
readonly property int scrollbarHideDelay: 1200
|
|
readonly property real menuMaxHeight: 400
|
|
readonly property real clockFaceSize: 250
|
|
readonly property real clockOuterRingRatio: 0.34
|
|
readonly property real clockInnerRingRatio: 0.2
|
|
readonly property real clockHandWidth: 2
|
|
readonly property real clockHandleSize: 40
|
|
readonly property real clockCenterSize: 8
|
|
readonly property int clockSwitchDelay: 100
|
|
readonly property real chipIconSize: 18
|
|
readonly property real buttonGroupExpandRatio: 0.15
|
|
readonly property color contrastDark: "#000000"
|
|
readonly property color contrastLight: "#ffffff"
|
|
|
|
property real panelTransparency: 0.85
|
|
property real popupTransparency: {
|
|
if (typeof SettingsData === "undefined")
|
|
return 1.0;
|
|
return SettingsData.popupTransparency !== undefined ? SettingsData.popupTransparency : 1.0;
|
|
}
|
|
|
|
function screenTransition() {
|
|
screenTransitionNeeded();
|
|
}
|
|
|
|
function switchTheme(themeName, savePrefs = true, enableTransition = true) {
|
|
if (enableTransition) {
|
|
screenTransition();
|
|
themeTransitionTimer.themeName = themeName;
|
|
themeTransitionTimer.savePrefs = savePrefs;
|
|
themeTransitionTimer.restart();
|
|
return;
|
|
}
|
|
|
|
if (themeName === dynamic) {
|
|
currentTheme = dynamic;
|
|
if (currentThemeCategory !== "registry")
|
|
currentThemeCategory = dynamic;
|
|
} else if (themeName === custom) {
|
|
currentTheme = custom;
|
|
if (currentThemeCategory !== "registry")
|
|
currentThemeCategory = custom;
|
|
if (typeof SettingsData !== "undefined" && SettingsData.customThemeFile) {
|
|
loadCustomThemeFromFile(SettingsData.customThemeFile);
|
|
}
|
|
} else if (themeName === "" && currentThemeCategory === "registry") {
|
|
// Registry category selected but no theme chosen yet
|
|
} else {
|
|
currentTheme = themeName;
|
|
if (currentThemeCategory !== "registry") {
|
|
currentThemeCategory = "generic";
|
|
}
|
|
}
|
|
const isGreeterMode = (typeof SessionData !== "undefined" && SessionData.isGreeterMode);
|
|
if (savePrefs && typeof SettingsData !== "undefined" && !isGreeterMode) {
|
|
SettingsData.set("currentThemeCategory", currentThemeCategory);
|
|
SettingsData.set("currentThemeName", currentTheme);
|
|
}
|
|
|
|
if (!isGreeterMode) {
|
|
generateSystemThemesFromCurrentTheme();
|
|
}
|
|
}
|
|
|
|
function setLightMode(light, savePrefs = true, enableTransition = false) {
|
|
if (typeof SettingsData !== "undefined" && SettingsData.matugenSmartMode) {
|
|
SettingsData.matugenSmartMode = false;
|
|
SettingsData.saveSettings();
|
|
}
|
|
|
|
if (enableTransition) {
|
|
screenTransition();
|
|
lightModeTransitionTimer.lightMode = light;
|
|
lightModeTransitionTimer.savePrefs = savePrefs;
|
|
lightModeTransitionTimer.restart();
|
|
return;
|
|
}
|
|
|
|
const isGreeterMode = (typeof SessionData !== "undefined" && SessionData.isGreeterMode);
|
|
if (savePrefs && typeof SessionData !== "undefined" && !isGreeterMode) {
|
|
SessionData.setLightMode(light);
|
|
}
|
|
|
|
if (!isGreeterMode) {
|
|
if (typeof SettingsData !== "undefined") {
|
|
SettingsData.updateCosmicThemeMode(light);
|
|
}
|
|
generateSystemThemesFromCurrentTheme();
|
|
}
|
|
}
|
|
|
|
function toggleLightMode(savePrefs = true) {
|
|
setLightMode(!isLightMode, savePrefs, true);
|
|
}
|
|
|
|
function getThemeColors(themeName) {
|
|
if (themeName === "custom" && customThemeData) {
|
|
return customThemeData;
|
|
}
|
|
return StockThemes.getThemeByName(themeName, isLightMode);
|
|
}
|
|
|
|
function switchThemeCategory(category, defaultTheme) {
|
|
screenTransition();
|
|
themeCategoryTransitionTimer.category = category;
|
|
themeCategoryTransitionTimer.defaultTheme = defaultTheme;
|
|
themeCategoryTransitionTimer.restart();
|
|
}
|
|
|
|
function loadCustomTheme(themeData) {
|
|
customThemeRawData = themeData;
|
|
const colorMode = (typeof SessionData !== "undefined" && SessionData.isLightMode) ? "light" : "dark";
|
|
|
|
var baseColors = {};
|
|
if (themeData.dark || themeData.light) {
|
|
baseColors = themeData[colorMode] || themeData.dark || themeData.light || {};
|
|
} else {
|
|
baseColors = themeData;
|
|
}
|
|
|
|
if (themeData.variants) {
|
|
const themeId = themeData.id || "";
|
|
|
|
if (themeData.variants.type === "multi" && themeData.variants.flavors && themeData.variants.accents) {
|
|
const defaults = themeData.variants.defaults || {};
|
|
const modeDefaults = defaults[colorMode] || defaults.dark || {};
|
|
const stored = typeof SettingsData !== "undefined" ? SettingsData.getRegistryThemeMultiVariant(themeId, modeDefaults, colorMode) : modeDefaults;
|
|
var flavorId = stored.flavor || modeDefaults.flavor || "";
|
|
const accentId = stored.accent || modeDefaults.accent || "";
|
|
var flavor = findVariant(themeData.variants.flavors, flavorId);
|
|
if (flavor) {
|
|
const hasCurrentModeColors = flavor[colorMode] && (flavor[colorMode].primary || flavor[colorMode].surface);
|
|
if (!hasCurrentModeColors) {
|
|
flavorId = modeDefaults.flavor || "";
|
|
flavor = findVariant(themeData.variants.flavors, flavorId);
|
|
}
|
|
}
|
|
const accent = findAccent(themeData.variants.accents, accentId);
|
|
if (flavor) {
|
|
const flavorColors = flavor[colorMode] || flavor.dark || flavor.light || {};
|
|
baseColors = mergeColors(baseColors, flavorColors);
|
|
}
|
|
if (accent && flavor) {
|
|
const accentColors = accent[flavor.id] || {};
|
|
baseColors = mergeColors(baseColors, accentColors);
|
|
}
|
|
customThemeData = baseColors;
|
|
generateSystemThemesFromCurrentTheme();
|
|
return;
|
|
}
|
|
|
|
if (themeData.variants.options && themeData.variants.options.length > 0) {
|
|
const selectedVariantId = typeof SettingsData !== "undefined" ? SettingsData.getRegistryThemeVariant(themeId, themeData.variants.default) : themeData.variants.default;
|
|
const variant = findVariant(themeData.variants.options, selectedVariantId);
|
|
if (variant) {
|
|
const variantColors = variant[colorMode] || variant.dark || variant.light || {};
|
|
customThemeData = mergeColors(baseColors, variantColors);
|
|
generateSystemThemesFromCurrentTheme();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
customThemeData = baseColors;
|
|
generateSystemThemesFromCurrentTheme();
|
|
}
|
|
|
|
function findVariant(options, variantId) {
|
|
if (!variantId || !options)
|
|
return null;
|
|
for (var i = 0; i < options.length; i++) {
|
|
if (options[i].id === variantId)
|
|
return options[i];
|
|
}
|
|
return options[0] || null;
|
|
}
|
|
|
|
function findAccent(accents, accentId) {
|
|
if (!accentId || !accents)
|
|
return null;
|
|
for (var i = 0; i < accents.length; i++) {
|
|
if (accents[i].id === accentId)
|
|
return accents[i];
|
|
}
|
|
return accents[0] || null;
|
|
}
|
|
|
|
function mergeColors(base, overlay) {
|
|
var result = JSON.parse(JSON.stringify(base));
|
|
for (var key in overlay) {
|
|
if (overlay[key])
|
|
result[key] = overlay[key];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function loadCustomThemeFromFile(filePath) {
|
|
customThemeFileView.path = Paths.expandTilde(filePath);
|
|
}
|
|
|
|
function reloadCustomThemeVariant() {
|
|
if (currentTheme !== "custom" || !customThemeRawData)
|
|
return;
|
|
loadCustomTheme(customThemeRawData);
|
|
}
|
|
|
|
property alias availableThemeNames: root._availableThemeNames
|
|
readonly property var _availableThemeNames: StockThemes.getAllThemeNames()
|
|
property string currentThemeName: currentTheme
|
|
|
|
property real notepadTransparency: SettingsData.notepadTransparencyOverride >= 0 ? SettingsData.notepadTransparencyOverride : floatingWindowTransparency
|
|
|
|
property bool widgetBackgroundHasAlpha: {
|
|
const colorMode = typeof SettingsData !== "undefined" ? SettingsData.widgetBackgroundColor : "default";
|
|
return colorMode === "sth" || colorMode === "custom";
|
|
}
|
|
|
|
function safeColor(value, fallback) {
|
|
try {
|
|
if (value === undefined || value === null || value === "")
|
|
return fallback;
|
|
return Qt.color(value);
|
|
} catch (e) {
|
|
return fallback;
|
|
}
|
|
}
|
|
|
|
readonly property color widgetBackgroundCustomBaseColor: safeColor(typeof SettingsData !== "undefined" ? SettingsData.widgetBackgroundCustomColor : "#6750A4", primaryContainer)
|
|
readonly property real widgetBackgroundCustomStrength: Math.max(0, Math.min(1, typeof SettingsData !== "undefined" ? (SettingsData.widgetBackgroundCustomStrength ?? 0.4) : 0.4))
|
|
|
|
property var widgetBaseBackgroundColor: {
|
|
const colorMode = typeof SettingsData !== "undefined" ? SettingsData.widgetBackgroundColor : "default";
|
|
switch (colorMode) {
|
|
case "default":
|
|
return cardSurface;
|
|
case "s":
|
|
return surface;
|
|
case "sc":
|
|
return surfaceContainer;
|
|
case "sch":
|
|
return surfaceContainerHigh;
|
|
case "primaryContainer":
|
|
return primaryContainer;
|
|
case "secondaryContainer":
|
|
return secondaryContainer;
|
|
case "tertiaryContainer":
|
|
return tertiaryContainer;
|
|
case "custom":
|
|
return blend(surfaceContainerHigh, widgetBackgroundCustomBaseColor, widgetBackgroundCustomStrength);
|
|
case "sth":
|
|
default:
|
|
return surfaceTextHover;
|
|
}
|
|
}
|
|
|
|
property color widgetBaseHoverColor: {
|
|
const blended = blend(widgetBaseBackgroundColor, primary, 0.1);
|
|
return withAlpha(blended, Math.max(0.3, blended.a));
|
|
}
|
|
|
|
property color widgetIconColor: {
|
|
if (typeof SettingsData === "undefined") {
|
|
return surfaceText;
|
|
}
|
|
|
|
switch (SettingsData.widgetColorMode) {
|
|
case "colorful":
|
|
return surfaceText;
|
|
case "default":
|
|
default:
|
|
return surfaceText;
|
|
}
|
|
}
|
|
|
|
property color widgetInactiveIconColor: withAlpha(widgetIconColor, 0.6)
|
|
|
|
property color widgetTextColor: {
|
|
if (typeof SettingsData === "undefined") {
|
|
return surfaceText;
|
|
}
|
|
|
|
switch (SettingsData.widgetColorMode) {
|
|
case "colorful":
|
|
return primary;
|
|
case "default":
|
|
default:
|
|
return surfaceText;
|
|
}
|
|
}
|
|
|
|
function barIconSize(barThickness, offset, maximizeIcon, iconScale) {
|
|
const defaultOffset = offset !== undefined ? offset : -6;
|
|
const size = (maximizeIcon ?? false) ? iconSizeLarge : iconSize;
|
|
const s = iconScale !== undefined ? iconScale : 1.0;
|
|
|
|
return 2 * Math.round((barThickness / 48) * (size + defaultOffset) * s / 2);
|
|
}
|
|
|
|
function barTextSize(barThickness, fontScale, maximizeText) {
|
|
const scale = barThickness / 48;
|
|
const dankBarScale = fontScale !== undefined ? fontScale : 1.0;
|
|
const maximized = maximizeText ?? false;
|
|
if (scale <= 0.75)
|
|
return Math.round((maximized ? fontSizeMedium : fontSizeSmall * 0.9) * dankBarScale);
|
|
if (scale >= 1.25)
|
|
return Math.round((maximized ? fontSizeXLarge : fontSizeMedium) * dankBarScale);
|
|
return Math.round((maximized ? fontSizeLarge : fontSizeSmall) * dankBarScale);
|
|
}
|
|
|
|
// !TODO: plugin API only (dms-plugins DankKDEConnect); fold into a parametrized BatteryService ladder and drop from Theme
|
|
function getBatteryIcon(level, isCharging, batteryAvailable) {
|
|
if (!batteryAvailable)
|
|
return "battery_std";
|
|
|
|
if (isCharging) {
|
|
if (level >= 90)
|
|
return "battery_charging_full";
|
|
if (level >= 80)
|
|
return "battery_charging_90";
|
|
if (level >= 60)
|
|
return "battery_charging_80";
|
|
if (level >= 50)
|
|
return "battery_charging_60";
|
|
if (level >= 30)
|
|
return "battery_charging_50";
|
|
if (level >= 20)
|
|
return "battery_charging_30";
|
|
return "battery_charging_20";
|
|
} else {
|
|
if (level >= 95)
|
|
return "battery_full";
|
|
if (level >= 85)
|
|
return "battery_6_bar";
|
|
if (level >= 70)
|
|
return "battery_5_bar";
|
|
if (level >= 55)
|
|
return "battery_4_bar";
|
|
if (level >= 40)
|
|
return "battery_3_bar";
|
|
if (level >= 25)
|
|
return "battery_2_bar";
|
|
if (level >= 10)
|
|
return "battery_1_bar";
|
|
return "battery_alert";
|
|
}
|
|
}
|
|
|
|
function getPowerProfileIcon(profile) {
|
|
switch (profile) {
|
|
case 0:
|
|
return "battery_saver";
|
|
case 1:
|
|
return "battery_std";
|
|
case 2:
|
|
return "flash_on";
|
|
default:
|
|
return "settings";
|
|
}
|
|
}
|
|
|
|
function getPowerProfileLabel(profile) {
|
|
switch (profile) {
|
|
case 0:
|
|
return I18n.tr("Power Saver", "power profile option");
|
|
case 1:
|
|
return I18n.tr("Balanced", "power profile option");
|
|
case 2:
|
|
return I18n.tr("Performance", "power profile option");
|
|
default:
|
|
return I18n.tr("Unknown", "power profile option");
|
|
}
|
|
}
|
|
|
|
function onLightModeChanged() {
|
|
if (currentTheme === "custom" && customThemeFileView.path) {
|
|
customThemeFileView.reload();
|
|
}
|
|
}
|
|
|
|
function setDesiredTheme(kind, value, isLight, iconTheme, matugenType, stockColors) {
|
|
if (!matugenAvailable) {
|
|
log.warn("matugen not available or disabled - cannot set system theme");
|
|
return;
|
|
}
|
|
|
|
if (workerRunning) {
|
|
log.info("Worker already running, queueing request");
|
|
pendingThemeRequest = {
|
|
kind,
|
|
value,
|
|
isLight,
|
|
iconTheme,
|
|
matugenType,
|
|
stockColors
|
|
};
|
|
return;
|
|
}
|
|
|
|
const desired = {
|
|
"kind": kind,
|
|
"value": value,
|
|
"mode": (typeof SettingsData !== "undefined" && SettingsData.matugenSmartMode && kind === "image" && !stockColors) ? "smart" : (isLight ? "light" : "dark"),
|
|
"iconTheme": iconTheme || "System Default",
|
|
"matugenType": matugenType || "scheme-tonal-spot",
|
|
"runUserTemplates": (typeof SettingsData !== "undefined") ? SettingsData.runUserMatugenTemplates : true
|
|
};
|
|
|
|
const args = ["dms", "matugen", "queue", "--state-dir", stateDir, "--shell-dir", shellDir, "--config-dir", configDir, "--kind", desired.kind, "--value", desired.value, "--mode", desired.mode, "--icon-theme", desired.iconTheme, "--matugen-type", desired.matugenType,];
|
|
|
|
if (!desired.runUserTemplates) {
|
|
args.push("--run-user-templates=false");
|
|
}
|
|
if (stockColors) {
|
|
args.push("--stock-colors", JSON.stringify(stockColors));
|
|
}
|
|
if (typeof SettingsData !== "undefined" && SettingsData.syncModeWithPortal) {
|
|
args.push("--sync-mode-with-portal");
|
|
}
|
|
if (typeof SettingsData !== "undefined" && SettingsData.terminalsAlwaysDark) {
|
|
args.push("--terminals-always-dark");
|
|
}
|
|
if (typeof SettingsData !== "undefined" && SettingsData.matugenContrast !== 0) {
|
|
args.push("--contrast", SettingsData.matugenContrast.toString());
|
|
}
|
|
// Only sent when it would change something. A shell newer than the dms
|
|
// binary is a supported setup (DMS_SHELL_DIR / -c), and an older binary
|
|
// exits with "unknown flag: --source-mode" rather than ignoring it, so
|
|
// the default must not put the flag on the command line at all.
|
|
const seedColor = (typeof SettingsData !== "undefined" && !stockColors) ? SettingsData.matugenSeedColor : "";
|
|
if (seedColor) {
|
|
args.push("--seed-color", seedColor);
|
|
} else if (typeof SettingsData !== "undefined" && SettingsData.matugenSourceMode && SettingsData.matugenSourceMode !== "dominant") {
|
|
args.push("--source-mode", SettingsData.matugenSourceMode);
|
|
}
|
|
if (typeof SettingsData !== "undefined" && !stockColors && SettingsData.matugenSpec === "2025") {
|
|
args.push("--spec", "2025");
|
|
}
|
|
|
|
if (typeof SettingsData !== "undefined") {
|
|
const skipTemplates = [];
|
|
if (!SettingsData.runDmsMatugenTemplates) {
|
|
skipTemplates.push("gtk", "nvim", "niri", "qt5ct", "qt6ct", "qtengine", "fcitx5", "firefox", "pywalfox", "zenbrowser", "vesktop", "vencord", "equibop", "ghostty", "kitty", "foot", "alacritty", "wezterm", "dgop", "kcolorscheme", "vscode", "emacs", "zed");
|
|
} else {
|
|
if (!SettingsData.matugenTemplateGtk)
|
|
skipTemplates.push("gtk");
|
|
if (!SettingsData.matugenTemplateNiri)
|
|
skipTemplates.push("niri");
|
|
if (!SettingsData.matugenTemplateHyprland)
|
|
skipTemplates.push("hyprland");
|
|
if (!SettingsData.matugenTemplateMangowc)
|
|
skipTemplates.push("mangowc");
|
|
if (!SettingsData.matugenTemplateQt5ct)
|
|
skipTemplates.push("qt5ct");
|
|
if (!SettingsData.matugenTemplateQt6ct)
|
|
skipTemplates.push("qt6ct");
|
|
if (!SettingsData.matugenTemplateQtengine)
|
|
skipTemplates.push("qtengine");
|
|
if (!SettingsData.matugenTemplateFcitx5)
|
|
skipTemplates.push("fcitx5");
|
|
if (!SettingsData.matugenTemplateFirefox)
|
|
skipTemplates.push("firefox");
|
|
if (!SettingsData.matugenTemplatePywalfox)
|
|
skipTemplates.push("pywalfox");
|
|
if (!SettingsData.matugenTemplateZenBrowser)
|
|
skipTemplates.push("zenbrowser");
|
|
if (!SettingsData.matugenTemplateVesktop)
|
|
skipTemplates.push("vesktop");
|
|
if (!SettingsData.matugenTemplateVencord)
|
|
skipTemplates.push("vencord");
|
|
if (!SettingsData.matugenTemplateEquibop)
|
|
skipTemplates.push("equibop");
|
|
if (!SettingsData.matugenTemplateGhostty)
|
|
skipTemplates.push("ghostty");
|
|
if (!SettingsData.matugenTemplateKitty)
|
|
skipTemplates.push("kitty");
|
|
if (!SettingsData.matugenTemplateFoot)
|
|
skipTemplates.push("foot");
|
|
if (!SettingsData.matugenTemplateNeovim)
|
|
skipTemplates.push("nvim");
|
|
if (!SettingsData.matugenTemplateAlacritty)
|
|
skipTemplates.push("alacritty");
|
|
if (!SettingsData.matugenTemplateWezterm)
|
|
skipTemplates.push("wezterm");
|
|
if (!SettingsData.matugenTemplateDgop)
|
|
skipTemplates.push("dgop");
|
|
if (!SettingsData.matugenTemplateKcolorscheme)
|
|
skipTemplates.push("kcolorscheme");
|
|
if (!SettingsData.matugenTemplateVscode)
|
|
skipTemplates.push("vscode");
|
|
if (!SettingsData.matugenTemplateEmacs)
|
|
skipTemplates.push("emacs");
|
|
if (!SettingsData.matugenTemplateZed)
|
|
skipTemplates.push("zed");
|
|
}
|
|
if (skipTemplates.length > 0) {
|
|
args.push("--skip-templates", skipTemplates.join(","));
|
|
}
|
|
}
|
|
|
|
const runKey = Qt.md5(JSON.stringify(args));
|
|
const skipUnchanged = !_matugenRunKey && !colorsFileLoadFailed && typeof SettingsData !== "undefined" && !SettingsData.generateThemeAtStartup;
|
|
if (skipUnchanged && runKey === CacheData.matugenAppliedKey) {
|
|
log.info("Theme inputs unchanged since the last run, skipping startup generation");
|
|
return;
|
|
}
|
|
|
|
log.info("Setting desired theme -", kind, "mode:", isLight ? "light" : "dark", stockColors ? "(stock colors)" : "(dynamic)");
|
|
themeGenerationStarting();
|
|
|
|
log.debug("Starting matugen worker");
|
|
workerRunning = true;
|
|
_matugenRunKey = runKey;
|
|
_lastGenerateMs = Date.now();
|
|
systemThemeGenerator.command = args;
|
|
systemThemeGenerator.running = true;
|
|
}
|
|
|
|
function generateSystemThemesFromCurrentTheme() {
|
|
const isGreeterMode = (typeof SessionData !== "undefined" && SessionData.isGreeterMode);
|
|
if (!matugenAvailable || isGreeterMode)
|
|
return;
|
|
|
|
_pendingGenerateParams = true;
|
|
_themeGenerateDebounce.restart();
|
|
}
|
|
|
|
function _executeThemeGeneration() {
|
|
if (!_pendingGenerateParams)
|
|
return;
|
|
_pendingGenerateParams = null;
|
|
|
|
const isLight = (typeof SessionData !== "undefined" && SessionData.isLightMode);
|
|
const iconTheme = (typeof SettingsData !== "undefined" && SettingsData.iconTheme) ? SettingsData.iconTheme : "System Default";
|
|
|
|
if (currentTheme === dynamic) {
|
|
if (!rawWallpaperPath) {
|
|
log.warn("Auto theme has no wallpaper - skipping matugen");
|
|
return;
|
|
}
|
|
const selectedMatugenType = (typeof SettingsData !== "undefined" && SettingsData.matugenScheme) ? SettingsData.matugenScheme : "scheme-tonal-spot";
|
|
const kind = rawWallpaperPath.startsWith("#") ? "hex" : "image";
|
|
setDesiredTheme(kind, rawWallpaperPath, isLight, iconTheme, selectedMatugenType, null);
|
|
return;
|
|
}
|
|
|
|
let darkTheme, lightTheme;
|
|
if (currentTheme === "custom") {
|
|
if (customThemeRawData && (customThemeRawData.dark || customThemeRawData.light)) {
|
|
darkTheme = customThemeRawData.dark || customThemeRawData.light;
|
|
lightTheme = customThemeRawData.light || customThemeRawData.dark;
|
|
|
|
if (customThemeRawData.variants) {
|
|
const themeId = customThemeRawData.id || "";
|
|
|
|
if (customThemeRawData.variants.type === "multi" && customThemeRawData.variants.flavors && customThemeRawData.variants.accents) {
|
|
const defaults = customThemeRawData.variants.defaults || {};
|
|
const darkDefaults = defaults.dark || {};
|
|
const lightDefaults = defaults.light || defaults.dark || {};
|
|
const storedDark = typeof SettingsData !== "undefined" ? SettingsData.getRegistryThemeMultiVariant(themeId, darkDefaults, "dark") : darkDefaults;
|
|
const storedLight = typeof SettingsData !== "undefined" ? SettingsData.getRegistryThemeMultiVariant(themeId, lightDefaults, "light") : lightDefaults;
|
|
const darkFlavorId = storedDark.flavor || darkDefaults.flavor || "";
|
|
const lightFlavorId = storedLight.flavor || lightDefaults.flavor || "";
|
|
const darkAccentId = storedDark.accent || darkDefaults.accent || "";
|
|
const lightAccentId = storedLight.accent || lightDefaults.accent || "";
|
|
const darkFlavor = findVariant(customThemeRawData.variants.flavors, darkFlavorId);
|
|
const lightFlavor = findVariant(customThemeRawData.variants.flavors, lightFlavorId);
|
|
const darkAccent = findAccent(customThemeRawData.variants.accents, darkAccentId);
|
|
const lightAccent = findAccent(customThemeRawData.variants.accents, lightAccentId);
|
|
if (darkFlavor) {
|
|
darkTheme = mergeColors(darkTheme, darkFlavor.dark || {});
|
|
if (darkAccent)
|
|
darkTheme = mergeColors(darkTheme, darkAccent[darkFlavor.id] || {});
|
|
}
|
|
if (lightFlavor) {
|
|
lightTheme = mergeColors(lightTheme, lightFlavor.light || {});
|
|
if (lightAccent)
|
|
lightTheme = mergeColors(lightTheme, lightAccent[lightFlavor.id] || {});
|
|
}
|
|
} else if (customThemeRawData.variants.options) {
|
|
const selectedVariantId = typeof SettingsData !== "undefined" ? SettingsData.getRegistryThemeVariant(themeId, customThemeRawData.variants.default) : customThemeRawData.variants.default;
|
|
const variant = findVariant(customThemeRawData.variants.options, selectedVariantId);
|
|
if (variant) {
|
|
darkTheme = mergeColors(darkTheme, variant.dark || {});
|
|
lightTheme = mergeColors(lightTheme, variant.light || {});
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
darkTheme = customThemeData;
|
|
lightTheme = customThemeData;
|
|
}
|
|
} else {
|
|
darkTheme = StockThemes.getThemeByName(currentTheme, false);
|
|
lightTheme = StockThemes.getThemeByName(currentTheme, true);
|
|
}
|
|
|
|
if (!darkTheme || !darkTheme.primary) {
|
|
log.warn("Theme data not available for:", currentTheme);
|
|
return;
|
|
}
|
|
|
|
const stockColors = buildMatugenColorsFromTheme(darkTheme, lightTheme);
|
|
const themeData = isLight ? lightTheme : darkTheme;
|
|
setDesiredTheme("hex", themeData.primary, isLight, iconTheme, themeData.matugen_type, stockColors);
|
|
}
|
|
|
|
function buildMatugenColorsFromTheme(darkTheme, lightTheme) {
|
|
const colors = {};
|
|
const isLight = SessionData !== "undefined" && SessionData.isLightMode;
|
|
|
|
function addColor(matugenKey, darkVal, lightVal) {
|
|
if (!darkVal && !lightVal)
|
|
return;
|
|
colors[matugenKey] = {
|
|
"dark": {
|
|
"color": String(darkVal || lightVal)
|
|
},
|
|
"light": {
|
|
"color": String(lightVal || darkVal)
|
|
},
|
|
"default": {
|
|
"color": String((isLight && lightVal) ? lightVal : darkVal)
|
|
}
|
|
};
|
|
}
|
|
|
|
function get(theme, key, fallback) {
|
|
return theme[key] || fallback;
|
|
}
|
|
|
|
function onContainer(theme, container, explicit) {
|
|
if (explicit)
|
|
return explicit;
|
|
if (!container || !theme.surfaceText || !theme.surface)
|
|
return theme.surfaceText;
|
|
return Contrast.readableOn(Qt.color(container), [Qt.color(theme.surfaceText), Qt.color(theme.surface), contrastLight, contrastDark]).toString();
|
|
}
|
|
|
|
addColor("primary", darkTheme.primary, lightTheme.primary);
|
|
addColor("on_primary", darkTheme.primaryText, lightTheme.primaryText);
|
|
addColor("primary_container", darkTheme.primaryContainer, lightTheme.primaryContainer);
|
|
addColor("on_primary_container", onContainer(darkTheme, darkTheme.primaryContainer, darkTheme.onPrimaryContainer || darkTheme.primaryContainerText), onContainer(lightTheme, lightTheme.primaryContainer, lightTheme.onPrimaryContainer || lightTheme.primaryContainerText));
|
|
addColor("secondary", darkTheme.secondary, lightTheme.secondary);
|
|
addColor("on_secondary", darkTheme.secondaryText || darkTheme.primaryText, lightTheme.secondaryText || lightTheme.primaryText);
|
|
addColor("secondary_container", darkTheme.secondaryContainer || darkTheme.surfaceContainerHigh, lightTheme.secondaryContainer || lightTheme.surfaceContainerHigh);
|
|
addColor("on_secondary_container", onContainer(darkTheme, darkTheme.secondaryContainer, darkTheme.onSecondaryContainer || darkTheme.secondaryContainerText), onContainer(lightTheme, lightTheme.secondaryContainer, lightTheme.onSecondaryContainer || lightTheme.secondaryContainerText));
|
|
addColor("tertiary", darkTheme.tertiary || darkTheme.secondary, lightTheme.tertiary || lightTheme.secondary);
|
|
addColor("on_tertiary", darkTheme.tertiaryText || darkTheme.secondaryText || darkTheme.primaryText, lightTheme.tertiaryText || lightTheme.secondaryText || lightTheme.primaryText);
|
|
addColor("tertiary_container", darkTheme.tertiaryContainer || darkTheme.secondaryContainer || darkTheme.surfaceContainerHigh, lightTheme.tertiaryContainer || lightTheme.secondaryContainer || lightTheme.surfaceContainerHigh);
|
|
addColor("on_tertiary_container", onContainer(darkTheme, darkTheme.tertiaryContainer, darkTheme.onTertiaryContainer || darkTheme.tertiaryContainerText), onContainer(lightTheme, lightTheme.tertiaryContainer, lightTheme.onTertiaryContainer || lightTheme.tertiaryContainerText));
|
|
addColor("error", darkTheme.error || "#F2B8B5", lightTheme.error || "#B3261E");
|
|
addColor("on_error", darkTheme.errorText || "#601410", lightTheme.errorText || "#FFFFFF");
|
|
addColor("error_container", darkTheme.errorContainer || "#8C1D18", lightTheme.errorContainer || "#F9DEDC");
|
|
addColor("on_error_container", darkTheme.errorContainerText || "#F9DEDC", lightTheme.errorContainerText || "#410E0B");
|
|
addColor("surface", darkTheme.surface, lightTheme.surface);
|
|
addColor("on_surface", darkTheme.surfaceText, lightTheme.surfaceText);
|
|
addColor("surface_variant", darkTheme.surfaceVariant, lightTheme.surfaceVariant);
|
|
addColor("on_surface_variant", darkTheme.surfaceVariantText, lightTheme.surfaceVariantText);
|
|
addColor("surface_tint", darkTheme.surfaceTint, lightTheme.surfaceTint);
|
|
addColor("background", darkTheme.background, lightTheme.background);
|
|
addColor("on_background", darkTheme.backgroundText, lightTheme.backgroundText);
|
|
addColor("outline", darkTheme.outline, lightTheme.outline);
|
|
addColor("outline_variant", darkTheme.outlineVariant || darkTheme.surfaceVariant, lightTheme.outlineVariant || lightTheme.surfaceVariant);
|
|
addColor("surface_container", darkTheme.surfaceContainer, lightTheme.surfaceContainer);
|
|
addColor("surface_container_high", darkTheme.surfaceContainerHigh, lightTheme.surfaceContainerHigh);
|
|
addColor("surface_container_highest", darkTheme.surfaceContainerHighest || darkTheme.surfaceContainerHigh, lightTheme.surfaceContainerHighest || lightTheme.surfaceContainerHigh);
|
|
addColor("surface_container_low", darkTheme.surfaceContainerLow || darkTheme.surface, lightTheme.surfaceContainerLow || lightTheme.surface);
|
|
addColor("surface_container_lowest", darkTheme.surfaceContainerLowest || darkTheme.background, lightTheme.surfaceContainerLowest || lightTheme.background);
|
|
addColor("surface_bright", darkTheme.surfaceBright || darkTheme.surfaceContainerHighest || darkTheme.surfaceContainerHigh, lightTheme.surfaceBright || lightTheme.surface);
|
|
addColor("surface_dim", darkTheme.surfaceDim || darkTheme.background, lightTheme.surfaceDim || lightTheme.surfaceContainer);
|
|
addColor("inverse_surface", darkTheme.inverseSurface || lightTheme.surface, lightTheme.inverseSurface || darkTheme.surface);
|
|
addColor("inverse_on_surface", darkTheme.inverseOnSurface || lightTheme.surfaceText, lightTheme.inverseOnSurface || darkTheme.surfaceText);
|
|
addColor("inverse_primary", darkTheme.inversePrimary || lightTheme.primary, lightTheme.inversePrimary || darkTheme.primary);
|
|
addColor("scrim", darkTheme.scrim || "#000000", lightTheme.scrim || "#000000");
|
|
addColor("shadow", darkTheme.shadow || "#000000", lightTheme.shadow || "#000000");
|
|
addColor("source_color", darkTheme.primary, lightTheme.primary);
|
|
addColor("primary_fixed", darkTheme.primaryFixed || darkTheme.primaryContainer, lightTheme.primaryFixed || lightTheme.primaryContainer);
|
|
addColor("primary_fixed_dim", darkTheme.primaryFixedDim || darkTheme.primary, lightTheme.primaryFixedDim || lightTheme.primary);
|
|
addColor("on_primary_fixed", darkTheme.onPrimaryFixed || darkTheme.primaryText, lightTheme.onPrimaryFixed || lightTheme.primaryText);
|
|
addColor("on_primary_fixed_variant", darkTheme.onPrimaryFixedVariant || darkTheme.primaryText, lightTheme.onPrimaryFixedVariant || lightTheme.primaryText);
|
|
addColor("secondary_fixed", darkTheme.secondaryFixed || darkTheme.secondary, lightTheme.secondaryFixed || lightTheme.secondary);
|
|
addColor("secondary_fixed_dim", darkTheme.secondaryFixedDim || darkTheme.secondary, lightTheme.secondaryFixedDim || lightTheme.secondary);
|
|
addColor("on_secondary_fixed", darkTheme.onSecondaryFixed || darkTheme.primaryText, lightTheme.onSecondaryFixed || lightTheme.primaryText);
|
|
addColor("on_secondary_fixed_variant", darkTheme.onSecondaryFixedVariant || darkTheme.primaryText, lightTheme.onSecondaryFixedVariant || lightTheme.primaryText);
|
|
addColor("tertiary_fixed", darkTheme.tertiaryFixed || darkTheme.tertiary || darkTheme.secondary, lightTheme.tertiaryFixed || lightTheme.tertiary || lightTheme.secondary);
|
|
addColor("tertiary_fixed_dim", darkTheme.tertiaryFixedDim || darkTheme.tertiary || darkTheme.secondary, lightTheme.tertiaryFixedDim || lightTheme.tertiary || lightTheme.secondary);
|
|
addColor("on_tertiary_fixed", darkTheme.onTertiaryFixed || darkTheme.primaryText, lightTheme.onTertiaryFixed || lightTheme.primaryText);
|
|
addColor("on_tertiary_fixed_variant", darkTheme.onTertiaryFixedVariant || darkTheme.primaryText, lightTheme.onTertiaryFixedVariant || lightTheme.primaryText);
|
|
|
|
return colors;
|
|
}
|
|
|
|
function refreshGtkTheme() {
|
|
const isLight = (typeof SessionData !== "undefined" && SessionData.isLightMode);
|
|
const theme = isLight ? "adw-gtk3" : "adw-gtk3-dark";
|
|
const schema = "org.gnome.desktop.interface";
|
|
const key = "gtk-theme";
|
|
const reset = GSettings.setCmd(schema, key, "");
|
|
const apply = GSettings.setCmd(schema, key, theme);
|
|
|
|
Proc.runCommand("gtkRefresher", ["sh", "-c", `${reset}; ${apply}`], (output, exitCode) => {
|
|
if (exitCode !== 0) {
|
|
log.warn("Failed to refresh gtk-theme");
|
|
}
|
|
});
|
|
}
|
|
|
|
function patchGtk3colors() {
|
|
const isLight = (typeof SessionData !== "undefined" && SessionData.isLightMode);
|
|
Proc.runCommand("gtk3Patcher", ["bash", shellDir + "/scripts/gtk.sh", configDir, "patch", isLight], (output, exitCode) => {
|
|
switch (exitCode) {
|
|
case 0:
|
|
refreshGtkTheme();
|
|
break;
|
|
case 2:
|
|
break;
|
|
default:
|
|
log.warn(`Failed to patch GTK3 colors: ${output}`);
|
|
}
|
|
});
|
|
}
|
|
|
|
function applyGtkColors() {
|
|
if (!matugenAvailable) {
|
|
if (typeof ToastService !== "undefined") {
|
|
ToastService.showError(I18n.tr("matugen not available or disabled - cannot apply %1 colors", "error toast, %1 is GTK or Qt").arg("GTK"));
|
|
}
|
|
return;
|
|
}
|
|
|
|
const isLight = (typeof SessionData !== "undefined" && SessionData.isLightMode) ? "true" : "false";
|
|
Proc.runCommand("gtkApplier", ["bash", shellDir + "/scripts/gtk.sh", configDir, "apply", isLight], (output, exitCode) => {
|
|
if (exitCode === 0) {
|
|
if (typeof ToastService !== "undefined" && !root.matugenToastSuppressed) {
|
|
ToastService.showInfo(I18n.tr("GTK colors applied successfully"));
|
|
}
|
|
} else {
|
|
if (typeof ToastService !== "undefined") {
|
|
ToastService.showError(I18n.tr("Failed to apply %1 colors", "error toast, %1 is GTK or Qt").arg("GTK"));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
function applyQtColors() {
|
|
if (!matugenAvailable) {
|
|
if (typeof ToastService !== "undefined") {
|
|
ToastService.showError(I18n.tr("matugen not available or disabled - cannot apply %1 colors").arg("Qt"));
|
|
}
|
|
return;
|
|
}
|
|
|
|
const isQtengineActive = SettingsData.qtengineActive;
|
|
let pendingAppliers = isQtengineActive ? 2 : 1;
|
|
let anyApplierSucceeded = false;
|
|
let qtengineFailed = false;
|
|
|
|
const finishApplyQtColors = succeeded => {
|
|
anyApplierSucceeded = anyApplierSucceeded || succeeded;
|
|
pendingAppliers -= 1;
|
|
if (pendingAppliers !== 0)
|
|
return;
|
|
if (typeof ToastService === "undefined")
|
|
return;
|
|
if (anyApplierSucceeded && !qtengineFailed) {
|
|
ToastService.showInfo(I18n.tr("Qt colors applied successfully"));
|
|
} else {
|
|
ToastService.showError(I18n.tr("Failed to apply %1 colors").arg("Qt"));
|
|
}
|
|
};
|
|
|
|
Proc.runCommand("qtApplier", ["bash", shellDir + "/scripts/qt.sh", configDir], (output, exitCode) => {
|
|
finishApplyQtColors(exitCode === 0);
|
|
});
|
|
|
|
if (isQtengineActive) {
|
|
Proc.runCommand("qtengineApplier", [Proc.dmsBin, "matugen", "qtengine", "--config-dir", configDir], (output, exitCode) => {
|
|
qtengineFailed = exitCode !== 0;
|
|
finishApplyQtColors(exitCode === 0);
|
|
});
|
|
}
|
|
}
|
|
|
|
function withAlpha(c, a) {
|
|
if (!c || c.r === undefined)
|
|
return Qt.rgba(0, 0, 0, 0);
|
|
return Qt.rgba(c.r, c.g, c.b, a);
|
|
}
|
|
|
|
function blendAlpha(c, a) {
|
|
if (!c || c.r === undefined)
|
|
return Qt.rgba(0, 0, 0, 0);
|
|
return Qt.rgba(c.r, c.g, c.b, c.a * a);
|
|
}
|
|
|
|
function hoverTint(base) {
|
|
const factor = 1.2;
|
|
return isLightMode ? Qt.darker(base, factor) : Qt.lighter(base, factor);
|
|
}
|
|
|
|
function blend(c1, c2, r) {
|
|
return Qt.rgba(c1.r * (1 - r) + c2.r * r, c1.g * (1 - r) + c2.g * r, c1.b * (1 - r) + c2.b * r, c1.a * (1 - r) + c2.a * r);
|
|
}
|
|
|
|
function luminance(c) {
|
|
if (!c || c.r === undefined)
|
|
return 0;
|
|
return 0.299 * c.r + 0.587 * c.g + 0.114 * c.b;
|
|
}
|
|
|
|
function isLightColor(c, threshold = 0.5) {
|
|
return luminance(c) > threshold;
|
|
}
|
|
|
|
function getFillMode(modeName) {
|
|
switch (modeName) {
|
|
case "Stretch":
|
|
return Image.Stretch;
|
|
case "Fit":
|
|
case "PreserveAspectFit":
|
|
return Image.PreserveAspectFit;
|
|
case "Fill":
|
|
case "PreserveAspectCrop":
|
|
return Image.PreserveAspectCrop;
|
|
case "Tile":
|
|
return Image.Tile;
|
|
case "TileVertically":
|
|
return Image.TileVertically;
|
|
case "TileHorizontally":
|
|
return Image.TileHorizontally;
|
|
case "Pad":
|
|
return Image.Pad;
|
|
default:
|
|
return Image.PreserveAspectCrop;
|
|
}
|
|
}
|
|
|
|
// Returns numeric fillMode value for shader use (matches shader calculateUV logic)
|
|
function getShaderFillMode(modeName) {
|
|
switch (modeName) {
|
|
case "Stretch":
|
|
return 0;
|
|
case "Fit":
|
|
case "PreserveAspectFit":
|
|
return 1;
|
|
case "Fill":
|
|
case "PreserveAspectCrop":
|
|
return 2;
|
|
case "Tile":
|
|
return 3;
|
|
case "TileVertically":
|
|
return 4;
|
|
case "TileHorizontally":
|
|
return 5;
|
|
case "Pad":
|
|
return 6;
|
|
case "Scrolling":
|
|
return 7;
|
|
default:
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
function snap(value, dpr) {
|
|
const s = dpr || 1;
|
|
return Math.round(value * s) / s;
|
|
}
|
|
|
|
// Qt rounds a centred anchor offset to whole pixels, so a box must share its content's parity
|
|
function snapEven(value, dpr) {
|
|
const s = dpr || 1;
|
|
return 2 * Math.round(value * s / 2) / s;
|
|
}
|
|
|
|
function px(value, dpr) {
|
|
const s = dpr || 1;
|
|
return Math.round(value * s) / s;
|
|
}
|
|
|
|
// the epsilon keeps a value already on the grid from gaining a pixel through float error
|
|
function pxCeil(value, dpr) {
|
|
const s = dpr || 1;
|
|
return Math.ceil(value * s - 0.001) / s;
|
|
}
|
|
|
|
function barWidgetThickness(innerPadding, dpr) {
|
|
return snapEven(Math.max(20, 26 + innerPadding * 0.6), dpr);
|
|
}
|
|
|
|
function barThickness(innerPadding, dpr) {
|
|
return snapEven(Math.max(barWidgetThickness(innerPadding, dpr) + innerPadding + 4, barHeight - 4 - (8 - innerPadding)), dpr);
|
|
}
|
|
|
|
function hairline(dpr) {
|
|
return 1 / (dpr || 1);
|
|
}
|
|
|
|
Process {
|
|
id: systemThemeGenerator
|
|
running: false
|
|
stdout: SplitParser {
|
|
onRead: data => log.info("Theme worker:", data)
|
|
}
|
|
stderr: SplitParser {
|
|
onRead: data => log.warn("Theme worker:", data)
|
|
}
|
|
|
|
onExited: exitCode => {
|
|
workerRunning = false;
|
|
const currentMode = (typeof SessionData !== "undefined" && SessionData.isLightMode) ? "light" : "dark";
|
|
|
|
switch (exitCode) {
|
|
case 0:
|
|
log.info("Matugen worker completed successfully");
|
|
root.matugenCompleted(currentMode, "success");
|
|
break;
|
|
case 2:
|
|
log.debug("Matugen worker completed with code 2 (no changes needed)");
|
|
root.matugenCompleted(currentMode, "no-changes");
|
|
break;
|
|
default:
|
|
if (typeof ToastService !== "undefined") {
|
|
ToastService.showError(I18n.tr("Theme worker failed (%1)", "error toast, %1 is a process exit code").arg(exitCode));
|
|
}
|
|
log.warn("Matugen worker failed with exit code:", exitCode);
|
|
root.matugenCompleted(currentMode, "error");
|
|
}
|
|
|
|
const appliedKey = (exitCode === 0 || exitCode === 2) ? _matugenRunKey : "";
|
|
if (CacheData.matugenAppliedKey !== appliedKey)
|
|
CacheData.set("matugenAppliedKey", appliedKey);
|
|
|
|
if (!pendingThemeRequest) {
|
|
if (SettingsData.matugenTemplateGtk)
|
|
patchGtk3colors();
|
|
return;
|
|
}
|
|
|
|
const req = pendingThemeRequest;
|
|
pendingThemeRequest = null;
|
|
log.info("Processing queued theme request");
|
|
setDesiredTheme(req.kind, req.value, req.isLight, req.iconTheme, req.matugenType, req.stockColors);
|
|
}
|
|
}
|
|
|
|
FileView {
|
|
id: customThemeFileView
|
|
blockLoading: false
|
|
watchChanges: currentTheme === "custom"
|
|
|
|
function parseAndLoadTheme() {
|
|
try {
|
|
var themeData = JSON.parse(customThemeFileView.text());
|
|
loadCustomTheme(themeData);
|
|
} catch (e) {
|
|
ToastService.showError(I18n.tr("Invalid JSON format: %1", "custom theme file error toast, %1 is the error message").arg(e.message));
|
|
}
|
|
}
|
|
|
|
onLoaded: {
|
|
parseAndLoadTheme();
|
|
}
|
|
|
|
onFileChanged: {
|
|
customThemeFileView.reload();
|
|
}
|
|
|
|
onLoadFailed: function (error) {
|
|
if (typeof ToastService !== "undefined") {
|
|
ToastService.showError(I18n.tr("Failed to read theme file: %1", "error toast, %1 is the error message").arg(error));
|
|
}
|
|
}
|
|
}
|
|
|
|
readonly property string _greeterCacheDir: Quickshell.env("DMS_GREET_CFG_DIR") || "/var/cache/dms-greeter"
|
|
|
|
property string greeterColorsBaseDir: root._greeterCacheDir
|
|
|
|
function setGreeterColorsBaseDir(dir) {
|
|
const next = dir || root._greeterCacheDir;
|
|
if (greeterColorsBaseDir === next)
|
|
return;
|
|
greeterColorsBaseDir = next;
|
|
if (typeof SessionData !== "undefined" && SessionData.isGreeterMode)
|
|
dynamicColorsFileView.reload();
|
|
}
|
|
|
|
function resetGreeterColorsBaseDir() {
|
|
setGreeterColorsBaseDir(root._greeterCacheDir);
|
|
}
|
|
|
|
FileView {
|
|
id: dynamicColorsFileView
|
|
path: {
|
|
if (SessionData.isGreeterMode)
|
|
return root.greeterColorsBaseDir ? (root.greeterColorsBaseDir + "/colors.json") : "";
|
|
return stateDir + "/dms-colors.json";
|
|
}
|
|
blockLoading: false
|
|
watchChanges: !SessionData.isGreeterMode
|
|
|
|
function parseAndLoadColors() {
|
|
try {
|
|
const colorsText = dynamicColorsFileView.text();
|
|
if (colorsText) {
|
|
root.matugenColors = JSON.parse(colorsText);
|
|
if (typeof SettingsData !== "undefined" && SettingsData.matugenSmartMode && currentTheme === dynamic && root.matugenColors && root.matugenColors.mode && typeof SessionData !== "undefined" && !SessionData.isSwitchingMode) {
|
|
const resolvedLight = root.matugenColors.mode === "light";
|
|
if (SessionData.isLightMode !== resolvedLight) {
|
|
SessionData.setLightMode(resolvedLight, true);
|
|
SettingsData.updateCosmicThemeMode(resolvedLight);
|
|
}
|
|
}
|
|
if (typeof ToastService !== "undefined") {
|
|
ToastService.clearWallpaperError();
|
|
}
|
|
}
|
|
} catch (e) {
|
|
log.error("Failed to parse dynamic colors:", e);
|
|
if (typeof ToastService !== "undefined") {
|
|
ToastService.wallpaperErrorStatus = "error";
|
|
ToastService.showError(I18n.tr("Dynamic colors parse error: %1", "error toast, %1 is the error message").arg(e.message));
|
|
}
|
|
}
|
|
}
|
|
|
|
onLoaded: {
|
|
_colorsRetryCount = 0;
|
|
if (currentTheme === dynamic)
|
|
colorsFileLoadFailed = false;
|
|
parseAndLoadColors();
|
|
}
|
|
|
|
onFileChanged: {
|
|
dynamicColorsFileView.reload();
|
|
}
|
|
|
|
onLoadFailed: function (error) {
|
|
if (currentTheme !== dynamic)
|
|
return;
|
|
|
|
if (SessionData.isGreeterMode)
|
|
return;
|
|
|
|
if (workerRunning) {
|
|
colorsReloadRetry.restart();
|
|
return;
|
|
}
|
|
|
|
if (_colorsRetryCount < 3) {
|
|
_colorsRetryCount++;
|
|
colorsReloadRetry.restart();
|
|
return;
|
|
}
|
|
|
|
colorsFileLoadFailed = true;
|
|
const stale = Date.now() - _lastGenerateMs > 5000;
|
|
if (matugenAvailable && rawWallpaperPath && stale) {
|
|
log.debug("Dynamic colors unrecoverable, regenerating");
|
|
generateSystemThemesFromCurrentTheme();
|
|
}
|
|
}
|
|
|
|
onPathChanged: {
|
|
colorsFileLoadFailed = false;
|
|
}
|
|
}
|
|
|
|
Timer {
|
|
id: colorsReloadRetry
|
|
interval: 150
|
|
repeat: false
|
|
onTriggered: dynamicColorsFileView.reload()
|
|
}
|
|
|
|
IpcHandler {
|
|
target: "theme"
|
|
|
|
function toggle(): string {
|
|
root.toggleLightMode();
|
|
return root.isLightMode ? "dark" : "light";
|
|
}
|
|
|
|
function light(): string {
|
|
root.setLightMode(true, true, true);
|
|
return "light";
|
|
}
|
|
|
|
function dark(): string {
|
|
root.setLightMode(false, true, true);
|
|
return "dark";
|
|
}
|
|
|
|
function getMode(): string {
|
|
return root.isLightMode ? "light" : "dark";
|
|
}
|
|
}
|
|
|
|
Timer {
|
|
id: _themeGenerateDebounce
|
|
interval: 100
|
|
repeat: false
|
|
onTriggered: root._executeThemeGeneration()
|
|
}
|
|
|
|
// These timers are for screen transitions, since sometimes QML still beats the niri call
|
|
Timer {
|
|
id: themeTransitionTimer
|
|
interval: 50
|
|
repeat: false
|
|
property string themeName: ""
|
|
property bool savePrefs: true
|
|
onTriggered: root.switchTheme(themeName, savePrefs, false)
|
|
}
|
|
|
|
Timer {
|
|
id: lightModeTransitionTimer
|
|
interval: 100
|
|
repeat: false
|
|
property bool lightMode: false
|
|
property bool savePrefs: true
|
|
onTriggered: root.setLightMode(lightMode, savePrefs, false)
|
|
}
|
|
|
|
Timer {
|
|
id: themeCategoryTransitionTimer
|
|
interval: 50
|
|
repeat: false
|
|
property string category: ""
|
|
property string defaultTheme: ""
|
|
onTriggered: {
|
|
root.currentThemeCategory = category;
|
|
root.switchTheme(defaultTheme, true, false);
|
|
}
|
|
}
|
|
}
|