diff options
Diffstat (limited to 'raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules')
10 files changed, 1564 insertions, 0 deletions
diff --git a/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/info-fetcher.js b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/info-fetcher.js new file mode 100644 index 0000000..e18df7b --- /dev/null +++ b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/info-fetcher.js @@ -0,0 +1,108 @@ +// SPDX-FileCopyrightText: 2023 Deminder <tremminder@gmail.com> +// SPDX-License-Identifier: GPL-3.0-or-later + +import Gio from 'gi://Gio'; +import GLib from 'gi://GLib'; +import * as Signals from 'resource:///org/gnome/shell/misc/signals.js'; + +import { throttleTimeout, logDebug, readFileAsync } from './util.js'; + +export class InfoFetcher extends Signals.EventEmitter { + constructor() { + super(); + this._intervalId = null; + this._tickPromise = null; + this._shutdownInfo = {}; + this._wakeInfo = {}; + this._rtc = 'rtc0'; + this._cancellable = new Gio.Cancellable(); + [this.refresh, this._refreshCancel] = throttleTimeout( + this._refresh.bind(this), + 300 + ); + } + + _refresh() { + this._refreshCancel(); + this._clearInterval(); + logDebug('Extra info refresh...'); + this._intervalId = setInterval(this.tick.bind(this), 5000); + this.tick(); + } + + _clearInterval() { + if (this._intervalId !== null) { + clearInterval(this._intervalId); + this._intervalId = null; + } + } + + tick() { + if (this._tickPromise === null) { + this._tickPromise = Promise.all([ + this._fetchShutdownInfo(), + this._fetchWakeInfo(this._rtc), + ]).then(([shutdown, wake]) => { + this._tickPromise = null; + this._shutdownInfo = shutdown; + this._wakeInfo = wake; + this.emit('changed'); + }); + } + } + + _readFile(path) { + return readFileAsync(path, this._cancellable); + } + + async _isWakeInfoLocal() { + const content = await this._readFile('/etc/adjtime').catch(() => ''); + return content.trim().toLowerCase().endsWith('local'); + } + + async _fetchWakeInfo(rtc) { + const content = await this._readFile( + `/sys/class/rtc/${rtc}/wakealarm` + ).catch(() => ''); + let timestamp = content !== '' ? parseInt(content) : -1; + if (timestamp > -1 && (await this._isWakeInfoLocal())) { + const dt = GLib.DateTime.new_from_unix_local(timestamp); + timestamp = dt.to_unix() - dt.get_utc_offset() / 1000000; + dt.unref(); + } + return { deadline: timestamp }; + } + + async _fetchShutdownInfo() { + const content = await this._readFile( + '/run/systemd/shutdown/scheduled' + ).catch(() => ''); + if (content === '') { + return { deadline: -1 }; + } + // content: schedule unix-timestamp (micro-seconds), warn-all, shutdown-mode + const [usec, _, mode] = content.split('\n').map(l => l.split('=')[1]); + return { + mode, + deadline: parseInt(usec) / 1000000, + }; + } + + get shutdownInfo() { + return this._shutdownInfo; + } + + get wakeInfo() { + return this._wakeInfo; + } + + destroy() { + this.disconnectAll(); + this._refreshCancel(); + this._clearInterval(); + if (this._cancellable !== null) { + this._cancellable.cancel(); + this._cancellable = null; + } + } +} diff --git a/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/injection.js b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/injection.js new file mode 100644 index 0000000..7d5bdd1 --- /dev/null +++ b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/injection.js @@ -0,0 +1,192 @@ +// SPDX-FileCopyrightText: 2023 Deminder <tremminder@gmail.com> +// SPDX-License-Identifier: GPL-3.0-or-later +import { logDebug } from './util.js'; + +/** + * The InjectionTracker helps revert object property injections 'out of order' + * by keeping track of the injection history. + * This is useful when overriding the same method from mulitple extensions, + * for instance, `Main.panel.statusArea.quickSettings._addItems`. + * + * The InjectionManager does not work when multiple extensions override the same method. + * Its `restoreMethod` only restores correctly if it is called in reverse order to `overrideMethod`. + * + */ +export class InjectionTracker { + localInjections = []; + + /** + * Inject a property into an object. + * + * To revert the injection call `injection.clear()`. + * + * @param {object} obj the target object + * @param {string} prop the property name + * @param {any} value the new property value + * @param {boolean} isPropertyDescriptor whether the value is a property descriptor + * + * @returns {object} an injection object + * provding `injection.original` and `injection.previous` property values + */ + injectProperty(obj, prop, value, isPropertyDescriptor) { + let propertyDescriptor = Object.getOwnPropertyDescriptor(obj, prop); + if (!propertyDescriptor) { + if (prop in obj) { + propertyDescriptor = { + value: obj[prop], + writable: true, + configurable: true, + }; + } else { + throw new Error( + `Injection target object does not have a '${prop}' property!` + ); + } + } + // Keep history; mutated by each injection + const histories = obj.__injectionHistories ?? {}; + const history = histories[prop] ?? []; + // Push old property descriptor to history + history.push(propertyDescriptor); + histories[prop] = history; + obj.__injectionHistories = histories; + + const injectionId = history.length; + logDebug('[new] injectionid', injectionId); + + // Override value + Object.defineProperty( + obj, + prop, + isPropertyDescriptor + ? value + : { value, writable: false, configurable: true } + ); + + const localInjectionId = this.localInjections.length; + const injection = createInjection(obj, prop, history, injectionId, () => { + // Remove from local injections + this.localInjections[localInjectionId] = undefined; + const pruneIndex = + this.localInjections.length - + 1 - + [...this.localInjections].reverse().findIndex(inj => inj !== undefined); + if (pruneIndex === this.localInjections.length) { + logDebug('[local-cleanclear]'); + this.localInjections = []; + } else { + logDebug('[local-nocleanclear]'); + this.localInjections = this.localInjections.slice(0, pruneIndex); + } + }); + this.localInjections.push(injection); + return injection; + } + + /** + * Clear all injections made by this instance. + */ + clearAll() { + this.localInjections + .filter(inj => inj !== undefined) + .forEach(inj => inj.clear()); + } +} + +function createInjection(obj, prop, history, injectionId, clearHook) { + let reverted = false; + const readDescriptorValue = descriptor => + 'get' in descriptor ? descriptor.get.call(obj) : descriptor.value; + return { + /** + * Read the original property value before any injections. + */ + get original() { + // Using h instead history to remain valid after `clear()` + const h = obj.__injectionHistories?.[prop]; + return readDescriptorValue( + h?.length ? h[0] : Object.getOwnPropertyDescriptor(obj, prop) + ); + }, + + /** + * Read the previous property value from the injection history. + * + * Valid after `clear()` as long as no new injection occurs. + */ + get previous() { + return history.length + ? readDescriptorValue( + injectionId > history.length + ? Object.getOwnPropertyDescriptor(obj, prop) + : popPropertyDescriptorFromHistory( + // previous history + history.slice(0, injectionId) + ) + ) + : this.original; + }, + + /** + * Clear the injection from the injection history. + */ + clear() { + if (!reverted) { + reverted = true; + clearHook(); + + // Remove from global injections + if (injectionId >= history.length) { + logDebug( + '[remclear] injectionID', + injectionId, + 'historylen', + history.length + ); + // Restore property of obj + Object.defineProperty( + obj, + prop, + popPropertyDescriptorFromHistory(history) + ); + // Cleanup empty history + if (history.length === 0) { + logDebug('[cleanclear]'); + delete obj.__injectionHistories[prop]; + + // Cleanup empty history store + if (Object.keys(obj.__injectionHistories).length === 0) { + delete obj.__injectionHistories; + } + } else { + logDebug('[nocleanclear] history.length', history.length); + } + } else { + logDebug( + '[setclear] injectionID', + injectionId, + 'historylen', + history.length + ); + // Clear injection from history + history[injectionId] = undefined; + } + } + }, + + /** + * Count of previous injections. Is 1 if there is only this injection. + */ + get count() { + return history.slice(0, injectionId).filter(i => i !== undefined).length; + }, + }; +} + +function popPropertyDescriptorFromHistory(history) { + let propertyDescriptor; + do { + propertyDescriptor = history.pop(); + } while (history.length && propertyDescriptor === undefined); + return propertyDescriptor; +} diff --git a/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/install.js b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/install.js new file mode 100644 index 0000000..701da6a --- /dev/null +++ b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/install.js @@ -0,0 +1,64 @@ +// SPDX-FileCopyrightText: 2023 Deminder <tremminder@gmail.com> +// SPDX-License-Identifier: GPL-3.0-or-later + +import GLib from 'gi://GLib'; +import Gio from 'gi://Gio'; +import { gettext as _ } from './translation.js'; + +import { execCheck, installedScriptPath } from '../dbus-service/control.js'; +import { logDebug } from './util.js'; + +export class Install { + destroy() { + if (this.installCancel !== undefined) { + this.installCancel.cancel(); + } + this.installCancel = undefined; + } + + /** + * @param installerScriptPath + * @param action + * @param logInstall + */ + async installAction(installerScriptPath, action, logInstall) { + const label = this.actionLabel(action); + if (this.installCancel !== undefined) { + logDebug(`Trigger cancel install. ${label}`); + this.installCancel.cancel(); + } else { + logDebug(`Trigger ${action} action.`); + this.installCancel = new Gio.Cancellable(); + logInstall(`[${_('START')} ${label}]`); + try { + const user = GLib.get_user_name(); + logDebug(`? installer.sh --tool-user ${user} ${action}`); + await execCheck( + ['pkexec', installerScriptPath, '--tool-user', user, action], + this.installCancel, + false, + logInstall + ); + logInstall(`[${_('END')} ${label}]`); + } catch (err) { + logInstall(`[${_('FAIL')} ${label}]\n# ${err}`); + console.error(err, 'InstallError'); + } finally { + this.installCancel = undefined; + } + } + } + + checkInstalled() { + const scriptPath = installedScriptPath(); + const isScriptInstalled = scriptPath !== null; + if (isScriptInstalled) { + logDebug(`Existing installation at: ${scriptPath}`); + } + return isScriptInstalled; + } + + actionLabel(action) { + return { install: _('install'), uninstall: _('uninstall') }[action]; + } +} diff --git a/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/menu-item.js b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/menu-item.js new file mode 100644 index 0000000..3a80198 --- /dev/null +++ b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/menu-item.js @@ -0,0 +1,573 @@ +// SPDX-FileCopyrightText: 2023 Deminder <tremminder@gmail.com> +// SPDX-License-Identifier: GPL-3.0-or-later + +import GObject from 'gi://GObject'; +import St from 'gi://St'; +import Gio from 'gi://Gio'; +import Clutter from 'gi://Clutter'; +import * as Main from 'resource:///org/gnome/shell/ui/main.js'; +import * as PopupMenu from 'resource:///org/gnome/shell/ui/popupMenu.js'; +import * as Slider from 'resource:///org/gnome/shell/ui/slider.js'; +import * as QuickSettings from 'resource:///org/gnome/shell/ui/quickSettings.js'; + +import { InfoFetcher } from './info-fetcher.js'; +import { Textbox } from './text-box.js'; +import { gettext as _, ngettext as _n, pgettext as C_ } from './translation.js'; +import * as SessionModeAware from './session-mode-aware.js'; +import { getShutdownScheduleFromSettings } from './schedule-info.js'; +import { + ShutdownTimerName, + ShutdownTimerObjectPath, +} from '../dbus-service/shutdown-timer-dbus.js'; + +import { + foregroundActive, + observeForegroundActive, + unobserveForegroundActive, +} from './session-mode-aware.js'; +import { + durationString, + longDurationString, + absoluteTimeString, + getSliderMinutesFromSettings, + ScheduleInfo, +} from './schedule-info.js'; + +import { logDebug, proxyPromise } from './util.js'; +import { + WAKE_ACTIONS, + actionLabel, + ACTIONS, + mapLegacyAction, +} from '../dbus-service/action.js'; + +/** + * The ShutdownTimerItem controls wake/shutdown action time and mode. + * Additionally, it shows wake and external/internal shutdown schedules. + * + * The external schedule of the `shutdown` command is fetched by the InfoFetcher. + * Note that there is no external schedule for `suspend`. + */ +const ShutdownTimerItem = GObject.registerClass( + { + Properties: { + 'shutdown-text': GObject.ParamSpec.string( + 'shutdown-text', + '', + '', + GObject.ParamFlags.READWRITE, + '' + ), + 'indicator-icon-name': GObject.ParamSpec.string( + 'indicator-icon-name', + '', + '', + GObject.ParamFlags.READWRITE, + 'go-down-symbolic' + ), + }, + Signals: { + 'open-preferences': {}, + shutdown: { + param_types: [GObject.TYPE_BOOLEAN, GObject.TYPE_STRING], + }, + wake: { + param_types: [GObject.TYPE_BOOLEAN], + }, + }, + }, + class ShutdownTimerItem extends QuickSettings.QuickMenuToggle { + _init({ path, settings }) { + const gicon = Gio.icon_new_for_string( + `${path}/icons/shutdown-timer-symbolic.svg` + ); + super._init({ gicon, accessible_name: _('Shutdown Timer') }); + this.info = { + internalShutdown: getShutdownScheduleFromSettings(settings), + externalShutdown: new ScheduleInfo({ external: true }), + externalWake: new ScheduleInfo({ mode: 'wake' }), + state: 'inactive', + }; + this._settings = settings; + this.shutdownTimerIcon = gicon; + this._updatingSwitcherState = false; + + // submenu in status area menu with slider and toggle button + this.sliderItems = {}; + this.sliders = {}; + ['shutdown', 'wake'].forEach(prefix => { + const [item, slider] = this._createSliderItem(prefix); + this.sliderItems[prefix] = item; + this.sliders[prefix] = slider; + this._onShowSliderChanged(prefix); + }); + this.switcher = new PopupMenu.PopupSwitchMenuItem('', false); + // start/stop shutdown timer + this.switcher.connect('toggled', () => { + if (!this._updatingSwitcherState) { + this.emit( + 'shutdown', + this.switcher.state, + this.info.internalShutdown.mode + ); + } + }); + this.switcherSettingsButton = new St.Button({ + reactive: true, + can_focus: true, + track_hover: true, + accessible_name: _('Settings'), + style_class: 'icon-button settings-button', + }); + this.switcherSettingsButton.child = new St.Icon({ + icon_name: 'applications-system-symbolic', + }); + this.switcherSettingsButton.connect('clicked', () => + this.emit('open-preferences') + ); + this.switcher.add_child(this.switcherSettingsButton); + + this.menu.addMenuItem(this.switcher); + // make switcher toggle without popup menu closing + this.switcher.activate = __ => { + if (this.switcher._switch.mapped) { + this.switcher.toggle(); + } + }; + this.menu.addMenuItem(this.sliderItems['shutdown']); + + this.modeItems = Object.keys(ACTIONS).map(action => { + const modeItem = new PopupMenu.PopupMenuItem(actionLabel(action)); + modeItem.connect('activate', () => { + this.emit('shutdown', true, action); + }); + this.menu.addMenuItem(modeItem); + return [action, modeItem]; + }); + + this.wakeItems = [ + new PopupMenu.PopupSeparatorMenuItem(), + this.sliderItems['wake'], + ...Object.keys(WAKE_ACTIONS).map(action => { + const modeItem = new PopupMenu.PopupMenuItem(actionLabel(action)); + if (action === 'wake') { + this.wakeModeItem = modeItem; + } + modeItem.connect('activate', () => + this.emit('wake', action === 'wake') + ); + return modeItem; + }), + ]; + this.wakeItems.forEach(item => { + this.menu.addMenuItem(item); + }); + this._updateWakeModeItem(); + this._updateSwitchLabel(); + + // handlers for changed values in settings + const settingsHandlerIds = [ + [ + [ + 'shutdown-max-timer-value', + 'nonlinear-shutdown-slider-value', + 'shutdown-ref-timer-value', + 'show-shutdown-absolute-timer-value', + 'root-mode-value', + 'shutdown-slider-value', + ], + () => this._updateSwitchLabel(), + ], + [ + [ + 'wake-max-timer-value', + 'wake-ref-timer-value', + 'show-wake-absolute-timer-value', + 'nonlinear-wake-slider-value', + 'wake-slider-value', + ], + () => this._updateWakeModeItem(), + ], + [['shutdown-slider-value'], () => this._updateSlider('shutdown')], + [['wake-slider-value'], () => this._updateSlider('wake')], + [ + [ + 'show-wake-items-value', + 'show-shutdown-mode-value', + 'show-shutdown-slider-value', + 'show-wake-slider-value', + 'show-shutdown-indicator-value', + 'show-settings-value', + ], + () => this._sync(), + ], + ] + .flatMap(([names, func]) => names.map(n => [n, func])) + .map(([name, func]) => + this._settings.connect(`changed::${name}`, func) + ); + + this.connect('clicked', () => this.switcher.toggle()); + observeForegroundActive(this, () => this._sync()); + const tickHandlerId = setInterval(() => this.updateShutdownInfo(), 1000); + this.connect('destroy', () => { + unobserveForegroundActive(this); + clearInterval(tickHandlerId); + settingsHandlerIds.forEach(handlerId => { + this._settings.disconnect(handlerId); + }); + }); + } + + _sync() { + // Update wake mode items + this.wakeItems.forEach(item => { + item.visible = this._settings.get_boolean('show-wake-items-value'); + }); + this._onShowSliderChanged('wake'); + + // Update shutdown mode items + const activeActions = this._settings + .get_string('show-shutdown-mode-value') + .split(',') + .map(s => mapLegacyAction(s.trim())) + .filter(action => action in ACTIONS); + logDebug('[menu-item]', activeActions); + this.modeItems.forEach(([action, item]) => { + const position = activeActions.indexOf(action); + if (position > -1) { + this.menu.moveMenuItem(item, position + 2); + } + item.visible = position > -1; + }); + + this._onShowSliderChanged('shutdown'); + + this.switcherSettingsButton.visible = + foregroundActive() && this._settings.get_boolean('show-settings-value'); + + this.updateShutdownInfo(); + } + + updateShutdownInfo() { + const schedule = this.info.internalShutdown; + const externalSchedule = this.info.externalShutdown; + const externalWake = this.info.externalWake; + const urgendSchedule = externalSchedule.isMoreUrgendThan(schedule) + ? externalSchedule + : schedule; + const active = schedule.scheduled || this.info.state !== 'inactive'; + const showIndicator = this._settings.get_boolean( + 'show-shutdown-indicator-value' + ); + + // Update Indicator + this.set({ + checked: active, + shutdownText: + urgendSchedule.scheduled && showIndicator + ? urgendSchedule.secondsLeft > 0 + ? durationString(urgendSchedule.secondsLeft) + : _('now') + : '', + indicatorIconName: + showIndicator && + (this.info.internalShutdown.scheduled || + this.info.externalShutdown.scheduled) + ? 'go-down-symbolic' + : '', + }); + + // Update selected shutdown mode + this.modeItems.forEach(([mode, item]) => { + item.setOrnament( + mode === schedule.mode + ? PopupMenu.Ornament.DOT + : PopupMenu.Ornament.NONE + ); + }); + + // Update title with scheduled action + this.title = actionLabel(schedule.mode); + + // Update toggle state of switcher + this._updatingSwitcherState = true; + this.switcher.setToggleState(active); + this._updatingSwitcherState = false; + + // Update long status description in menu + this.menu.setHeader( + this.shutdownTimerIcon, + _('Shutdown Timer'), + [schedule.label, externalWake.label].filter(v => !!v).join('\n') + ); + if (this._settings.get_boolean('show-shutdown-absolute-timer-value')) { + this._updateSwitchLabel(); + } + if (this._settings.get_boolean('show-wake-absolute-timer-value')) { + this._updateWakeModeItem(); + } + this._updateSubtitle(); + } + + // update timer value if slider has changed + _updateSlider(prefix) { + this.sliders[prefix].value = + this._settings.get_double(`${prefix}-slider-value`) / 100.0; + } + + _createSliderItem(settingsPrefix) { + const valueName = `${settingsPrefix}-slider-value`; + const sliderValue = this._settings.get_double(valueName) / 100.0; + const item = new PopupMenu.PopupBaseMenuItem({ activate: false }); + const sliderIcon = new St.Icon({ + icon_name: + settingsPrefix === 'wake' + ? 'alarm-symbolic' + : 'system-shutdown-symbolic', + style_class: 'popup-menu-icon', + }); + item.add_child(sliderIcon); + const slider = new Slider.Slider(sliderValue); + slider.connect('notify::value', () => { + const v = slider.value * 100; + if (v !== this._settings.get_double(valueName)) + this._settings.set_double(valueName, v); + }); + item.add_child(slider); + return [item, slider]; + } + + get shutdownTimeStr() { + const minutes = Math.abs( + getSliderMinutesFromSettings(this._settings, 'shutdown') + ); + return this._settings.get_boolean('show-shutdown-absolute-timer-value') + ? absoluteTimeString(minutes, C_('absolute time notation', '%a, %R')) + : longDurationString( + minutes, + h => _n('%s hr', '%s hrs', h), + m => _n('%s min', '%s mins', m) + ); + } + + _updateSwitchLabel() { + this.switcher.label.text = this._settings.get_boolean('root-mode-value') + ? _('%s (protect)').format(this.shutdownTimeStr) + : this.shutdownTimeStr; + + if (this._settings.get_string('wake-ref-timer-value') === 'shutdown') { + this._updateWakeModeItem(); + } + if (!this.info.internalShutdown.scheduled) { + this._updateSubtitle(); + } + } + + _updateSubtitle() { + this.subtitle = this.info.internalShutdown.scheduled + ? this._settings.get_boolean('show-shutdown-absolute-timer-value') + ? this.info.internalShutdown.absoluteTimeString + : durationString(this.info.internalShutdown.secondsLeft) + : this.shutdownTimeStr; + } + + _updateWakeModeItem() { + const minutes = getSliderMinutesFromSettings(this._settings, 'wake'); + const abs = this._settings.get_boolean('show-wake-absolute-timer-value'); + this.wakeModeItem.label.text = ( + abs + ? C_('WakeButtonText', '%s at %s') + : C_('WakeButtonText', '%s after %s') + ).format( + actionLabel('wake'), + abs + ? absoluteTimeString(minutes, C_('absolute time notation', '%a, %R')) + : longDurationString( + minutes, + h => _n('%s hour', '%s hours', h), + m => _n('%s minute', '%s minutes', m) + ) + ); + } + + _onShowSliderChanged(settingsPrefix) { + this.sliderItems[settingsPrefix].visible = + (settingsPrefix !== 'wake' || + this._settings.get_boolean('show-wake-items-value')) && + this._settings.get_boolean(`show-${settingsPrefix}-slider-value`); + } + } +); + +export const ShutdownTimerIndicator = GObject.registerClass( + { + Properties: { + 'wake-minutes': GObject.ParamSpec.int( + 'wake-minutes', + '', + '', + GObject.ParamFlags.READABLE, + 0 + ), + 'shutdown-minutes': GObject.ParamSpec.int( + 'shutdown-minutes', + '', + '', + GObject.ParamFlags.READABLE, + 0 + ), + }, + Signals: { + 'open-preferences': {}, + shutdown: { + param_types: [GObject.TYPE_BOOLEAN, GObject.TYPE_STRING], + }, + wake: { + param_types: [GObject.TYPE_BOOLEAN], + }, + }, + }, + class ShutdownTimerIndicator extends QuickSettings.SystemIndicator { + _init({ path, settings }) { + super._init(); + this._state = 'inactive'; + this._settings = settings; + this._textbox = new Textbox({ settings }); + const item = new ShutdownTimerItem({ path, settings }); + const infoFetcher = new InfoFetcher(); + const proxyCancel = new Gio.Cancellable(); + this._sdtProxy = null; + this._initProxy(item, this._textbox, infoFetcher, proxyCancel).catch( + err => { + if (!proxyCancel.is_cancelled()) console.error('[sdt-proxy]', err); + } + ); + // React to changes in external shutdown and wake schedule + infoFetcher.connect('changed', () => this._syncShutdownInfo()); + this._infoFetcher = infoFetcher; + this._shutdownTimerItem = item; + + item.connect('open-preferences', () => this.emit('open-preferences')); + + const icon = new St.Icon({ style_class: 'system-status-icon' }); + const updateIcon = () => { + const name = item.indicatorIconName; + icon.visible = !!name; + if (icon.visible) icon.iconName = name; + this._syncIndicatorsVisible(); + }; + + const scheduleLabel = new St.Label({ + y_expand: true, + y_align: Clutter.ActorAlign.CENTER, + }); + const updateLabel = () => { + const text = item.shutdownText; + scheduleLabel.text = text; + scheduleLabel.visible = !!text; + this._syncIndicatorsVisible(); + }; + + this.add_child(icon); + this.add_child(scheduleLabel); + + item.connect('notify::indicator-icon-name', () => updateIcon()); + item.connect('notify::shutdown-text', () => updateLabel()); + + updateLabel(); + updateIcon(); + + this.quickSettingsItems.push(item); + this.connect('destroy', () => { + proxyCancel.cancel(); + infoFetcher.destroy(); + this._infoFetcher = null; + this._textbox.destroy(); + this.quickSettingsItems.forEach(i => i.destroy()); + this.quickSettingsItems = []; + this._shutdownTimerItem = null; + if (this._sdtProxy !== null) { + this._sdtProxy.destroy(); + this._sdtProxy = null; + } + this._settings = null; + }); + item.connect('destroy', () => { + // Mitigate already destroyed error when logging out + // Does js/ui/layout.js:256 destroy quickSettingsItems? + this.quickSettingsItems = []; + }); + } + + async _initProxy(item, textbox, infoFetcher, cancellable) { + const proxy = await proxyPromise( + ShutdownTimerName, + Gio.DBus.session, + 'org.gnome.Shell', + ShutdownTimerObjectPath, + cancellable + ); + if (cancellable?.is_cancelled()) return; + item.connect('shutdown', (__, shutdown, action) => { + logDebug( + '[menu-item] [shutdown-signal] shutdown: ', + shutdown, + 'action:', + action + ); + proxy + .ScheduleShutdownAsync(shutdown, action) + .catch(err => console.error('[shutdown]', err)); + }); + item.connect('wake', (__, wake) => { + proxy + .ScheduleWakeAsync(wake) + .catch(err => console.error('[wake]', err)); + }); + + const signalIds = [ + proxy.connectSignal('OnMessage', (__, ___, [msg]) => { + textbox.showTextbox(msg); + }), + proxy.connectSignal('OnStateChange', (__, ___, [state]) => { + logDebug('[menu-item] [OnStateChange-signal] state:', state); + this._state = state; + this._syncShutdownInfo(); + }), + proxy.connectSignal('OnExternalChange', () => { + infoFetcher.refresh(); + }), + ]; + proxy.destroy = function () { + signalIds.forEach(signalId => this.disconnectSignal(signalId)); + }; + + this._sdtProxy = proxy; + [this._state] = await this._sdtProxy.GetStateAsync(); + if (cancellable?.is_cancelled()) return; + logDebug('[sdt-proxy] state', this._state); + this._syncShutdownInfo(); + infoFetcher.refresh(); + } + + _syncShutdownInfo() { + const item = this._shutdownTimerItem; + if (this._state === 'action') { + if (SessionModeAware.foregroundActive()) Main.overview.hide(); + this._textbox.hideAll(); + } + item.info = { + internalShutdown: getShutdownScheduleFromSettings(this._settings), + externalShutdown: item.info.externalShutdown.copy({ + ...this._infoFetcher.shutdownInfo, + }), + externalWake: item.info.externalWake.copy({ + ...this._infoFetcher.wakeInfo, + }), + state: this._state, + }; + item.updateShutdownInfo(); + } + } +); diff --git a/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/quicksettings.js b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/quicksettings.js new file mode 100644 index 0000000..dd7b161 --- /dev/null +++ b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/quicksettings.js @@ -0,0 +1,77 @@ +// SPDX-FileCopyrightText: 2023 Deminder <tremminder@gmail.com> +// SPDX-License-Identifier: GPL-3.0-or-later + +import * as Main from 'resource:///org/gnome/shell/ui/main.js'; + +/** + * Add an external indicator after an existing indicator and above an existing indicator item. + */ +export function addExternalIndicator( + tracker, + indicator, + after = '_system', + above = '_backgroundApps', + colSpan +) { + const qs = Main.panel.statusArea.quickSettings; + const indicatorItems = indicator.quickSettingsItems; + const aboveIndicator = qs[above]; + if (aboveIndicator === undefined) { + if ('_addItems' in qs) { + // 45.beta.1: _setupIndicators is not done + const injection = tracker.injectProperty( + qs, + '_addItems', + (items, col) => { + if (Object.is(items, qs[above].quickSettingsItems)) { + injection.clear(); + // Insert after: insert_child_above(a,b): inserts 'a' after 'b' + qs._indicators.insert_child_above(indicator, qs[after]); + // Insert above + injection.original.call(qs, indicatorItems, colSpan); + } + injection.previous.call(qs, items, col); + } + ); + } else { + // 45.rc: _setupIndicators is not done + const qsm = qs.menu; + const injection = tracker.injectProperty( + qsm, + '_completeAddItem', + (item, col) => { + const firstAboveItem = qs[above]?.quickSettingsItems.at(-1); + if (Object.is(firstAboveItem, item)) { + injection.clear(); + // Insert after: insert_child_above(a,b): inserts 'a' after 'b' + qs._indicators.insert_child_above(indicator, qs[after]); + // Insert above + indicatorItems.forEach(newItem => + qsm.insertItemBefore(newItem, item, colSpan) + ); + } + injection.previous.call(qsm, item, col); + } + ); + } + } else if ('_addItems' in qs) { + // 45.beta.1: _setupIndicators is done + // Insert after: insert_child_above(a,b): inserts 'a' after 'b' + qs._indicators.insert_child_above(indicator, qs[after]); + // Insert above + qs._addItems(indicatorItems, colSpan); + const firstAboveItem = aboveIndicator.quickSettingsItems.at(-1); + indicatorItems.forEach(item => { + qs.menu._grid.remove_child(item); + qs.menu._grid.insert_child_below(item, firstAboveItem); + }); + } else { + // 45.rc: _setupIndicators is done + // Insert after + qs._indicators.insert_child_above(indicator, qs[after]); + + // Insert above + const firstAboveItem = aboveIndicator.quickSettingsItems.at(-1); + qs._addItemsBefore(indicatorItems, firstAboveItem, colSpan); + } +} diff --git a/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/schedule-info.js b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/schedule-info.js new file mode 100644 index 0000000..394ebc8 --- /dev/null +++ b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/schedule-info.js @@ -0,0 +1,150 @@ +// SPDX-FileCopyrightText: 2023 Deminder <tremminder@gmail.com> +// SPDX-License-Identifier: GPL-3.0-or-later + +import GLib from 'gi://GLib'; +import { gettext as _, ngettext as _n, pgettext as C_ } from './translation.js'; +import { mapLegacyAction, untilText } from '../dbus-service/action.js'; + +export class ScheduleInfo { + constructor({ mode = '?', deadline = -1, external = false }) { + this._v = { mode: mapLegacyAction(mode), deadline, external }; + } + + copy(vals) { + return new ScheduleInfo({ ...this._v, ...vals }); + } + + get deadline() { + return this._v.deadline; + } + + get external() { + return this._v.external; + } + + get mode() { + return this._v.mode; + } + + get scheduled() { + return this.deadline > -1; + } + + get secondsLeft() { + return this.deadline - GLib.DateTime.new_now_utc().to_unix(); + } + + get minutes() { + return Math.floor(this.secondsLeft / 60); + } + + get label() { + let label = ''; + if (this.scheduled) { + label = _('{durationString} until {untiltext}') + .replace('{durationString}', durationString(this.secondsLeft)) + .replace('{untiltext}', untilText(this.mode)); + if (this.external) { + label = _('{label} (sys)').replace('{label}', label); + } + } + return label; + } + + get absoluteTimeString() { + return GLib.DateTime.new_from_unix_utc(this.deadline) + .to_local() + .format(C_('absolute schedule notation', '%a, %T')); + } + + isMoreUrgendThan(otherInfo) { + return ( + !otherInfo.scheduled || + (this.scheduled && + // external deadline is instant, internal deadline has 1 min slack time + (this.external ? this.deadline : this.deadline + 58) < + otherInfo.deadline) + ); + } +} + +export function getShutdownScheduleFromSettings(settings) { + return new ScheduleInfo({ + mode: settings.get_string('shutdown-mode-value'), + deadline: settings.get_int('shutdown-timestamp-value'), + }); +} + +export function getSliderMinutesFromSettings(settings, prefix) { + const sliderValue = settings.get_double(`${prefix}-slider-value`) / 100.0; + const rampUp = settings.get_double(`nonlinear-${prefix}-slider-value`); + const ramp = x => Math.expm1(rampUp * x) / Math.expm1(rampUp); + let minutes = Math.floor( + (rampUp === 0 ? sliderValue : ramp(sliderValue)) * + settings.get_int(`${prefix}-max-timer-value`) + ); + + const refstr = settings.get_string(`${prefix}-ref-timer-value`); + // default: 'now' + const MS = 1000 * 60; + if (refstr.includes(':')) { + const mh = refstr + .split(':') + .map(s => Number.parseInt(s)) + .filter(n => !Number.isNaN(n) && n >= 0); + if (mh.length >= 2) { + const d = new Date(); + const nowTime = d.getTime(); + d.setHours(mh[0]); + d.setMinutes(mh[1]); + + if (d.getTime() + MS * minutes < nowTime) { + d.setDate(d.getDate() + 1); + } + minutes += Math.floor(new Date(d.getTime() - nowTime).getTime() / MS); + } + } else if (prefix !== 'shutdown' && refstr === 'shutdown') { + minutes += getSliderMinutesFromSettings(settings, 'shutdown'); + } + return minutes; +} + +/** + * A short duration string showing >=3 hours, >=1 mins, or secs. + * + * @param {number} seconds duration in seconds + */ +export function durationString(seconds) { + const sign = Math.sign(seconds); + const absSec = Math.floor(Math.abs(seconds)); + const minutes = Math.floor(absSec / 60); + const hours = Math.floor(minutes / 60); + if (hours >= 3) { + return _n('%s hour', '%s hours', hours).format(sign * hours); + } else if (minutes === 0) { + return _n('%s sec', '%s secs', absSec).format( + sign * (absSec > 5 ? 10 * Math.ceil(absSec / 10) : absSec) + ); + } + return _n('%s min', '%s mins', minutes).format(sign * minutes); +} + +/** + * + * @param minutes + * @param hrFmt + * @param minFmt + */ +export function longDurationString(minutes, hrFmt, minFmt) { + const hours = Math.floor(minutes / 60); + const residualMinutes = minutes % 60; + let parts = [minFmt(residualMinutes).format(residualMinutes)]; + if (hours) { + parts = [hrFmt(hours).format(hours)].concat(parts); + } + return parts.join(' '); +} + +export function absoluteTimeString(minutes, timeFmt) { + return GLib.DateTime.new_now_local().add_minutes(minutes).format(timeFmt); +} diff --git a/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/session-mode-aware.js b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/session-mode-aware.js new file mode 100644 index 0000000..cb6e562 --- /dev/null +++ b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/session-mode-aware.js @@ -0,0 +1,41 @@ +// SPDX-FileCopyrightText: 2023 Deminder <tremminder@gmail.com> +// SPDX-License-Identifier: GPL-3.0-or-later + +import * as Main from 'resource:///org/gnome/shell/ui/main.js'; + +export function currentSessionMode() { + return Main.sessionMode.currentMode; +} + +/** + * Check if we want to show foreground activity + */ +export function foregroundActive() { + // ubuntu22.04 uses 'ubuntu' as 'user' sessionMode + return Main.sessionMode.currentMode !== 'unlock-dialog'; +} + +/** + * Observe foreground activity changes + * + * @param {object} obj bind obj as observer + * @param {Function} callback called upon change + */ +export function observeForegroundActive(obj, callback) { + if (!obj._sessionModeSignalId) { + obj._sessionModeSignalId = Main.sessionMode.connect('updated', () => { + callback(foregroundActive()); + }); + } + callback(foregroundActive()); +} + +/** + * Unobserve session mode + */ +export function unobserveForegroundActive(obj) { + if (obj._sessionModeSignalId) { + Main.sessionMode.disconnect(obj._sessionModeSignalId); + delete obj._sessionModeSignalId; + } +} diff --git a/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/text-box.js b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/text-box.js new file mode 100644 index 0000000..b97cdb1 --- /dev/null +++ b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/text-box.js @@ -0,0 +1,130 @@ +// SPDX-FileCopyrightText: 2023 Deminder <tremminder@gmail.com> +// SPDX-License-Identifier: GPL-3.0-or-later + +import St from 'gi://St'; +import Clutter from 'gi://Clutter'; + +import * as Main from 'resource:///org/gnome/shell/ui/main.js'; +import { throttleTimeout, logDebug } from './util.js'; +import { + foregroundActive, + observeForegroundActive, + unobserveForegroundActive, +} from './session-mode-aware.js'; + +export class Textbox { + textboxes = []; + constructor({ settings }) { + this.settings = settings; + [this.syncThrottled, this.syncThrottledCancel] = throttleTimeout( + this.sync.bind(this), + 50 + ); + this.showSettingsId = settings.connect( + 'changed::show-textboxes-value', + this.sync.bind(this) + ); + observeForegroundActive(this, fgActive => { + if (!fgActive) { + this.hideAll(); + } + }); + } + + destroy() { + if (this.showSettingsId) { + unobserveForegroundActive(this); + this.hideAll(); + this.settings.disconnect(this.showSettingsId); + this.showSettingsId = null; + } + } + + sync() { + this.syncThrottledCancel(); + // remove hidden textboxes + this.textboxes = this.textboxes.filter(t => { + if (t['_hidden']) { + const sid = t['_sourceId']; + if (sid) { + clearTimeout(sid); + } + delete t['_sourceId']; + t.destroy(); + } + return !t['_hidden']; + }); + const monitor = Main.layoutManager.primaryMonitor; + let heightOffset = 0; + this.textboxes.forEach((textbox, i) => { + if (!('_sourceId' in textbox)) { + // start fadeout of textbox after 3 seconds + textbox['_sourceId'] = setTimeout(() => { + textbox['_sourceId'] = 0; + textbox.ease({ + opacity: 0, + duration: 1000, + mode: Clutter.AnimationMode.EASE_OUT_QUAD, + onComplete: () => { + textbox['_hidden'] = 1; + this.syncThrottled(); + }, + }); + }, 3000); + } + textbox.visible = this.settings.get_boolean('show-textboxes-value'); + if (!textbox.visible) return; + + if (i === 0) { + heightOffset = -textbox.height / 2; + } + textbox.set_position( + monitor.x + Math.floor(monitor.width / 2 - textbox.width / 2), + monitor.y + Math.floor(monitor.height / 2 + heightOffset) + ); + heightOffset += textbox.height + 10; + if (textbox['_sourceId']) { + // set opacity before fadeout starts + textbox.opacity = + i === 0 + ? 255 + : Math.max( + 25, + 25 + 230 * (1 - heightOffset / (monitor.height / 2)) + ); + } + }); + } + + hideAll() { + for (const t of this.textboxes) { + t['_hidden'] = 1; + } + this.sync(); + } + + /** + * Show a textbox message on the primary monitor + * + * @param textmsg + */ + showTextbox(textmsg) { + if (textmsg && foregroundActive()) { + for (const t of this.textboxes) { + // replace old textbox if it has the same text + if (t.text === textmsg) { + t['_hidden'] = 1; + } + } + logDebug(`show textbox: ${textmsg}`); + const textbox = new St.Label({ + style_class: 'textbox-label', + text: textmsg, + opacity: 0, + }); + Main.uiGroup.add_child(textbox); + this.textboxes.unshift(textbox); + this.syncThrottled(); + } + } +} diff --git a/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/translation.js b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/translation.js new file mode 100644 index 0000000..af18232 --- /dev/null +++ b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/translation.js @@ -0,0 +1,51 @@ +// SPDX-FileCopyrightText: 2023 Deminder <tremminder@gmail.com> +// SPDX-License-Identifier: GPL-3.0-or-later + +import GLib from 'gi://GLib'; + +/** + * The import paths for translations differ for `extension.js` and `prefs.js`. + * https://gjs.guide/extensions/upgrading/gnome-shell-45.html#esm + * + * This module provides shared access to translations. + * It is assumed that the gettext-domain is already bound. + */ +const domain = 'ShutdownTimer'; + +/** + * Translate `str` using the extension's gettext domain + * + * @param {string} str - the string to translated + * + * @returns {string} the translated string + */ +export function gettext(str) { + return GLib.dgettext(domain, str); +} + +/** + * Translate `str` and choose plural form using the extension's + * gettext domain + * + * @param {string} str - the string to translate + * @param {string} strPlural - the plural form of the string + * @param {number} n - the quantity for which translation is needed + * + * @returns {string} the translated string + */ +export function ngettext(str, strPlural, n) { + return GLib.dngettext(domain, str, strPlural, n); +} + +/** + * Translate `str` in the context of `context` using the extension's + * gettext domain + * + * @param {string} context - context to disambiguate `str` + * @param {string} str - the string to translate + * + * @returns {string} the translated string + */ +export function pgettext(context, str) { + return GLib.dpgettext2(domain, context, str); +} diff --git a/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/util.js b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/util.js new file mode 100644 index 0000000..6f360aa --- /dev/null +++ b/raveos-theme/gnome/theme-data/extensions/installed/ShutdownTimer@deminder/modules/util.js @@ -0,0 +1,178 @@ +// SPDX-FileCopyrightText: 2023 Deminder <tremminder@gmail.com> +// SPDX-License-Identifier: GPL-3.0-or-later + +import GLib from 'gi://GLib'; +import Gio from 'gi://Gio'; + +export const debugMode = false; + +/** + * Log debug message if debug is enabled . + * + * @param {...any} args log arguments + */ +export function logDebug(...args) { + if ('logDebug' in globalThis) { + globalThis.logDebug(...args); + } else if (debugMode) { + console.log('[SDT]', ...args); + } +} + +export async function proxyPromise( + ProxyTypeOrName, + session, + dest, + objectPath, + cancellable = null +) { + if (typeof ProxyTypeOrName === 'string') { + try { + ProxyTypeOrName = Gio.DBusProxy.makeProxyWrapper( + await loadInterfaceXML(ProxyTypeOrName, cancellable) + ); + } catch (err) { + throw new Error('Failed to load proxy interface!', { cause: err }); + } + } + const p = await new Promise((resolve, reject) => { + new ProxyTypeOrName( + session, + dest, + objectPath, + (proxy, error) => { + if (error) { + reject(error); + } else { + resolve(proxy); + } + }, + cancellable + ); + }); + return p; +} + +export class Idle { + #idleSourceId = null; + #idleResolves = []; + + destroy() { + // Ensure that promises are resolved + for (const resolve of this.#idleResolves) { + resolve(); + } + this.#idleResolves = []; + if (this.#idleSourceId) { + GLib.Source.remove(this.#idleSourceId); + } + this.#idleSourceId = null; + } + + /** + * Resolves when event loop is idle + */ + guiIdle() { + return new Promise(resolve => { + this.#idleResolves.push(resolve); + if (!this.#idleSourceId) { + this.#idleSourceId = GLib.idle_add(GLib.PRIORITY_DEFAULT_IDLE, () => { + for (const res of this.#idleResolves) { + res(); + } + this.#idleResolves = []; + this.#idleSourceId = null; + return GLib.SOURCE_REMOVE; + }); + } + }); + } +} + +/** + * Calls to `event` are delayed (throttled). + * Call `cancel` drop last event. + * + * @param {Function} timeoutFunc called function after delay + * @param {number} delayMillis delay in milliseconds + * @returns [event, cancel] + */ +export function throttleTimeout(timeoutFunc, delayMillis) { + let current = null; + return [ + () => { + if (current === null) { + current = setTimeout(() => { + current = null; + timeoutFunc(); + }, delayMillis); + } + }, + () => { + if (current) { + clearTimeout(current); + current = null; + } + }, + ]; +} + +export function extensionDirectory() { + const utilModulePath = /(.*)@file:\/\/(.*):\d+:\d+$/.exec( + new Error().stack.split('\n')[1] + )[2]; + const extOrModuleDir = GLib.path_get_dirname( + GLib.path_get_dirname(utilModulePath) + ); + // This file is either at /modules/util.js or /modules/sdt/util.js + return GLib.path_get_basename(extOrModuleDir) === 'modules' + ? GLib.path_get_dirname(extOrModuleDir) + : extOrModuleDir; +} + +export function readFileAsync(pathOrFile, cancellable = null) { + return new Promise((resolve, reject) => { + try { + const file = + typeof pathOrFile === 'string' + ? Gio.File.new_for_path(pathOrFile) + : pathOrFile; + file.load_contents_async(cancellable, (f, res) => { + try { + const [, contents] = f.load_contents_finish(res); + const decoder = new TextDecoder('utf-8'); + resolve(decoder.decode(contents)); + } catch (err) { + reject(err); + } + }); + } catch (err) { + reject(err); + } + }); +} + +export async function loadInterfaceXML(iface, cancellable = null) { + const readPromises = [ + Gio.File.new_for_path( + `${extensionDirectory()}/dbus-interfaces/${iface}.xml` + ), + Gio.File.new_for_uri( + `resource:///org/gnome/shell/dbus-interfaces/${iface}.xml` + ), + ].map(async file => { + try { + return await readFileAsync(file, cancellable); + } catch (err) { + return ''; + } + }); + for await (const xml of readPromises) { + if (xml) return xml; + } + throw new Error( + `Failed to load D-Bus interface '${iface}'${ + cancellable && cancellable.is_cancelled() ? ' (canceled)' : '' + }` + ); +} |