diff options
Diffstat (limited to 'js/ui/unlockDialog.js')
| -rw-r--r-- | js/ui/unlockDialog.js | 899 |
1 files changed, 899 insertions, 0 deletions
diff --git a/js/ui/unlockDialog.js b/js/ui/unlockDialog.js new file mode 100644 index 0000000..24c8160 --- /dev/null +++ b/js/ui/unlockDialog.js @@ -0,0 +1,899 @@ +// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- +/* exported UnlockDialog */ + +const { + AccountsService, Atk, Clutter, Gdm, Gio, + GnomeDesktop, GLib, GObject, Meta, Shell, St, +} = imports.gi; + +const Background = imports.ui.background; +const Layout = imports.ui.layout; +const Main = imports.ui.main; +const MessageTray = imports.ui.messageTray; +const SwipeTracker = imports.ui.swipeTracker; + +const AuthPrompt = imports.gdm.authPrompt; + +// The timeout before going back automatically to the lock screen (in seconds) +const IDLE_TIMEOUT = 2 * 60; + +// The timeout before showing the unlock hint (in seconds) +const HINT_TIMEOUT = 4; + +const CROSSFADE_TIME = 300; +const FADE_OUT_TRANSLATION = 200; +const FADE_OUT_SCALE = 0.3; + +const BLUR_BRIGHTNESS = 0.55; +const BLUR_SIGMA = 60; + +const SUMMARY_ICON_SIZE = 32; + +var NotificationsBox = GObject.registerClass({ + Signals: { 'wake-up-screen': {} }, +}, class NotificationsBox extends St.BoxLayout { + _init() { + super._init({ + vertical: true, + name: 'unlockDialogNotifications', + style_class: 'unlock-dialog-notifications-container', + }); + + this._scrollView = new St.ScrollView({ hscrollbar_policy: St.PolicyType.NEVER }); + this._notificationBox = new St.BoxLayout({ + vertical: true, + style_class: 'unlock-dialog-notifications-container', + }); + this._scrollView.add_actor(this._notificationBox); + + this.add_child(this._scrollView); + + this._settings = new Gio.Settings({ + schema_id: 'org.gnome.desktop.notifications', + }); + + this._sources = new Map(); + Main.messageTray.getSources().forEach(source => { + this._sourceAdded(Main.messageTray, source, true); + }); + this._updateVisibility(); + + Main.messageTray.connectObject('source-added', + this._sourceAdded.bind(this), this); + + this.connect('destroy', this._onDestroy.bind(this)); + } + + _onDestroy() { + let items = this._sources.entries(); + for (let [source, obj] of items) + this._removeSource(source, obj); + } + + _updateVisibility() { + this._notificationBox.visible = + this._notificationBox.get_children().some(a => a.visible); + + this.visible = this._notificationBox.visible; + } + + _makeNotificationSource(source, box) { + let sourceActor = new MessageTray.SourceActor(source, SUMMARY_ICON_SIZE); + box.add_child(sourceActor); + + let textBox = new St.BoxLayout({ + x_expand: true, + y_expand: true, + y_align: Clutter.ActorAlign.CENTER, + }); + box.add_child(textBox); + + let title = new St.Label({ + text: source.title, + style_class: 'unlock-dialog-notification-label', + x_expand: true, + x_align: Clutter.ActorAlign.START, + }); + textBox.add(title); + + let count = source.unseenCount; + let countLabel = new St.Label({ + text: `${count}`, + visible: count > 1, + style_class: 'unlock-dialog-notification-count-text', + }); + textBox.add(countLabel); + + box.visible = count !== 0; + return [title, countLabel]; + } + + _makeNotificationDetailedSource(source, box) { + let sourceActor = new MessageTray.SourceActor(source, SUMMARY_ICON_SIZE); + let sourceBin = new St.Bin({ child: sourceActor }); + box.add(sourceBin); + + let textBox = new St.BoxLayout({ vertical: true }); + box.add_child(textBox); + + let title = new St.Label({ + text: source.title.replace(/\n/g, ' '), + style_class: 'unlock-dialog-notification-label', + }); + textBox.add(title); + + let visible = false; + for (let i = 0; i < source.notifications.length; i++) { + let n = source.notifications[i]; + + if (n.acknowledged) + continue; + + let body = ''; + if (n.bannerBodyText) { + const bodyText = n.bannerBodyText.replace(/\n/g, ' '); + body = n.bannerBodyMarkup + ? bodyText + : GLib.markup_escape_text(bodyText, -1); + } + + let label = new St.Label({ style_class: 'unlock-dialog-notification-count-text' }); + label.clutter_text.set_markup(`<b>${n.title}</b> ${body}`); + textBox.add(label); + + visible = true; + } + + box.visible = visible; + return [title, null]; + } + + _shouldShowDetails(source) { + return source.policy.detailsInLockScreen || + source.narrowestPrivacyScope === MessageTray.PrivacyScope.SYSTEM; + } + + _updateSourceBoxStyle(source, obj, box) { + let hasCriticalNotification = + source.notifications.some(n => n.urgency === MessageTray.Urgency.CRITICAL); + + if (hasCriticalNotification !== obj.hasCriticalNotification) { + obj.hasCriticalNotification = hasCriticalNotification; + + if (hasCriticalNotification) + box.add_style_class_name('critical'); + else + box.remove_style_class_name('critical'); + } + } + + _showSource(source, obj, box) { + if (obj.detailed) + [obj.titleLabel, obj.countLabel] = this._makeNotificationDetailedSource(source, box); + else + [obj.titleLabel, obj.countLabel] = this._makeNotificationSource(source, box); + + box.visible = obj.visible && (source.unseenCount > 0); + + this._updateSourceBoxStyle(source, obj, box); + } + + _wakeUpScreenForSource(source) { + if (!this._settings.get_boolean('show-banners')) + return; + const obj = this._sources.get(source); + if (obj?.sourceBox.visible) + this.emit('wake-up-screen'); + } + + _sourceAdded(tray, source, initial) { + let obj = { + visible: source.policy.showInLockScreen, + detailed: this._shouldShowDetails(source), + sourceBox: null, + titleLabel: null, + countLabel: null, + hasCriticalNotification: false, + }; + + obj.sourceBox = new St.BoxLayout({ + style_class: 'unlock-dialog-notification-source', + x_expand: true, + }); + this._showSource(source, obj, obj.sourceBox); + this._notificationBox.add_child(obj.sourceBox); + + source.connectObject( + 'notify::count', () => this._countChanged(source, obj), + 'notify::title', () => this._titleChanged(source, obj), + 'destroy', () => { + this._removeSource(source, obj); + this._updateVisibility(); + }, this); + obj.policyChangedId = source.policy.connect('notify', (policy, pspec) => { + if (pspec.name === 'show-in-lock-screen') + this._visibleChanged(source, obj); + else + this._detailedChanged(source, obj); + }); + + this._sources.set(source, obj); + + if (!initial) { + // block scrollbars while animating, if they're not needed now + let boxHeight = this._notificationBox.height; + if (this._scrollView.height >= boxHeight) + this._scrollView.vscrollbar_policy = St.PolicyType.NEVER; + + let widget = obj.sourceBox; + let [, natHeight] = widget.get_preferred_height(-1); + widget.height = 0; + widget.ease({ + height: natHeight, + mode: Clutter.AnimationMode.EASE_OUT_QUAD, + duration: 250, + onComplete: () => { + this._scrollView.vscrollbar_policy = St.PolicyType.AUTOMATIC; + widget.set_height(-1); + }, + }); + + this._updateVisibility(); + this._wakeUpScreenForSource(source); + } + } + + _titleChanged(source, obj) { + obj.titleLabel.text = source.title; + } + + _countChanged(source, obj) { + // A change in the number of notifications may change whether we show + // details. + let newDetailed = this._shouldShowDetails(source); + let oldDetailed = obj.detailed; + + obj.detailed = newDetailed; + + if (obj.detailed || oldDetailed !== newDetailed) { + // A new notification was pushed, or a previous notification was destroyed. + // Give up, and build the list again. + + obj.sourceBox.destroy_all_children(); + obj.titleLabel = obj.countLabel = null; + this._showSource(source, obj, obj.sourceBox); + } else { + let count = source.unseenCount; + obj.countLabel.text = `${count}`; + obj.countLabel.visible = count > 1; + } + + obj.sourceBox.visible = obj.visible && (source.unseenCount > 0); + + this._updateVisibility(); + this._wakeUpScreenForSource(source); + } + + _visibleChanged(source, obj) { + if (obj.visible === source.policy.showInLockScreen) + return; + + obj.visible = source.policy.showInLockScreen; + obj.sourceBox.visible = obj.visible && source.unseenCount > 0; + + this._updateVisibility(); + this._wakeUpScreenForSource(source); + } + + _detailedChanged(source, obj) { + let newDetailed = this._shouldShowDetails(source); + if (obj.detailed === newDetailed) + return; + + obj.detailed = newDetailed; + + obj.sourceBox.destroy_all_children(); + obj.titleLabel = obj.countLabel = null; + this._showSource(source, obj, obj.sourceBox); + } + + _removeSource(source, obj) { + obj.sourceBox.destroy(); + obj.sourceBox = obj.titleLabel = obj.countLabel = null; + + source.policy.disconnect(obj.policyChangedId); + + this._sources.delete(source); + } +}); + +var Clock = GObject.registerClass( +class UnlockDialogClock extends St.BoxLayout { + _init() { + super._init({ style_class: 'unlock-dialog-clock', vertical: true }); + + this._time = new St.Label({ + style_class: 'unlock-dialog-clock-time', + x_align: Clutter.ActorAlign.CENTER, + }); + this._date = new St.Label({ + style_class: 'unlock-dialog-clock-date', + x_align: Clutter.ActorAlign.CENTER, + }); + this._hint = new St.Label({ + style_class: 'unlock-dialog-clock-hint', + x_align: Clutter.ActorAlign.CENTER, + opacity: 0, + }); + + this.add_child(this._time); + this.add_child(this._date); + this.add_child(this._hint); + + this._wallClock = new GnomeDesktop.WallClock({ time_only: true }); + this._wallClock.connect('notify::clock', this._updateClock.bind(this)); + + this._seat = Clutter.get_default_backend().get_default_seat(); + this._seat.connectObject('notify::touch-mode', + this._updateHint.bind(this), this); + + this._monitorManager = Meta.MonitorManager.get(); + this._monitorManager.connectObject('power-save-mode-changed', + () => (this._hint.opacity = 0), this); + + this._idleMonitor = global.backend.get_core_idle_monitor(); + this._idleWatchId = this._idleMonitor.add_idle_watch(HINT_TIMEOUT * 1000, () => { + this._hint.ease({ + opacity: 255, + duration: CROSSFADE_TIME, + }); + }); + + this._updateClock(); + this._updateHint(); + + this.connect('destroy', this._onDestroy.bind(this)); + } + + _updateClock() { + this._time.text = this._wallClock.clock; + + let date = new Date(); + /* Translators: This is a time format for a date in + long format */ + let dateFormat = Shell.util_translate_time_string(N_('%A %B %-d')); + this._date.text = date.toLocaleFormat(dateFormat); + } + + _updateHint() { + this._hint.text = this._seat.touch_mode + ? _('Swipe up to unlock') + : _('Click or press a key to unlock'); + } + + _onDestroy() { + this._wallClock.run_dispose(); + + this._idleMonitor.remove_watch(this._idleWatchId); + } +}); + +var UnlockDialogLayout = GObject.registerClass( +class UnlockDialogLayout extends Clutter.LayoutManager { + _init(stack, notifications, switchUserButton) { + super._init(); + + this._stack = stack; + this._notifications = notifications; + this._switchUserButton = switchUserButton; + } + + vfunc_get_preferred_width(container, forHeight) { + return this._stack.get_preferred_width(forHeight); + } + + vfunc_get_preferred_height(container, forWidth) { + return this._stack.get_preferred_height(forWidth); + } + + vfunc_allocate(container, box) { + let [width, height] = box.get_size(); + + let tenthOfHeight = height / 10.0; + let thirdOfHeight = height / 3.0; + + let [, , stackWidth, stackHeight] = + this._stack.get_preferred_size(); + + let [, , notificationsWidth, notificationsHeight] = + this._notifications.get_preferred_size(); + + let columnWidth = Math.max(stackWidth, notificationsWidth); + + let columnX1 = Math.floor((width - columnWidth) / 2.0); + let actorBox = new Clutter.ActorBox(); + + // Notifications + let maxNotificationsHeight = Math.min( + notificationsHeight, + height - tenthOfHeight - stackHeight); + + actorBox.x1 = columnX1; + actorBox.y1 = height - maxNotificationsHeight; + actorBox.x2 = columnX1 + columnWidth; + actorBox.y2 = actorBox.y1 + maxNotificationsHeight; + + this._notifications.allocate(actorBox); + + // Authentication Box + let stackY = Math.min( + thirdOfHeight, + height - stackHeight - maxNotificationsHeight); + + actorBox.x1 = columnX1; + actorBox.y1 = stackY; + actorBox.x2 = columnX1 + columnWidth; + actorBox.y2 = stackY + stackHeight; + + this._stack.allocate(actorBox); + + // Switch User button + if (this._switchUserButton.visible) { + let [, , natWidth, natHeight] = + this._switchUserButton.get_preferred_size(); + + const textDirection = this._switchUserButton.get_text_direction(); + if (textDirection === Clutter.TextDirection.RTL) + actorBox.x1 = box.x1 + natWidth; + else + actorBox.x1 = box.x2 - (natWidth * 2); + + actorBox.y1 = box.y2 - (natHeight * 2); + actorBox.x2 = actorBox.x1 + natWidth; + actorBox.y2 = actorBox.y1 + natHeight; + + this._switchUserButton.allocate(actorBox); + } + } +}); + +var UnlockDialog = GObject.registerClass({ + Signals: { + 'failed': {}, + 'wake-up-screen': {}, + }, +}, class UnlockDialog extends St.Widget { + _init(parentActor) { + super._init({ + accessible_role: Atk.Role.WINDOW, + style_class: 'unlock-dialog', + visible: false, + reactive: true, + }); + + parentActor.add_child(this); + + this._gdmClient = new Gdm.Client(); + + try { + this._gdmClient.set_enabled_extensions([ + Gdm.UserVerifierChoiceList.interface_info().name, + ]); + } catch (e) { + } + + this._adjustment = new St.Adjustment({ + actor: this, + lower: 0, + upper: 2, + page_size: 1, + page_increment: 1, + }); + this._adjustment.connect('notify::value', () => { + this._setTransitionProgress(this._adjustment.value); + }); + + this._swipeTracker = new SwipeTracker.SwipeTracker(this, + Clutter.Orientation.VERTICAL, + Shell.ActionMode.UNLOCK_SCREEN); + this._swipeTracker.connect('begin', this._swipeBegin.bind(this)); + this._swipeTracker.connect('update', this._swipeUpdate.bind(this)); + this._swipeTracker.connect('end', this._swipeEnd.bind(this)); + + this.connect('scroll-event', (o, event) => { + if (this._swipeTracker.canHandleScrollEvent(event)) + return Clutter.EVENT_PROPAGATE; + + let direction = event.get_scroll_direction(); + if (direction === Clutter.ScrollDirection.UP) + this._showClock(); + else if (direction === Clutter.ScrollDirection.DOWN) + this._showPrompt(); + return Clutter.EVENT_STOP; + }); + + this._activePage = null; + + let tapAction = new Clutter.TapAction(); + tapAction.connect('tap', this._showPrompt.bind(this)); + this.add_action(tapAction); + + // Background + this._backgroundGroup = new Clutter.Actor(); + this.add_child(this._backgroundGroup); + + this._bgManagers = []; + + const themeContext = St.ThemeContext.get_for_stage(global.stage); + themeContext.connectObject('notify::scale-factor', + () => this._updateBackgroundEffects(), this); + + this._updateBackgrounds(); + Main.layoutManager.connectObject('monitors-changed', + this._updateBackgrounds.bind(this), this); + + this._userManager = AccountsService.UserManager.get_default(); + this._userName = GLib.get_user_name(); + this._user = this._userManager.get_user(this._userName); + + // Authentication & Clock stack + this._stack = new Shell.Stack(); + + this._promptBox = new St.BoxLayout({ vertical: true }); + this._promptBox.set_pivot_point(0.5, 0.5); + this._promptBox.hide(); + this._stack.add_child(this._promptBox); + + this._clock = new Clock(); + this._clock.set_pivot_point(0.5, 0.5); + this._stack.add_child(this._clock); + this._showClock(); + + this.allowCancel = false; + + Main.ctrlAltTabManager.addGroup(this, _('Unlock Window'), 'dialog-password-symbolic'); + + // Notifications + this._notificationsBox = new NotificationsBox(); + this._notificationsBox.connect('wake-up-screen', () => this.emit('wake-up-screen')); + + // Switch User button + this._otherUserButton = new St.Button({ + style_class: 'modal-dialog-button button switch-user-button', + accessible_name: _('Log in as another user'), + button_mask: St.ButtonMask.ONE | St.ButtonMask.THREE, + reactive: false, + opacity: 0, + x_align: Clutter.ActorAlign.END, + y_align: Clutter.ActorAlign.END, + icon_name: 'system-users-symbolic', + }); + this._otherUserButton.set_pivot_point(0.5, 0.5); + this._otherUserButton.connect('clicked', this._otherUserClicked.bind(this)); + + this._screenSaverSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.screensaver' }); + + this._screenSaverSettings.connectObject('changed::user-switch-enabled', + this._updateUserSwitchVisibility.bind(this), this); + + this._lockdownSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.lockdown' }); + this._lockdownSettings.connect('changed::disable-user-switching', + this._updateUserSwitchVisibility.bind(this)); + + this._user.connectObject('notify::is-loaded', + this._updateUserSwitchVisibility.bind(this), this); + + this._updateUserSwitchVisibility(); + + // Main Box + let mainBox = new St.Widget(); + mainBox.add_constraint(new Layout.MonitorConstraint({ primary: true })); + mainBox.add_child(this._stack); + mainBox.add_child(this._notificationsBox); + mainBox.add_child(this._otherUserButton); + mainBox.layout_manager = new UnlockDialogLayout( + this._stack, + this._notificationsBox, + this._otherUserButton); + this.add_child(mainBox); + + this._idleMonitor = global.backend.get_core_idle_monitor(); + this._idleWatchId = this._idleMonitor.add_idle_watch(IDLE_TIMEOUT * 1000, this._escape.bind(this)); + + this.connect('destroy', this._onDestroy.bind(this)); + } + + vfunc_key_press_event(keyEvent) { + if (this._activePage === this._promptBox || + (this._promptBox && this._promptBox.visible)) + return Clutter.EVENT_PROPAGATE; + + const { keyval } = keyEvent; + if (keyval === Clutter.KEY_Shift_L || + keyval === Clutter.KEY_Shift_R || + keyval === Clutter.KEY_Shift_Lock || + keyval === Clutter.KEY_Caps_Lock) + return Clutter.EVENT_PROPAGATE; + + let unichar = keyEvent.unicode_value; + + this._showPrompt(); + + if (GLib.unichar_isgraph(unichar)) + this._authPrompt.addCharacter(unichar); + + return Clutter.EVENT_PROPAGATE; + } + + vfunc_captured_event(event) { + if (Main.keyboard.maybeHandleEvent(event)) + return Clutter.EVENT_STOP; + + return Clutter.EVENT_PROPAGATE; + } + + _createBackground(monitorIndex) { + let monitor = Main.layoutManager.monitors[monitorIndex]; + let widget = new St.Widget({ + style_class: 'screen-shield-background', + x: monitor.x, + y: monitor.y, + width: monitor.width, + height: monitor.height, + effect: new Shell.BlurEffect({ name: 'blur' }), + }); + + let bgManager = new Background.BackgroundManager({ + container: widget, + monitorIndex, + controlPosition: false, + }); + + this._bgManagers.push(bgManager); + + this._backgroundGroup.add_child(widget); + } + + _updateBackgroundEffects() { + const themeContext = St.ThemeContext.get_for_stage(global.stage); + + for (const widget of this._backgroundGroup) { + const effect = widget.get_effect('blur'); + + if (effect) { + effect.set({ + brightness: BLUR_BRIGHTNESS, + sigma: BLUR_SIGMA * themeContext.scale_factor, + }); + } + } + } + + _updateBackgrounds() { + for (let i = 0; i < this._bgManagers.length; i++) + this._bgManagers[i].destroy(); + + this._bgManagers = []; + this._backgroundGroup.destroy_all_children(); + + for (let i = 0; i < Main.layoutManager.monitors.length; i++) + this._createBackground(i); + this._updateBackgroundEffects(); + } + + _ensureAuthPrompt() { + if (!this._authPrompt) { + this._authPrompt = new AuthPrompt.AuthPrompt(this._gdmClient, + AuthPrompt.AuthPromptMode.UNLOCK_ONLY); + this._authPrompt.connect('failed', this._fail.bind(this)); + this._authPrompt.connect('cancelled', this._fail.bind(this)); + this._authPrompt.connect('reset', this._onReset.bind(this)); + this._promptBox.add_child(this._authPrompt); + } + + this._authPrompt.reset(); + this._authPrompt.updateSensitivity(true); + } + + _maybeDestroyAuthPrompt() { + let focus = global.stage.key_focus; + if (focus === null || + (this._authPrompt && this._authPrompt.contains(focus)) || + (this._otherUserButton && focus === this._otherUserButton)) + this.grab_key_focus(); + + if (this._authPrompt) { + this._authPrompt.destroy(); + this._authPrompt = null; + } + } + + _showClock() { + if (this._activePage === this._clock) + return; + + this._activePage = this._clock; + + this._adjustment.ease(0, { + duration: CROSSFADE_TIME, + mode: Clutter.AnimationMode.EASE_OUT_QUAD, + onComplete: () => this._maybeDestroyAuthPrompt(), + }); + } + + _showPrompt() { + this._ensureAuthPrompt(); + + if (this._activePage === this._promptBox) + return; + + this._activePage = this._promptBox; + + this._adjustment.ease(1, { + duration: CROSSFADE_TIME, + mode: Clutter.AnimationMode.EASE_OUT_QUAD, + }); + } + + _setTransitionProgress(progress) { + this._promptBox.visible = progress > 0; + this._clock.visible = progress < 1; + + this._otherUserButton.set({ + reactive: progress > 0, + can_focus: progress > 0, + }); + + const { scaleFactor } = St.ThemeContext.get_for_stage(global.stage); + + this._promptBox.set({ + opacity: 255 * progress, + scale_x: FADE_OUT_SCALE + (1 - FADE_OUT_SCALE) * progress, + scale_y: FADE_OUT_SCALE + (1 - FADE_OUT_SCALE) * progress, + translation_y: FADE_OUT_TRANSLATION * (1 - progress) * scaleFactor, + }); + + this._clock.set({ + opacity: 255 * (1 - progress), + scale_x: FADE_OUT_SCALE + (1 - FADE_OUT_SCALE) * (1 - progress), + scale_y: FADE_OUT_SCALE + (1 - FADE_OUT_SCALE) * (1 - progress), + translation_y: -FADE_OUT_TRANSLATION * progress * scaleFactor, + }); + + this._otherUserButton.set({ + opacity: 255 * progress, + scale_x: FADE_OUT_SCALE + (1 - FADE_OUT_SCALE) * progress, + scale_y: FADE_OUT_SCALE + (1 - FADE_OUT_SCALE) * progress, + }); + } + + _fail() { + this._showClock(); + this.emit('failed'); + } + + _onReset(authPrompt, beginRequest) { + let userName; + if (beginRequest == AuthPrompt.BeginRequestType.PROVIDE_USERNAME) { + this._authPrompt.setUser(this._user); + userName = this._userName; + } else { + userName = null; + } + + this._authPrompt.begin({ userName }); + } + + _escape() { + if (this._authPrompt && this.allowCancel) + this._authPrompt.cancel(); + } + + _swipeBegin(tracker, monitor) { + if (monitor !== Main.layoutManager.primaryIndex) + return; + + this._adjustment.remove_transition('value'); + + this._ensureAuthPrompt(); + + let progress = this._adjustment.value; + tracker.confirmSwipe(this._stack.height, + [0, 1], + progress, + Math.round(progress)); + } + + _swipeUpdate(tracker, progress) { + this._adjustment.value = progress; + } + + _swipeEnd(tracker, duration, endProgress) { + this._activePage = endProgress + ? this._promptBox + : this._clock; + + this._adjustment.ease(endProgress, { + mode: Clutter.AnimationMode.EASE_OUT_CUBIC, + duration, + onComplete: () => { + if (this._activePage === this._clock) + this._maybeDestroyAuthPrompt(); + }, + }); + } + + _otherUserClicked() { + Gdm.goto_login_session_sync(null); + + this._authPrompt.cancel(); + } + + _onDestroy() { + this.popModal(); + + if (this._idleWatchId) { + this._idleMonitor.remove_watch(this._idleWatchId); + this._idleWatchId = 0; + } + + if (this._gdmClient) { + this._gdmClient = null; + delete this._gdmClient; + } + } + + _updateUserSwitchVisibility() { + this._otherUserButton.visible = this._userManager.can_switch() && + this._screenSaverSettings.get_boolean('user-switch-enabled') && + !this._lockdownSettings.get_boolean('disable-user-switching'); + } + + cancel() { + if (this._authPrompt) + this._authPrompt.cancel(); + } + + finish(onComplete) { + if (!this._authPrompt) { + onComplete(); + return; + } + + this._authPrompt.finish(onComplete); + } + + open(timestamp) { + this.show(); + + if (this._isModal) + return true; + + let modalParams = { + timestamp, + actionMode: Shell.ActionMode.UNLOCK_SCREEN, + }; + let grab = Main.pushModal(Main.uiGroup, modalParams); + if (grab.get_seat_state() !== Clutter.GrabState.ALL) { + Main.popModal(grab); + return false; + } + + this._grab = grab; + this._isModal = true; + + return true; + } + + activate() { + this._showPrompt(); + } + + popModal(timestamp) { + if (this._isModal) { + Main.popModal(this._grab, timestamp); + this._grab = null; + this._isModal = false; + } + } +}); |