Bram/linux-presets
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

lets go

Browse Source
This commit is contained in:
Bram Kelchtermans
2024-07-08 22:46:35 +02:00
parent 02f44c49d2
commit 27254d817a
56249 changed files with 808097 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
gui/gnome/autocustom-gnome-macos/res/extensions/nightthemeswitcher@romainvigier.fr/modules/ColorSchemeSwitcher.js Executable file
View File

@ -0,0 +1,88 @@
// SPDX-FileCopyrightText: Night Theme Switcher Contributors
// SPDX-License-Identifier: GPL-3.0-or-later
import Gio from 'gi://Gio';
import * as debug from '../debug.js';
import { Time } from '../enums/Time.js';
import { Switcher } from './Switcher.js';
/**
* The Color Scheme Switcher changes the system color scheme according to the time.
*/
export class ColorSchemeSwitcher extends Switcher {
#settings;
#interfaceSettings;
#timer;
#settingsConnections = [];
/**
* @param {object} params Params object.
* @param {Timer} params.timer Timer to listen to.
*/
constructor({ timer }) {
const settings = NTS.getSettings(`${NTS.metadata['settings-schema']}.color-scheme`);
super({
name: 'Color Scheme',
timer,
settings,
callback: time => this.#onTimeChanged(time),
});
this.#timer = timer;
this.#settings = settings;
this.#interfaceSettings = new Gio.Settings({ schema: 'org.gnome.desktop.interface' });
}
enable() {
super.enable();
this.#connectSettings();
}
disable() {
super.disable();
this.#disconnectSettings();
}
#connectSettings() {
debug.message('Connecting Color Scheme Switcher to settings...');
this.#settingsConnections.push({
settings: this.#settings,
id: this.#settings.connect('changed::day', this.#onColorSchemeChanged.bind(this)),
});
this.#settingsConnections.push({
settings: this.#settings,
id: this.#settings.connect('changed::night', this.#onColorSchemeChanged.bind(this)),
});
this.#settingsConnections.push({
settings: this.#interfaceSettings,
id: this.#interfaceSettings.connect('changed::color-scheme', this.#onSystemColorSchemeChanged.bind(this)),
});
}
#disconnectSettings() {
this.#settingsConnections.forEach(({ settings, id }) => settings.disconnect(id));
this.#settingsConnections = [];
debug.message('Disconnected Color Scheme Switcher from settings.');
}
#onTimeChanged(time) {
const colorScheme = time === Time.NIGHT ? this.#settings.get_string('night') : this.#settings.get_string('day');
this.#interfaceSettings.set_string('color-scheme', colorScheme);
}
#onColorSchemeChanged(_settings, time) {
const colorScheme = this.#settings.get_string(time);
debug.message(`${time} color scheme changed to ${colorScheme}.`);
if (time === this.#timer.time)
this.#interfaceSettings.set_string('color-scheme', colorScheme);
}
#onSystemColorSchemeChanged() {
const colorScheme = this.#interfaceSettings.get_string('color-scheme');
debug.message(`System color scheme changed to ${colorScheme}.`);
this.#timer.syncTimeToColorScheme(colorScheme);
}
}

44
gui/gnome/autocustom-gnome-macos/res/extensions/nightthemeswitcher@romainvigier.fr/modules/CommandsSwitcher.js Executable file
View File

@ -0,0 +1,44 @@
// SPDX-FileCopyrightText: Night Theme Switcher Contributors
// SPDX-License-Identifier: GPL-3.0-or-later
import GLib from 'gi://GLib';
import * as debug from '../debug.js';
import { Time } from '../enums/Time.js';
import { Switcher } from './Switcher.js';
/**
* The Commands Switcher spawns commands according to the time.
*/
export class CommandsSwitcher extends Switcher {
#settings;
/**
* @param {object} params Params object.
* @param {Timer} params.timer Timer to listen to.
*/
constructor({ timer }) {
const settings = NTS.getSettings(`${NTS.metadata['settings-schema']}.commands`);
super({
name: 'Command',
timer,
settings,
callback: time => this.#onTimeChanged(time),
disableable: true,
});
this.#settings = settings;
}
#onTimeChanged(time) {
if (time === Time.UNKNOWN)
return;
const command = this.#settings.get_string(time === Time.DAY ? 'sunrise' : 'sunset');
if (!command)
return;
GLib.spawn_async(null, ['sh', '-c', command], null, GLib.SpawnFlags.SEARCH_PATH, null);
debug.message(`Spawned ${time} command.`);
}
}

101
gui/gnome/autocustom-gnome-macos/res/extensions/nightthemeswitcher@romainvigier.fr/modules/Switcher.js Executable file
View File

@ -0,0 +1,101 @@
// SPDX-FileCopyrightText: Night Theme Switcher Contributors
// SPDX-License-Identifier: GPL-3.0-or-later
import * as debug from '../debug.js';
/**
* Function called when the time changes.
*
* @callback TimeChangedCallback
* @param {Time} time New time.
*/
/**
* The Switcher runs a callback function when the time changes.
*
*/
export class Switcher {
#name;
#timer;
#settings;
#callback;
#disableable;
#statusConnection = null;
#timerConnection = null;
/**
* @param {object} params Params object.
* @param {string} params.name Name of the switcher.
* @param {Timer} params.timer Timer to listen to.
* @param {Gio.Settings} params.settings Settings.
* @param {TimeChangedCallback} params.callback Callback function.
* @param {boolean} params.disableable If the switcher can be disabled using an `enabled` key in the settings.
*/
constructor({ name, timer, settings, callback, disableable = false }) {
this.#name = name;
this.#timer = timer;
this.#settings = settings;
this.#callback = callback;
this.#disableable = disableable;
}
enable() {
debug.message(`Enabling ${this.#name} switcher...`);
if (this.#disableable)
this.#watchStatus();
if (!this.#disableable || this.#settings.get_boolean('enabled')) {
this.#connectTimer();
this.#onTimeChanged();
}
debug.message(`${this.#name} switcher enabled.`);
}
disable() {
debug.message(`Disabling ${this.#name} switcher...`);
this.#disconnectTimer();
if (this.#disableable)
this.#unwatchStatus();
debug.message(`${this.#name} switcher disabled.`);
}
#watchStatus() {
debug.message(`Watching ${this.#name} switching status...`);
this.#statusConnection = this.#settings.connect('changed::enabled', this.#onStatusChanged.bind(this));
}
#unwatchStatus() {
if (this.#statusConnection) {
this.#settings.disconnect(this.#statusConnection);
this.#statusConnection = null;
}
debug.message(`Stopped watching ${this.#name} switching status.`);
}
#connectTimer() {
debug.message(`Connecting ${this.#name} switcher to Timer...`);
this.#timerConnection = this.#timer.connect('notify::time', this.#onTimeChanged.bind(this));
}
#disconnectTimer() {
if (this.#timerConnection) {
this.#timer.disconnect(this.#timerConnection);
this.#timerConnection = null;
}
debug.message(`Disconnected ${this.#name} switcher from Timer.`);
}
#onStatusChanged() {
debug.message(`${this.#name} switching has been ${this.#settings.get_boolean('enabled') ? 'enabled' : 'disabled'}.`);
this.disable();
this.enable();
}
#onTimeChanged() {
this.#callback(this.#timer.time);
}
}

377
gui/gnome/autocustom-gnome-macos/res/extensions/nightthemeswitcher@romainvigier.fr/modules/Timer.js Executable file
View File

@ -0,0 +1,377 @@
// SPDX-FileCopyrightText: Night Theme Switcher Contributors
// SPDX-License-Identifier: GPL-3.0-or-later
import Geoclue from 'gi://Geoclue';
import Gio from 'gi://Gio';
import GLib from 'gi://GLib';
import GObject from 'gi://GObject';
import Meta from 'gi://Meta';
import Shell from 'gi://Shell';
import { gettext as _ } from 'resource:///org/gnome/shell/extensions/extension.js';
import { layoutManager, messageTray, wm } from 'resource:///org/gnome/shell/ui/main.js';
import * as MessageTray from 'resource:///org/gnome/shell/ui/messageTray.js';
import * as debug from '../debug.js';
import { ColorScheme } from '../enums/ColorScheme.js'; // eslint-disable-line no-unused-vars
import { Time } from '../enums/Time.js';
/**
* The Timer is responsible for signaling any time change to the other modules.
*
* They can connect to its 'time' property and query it for the current time.
*
* It will try to use the current location as a time source but will fall back
* to a manual schedule if the location services are disabled or if the user
* forced the manual schedule in the preferences.
*/
export class Timer extends GObject.Object {
#settings;
#colorSchemeSettings;
#interfaceSettings;
#locationSettings;
#time;
#cancellable = null;
#previousKeybinding = null;
#timeTimeoutId = null;
#geoclue = null;
#geoclueLocationConnectionId = null;
#suntimesTimeoutId = null;
#manuallySetTime = false;
#settingsConnections = [];
static {
GObject.registerClass({
Properties: {
time: GObject.ParamSpec.string('time', 'Time', 'Time', GObject.ParamFlags.READWRITE, Time.UNKNOWN),
},
}, this);
}
constructor() {
super();
this.#settings = NTS.getSettings(`${NTS.metadata['settings-schema']}.time`);
this.#colorSchemeSettings = NTS.getSettings(`${NTS.metadata['settings-schema']}.color-scheme`);
this.#interfaceSettings = new Gio.Settings({ schema: 'org.gnome.desktop.interface' });
this.#locationSettings = new Gio.Settings({ schema: 'org.gnome.system.location' });
}
enable() {
debug.message('Enabling Timer...');
this.#cancellable = new Gio.Cancellable();
this.#connectSettings();
this.#trackTime();
if (this.#settings.get_boolean('manual-schedule')) {
debug.message('Using the manual schedule.');
} else {
debug.message('Using location.');
this.#trackLocation();
this.#trackSuntimes();
}
this.#addKeybinding();
this.#changeTime(this.#computeTime());
debug.message('Timer enabled.');
}
disable() {
debug.message('Disabling Timer...');
this.#removeKeybinding();
this.#untrackSuntimes();
this.#untrackLocation();
this.#untrackTime();
this.#disconnectSettings();
this.#cancellable.cancel();
debug.message('Timer disabled.');
}
/**
* @param {ColorScheme} colorScheme Color scheme to sync the time to.
*/
syncTimeToColorScheme(colorScheme) {
this.#changeTime(this.#colorSchemeToTime(colorScheme), true);
}
get time() {
return this.#time || Time.UNKNOWN;
}
#changeTime(time, manual = false) {
if (time === this.#time) {
if (!manual && this.#manuallySetTime)
this.#manuallySetTime = false;
return;
}
if (!manual && time !== this.#time && this.#manuallySetTime)
return;
this.#time = time;
this.#manuallySetTime = manual;
debug.message(manual ? `Time manually set to ${time}.` : `Time changed to ${time}.`);
const isMonitorFullscreen = layoutManager.monitors.some(monitor => monitor.inFullscreen);
if (this.#settings.get_boolean('fullscreen-transition') || !isMonitorFullscreen)
layoutManager.screenTransition.run();
this.notify('time');
}
#connectSettings() {
debug.message('Connecting Timer to settings...');
this.#settingsConnections.push({
settings: this.#locationSettings,
id: this.#locationSettings.connect('changed::enabled', this.#onLocationStateChanged.bind(this)),
});
this.#settingsConnections.push({
settings: this.#settings,
id: this.#settings.connect('changed::manual-schedule', this.#onManualScheduleStateChanged.bind(this)),
});
this.#settingsConnections.push({
settings: this.#settings,
id: this.#settings.connect('changed::nightthemeswitcher-ondemand-keybinding', this.#onOndemandKeybindingChanged.bind(this)),
});
// Only listen to the offset setting when not using a manual schedule
if (!this.#settings.get_boolean('manual-schedule')) {
this.#settingsConnections.push({
settings: this.#settings,
id: this.#settings.connect('changed::offset', this.#onOffsetChanged.bind(this)),
});
}
}
#disconnectSettings() {
this.#settingsConnections.forEach(({ settings, id }) => settings.disconnect(id));
this.#settingsConnections = [];
debug.message('Disconnected Timer from settings.');
}
#trackTime() {
debug.message('Watching for time change...');
this.#timeTimeoutId = GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, 1, () => {
this.#changeTime(this.#computeTime());
return GLib.SOURCE_CONTINUE;
});
}
#untrackTime() {
if (this.#timeTimeoutId) {
GLib.Source.remove(this.#timeTimeoutId);
this.#timeTimeoutId = null;
}
debug.message('Stopped watching for time change.');
}
#trackLocation() {
debug.message('Connecting to GeoClue...');
Geoclue.Simple.new(
'org.gnome.Shell',
Geoclue.AccuracyLevel.CITY,
this.#cancellable,
this.#onGeoclueReady.bind(this)
);
}
#untrackLocation() {
debug.message('Disconnecting from GeoClue...');
if (this.#geoclue && this.#geoclueLocationConnectionId) {
this.#geoclue.disconnect(this.#geoclueLocationConnectionId);
this.#geoclueLocationConnectionId = null;
this.#geoclue = null;
}
debug.message('Disconnected from GeoClue.');
}
#trackSuntimes() {
debug.message('Regularly updating sun times...');
this.#suntimesTimeoutId = GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, 3600, () => {
this.#updateSuntimes();
return GLib.SOURCE_CONTINUE;
});
}
#untrackSuntimes() {
if (this.#suntimesTimeoutId) {
GLib.Source.remove(this.#suntimesTimeoutId);
this.#suntimesTimeoutId = null;
}
debug.message('Stopped regularly updating sun times.');
}
#addKeybinding() {
this.#previousKeybinding = this.#settings.get_strv('nightthemeswitcher-ondemand-keybinding')[0];
if (!this.#settings.get_strv('nightthemeswitcher-ondemand-keybinding')[0])
return;
debug.message('Adding keybinding...');
wm.addKeybinding(
'nightthemeswitcher-ondemand-keybinding',
this.#settings,
Meta.KeyBindingFlags.IGNORE_AUTOREPEAT,
Shell.ActionMode.NORMAL | Shell.ActionMode.OVERVIEW,
() => {
const time = this.time === Time.NIGHT ? Time.DAY : Time.NIGHT;
this.#changeTime(time, true);
}
);
debug.message('Added keybinding.');
}
#removeKeybinding() {
if (this.#previousKeybinding) {
debug.message('Removing keybinding...');
wm.removeKeybinding('nightthemeswitcher-ondemand-keybinding');
debug.message('Removed keybinding.');
}
}
#colorSchemeToTime(colorScheme) {
return colorScheme === this.#colorSchemeSettings.get_string('night') ? Time.NIGHT : Time.DAY;
}
#onLocationStateChanged() {
this.disable();
this.enable();
}
#onManualScheduleStateChanged() {
this.disable();
this.enable();
}
#onOffsetChanged() {
this.#updateSuntimes();
}
#onOndemandKeybindingChanged() {
this.#removeKeybinding();
this.#addKeybinding();
}
#onGeoclueReady(_geoclue, result) {
try {
this.#geoclue = Geoclue.Simple.new_finish(result);
this.#geoclueLocationConnectionId = this.#geoclue.connect('notify::location', this.#onLocationChanged.bind(this));
debug.message('Connected to GeoClue.');
this.#onLocationChanged();
} catch (e) {
const [latitude, longitude] = this.#settings.get_value('location').deepUnpack();
if (latitude >= -90 && latitude <= 90 && longitude >= -180 && longitude <= 180) {
console.error(`[${NTS.metadata.name}] Unable to retrieve the location, using the last known location instead.\n${e}`);
this.#updateSuntimes();
} else {
console.error(`[${NTS.metadata.name}] Unable to retrieve the location, using the manual schedule times instead.\n${e}`);
const source = new MessageTray.Source({
title: NTS.metadata.name,
icon: Gio.icon_new_for_string(GLib.build_filenamev([NTS.metadata.path, 'icons', 'nightthemeswitcher-symbolic.svg'])),
});
messageTray.add(source);
const notification = new MessageTray.Notification(
{
source,
title: _('Unknown Location'),
body: _('A manual schedule will be used to switch the dark mode.'),
'icon-name': 'location-services-disabled-symbolic',
}
);
notification.addAction(_('Edit Manual Schedule'), () => NTS.openPreferences());
notification.connect('activated', () => NTS.openPreferences());
source.addNotification(notification);
this.#settings.set_boolean('manual-schedule', true);
}
}
}
#onLocationChanged(_geoclue, _location) {
debug.message('Location has changed.');
const { latitude, longitude } = this.#geoclue.get_location();
this.#settings.set_value('location', new GLib.Variant('(dd)', [latitude, longitude]));
debug.message(`Current location: (${latitude};${longitude})`);
this.#updateSuntimes();
}
#computeTime() {
const sunrise = this.#settings.get_double('sunrise');
const sunset = this.#settings.get_double('sunset');
const datetime = GLib.DateTime.new_now_local();
const hour = datetime.get_hour() + datetime.get_minute() / 60 + datetime.get_second() / 3600;
// Regular schedule
if (sunrise < sunset)
return hour >= sunrise && hour < sunset ? Time.DAY : Time.NIGHT;
// Sunset happens on the day after
else if (sunrise > sunset)
return hour >= sunrise || hour < sunset ? Time.DAY : Time.NIGHT;
// Sunset and Sunrise times are identical; preserve current theme
else
return this.#time || this.#colorSchemeToTime(this.#interfaceSettings.get_string('color-scheme'));
}
#updateSuntimes() {
const [latitude, longitude] = this.#settings.get_value('location').deepUnpack();
if (latitude < -90 && latitude > 90 && longitude < -180 && longitude > 180)
return;
debug.message('Updating sun times...');
const rad = degrees => degrees * Math.PI / 180;
const deg = radians => radians * 180 / Math.PI;
// Calculations from https://www.esrl.noaa.gov/gmd/grad/solcalc/calcdetails.html
const dtNow = GLib.DateTime.new_now_local();
const dtZero = GLib.DateTime.new_utc(1900, 1, 1, 0, 0, 0);
const timeSpan = dtNow.difference(dtZero);
const date = timeSpan / 1000 / 1000 / 60 / 60 / 24 + 2;
const tzOffset = dtNow.get_utc_offset() / 1000 / 1000 / 60 / 60;
const julianDay = date + 2415018.5 - tzOffset / 24;
const julianCentury = (julianDay - 2451545) / 36525;
const geomMeanLongSun = (280.46646 + julianCentury * (36000.76983 + julianCentury * 0.0003032)) % 360;
const geomMeanAnomSun = 357.52911 + julianCentury * (35999.05029 - 0.0001537 * julianCentury);
const eccentEarthOrbit = 0.016708634 - julianCentury * (0.000042037 + 0.0000001267 * julianCentury);
const sunEqOfCtr = Math.sin(rad(geomMeanAnomSun)) * (1.914602 - julianCentury * (0.004817 + 0.000014 * julianCentury)) + Math.sin(rad(2 * geomMeanAnomSun)) * (0.019993 - 0.000101 * julianCentury) + Math.sin(rad(3 * geomMeanAnomSun)) * 0.000289;
const sunTrueLong = geomMeanLongSun + sunEqOfCtr;
const sunAppLong = sunTrueLong - 0.00569 - 0.00478 * Math.sin(rad(125.04 - 1934.136 * julianCentury));
const meanObliqEcliptic = 23 + (26 + ((21.448 - julianCentury * (46.815 + julianCentury * (0.00059 - julianCentury * 0.001813)))) / 60) / 60;
const obliqCorr = meanObliqEcliptic + 0.00256 * Math.cos(rad(125.04 - 1934.136 * julianCentury));
const sunDeclin = deg(Math.asin(Math.sin(rad(obliqCorr)) * Math.sin(rad(sunAppLong))));
const varY = Math.tan(rad(obliqCorr / 2)) * Math.tan(rad(obliqCorr / 2));
const eqOfTime = 4 * deg(varY * Math.sin(2 * rad(geomMeanLongSun)) - 2 * eccentEarthOrbit * Math.sin(rad(geomMeanAnomSun)) + 4 * eccentEarthOrbit * varY * Math.sin(rad(geomMeanAnomSun)) * Math.cos(2 * rad(geomMeanLongSun)) - 0.5 * varY * varY * Math.sin(4 * rad(geomMeanLongSun)) - 1.25 * eccentEarthOrbit * eccentEarthOrbit * Math.sin(2 * rad(geomMeanAnomSun)));
const haSunrise = deg(Math.acos(Math.cos(rad(90.833)) / (Math.cos(rad(latitude)) * Math.cos(rad(sunDeclin))) - Math.tan(rad(latitude)) * Math.tan(rad(sunDeclin))));
const solarNoon = (720 - 4 * longitude - eqOfTime + tzOffset * 60) / 1440;
const timeSunrise = solarNoon - haSunrise * 4 / 1440;
const timeSunset = solarNoon + haSunrise * 4 / 1440;
const modulo = (n, m) => ((n % m) + m) % m;
const offset = this.#settings.get_double('offset');
const sunrise = modulo(timeSunrise * 24 + offset, 24);
const sunset = modulo(timeSunset * 24 - offset, 24);
this.#settings.set_double('sunrise', sunrise);
this.#settings.set_double('sunset', sunset);
debug.message(`New sun times: (sunrise: ${sunrise}; sunset: ${sunset})`);
}
}