autorun: Use a dialog, not a notification.

- Improve the Dialog list widgets to allow selection, proper
  pseudo-classes for highlighting.
- Use existing login manager for lock/unlock listeners (and make
  our screensaver set the locked hint finally).

Author: mtwebster

data/theme/cinnamon-sass/widgets/_dialogs.scss

@@ -43,6 +43,12 @@
 
     .dialog-list-item {
       spacing: 1em;
+      border-radius: $base_border_radius;
+      padding: $base_padding $base_padding * 2;
+      transition-duration: 100ms;
+
+      &:hover { background-color: $light_bg_color; }
+      &:selected { background-color: $accent_bg_color; }
 
       .dialog-list-item-title { font-weight: bold; }
       .dialog-list-item-description {

js/misc/loginManager.js

@@ -38,6 +38,9 @@ const SystemdLoginSessionIface = `
     <signal name="Lock"/>
     <signal name="Unlock"/>
     <property name="Active" type="b" access="read"/>
+    <method name="SetLockedHint">
+      <arg type="b" direction="in"/>
+    </method>
   </interface>
 </node>`;
 
@@ -75,6 +78,8 @@ var LoginManagerSystemd = class {
     constructor() {
         this._managerProxy = null;
         this._sessionProxy = null;
+        this.sessionIsActive = true;
+        this.isLocked = false;
 
         this._initSession();
     }
@@ -146,25 +151,26 @@ var LoginManagerSystemd = class {
 
             this._sessionProxy.connectSignal('Lock', () => {
                 _log('LoginManager: Received Lock signal from logind, emitting lock');
+                this.isLocked = true;
                 this.emit('lock');
             });
 
             this._sessionProxy.connectSignal('Unlock', () => {
                 _log('LoginManager: Received Unlock signal from logind, emitting unlock');
+                this.isLocked = false;
                 this.emit('unlock');
             });
 
             this._sessionProxy.connect('g-properties-changed', (proxy, changed, invalidated) => {
                 if ('Active' in changed.deep_unpack()) {
                     let active = this._sessionProxy.Active;
+                    this.sessionIsActive = active;
                     _log(`LoginManager: Session Active property changed: ${active}`);
-                    if (active) {
-                        _log('LoginManager: Session became active, emitting active');
-                        this.emit('active');
-                    }
+                    this.emit('active-changed', active);
                 }
             });
 
+            this.sessionIsActive = this._sessionProxy.Active;
             this.emit('session-ready');
         } catch (e) {
             global.logError('LoginManager: Failed to connect to logind session: ' + e.message);
@@ -208,13 +214,25 @@ var LoginManagerSystemd = class {
                 }
             });
     }
+
+    setLockedHint(locked) {
+        if (!this._sessionProxy)
+            return;
+
+        this._sessionProxy.SetLockedHintRemote(locked, (result, error) => {
+            if (error)
+                global.logError('LoginManager: SetLockedHint failed: ' + error);
+        });
+    }
 };
 Signals.addSignalMethods(LoginManagerSystemd.prototype);
 
 var LoginManagerConsoleKit = class {
     constructor() {
         this._managerProxy = null;
         this._sessionProxy = null;
+        this.sessionIsActive = true;
+        this.isLocked = false;
 
         this._initSession();
     }
@@ -259,20 +277,20 @@ var LoginManagerConsoleKit = class {
 
             this._sessionProxy.connectSignal('Lock', () => {
                 _log('LoginManager: Received Lock signal from ConsoleKit, emitting lock');
+                this.isLocked = true;
                 this.emit('lock');
             });
 
             this._sessionProxy.connectSignal('Unlock', () => {
                 _log('LoginManager: Received Unlock signal from ConsoleKit, emitting unlock');
+                this.isLocked = false;
                 this.emit('unlock');
             });
 
             this._sessionProxy.connectSignal('ActiveChanged', (proxy, sender, [active]) => {
+                this.sessionIsActive = active;
                 _log(`LoginManager: ConsoleKit ActiveChanged: ${active}`);
-                if (active) {
-                    _log('LoginManager: Session became active, emitting active');
-                    this.emit('active');
-                }
+                this.emit('active-changed', active);
             });
 
             this.emit('session-ready');
@@ -291,6 +309,10 @@ var LoginManagerConsoleKit = class {
         // ConsoleKit doesn't have inhibitors
         callback(null);
     }
+
+    setLockedHint(_locked) {
+        // ConsoleKit doesn't have SetLockedHint
+    }
 };
 Signals.addSignalMethods(LoginManagerConsoleKit.prototype);
 

js/ui/automountManager.js

@@ -4,12 +4,10 @@
 const { Gio, GLib } = imports.gi;
 const Params = imports.misc.params;
 
-const GnomeSession = imports.misc.gnomeSession;
+const LoginManager = imports.misc.loginManager;
 const Main = imports.ui.main;
 const CinnamonMountOperation = imports.ui.cinnamonMountOperation;
 
-var GNOME_SESSION_AUTOMOUNT_INHIBIT = 16;
-
 // GSettings keys
 const SETTINGS_SCHEMA = 'org.cinnamon.desktop.media-handling';
 const SETTING_ENABLE_AUTOMOUNT = 'automount';
@@ -20,28 +18,16 @@ var AutomountManager = class {
     constructor() {
         this._settings = new Gio.Settings({ schema_id: SETTINGS_SCHEMA });
         this._activeOperations = new Map();
-        
-        GnomeSession.SessionManager((proxy, error) => {
-            if (error)
-                return;
-
-            this._session = proxy;
-            this.actor.show();
-            this.updateStatus();
-
-            this._session.connectSignal(
-                "InhibitorAdded",
-                this._InhibitorsChanged.bind(this)
-            );
-
-            this._session.connectSignal(
-                "InhibitorRemoved",
-                this._InhibitorsChanged.bind(this)
-            );
+        this._volumeQueue = [];
+
+        this._loginManager = LoginManager.getLoginManager();
+        this._loginManager.connect('lock', () => this._onScreenLocked());
+        this._loginManager.connect('unlock', () => this._onScreenUnlocked());
+        this._loginManager.connect('active-changed', (lm, active) => {
+            if (active)
+                this._drainVolumeQueue();
         });
 
-        this._inhibited = false;
-
         this._volumeMonitor = Gio.VolumeMonitor.get();
         this.enable();
     }
@@ -67,12 +53,21 @@ var AutomountManager = class {
         }
     }
 
-    async _InhibitorsChanged(_object, _senderName, [_inhibitor]) {
-        try {
-            const [inhibited] =
-                await this._session.IsInhibitedAsync(GNOME_SESSION_AUTOMOUNT_INHIBIT);
-            this._inhibited = inhibited;
-        } catch (e) {}
+    _onScreenLocked() {
+        // Volumes inserted while locked will be queued
+    }
+
+    _onScreenUnlocked() {
+        this._drainVolumeQueue();
+    }
+
+    _drainVolumeQueue() {
+        while (this._volumeQueue.length > 0) {
+            let volume = this._volumeQueue.shift();
+            this._checkAndMountVolume(volume, {
+                checkSession: false,
+            });
+        }
     }
 
     _startupMountAll() {
@@ -90,10 +85,8 @@ var AutomountManager = class {
     }
 
     _onDriveConnected() {
-        // if we're not in the current ConsoleKit session,
-        // or screensaver is active, don't play sounds
-        // if (!this._session.SessionIsActive)
-        //     return;
+        if (!this._loginManager.sessionIsActive)
+            return;
 
         let player = global.display.get_sound_player();
         player.play_from_theme('device-added-media',
@@ -102,10 +95,8 @@ var AutomountManager = class {
     }
 
     _onDriveDisconnected() {
-        // if we're not in the current ConsoleKit session,
-        // or screensaver is active, don't play sounds
-        // if (!this._session.SessionIsActive)
-        //     return;
+        if (!this._loginManager.sessionIsActive)
+            return;
 
         let player = global.display.get_sound_player();
         player.play_from_theme('device-removed-media',
@@ -114,13 +105,9 @@ var AutomountManager = class {
     }
 
     _onDriveEjectButton(monitor, drive) {
-        // TODO: this code path is not tested, as the GVfs volume monitor
-        // doesn't emit this signal just yet.
-        // if (!this._session.SessionIsActive)
-        //     return;
+        if (!this._loginManager.sessionIsActive)
+            return;
 
-        // we force stop/eject in this case, so we don't have to pass a
-        // mount operation object
         if (drive.can_stop()) {
             drive.stop(Gio.MountUnmountFlags.FORCE, null, null,
                 (o, res) => {
@@ -147,34 +134,28 @@ var AutomountManager = class {
     }
 
     _checkAndMountVolume(volume, params) {
-        global.log("check and mount");
         params = Params.parse(params, {
             checkSession: true,
             useMountOp: true,
             allowAutorun: true,
         });
 
         if (params.checkSession) {
-            // if we're not in the current ConsoleKit session,
-            // don't attempt automount
-            // if (!this._session.SessionIsActive)
-            //     return;
-        }
+            if (!this._loginManager.sessionIsActive)
+                return;
 
-        if (this._inhibited)
-            return;
+            if (this._loginManager.isLocked) {
+                this._volumeQueue.push(volume);
+                return;
+            }
+        }
 
-        // Volume is already mounted, don't bother.
         if (volume.get_mount())
             return;
 
         if (!this._settings.get_boolean(SETTING_ENABLE_AUTOMOUNT) ||
             !volume.should_automount() ||
             !volume.can_mount()) {
-            // allow the autorun to run anyway; this can happen if the
-            // mount gets added programmatically later, even if
-            // should_automount() or can_mount() are false, like for
-            // blank optical media.
             this._allowAutorun(volume);
             this._allowAutorunExpire(volume);
 
@@ -201,23 +182,15 @@ var AutomountManager = class {
     }
 
     _onVolumeMounted(volume, res) {
-        global.log("on volume mounted");
         this._allowAutorunExpire(volume);
 
         try {
             volume.mount_finish(res);
             this._closeOperation(volume);
         } catch (e) {
-            // FIXME: we will always get G_IO_ERROR_FAILED from the gvfs udisks
-            // backend, see https://bugs.freedesktop.org/show_bug.cgi?id=51271
-            // To reask the password if the user input was empty or wrong, we
-            // will check for corresponding error messages. However, these
-            // error strings are not unique for the cases in the comments below.
-            if (e.message.includes('No key available with this passphrase') || // cryptsetup
-                e.message.includes('No key available to unlock device') ||     // udisks (no password)
-                // libblockdev wrong password opening LUKS device
+            if (e.message.includes('No key available with this passphrase') ||
+                e.message.includes('No key available to unlock device') ||
                 e.message.includes('Failed to activate device: Incorrect passphrase') ||
-                // cryptsetup returns EINVAL in many cases, including wrong TCRYPT password/parameters
                 e.message.includes('Failed to load device\'s parameters: Invalid argument')) {
                 this._reaskPassword(volume);
             } else {
@@ -238,6 +211,8 @@ var AutomountManager = class {
             GLib.source_remove(volume._allowAutorunExpireId);
             delete volume._allowAutorunExpireId;
         }
+
+        this._volumeQueue = this._volumeQueue.filter(v => v !== volume);
     }
 
     _reaskPassword(volume) {