ExtensionsPref: always convert the extension version to a string

This fixes: Wrong type number; string expected
MR: https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1060

js/extensionPrefs/css/application.css

@@ -0,0 +1,11 @@
+.details-button image {
+  transition: 250ms;
+}
+.details-button.expanded:dir(ltr) image {
+  -gtk-icon-transform: rotate(0.25turn);
+}
+.details-button.expanded:dir(rtl) image {
+  -gtk-icon-transform: rotate(-0.25turn);
+}
+
+image.warning { color: @warning_color; }

js/extensionPrefs/main.js

@@ -0,0 +1,763 @@
+/* exported main */
+imports.gi.versions.Gdk = '3.0';
+imports.gi.versions.Gtk = '3.0';
+
+const Gettext = imports.gettext;
+const { Gdk, GLib, Gio, GObject, Gtk } = imports.gi;
+const Format = imports.format;
+
+const _ = Gettext.gettext;
+
+const Config = imports.misc.config;
+const ExtensionUtils = imports.misc.extensionUtils;
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const { ExtensionState, ExtensionType } = ExtensionUtils;
+
+const GnomeShellIface = loadInterfaceXML('org.gnome.Shell.Extensions');
+const GnomeShellProxy = Gio.DBusProxy.makeProxyWrapper(GnomeShellIface);
+
+function stripPrefix(string, prefix) {
+    if (string.slice(0, prefix.length) == prefix)
+        return string.slice(prefix.length);
+    return string;
+}
+
+var Application = GObject.registerClass(
+class Application extends Gtk.Application {
+    _init() {
+        GLib.set_prgname('gnome-shell-extension-prefs');
+        super._init({
+            application_id: 'org.gnome.Extensions',
+            flags: Gio.ApplicationFlags.HANDLES_COMMAND_LINE,
+        });
+    }
+
+    get shellProxy() {
+        return this._shellProxy;
+    }
+
+    vfunc_activate() {
+        this._shellProxy.CheckForUpdatesRemote();
+        this._window.present();
+    }
+
+    vfunc_startup() {
+        super.vfunc_startup();
+
+        let provider = new Gtk.CssProvider();
+        let uri = 'resource:///org/gnome/shell/css/application.css';
+        try {
+            provider.load_from_file(Gio.File.new_for_uri(uri));
+        } catch (e) {
+            logError(e, 'Failed to add application style');
+        }
+        Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),
+            provider,
+            Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+        this._shellProxy = new GnomeShellProxy(Gio.DBus.session, 'org.gnome.Shell', '/org/gnome/Shell');
+        this._window = new ExtensionsWindow({ application: this });
+    }
+
+    vfunc_command_line(commandLine) {
+        let args = commandLine.get_arguments();
+
+        if (args.length) {
+            let uuid = args[0];
+
+            // Strip off "extension:///" prefix which fakes a URI, if it exists
+            uuid = stripPrefix(uuid, 'extension:///');
+
+            this._window.openPrefs(uuid);
+        } else {
+            this.activate();
+        }
+        return 0;
+    }
+});
+
+var ExtensionsWindow = GObject.registerClass({
+    GTypeName: 'ExtensionsWindow',
+    Template: 'resource:///org/gnome/shell/ui/extensions-window.ui',
+    InternalChildren: [
+        'userList',
+        'systemList',
+        'killSwitch',
+        'mainBox',
+        'mainStack',
+        'scrolledWindow',
+        'updatesBar',
+        'updatesLabel',
+    ],
+}, class ExtensionsWindow extends Gtk.ApplicationWindow {
+    _init(params) {
+        super._init(params);
+
+        this._startupUuid = null;
+        this._loaded = false;
+        this._prefsDialog = null;
+        this._updatesCheckId = 0;
+
+        this._mainBox.set_focus_vadjustment(this._scrolledWindow.vadjustment);
+
+        let action;
+        action = new Gio.SimpleAction({ name: 'show-about' });
+        action.connect('activate', this._showAbout.bind(this));
+        this.add_action(action);
+
+        action = new Gio.SimpleAction({ name: 'logout' });
+        action.connect('activate', this._logout.bind(this));
+        this.add_action(action);
+
+        this._settings = new Gio.Settings({ schema_id: 'org.gnome.shell' });
+        this._settings.bind('disable-user-extensions',
+            this._killSwitch, 'active',
+            Gio.SettingsBindFlags.DEFAULT | Gio.SettingsBindFlags.INVERT_BOOLEAN);
+
+        this._userList.set_sort_func(this._sortList.bind(this));
+        this._userList.set_header_func(this._updateHeader.bind(this));
+
+        this._systemList.set_sort_func(this._sortList.bind(this));
+        this._systemList.set_header_func(this._updateHeader.bind(this));
+
+        this._shellProxy.connectSignal('ExtensionStateChanged',
+            this._onExtensionStateChanged.bind(this));
+
+        this._scanExtensions();
+    }
+
+    get _shellProxy() {
+        return this.application.shellProxy;
+    }
+
+    uninstall(uuid) {
+        let row = this._findExtensionRow(uuid);
+
+        let dialog = new Gtk.MessageDialog({
+            transient_for: this,
+            modal: true,
+            text: _('Remove “%s”?').format(row.name),
+            secondary_text: _('If you remove the extension, you need to return to download it if you want to enable it again'),
+        });
+
+        dialog.add_button(_('Cancel'), Gtk.ResponseType.CANCEL);
+        dialog.add_button(_('Remove'), Gtk.ResponseType.ACCEPT)
+            .get_style_context().add_class('destructive-action');
+
+        dialog.connect('response', (dlg, response) => {
+            if (response === Gtk.ResponseType.ACCEPT)
+                this._shellProxy.UninstallExtensionRemote(uuid);
+            dialog.destroy();
+        });
+        dialog.present();
+    }
+
+    openPrefs(uuid) {
+        if (!this._loaded)
+            this._startupUuid = uuid;
+        else if (!this._showPrefs(uuid))
+            this.present();
+    }
+
+    _showPrefs(uuid) {
+        if (this._prefsDialog)
+            return false;
+
+        let row = this._findExtensionRow(uuid);
+        if (!row || !row.hasPrefs)
+            return false;
+
+        let widget;
+
+        try {
+            widget = row.prefsModule.buildPrefsWidget();
+        } catch (e) {
+            widget = this._buildErrorUI(row, e);
+        }
+
+        this._prefsDialog = new Gtk.Window({
+            application: this.application,
+            default_width: 600,
+            default_height: 400,
+            modal: this.visible,
+            type_hint: Gdk.WindowTypeHint.DIALOG,
+            window_position: Gtk.WindowPosition.CENTER,
+        });
+
+        this._prefsDialog.set_titlebar(new Gtk.HeaderBar({
+            show_close_button: true,
+            title: row.name,
+            visible: true,
+        }));
+
+        if (this.visible)
+            this._prefsDialog.transient_for = this;
+
+        this._prefsDialog.connect('destroy', () => {
+            this._prefsDialog = null;
+
+            if (!this.visible)
+                this.destroy();
+        });
+
+        this._prefsDialog.add(widget);
+        this._prefsDialog.show();
+
+        return true;
+    }
+
+    _showAbout() {
+        let aboutDialog = new Gtk.AboutDialog({
+            authors: [
+                'Florian Müllner <fmuellner@gnome.org>',
+                'Jasper St. Pierre <jstpierre@mecheye.net>',
+                'Didier Roche <didrocks@ubuntu.com>',
+            ],
+            translator_credits: _('translator-credits'),
+            program_name: _('Extensions'),
+            comments: _('Manage your GNOME Extensions'),
+            license_type: Gtk.License.GPL_2_0,
+            logo_icon_name: 'org.gnome.Extensions',
+            version: Config.PACKAGE_VERSION,
+
+            transient_for: this,
+            modal: true,
+        });
+        aboutDialog.present();
+    }
+
+    _logout() {
+        this.application.get_dbus_connection().call(
+            'org.gnome.SessionManager',
+            '/org/gnome/SessionManager',
+            'org.gnome.SessionManager',
+            'Logout',
+            new GLib.Variant('(u)', [0]),
+            null,
+            Gio.DBusCallFlags.NONE,
+            -1,
+            null,
+            (o, res) => {
+                o.call_finish(res);
+            });
+    }
+
+    _buildErrorUI(row, exc) {
+        let scroll = new Gtk.ScrolledWindow({
+            hscrollbar_policy: Gtk.PolicyType.NEVER,
+            propagate_natural_height: true,
+        });
+
+        let box = new Gtk.Box({
+            orientation: Gtk.Orientation.VERTICAL,
+            spacing: 12,
+            margin: 100,
+            margin_bottom: 60,
+        });
+        scroll.add(box);
+
+        let label = new Gtk.Label({
+            label: '<span size="x-large">%s</span>'.format(_("Something’s gone wrong")),
+            use_markup: true,
+        });
+        label.get_style_context().add_class(Gtk.STYLE_CLASS_DIM_LABEL);
+        box.add(label);
+
+        label = new Gtk.Label({
+            label: _("We’re very sorry, but there’s been a problem: the settings for this extension can’t be displayed. We recommend that you report the issue to the extension authors."),
+            justify: Gtk.Justification.CENTER,
+            wrap: true,
+        });
+        box.add(label);
+
+        let expander = new Expander({
+            label: _("Technical Details"),
+            margin_top: 12,
+        });
+        box.add(expander);
+
+        let errortext = '%s\n\nStack trace:\n'.format(exc);
+        // Indent stack trace.
+        errortext +=
+            exc.stack.split('\n').map(line => '  %s'.format(line)).join('\n');
+
+        let buffer = new Gtk.TextBuffer({ text: errortext });
+        let textview = new Gtk.TextView({
+            buffer,
+            wrap_mode: Gtk.WrapMode.WORD,
+            monospace: true,
+            editable: false,
+            top_margin: 12,
+            bottom_margin: 12,
+            left_margin: 12,
+            right_margin: 12,
+        });
+
+        let toolbar = new Gtk.Toolbar();
+        let provider = new Gtk.CssProvider();
+        provider.load_from_data(`* {
+            border: 0 solid @borders;
+            border-top-width: 1px;
+        }`);
+        toolbar.get_style_context().add_provider(
+            provider,
+            Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
+        );
+
+        let copyButton = new Gtk.ToolButton({
+            icon_name: 'edit-copy-symbolic',
+            tooltip_text: _("Copy Error"),
+        });
+        toolbar.add(copyButton);
+
+        copyButton.connect('clicked', w => {
+            let clipboard = Gtk.Clipboard.get_default(w.get_display());
+            // markdown for pasting in gitlab issues
+            let lines = [
+                'The settings of extension %s had an error:'.format(row.uuid),
+                '```', // '`' (xgettext throws up on odd number of backticks)
+                exc.toString(),
+                '```', // '`'
+                '',
+                'Stack trace:',
+                '```', // '`'
+                exc.stack.replace(/\n$/, ''), // stack without trailing newline
+                '```', // '`'
+                '',
+            ];
+            clipboard.set_text(lines.join('\n'), -1);
+        });
+
+        let spacing = new Gtk.SeparatorToolItem({ draw: false });
+        toolbar.add(spacing);
+        toolbar.child_set_property(spacing, "expand", true);
+
+        let urlButton = new Gtk.ToolButton({
+            label: _("Homepage"),
+            tooltip_text: _("Visit extension homepage"),
+            no_show_all: true,
+            visible: row.url !== '',
+        });
+        toolbar.add(urlButton);
+
+        urlButton.connect('clicked', w => {
+            let context = w.get_display().get_app_launch_context();
+            Gio.AppInfo.launch_default_for_uri(row.url, context);
+        });
+
+        let expandedBox = new Gtk.Box({
+            orientation: Gtk.Orientation.VERTICAL,
+        });
+        expandedBox.add(textview);
+        expandedBox.add(toolbar);
+
+        expander.add(expandedBox);
+
+        scroll.show_all();
+        return scroll;
+    }
+
+    _sortList(row1, row2) {
+        return row1.name.localeCompare(row2.name);
+    }
+
+    _updateHeader(row, before) {
+        if (!before || row.get_header())
+            return;
+
+        let sep = new Gtk.Separator({ orientation: Gtk.Orientation.HORIZONTAL });
+        row.set_header(sep);
+    }
+
+    _findExtensionRow(uuid) {
+        return [
+            ...this._userList.get_children(),
+            ...this._systemList.get_children(),
+        ].find(c => c.uuid === uuid);
+    }
+
+    _onExtensionStateChanged(proxy, senderName, [uuid, newState]) {
+        let extension = ExtensionUtils.deserializeExtension(newState);
+        let row = this._findExtensionRow(uuid);
+
+        this._queueUpdatesCheck();
+
+        // the extension's type changed; remove the corresponding row
+        // and reset the variable to null so that we create a new row
+        // below and add it to the appropriate list
+        if (row && row.type !== extension.type) {
+            row.destroy();
+            row = null;
+        }
+
+        if (row) {
+            if (extension.state === ExtensionState.UNINSTALLED)
+                row.destroy();
+            return; // we only deal with new and deleted extensions here
+        }
+        this._addExtensionRow(extension);
+    }
+
+    _scanExtensions() {
+        this._shellProxy.ListExtensionsRemote(([extensionsMap], e) => {
+            if (e) {
+                if (e instanceof Gio.DBusError) {
+                    log('Failed to connect to shell proxy: %s'.format(e.toString()));
+                    this._mainStack.visible_child_name = 'noshell';
+                } else {
+                    throw e;
+                }
+                return;
+            }
+
+            for (let uuid in extensionsMap) {
+                let extension = ExtensionUtils.deserializeExtension(extensionsMap[uuid]);
+                this._addExtensionRow(extension);
+            }
+            this._extensionsLoaded();
+        });
+    }
+
+    _addExtensionRow(extension) {
+        let row = new ExtensionRow(extension);
+        row.show_all();
+
+        if (row.type === ExtensionType.PER_USER)
+            this._userList.add(row);
+        else
+            this._systemList.add(row);
+    }
+
+    _queueUpdatesCheck() {
+        if (this._updatesCheckId)
+            return;
+
+        this._updatesCheckId = GLib.timeout_add_seconds(
+            GLib.PRIORITY_DEFAULT, 1, () => {
+                this._checkUpdates();
+
+                this._updatesCheckId = 0;
+                return GLib.SOURCE_REMOVE;
+            });
+    }
+
+    _checkUpdates() {
+        let nUpdates = this._userList.get_children().filter(c => c.hasUpdate).length;
+
+        this._updatesLabel.label = Gettext.ngettext(
+            '%d extension will be updated on next login.',
+            '%d extensions will be updated on next login.',
+            nUpdates).format(nUpdates);
+        this._updatesBar.visible = nUpdates > 0;
+    }
+
+    _extensionsLoaded() {
+        this._userList.visible = this._userList.get_children().length > 0;
+        this._systemList.visible = this._systemList.get_children().length > 0;
+
+        if (this._userList.visible || this._systemList.visible)
+            this._mainStack.visible_child_name = 'main';
+        else
+            this._mainStack.visible_child_name = 'placeholder';
+
+        this._checkUpdates();
+
+        if (this._startupUuid)
+            this._showPrefs(this._startupUuid);
+        this._startupUuid = null;
+        this._loaded = true;
+    }
+});
+
+var Expander = GObject.registerClass({
+    Properties: {
+        'label': GObject.ParamSpec.string(
+            'label', 'label', 'label',
+            GObject.ParamFlags.READWRITE,
+            null
+        ),
+    },
+}, class Expander extends Gtk.Box {
+    _init(params = {}) {
+        this._labelText = null;
+
+        super._init(Object.assign(params, {
+            orientation: Gtk.Orientation.VERTICAL,
+            spacing: 0,
+        }));
+
+        this._frame = new Gtk.Frame({
+            shadow_type: Gtk.ShadowType.IN,
+            hexpand: true,
+        });
+
+        let eventBox = new Gtk.EventBox();
+        this._frame.add(eventBox);
+
+        let hbox = new Gtk.Box({
+            spacing: 6,
+            margin: 12,
+        });
+        eventBox.add(hbox);
+
+        this._arrow = new Gtk.Image({
+            icon_name: 'pan-end-symbolic',
+        });
+        hbox.add(this._arrow);
+
+        this._label = new Gtk.Label({ label: this._labelText });
+        hbox.add(this._label);
+
+        this._revealer = new Gtk.Revealer();
+
+        this._childBin = new Gtk.Frame({
+            shadow_type: Gtk.ShadowType.IN,
+        });
+        this._revealer.add(this._childBin);
+
+        // Directly chain up to parent for internal children
+        super.add(this._frame);
+        super.add(this._revealer);
+
+        let provider = new Gtk.CssProvider();
+        provider.load_from_data('* { border-top-width: 0; }');
+        this._childBin.get_style_context().add_provider(
+            provider,
+            Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
+        );
+
+        this._gesture = new Gtk.GestureMultiPress({
+            widget: this._frame,
+            button: 0,
+            exclusive: true,
+        });
+        this._gesture.connect('released', (gesture, nPress) => {
+            if (nPress == 1)
+                this._revealer.reveal_child = !this._revealer.reveal_child;
+        });
+        this._revealer.connect('notify::reveal-child', () => {
+            if (this._revealer.reveal_child)
+                this._arrow.icon_name = 'pan-down-symbolic';
+            else
+                this._arrow.icon_name = 'pan-end-symbolic';
+        });
+    }
+
+    get label() {
+        return this._labelText;
+    }
+
+    set label(text) {
+        if (this._labelText == text)
+            return;
+
+        if (this._label)
+            this._label.label = text;
+        this._labelText = text;
+        this.notify('label');
+    }
+
+    add(child) {
+        // set expanded child
+        this._childBin.get_children().forEach(c => {
+            this._childBin.remove(c);
+        });
+
+        if (child)
+            this._childBin.add(child);
+    }
+});
+
+var ExtensionRow = GObject.registerClass({
+    GTypeName: 'ExtensionRow',
+    Template: 'resource:///org/gnome/shell/ui/extension-row.ui',
+    InternalChildren: [
+        'nameLabel',
+        'descriptionLabel',
+        'versionLabel',
+        'authorLabel',
+        'updatesIcon',
+        'revealButton',
+        'revealer',
+    ],
+}, class ExtensionRow extends Gtk.ListBoxRow {
+    _init(extension) {
+        super._init();
+
+        this._app = Gio.Application.get_default();
+        this._extension = extension;
+        this._prefsModule = null;
+
+        this._actionGroup = new Gio.SimpleActionGroup();
+        this.insert_action_group('row', this._actionGroup);
+
+        let action;
+        action = new Gio.SimpleAction({
+            name: 'show-prefs',
+            enabled: this.hasPrefs,
+        });
+        action.connect('activate', () => this.get_toplevel().openPrefs(this.uuid));
+        this._actionGroup.add_action(action);
+
+        action = new Gio.SimpleAction({
+            name: 'show-url',
+            enabled: this.url !== '',
+        });
+        action.connect('activate', () => {
+            Gio.AppInfo.launch_default_for_uri(
+                this.url, this.get_display().get_app_launch_context());
+        });
+        this._actionGroup.add_action(action);
+
+        action = new Gio.SimpleAction({
+            name: 'uninstall',
+            enabled: this.type === ExtensionType.PER_USER,
+        });
+        action.connect('activate', () => this.get_toplevel().uninstall(this.uuid));
+        this._actionGroup.add_action(action);
+
+        action = new Gio.SimpleAction({
+            name: 'enabled',
+            state: new GLib.Variant('b', false),
+        });
+        action.connect('activate', () => {
+            let state = action.get_state();
+            action.change_state(new GLib.Variant('b', !state.get_boolean()));
+        });
+        action.connect('change-state', (a, state) => {
+            if (state.get_boolean())
+                this._app.shellProxy.EnableExtensionRemote(this.uuid);
+            else
+                this._app.shellProxy.DisableExtensionRemote(this.uuid);
+        });
+        this._actionGroup.add_action(action);
+
+        let name = GLib.markup_escape_text(this.name, -1);
+        this._nameLabel.label = name;
+
+        let desc = this._extension.metadata.description.split('\n')[0];
+        this._descriptionLabel.label = desc;
+
+        this._revealButton.connect('clicked', () => {
+            this._revealer.reveal_child = !this._revealer.reveal_child;
+        });
+        this._revealer.connect('notify::reveal-child', () => {
+            if (this._revealer.reveal_child)
+                this._revealButton.get_style_context().add_class('expanded');
+            else
+                this._revealButton.get_style_context().remove_class('expanded');
+        });
+
+        this.connect('destroy', this._onDestroy.bind(this));
+
+        this._extensionStateChangedId = this._app.shellProxy.connectSignal(
+            'ExtensionStateChanged', (p, sender, [uuid, newState]) => {
+                if (this.uuid !== uuid)
+                    return;
+
+                this._extension = ExtensionUtils.deserializeExtension(newState);
+                this._updateState();
+            });
+        this._updateState();
+    }
+
+    get uuid() {
+        return this._extension.uuid;
+    }
+
+    get name() {
+        return this._extension.metadata.name;
+    }
+
+    get hasPrefs() {
+        return this._extension.hasPrefs;
+    }
+
+    get hasUpdate() {
+        return this._extension.hasUpdate || false;
+    }
+
+    get type() {
+        return this._extension.type;
+    }
+
+    get creator() {
+        return this._extension.metadata.creator || '';
+    }
+
+    get url() {
+        return this._extension.metadata.url || '';
+    }
+
+    get version() {
+        return this._extension.metadata.version.toString() || '';
+    }
+
+    _updateState() {
+        let state = this._extension.state === ExtensionState.ENABLED;
+
+        let action = this._actionGroup.lookup('enabled');
+        action.set_state(new GLib.Variant('b', state));
+        action.enabled = this._canToggle();
+
+        this._updatesIcon.visible = this.hasUpdate;
+
+        this._versionLabel.label = this.version;
+        this._versionLabel.visible = this.version !== '';
+
+        this._authorLabel.label = this.creator.toString();
+        this._authorLabel.visible = this.creator !== '';
+    }
+
+    _onDestroy() {
+        if (!this._app.shellProxy)
+            return;
+
+        if (this._extensionStateChangedId)
+            this._app.shellProxy.disconnectSignal(this._extensionStateChangedId);
+        this._extensionStateChangedId = 0;
+    }
+
+    _canToggle() {
+        return this._extension.canChange;
+    }
+
+    get prefsModule() {
+        // give extension prefs access to their own extension object
+        ExtensionUtils.getCurrentExtension = () => this._extension;
+
+        if (!this._prefsModule) {
+            ExtensionUtils.installImporter(this._extension);
+
+            this._prefsModule = this._extension.imports.prefs;
+            this._prefsModule.init(this._extension.metadata);
+        }
+
+        return this._prefsModule;
+    }
+});
+
+function initEnvironment() {
+    // Monkey-patch in a "global" object that fakes some Shell utilities
+    // that ExtensionUtils depends on.
+    window.global = {
+        log(...args) {
+            print(args.join(', '));
+        },
+
+        logError(s) {
+            log('ERROR: %s'.format(s));
+        },
+
+        userdatadir: GLib.build_filenamev([GLib.get_user_data_dir(), 'gnome-shell']),
+    };
+
+    String.prototype.format = Format.format;
+}
+
+function main(argv) {
+    initEnvironment();
+
+    new Application().run(argv);
+}

js/extensionPrefs/ui/extension-row.ui

@@ -0,0 +1,218 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.22.0 -->
+<interface>
+  <requires lib="gtk+" version="3.20"/>
+  <template class="ExtensionRow" parent="GtkListBoxRow">
+    <property name="visible">True</property>
+    <property name="activatable">False</property>
+    <child>
+      <object class="GtkGrid">
+        <property name="visible">True</property>
+        <property name="margin">12</property>
+        <property name="column_spacing">12</property>
+        <child>
+          <object class="GtkLabel" id="nameLabel">
+            <property name="visible">True</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkImage" id="updatesIcon">
+            <property name="no_show_all">True</property>
+            <property name="icon_name">software-update-available-symbolic</property>
+            <style>
+              <class name="warning"/>>
+            </style>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="visible">True</property>
+            <property name="hexpand">True</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="prefsButton">
+            <property name="no_show_all">True</property>
+            <property name="visible"
+                      bind-source="prefsButton"
+                      bind-property="sensitive"
+                      bind-flags="sync-create"/>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="valign">center</property>
+            <property name="action-name">row.show-prefs</property>
+            <style>
+              <class name="circular"/>>
+              <class name="image-button"/>>
+            </style>
+            <child>
+              <object class="GtkImage">
+                <property name="visible">True</property>
+                <property name="icon_name">emblem-system-symbolic</property>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSwitch">
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="valign">center</property>
+            <property name="action-name">row.enabled</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSeparator">
+            <property name="visible">True</property>
+          </object>
+        </child>
+         <child>
+          <object class="GtkButton" id="revealButton">
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="valign">center</property>
+            <style>
+              <class name="details-button"/>
+              <class name="image-button"/>
+              <class name="flat"/>
+            </style>
+            <child>
+              <object class="GtkImage">
+                <property name="visible">True</property>
+                <property name="icon_name">pan-end-symbolic</property>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkRevealer" id="revealer">
+            <property name="visible">True</property>
+            <child>
+              <object class="GtkGrid">
+                <property name="visible">True</property>
+                <property name="margin_top">12</property>
+                <property name="row_spacing">6</property>
+                <property name="column_spacing">12</property>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="label" translatable="yes">Description</property>
+                    <property name="xalign">0</property>
+                    <style>
+                      <class name="dim-label"/>
+                    </style>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkLabel" id="descriptionLabel">
+                    <property name="visible">True</property>
+                    <property name="ellipsize">end</property>
+                    <property name="max_width_chars">60</property>
+                    <property name="xalign">0</property>
+                    <property name="yalign">0</property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible"
+                              bind-source="versionLabel"
+                              bind-property="visible"
+                              bind-flags="sync-create"/>
+                    <property name="no_show_all">True</property>
+                    <property name="label" translatable="yes">Version</property>
+                    <property name="xalign">0</property>
+                    <style>
+                      <class name="dim-label"/>
+                    </style>
+                  </object>
+                  <packing>
+                    <property name="left_attach">0</property>
+                    <property name="top_attach">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkLabel" id="versionLabel">
+                    <property name="no_show_all">True</property>
+                    <property name="xalign">0</property>
+                  </object>
+                  <packing>
+                    <property name="left_attach">1</property>
+                    <property name="top_attach">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible"
+                              bind-source="authorLabel"
+                              bind-property="visible"
+                              bind-flags="sync-create"/>
+                    <property name="no_show_all">True</property>
+                    <property name="label" translatable="yes">Author</property>
+                    <property name="xalign">0</property>
+                    <style>
+                      <class name="dim-label"/>
+                    </style>
+                  </object>
+                  <packing>
+                    <property name="left_attach">0</property>
+                    <property name="top_attach">2</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkLabel" id="authorLabel">
+                    <property name="no_show_all">True</property>
+                    <property name="xalign">0</property>
+                  </object>
+                  <packing>
+                    <property name="left_attach">1</property>
+                    <property name="top_attach">2</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton">
+                    <property name="visible">True</property>
+                    <property name="label" translatable="yes">Website</property>
+                    <property name="action_name">row.show-url</property>
+                    <property name="valign">end</property>
+                    <property name="margin-top">12</property>
+                  </object>
+                  <packing>
+                    <property name="left_attach">0</property>
+                    <property name="top_attach">3</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="removeButton">
+                    <property name="visible"
+                              bind-source="removeButton"
+                              bind-property="sensitive"
+                              bind-flags="sync-create"/>
+                    <property name="no_show_all">True</property>
+                    <property name="label" translatable="yes">Remove…</property>
+                    <property name="action_name">row.uninstall</property>
+                    <property name="hexpand">True</property>
+                    <property name="halign">end</property>
+                    <property name="valign">end</property>
+                    <style>
+                      <class name="destructive-action"/>
+                    </style>
+                  </object>
+                  <packing>
+                    <property name="left_attach">1</property>
+                    <property name="top_attach">3</property>
+                  </packing>
+                </child>
+              </object>
+            </child>
+          </object>
+          <packing>
+            <property name="left_attach">0</property>
+            <property name="top_attach">1</property>
+            <property name="width">7</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>

js/extensionPrefs/ui/extensions-window.ui

@@ -0,0 +1,305 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.22.0 -->
+<interface>
+  <requires lib="gtk+" version="3.20"/>
+  <menu id="primary-menu">
+    <section>
+      <item>
+        <attribute name="label" translatable="yes">Help</attribute>
+        <attribute name="action">win.show-help</attribute>
+      </item>
+      <item>
+        <attribute name="label" translatable="yes">About Extensions</attribute>
+        <attribute name="action">win.show-about</attribute>
+      </item>
+    </section>
+  </menu>
+  <object class="GtkPopover" id="infoPopover">
+    <child>
+      <object class="GtkBox">
+        <property name="visible">True</property>
+        <property name="orientation">vertical</property>
+        <property name="margin">12</property>
+        <property name="spacing">6</property>
+        <child>
+          <object class="GtkLabel">
+            <property name="visible">True</property>
+            <property name="label" translatable="yes">To find and add extensions, visit &lt;a href="https://extensions.gnome.org"&gt;extensions.gnome.org&lt;/a&gt;.</property>
+            <property name="use_markup">True</property>
+            <property name="xalign">0</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="visible">True</property>
+            <property name="label" translatable="yes">Warning</property>
+            <property name="xalign">0</property>
+            <property name="margin_top">6</property>
+            <attributes>
+              <attribute name="weight" value="bold"/>
+            </attributes>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="visible">True</property>
+            <property name="label" translatable="yes">Extensions can cause system issues, including performance problems. If you encounter problems with your system, it is recommended to disable all extensions.</property>
+            <property name="wrap">True</property>
+            <property name="max_width_chars">40</property>
+            <property name="xalign">0</property>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+  <template class="ExtensionsWindow" parent="GtkApplicationWindow">
+    <property name="default_width">800</property>
+    <property name="default_height">500</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar">
+        <property name="visible">True</property>
+        <property name="title" translatable="yes">Extensions</property>
+        <property name="show_close_button">True</property>
+        <child>
+          <object class="GtkMenuButton">
+            <property name="visible">True</property>
+            <property name="popover">infoPopover</property>
+            <child>
+              <object class="GtkImage">
+                <property name="visible">True</property>
+                <property name="icon_name">dialog-information-symbolic</property>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkMenuButton" id="menuButton">
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="menu_model">primary-menu</property>
+            <child>
+              <object class="GtkImage">
+                <property name="visible">True</property>
+                <property name="icon_name">open-menu-symbolic</property>
+              </object>
+            </child>
+          </object>
+          <packing>
+            <property name="pack_type">end</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkSwitch" id="killSwitch">
+            <property name="visible">True</property>
+          </object>
+          <packing>
+            <property name="pack_type">end</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkBox">
+        <property name="visible">True</property>
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkStack" id="mainStack">
+            <property name="visible">True</property>
+            <property name="transition_type">crossfade</property>
+            <property name="vexpand">True</property>
+            <child>
+              <object class="GtkScrolledWindow" id="scrolledWindow">
+                <property name="visible">True</property>
+                <property name="hscrollbar_policy">never</property>
+                <child>
+                  <object class="GtkViewport">
+                    <property name="visible">True</property>
+                    <child>
+                      <object class="GtkBox" id="mainBox">
+                        <property name="visible">True</property>
+                        <property name="orientation">vertical</property>
+                        <property name="halign">center</property>
+                        <property name="margin">36</property>
+                        <property name="spacing">12</property>
+                        <child>
+                          <object class="GtkLabel">
+                            <property name="visible"
+                                      bind-source="userList"
+                                      bind-property="visible"
+                                      bind-flags="sync-create"/>
+                            <property name="halign">start</property>
+                            <property name="hexpand">True</property>
+                            <property name="label" translatable="yes">Manually Installed</property>
+                            <attributes>
+                              <attribute name="weight" value="bold"/>
+                            </attributes>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="GtkListBox" id="userList">
+                            <property name="visible">True</property>
+                            <property name="selection_mode">none</property>
+                            <property name="margin_bottom">24</property>
+                            <style>
+                              <class name="frame"/>
+                            </style>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="GtkLabel">
+                            <property name="visible"
+                                      bind-source="systemList"
+                                      bind-property="visible"
+                                      bind-flags="sync-create"/>
+                            <property name="halign">start</property>
+                            <property name="hexpand">True</property>
+                            <property name="label" translatable="yes">Built-In</property>
+                            <attributes>
+                              <attribute name="weight" value="bold"/>
+                            </attributes>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="GtkListBox" id="systemList">
+                            <property name="visible">True</property>
+                            <property name="selection_mode">none</property>
+                            <style>
+                              <class name="frame"/>
+                            </style>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+              </object>
+              <packing>
+                <property name="name">main</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="orientation">vertical</property>
+                <property name="margin">32</property>
+                <property name="spacing">6</property>
+                <property name="valign">center</property>
+                <child>
+                  <object class="GtkImage">
+                    <property name="visible">True</property>
+                    <property name="pixel_size">96</property>
+                    <property name="icon_name">org.gnome.Extensions-symbolic</property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="label" translatable="yes">No Installed Extensions</property>
+                    <attributes>
+                      <attribute name="weight" value="bold"/>
+                      <attribute name="scale" value="1.44"/>
+                    </attributes>
+                  </object>
+                </child>
+              </object>
+              <packing>
+                <property name="name">placeholder</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="margin_left">100</property>
+                <property name="margin_right">100</property>
+                <property name="margin_top">100</property>
+                <property name="margin_bottom">60</property>
+                <property name="orientation">vertical</property>
+                <property name="spacing">12</property>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="label" translatable="yes">Something’s gone wrong</property>
+                    <attributes>
+                      <attribute name="scale" value="1.44"/>
+                    </attributes>
+                    <style>
+                      <class name="dim-label"/>
+                    </style>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="label" translatable="yes">We’re very sorry, but it was not possible to get the list of installed extensions. Make sure you are logged into GNOME and try again.</property>
+                    <property name="justify">center</property>
+                    <property name="wrap">True</property>
+                    <style>
+                      <class name="dim-label"/>
+                    </style>
+                  </object>
+                </child>
+              </object>
+              <packing>
+                <property name="name">noshell</property>
+              </packing>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkActionBar" id="updatesBar">
+            <property name="no_show_all">True</property>
+            <child>
+              <object class="GtkImage">
+                <property name="visible">True</property>
+                <property name="pixel-size">24</property>
+                <property name="margin">6</property>
+                <property name="icon_name">software-update-available-symbolic</property>
+                <style>
+                  <class name="warning"/>
+                </style>
+              </object>
+            </child>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="orientation">vertical</property>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="halign">start</property>
+                    <property name="label">Extension Updates Ready</property>
+                    <attributes>
+                      <attribute name="weight" value="bold"/>
+                    </attributes>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkLabel" id="updatesLabel">
+                    <property name="visible">True</property>
+                    <property name="halign">start</property>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkButton">
+                <property name="label" translatable="yes">Log Out…</property>
+                <property name="visible">True</property>
+                <property name="valign">center</property>
+                <property name="action-name">win.logout</property>
+                <property name="receives_default">True</property>
+                <style>
+                  <class name="suggested-action"/>
+                </style>
+              </object>
+              <packing>
+                <property name="pack_type">end</property>
+              </packing>
+            </child>
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>

js/gdm/authPrompt.js

@@ -0,0 +1,536 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported AuthPrompt */
+
+const { Clutter, GObject, Pango, Shell, St } = imports.gi;
+
+const Animation = imports.ui.animation;
+const Batch = imports.gdm.batch;
+const GdmUtil = imports.gdm.util;
+const Util = imports.misc.util;
+const Params = imports.misc.params;
+const ShellEntry = imports.ui.shellEntry;
+const UserWidget = imports.ui.userWidget;
+
+var DEFAULT_BUTTON_WELL_ICON_SIZE = 16;
+var DEFAULT_BUTTON_WELL_ANIMATION_DELAY = 1000;
+var DEFAULT_BUTTON_WELL_ANIMATION_TIME = 300;
+
+var MESSAGE_FADE_OUT_ANIMATION_TIME = 500;
+
+var AuthPromptMode = {
+    UNLOCK_ONLY: 0,
+    UNLOCK_OR_LOG_IN: 1,
+};
+
+var AuthPromptStatus = {
+    NOT_VERIFYING: 0,
+    VERIFYING: 1,
+    VERIFICATION_FAILED: 2,
+    VERIFICATION_SUCCEEDED: 3,
+};
+
+var BeginRequestType = {
+    PROVIDE_USERNAME: 0,
+    DONT_PROVIDE_USERNAME: 1,
+};
+
+var AuthPrompt = GObject.registerClass({
+    Signals: {
+        'cancelled': {},
+        'failed': {},
+        'next': {},
+        'prompted': {},
+        'reset': { param_types: [GObject.TYPE_UINT] },
+    },
+}, class AuthPrompt extends St.BoxLayout {
+    _init(gdmClient, mode) {
+        super._init({
+            style_class: 'login-dialog-prompt-layout',
+            vertical: true,
+            x_expand: true,
+            x_align: Clutter.ActorAlign.CENTER,
+        });
+
+        this.verificationStatus = AuthPromptStatus.NOT_VERIFYING;
+
+        this._gdmClient = gdmClient;
+        this._mode = mode;
+        this._defaultButtonWellActor = null;
+
+        let reauthenticationOnly;
+        if (this._mode == AuthPromptMode.UNLOCK_ONLY)
+            reauthenticationOnly = true;
+        else if (this._mode == AuthPromptMode.UNLOCK_OR_LOG_IN)
+            reauthenticationOnly = false;
+
+        this._userVerifier = new GdmUtil.ShellUserVerifier(this._gdmClient, { reauthenticationOnly });
+
+        this._userVerifier.connect('ask-question', this._onAskQuestion.bind(this));
+        this._userVerifier.connect('show-message', this._onShowMessage.bind(this));
+        this._userVerifier.connect('verification-failed', this._onVerificationFailed.bind(this));
+        this._userVerifier.connect('verification-complete', this._onVerificationComplete.bind(this));
+        this._userVerifier.connect('reset', this._onReset.bind(this));
+        this._userVerifier.connect('smartcard-status-changed', this._onSmartcardStatusChanged.bind(this));
+        this._userVerifier.connect('ovirt-user-authenticated', this._onOVirtUserAuthenticated.bind(this));
+        this.smartcardDetected = this._userVerifier.smartcardDetected;
+
+        this.connect('destroy', this._onDestroy.bind(this));
+
+        this._userWell = new St.Bin({
+            x_expand: true,
+            y_expand: true,
+        });
+        this.add_child(this._userWell);
+
+        this._hasCancelButton = this._mode === AuthPromptMode.UNLOCK_OR_LOG_IN;
+
+        this._initEntryRow();
+
+        let capsLockPlaceholder = new St.Label();
+        this.add_child(capsLockPlaceholder);
+
+        this._capsLockWarningLabel = new ShellEntry.CapsLockWarning({
+            x_expand: true,
+            x_align: Clutter.ActorAlign.CENTER,
+        });
+        this.add_child(this._capsLockWarningLabel);
+
+        this._capsLockWarningLabel.bind_property('visible',
+            capsLockPlaceholder, 'visible',
+            GObject.BindingFlags.SYNC_CREATE | GObject.BindingFlags.INVERT_BOOLEAN);
+
+        this._message = new St.Label({
+            opacity: 0,
+            styleClass: 'login-dialog-message',
+            y_expand: true,
+            x_expand: true,
+            y_align: Clutter.ActorAlign.START,
+            x_align: Clutter.ActorAlign.CENTER,
+        });
+        this._message.clutter_text.line_wrap = true;
+        this._message.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+        this.add_child(this._message);
+    }
+
+    _onDestroy() {
+        this._userVerifier.destroy();
+        this._userVerifier = null;
+    }
+
+    vfunc_key_press_event(keyPressEvent) {
+        if (keyPressEvent.keyval == Clutter.KEY_Escape)
+            this.cancel();
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    _initEntryRow() {
+        this._mainBox = new St.BoxLayout({
+            style_class: 'login-dialog-button-box',
+            vertical: false,
+        });
+        this.add_child(this._mainBox);
+
+        this.cancelButton = new St.Button({
+            style_class: 'modal-dialog-button button cancel-button',
+            accessible_name: _('Cancel'),
+            button_mask: St.ButtonMask.ONE | St.ButtonMask.THREE,
+            reactive: this._hasCancelButton,
+            can_focus: this._hasCancelButton,
+            x_align: Clutter.ActorAlign.START,
+            y_align: Clutter.ActorAlign.CENTER,
+            child: new St.Icon({ icon_name: 'go-previous-symbolic' }),
+        });
+        if (this._hasCancelButton)
+            this.cancelButton.connect('clicked', () => this.cancel());
+        else
+            this.cancelButton.opacity = 0;
+        this._mainBox.add_child(this.cancelButton);
+
+        let entryParams = {
+            style_class: 'login-dialog-prompt-entry',
+            can_focus: true,
+            x_expand: true,
+        };
+
+        this._entry = null;
+
+        this._textEntry = new St.Entry(entryParams);
+        ShellEntry.addContextMenu(this._textEntry, { actionMode: Shell.ActionMode.NONE });
+
+        this._passwordEntry = new St.PasswordEntry(entryParams);
+        ShellEntry.addContextMenu(this._passwordEntry, { actionMode: Shell.ActionMode.NONE });
+
+        this._entry = this._passwordEntry;
+        this._mainBox.add_child(this._entry);
+        this._entry.grab_key_focus();
+
+        [this._textEntry, this._passwordEntry].forEach(entry => {
+            entry.clutter_text.connect('text-changed', () => {
+                if (!this._userVerifier.hasPendingMessages)
+                    this._fadeOutMessage();
+            });
+
+            entry.clutter_text.connect('activate', () => {
+                let shouldSpin = entry === this._passwordEntry;
+                if (entry.reactive)
+                    this._activateNext(shouldSpin);
+            });
+        });
+
+        this._defaultButtonWell = new St.Widget({
+            layout_manager: new Clutter.BinLayout(),
+            x_align: Clutter.ActorAlign.END,
+            y_align: Clutter.ActorAlign.CENTER,
+        });
+        this._defaultButtonWell.add_constraint(new Clutter.BindConstraint({
+            source: this.cancelButton,
+            coordinate: Clutter.BindCoordinate.SIZE,
+        }));
+        this._mainBox.add_child(this._defaultButtonWell);
+
+        this._spinner = new Animation.Spinner(DEFAULT_BUTTON_WELL_ICON_SIZE);
+        this._defaultButtonWell.add_child(this._spinner);
+    }
+
+    _activateNext(shouldSpin) {
+        this.updateSensitivity(false);
+
+        if (shouldSpin)
+            this.startSpinning();
+
+        if (this._queryingService)
+            this._userVerifier.answerQuery(this._queryingService, this._entry.text);
+        else
+            this._preemptiveAnswer = this._entry.text;
+
+        this.emit('next');
+    }
+
+    _updateEntry(secret) {
+        if (secret && this._entry !== this._passwordEntry) {
+            this._mainBox.replace_child(this._entry, this._passwordEntry);
+            this._entry = this._passwordEntry;
+        } else if (!secret && this._entry !== this._textEntry) {
+            this._mainBox.replace_child(this._entry, this._textEntry);
+            this._entry = this._textEntry;
+        }
+        this._capsLockWarningLabel.visible = secret;
+    }
+
+    _onAskQuestion(verifier, serviceName, question, secret) {
+        if (this._queryingService)
+            this.clear();
+
+        this._queryingService = serviceName;
+        if (this._preemptiveAnswer) {
+            this._userVerifier.answerQuery(this._queryingService, this._preemptiveAnswer);
+            this._preemptiveAnswer = null;
+            return;
+        }
+
+        this._updateEntry(secret);
+
+        // Hack: The question string comes directly from PAM, if it's "Password:"
+        // we replace it with our own to allow localization, if it's something
+        // else we remove the last colon and any trailing or leading spaces.
+        if (question === 'Password:' || question === 'Password: ')
+            this.setQuestion(_('Password'));
+        else
+            this.setQuestion(question.replace(/: *$/, '').trim());
+
+        this.updateSensitivity(true);
+        this.emit('prompted');
+    }
+
+    _onOVirtUserAuthenticated() {
+        if (this.verificationStatus != AuthPromptStatus.VERIFICATION_SUCCEEDED)
+            this.reset();
+    }
+
+    _onSmartcardStatusChanged() {
+        this.smartcardDetected = this._userVerifier.smartcardDetected;
+
+        // Most of the time we want to reset if the user inserts or removes
+        // a smartcard. Smartcard insertion "preempts" what the user was
+        // doing, and smartcard removal aborts the preemption.
+        // The exceptions are: 1) Don't reset on smartcard insertion if we're already verifying
+        //                        with a smartcard
+        //                     2) Don't reset if we've already succeeded at verification and
+        //                        the user is getting logged in.
+        if (this._userVerifier.serviceIsDefault(GdmUtil.SMARTCARD_SERVICE_NAME) &&
+            this.verificationStatus == AuthPromptStatus.VERIFYING &&
+            this.smartcardDetected)
+            return;
+
+        if (this.verificationStatus != AuthPromptStatus.VERIFICATION_SUCCEEDED)
+            this.reset();
+    }
+
+    _onShowMessage(userVerifier, message, type) {
+        this.setMessage(message, type);
+        this.emit('prompted');
+    }
+
+    _onVerificationFailed(userVerifier, canRetry) {
+        this._queryingService = null;
+        this.clear();
+
+        this.updateSensitivity(canRetry);
+        this.setActorInDefaultButtonWell(null);
+        this.verificationStatus = AuthPromptStatus.VERIFICATION_FAILED;
+
+        Util.wiggle(this._entry);
+    }
+
+    _onVerificationComplete() {
+        this.setActorInDefaultButtonWell(null);
+        this.verificationStatus = AuthPromptStatus.VERIFICATION_SUCCEEDED;
+        this.cancelButton.reactive = false;
+        this.cancelButton.can_focus = false;
+    }
+
+    _onReset() {
+        this.verificationStatus = AuthPromptStatus.NOT_VERIFYING;
+        this.reset();
+    }
+
+    setActorInDefaultButtonWell(actor, animate) {
+        if (!this._defaultButtonWellActor &&
+            !actor)
+            return;
+
+        let oldActor = this._defaultButtonWellActor;
+
+        if (oldActor)
+            oldActor.remove_all_transitions();
+
+        let wasSpinner;
+        if (oldActor == this._spinner)
+            wasSpinner = true;
+        else
+            wasSpinner = false;
+
+        let isSpinner;
+        if (actor == this._spinner)
+            isSpinner = true;
+        else
+            isSpinner = false;
+
+        if (this._defaultButtonWellActor != actor && oldActor) {
+            if (!animate) {
+                oldActor.opacity = 0;
+
+                if (wasSpinner) {
+                    if (this._spinner)
+                        this._spinner.stop();
+                }
+            } else {
+                oldActor.ease({
+                    opacity: 0,
+                    duration: DEFAULT_BUTTON_WELL_ANIMATION_TIME,
+                    delay: DEFAULT_BUTTON_WELL_ANIMATION_DELAY,
+                    mode: Clutter.AnimationMode.LINEAR,
+                    onComplete: () => {
+                        if (wasSpinner) {
+                            if (this._spinner)
+                                this._spinner.stop();
+                        }
+                    },
+                });
+            }
+        }
+
+        if (actor) {
+            if (isSpinner)
+                this._spinner.play();
+
+            if (!animate) {
+                actor.opacity = 255;
+            } else {
+                actor.ease({
+                    opacity: 255,
+                    duration: DEFAULT_BUTTON_WELL_ANIMATION_TIME,
+                    delay: DEFAULT_BUTTON_WELL_ANIMATION_DELAY,
+                    mode: Clutter.AnimationMode.LINEAR,
+                });
+            }
+        }
+
+        this._defaultButtonWellActor = actor;
+    }
+
+    startSpinning() {
+        this.setActorInDefaultButtonWell(this._spinner, true);
+    }
+
+    stopSpinning() {
+        this.setActorInDefaultButtonWell(null, false);
+    }
+
+    clear() {
+        this._entry.text = '';
+        this.stopSpinning();
+    }
+
+    setQuestion(question) {
+        this._entry.hint_text = question;
+
+        this._entry.show();
+        this._entry.grab_key_focus();
+    }
+
+    getAnswer() {
+        let text;
+
+        if (this._preemptiveAnswer) {
+            text = this._preemptiveAnswer;
+            this._preemptiveAnswer = null;
+        } else {
+            text = this._entry.get_text();
+        }
+
+        return text;
+    }
+
+    _fadeOutMessage() {
+        if (this._message.opacity == 0)
+            return;
+        this._message.remove_all_transitions();
+        this._message.ease({
+            opacity: 0,
+            duration: MESSAGE_FADE_OUT_ANIMATION_TIME,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        });
+    }
+
+    setMessage(message, type) {
+        if (type == GdmUtil.MessageType.ERROR)
+            this._message.add_style_class_name('login-dialog-message-warning');
+        else
+            this._message.remove_style_class_name('login-dialog-message-warning');
+
+        if (type == GdmUtil.MessageType.HINT)
+            this._message.add_style_class_name('login-dialog-message-hint');
+        else
+            this._message.remove_style_class_name('login-dialog-message-hint');
+
+        if (message) {
+            this._message.remove_all_transitions();
+            this._message.text = message;
+            this._message.opacity = 255;
+        } else {
+            this._message.opacity = 0;
+        }
+    }
+
+    updateSensitivity(sensitive) {
+        this._entry.reactive = sensitive;
+        this._entry.clutter_text.editable = sensitive;
+    }
+
+    vfunc_hide() {
+        this.setActorInDefaultButtonWell(null, true);
+        super.vfunc_hide();
+        this._message.opacity = 0;
+
+        this.setUser(null);
+
+        this.updateSensitivity(true);
+        this._entry.set_text('');
+    }
+
+    setUser(user) {
+        let oldChild = this._userWell.get_child();
+        if (oldChild)
+            oldChild.destroy();
+
+        let userWidget = new UserWidget.UserWidget(user, Clutter.Orientation.VERTICAL);
+        this._userWell.set_child(userWidget);
+
+        if (!user)
+            this._updateEntry(false);
+    }
+
+    reset() {
+        let oldStatus = this.verificationStatus;
+        this.verificationStatus = AuthPromptStatus.NOT_VERIFYING;
+        this.cancelButton.reactive = this._hasCancelButton;
+        this.cancelButton.can_focus = this._hasCancelButton;
+        this._preemptiveAnswer = null;
+
+        if (this._userVerifier)
+            this._userVerifier.cancel();
+
+        this._queryingService = null;
+        this.clear();
+        this._message.opacity = 0;
+        this.setUser(null);
+        this._updateEntry(true);
+        this.stopSpinning();
+
+        if (oldStatus == AuthPromptStatus.VERIFICATION_FAILED)
+            this.emit('failed');
+
+        let beginRequestType;
+
+        if (this._mode == AuthPromptMode.UNLOCK_ONLY) {
+            // The user is constant at the unlock screen, so it will immediately
+            // respond to the request with the username
+            beginRequestType = BeginRequestType.PROVIDE_USERNAME;
+        } else if (this._userVerifier.serviceIsForeground(GdmUtil.OVIRT_SERVICE_NAME) ||
+                   this._userVerifier.serviceIsForeground(GdmUtil.SMARTCARD_SERVICE_NAME)) {
+            // We don't need to know the username if the user preempted the login screen
+            // with a smartcard or with preauthenticated oVirt credentials
+            beginRequestType = BeginRequestType.DONT_PROVIDE_USERNAME;
+        } else {
+            // In all other cases, we should get the username up front.
+            beginRequestType = BeginRequestType.PROVIDE_USERNAME;
+        }
+
+        this.emit('reset', beginRequestType);
+    }
+
+    addCharacter(unichar) {
+        if (!this._entry.visible)
+            return;
+
+        this._entry.grab_key_focus();
+        this._entry.clutter_text.insert_unichar(unichar);
+    }
+
+    begin(params) {
+        params = Params.parse(params, { userName: null,
+                                        hold: null });
+
+        this.updateSensitivity(false);
+
+        let hold = params.hold;
+        if (!hold)
+            hold = new Batch.Hold();
+
+        this._userVerifier.begin(params.userName, hold);
+        this.verificationStatus = AuthPromptStatus.VERIFYING;
+    }
+
+    finish(onComplete) {
+        if (!this._userVerifier.hasPendingMessages) {
+            this._userVerifier.clear();
+            onComplete();
+            return;
+        }
+
+        let signalId = this._userVerifier.connect('no-more-messages', () => {
+            this._userVerifier.disconnect(signalId);
+            this._userVerifier.clear();
+            onComplete();
+        });
+    }
+
+    cancel() {
+        if (this.verificationStatus == AuthPromptStatus.VERIFICATION_SUCCEEDED)
+            return;
+
+        this.reset();
+        this.emit('cancelled');
+    }
+});

js/gdm/batch.js

@@ -0,0 +1,208 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/*
+ * Copyright 2011 Red Hat, Inc
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * In order for transformation animations to look good, they need to be
+ * incremental and have some order to them (e.g., fade out hidden items,
+ * then shrink to close the void left over). Chaining animations in this way can
+ * be error-prone and wordy using just ease() callbacks.
+ *
+ * The classes in this file help with this:
+ *
+ * - Task.  encapsulates schedulable work to be run in a specific scope.
+ *
+ * - ConsecutiveBatch.  runs a series of tasks in order and completes
+ *                      when the last in the series finishes.
+ *
+ * - ConcurrentBatch.  runs a set of tasks at the same time and completes
+ *                     when the last to finish completes.
+ *
+ * - Hold.  prevents a batch from completing the pending task until
+ *          the hold is released.
+ *
+ * The tasks associated with a batch are specified in a list at batch
+ * construction time as either task objects or plain functions.
+ * Batches are task objects, themselves, so they can be nested.
+ *
+ * These classes aren't specific to GDM, but were found to be unintuitive and so
+ * are not used elsewhere. These APIs may ultimately get dropped entirely and
+ * replaced by something else.
+ */
+
+const { GObject } = imports.gi;
+const Signals = imports.signals;
+
+var Task = class {
+    constructor(scope, handler) {
+        if (scope)
+            this.scope = scope;
+        else
+            this.scope = this;
+
+        this.handler = handler;
+    }
+
+    run() {
+        if (this.handler)
+            return this.handler.call(this.scope);
+
+        return null;
+    }
+};
+Signals.addSignalMethods(Task.prototype);
+
+var Hold = class extends Task {
+    constructor() {
+        super(null, () => this);
+
+        this._acquisitions = 1;
+    }
+
+    acquire() {
+        if (this._acquisitions <= 0)
+            throw new Error("Cannot acquire hold after it's been released");
+        this._acquisitions++;
+    }
+
+    acquireUntilAfter(hold) {
+        if (!hold.isAcquired())
+            return;
+
+        this.acquire();
+        let signalId = hold.connect('release', () => {
+            hold.disconnect(signalId);
+            this.release();
+        });
+    }
+
+    release() {
+        this._acquisitions--;
+
+        if (this._acquisitions == 0)
+            this.emit('release');
+    }
+
+    isAcquired() {
+        return this._acquisitions > 0;
+    }
+};
+Signals.addSignalMethods(Hold.prototype);
+
+var Batch = class extends Task {
+    constructor(scope, tasks) {
+        super();
+
+        this.tasks = [];
+
+        for (let i = 0; i < tasks.length; i++) {
+            let task;
+
+            if (tasks[i] instanceof Task)
+                task = tasks[i];
+            else if (typeof tasks[i] == 'function')
+                task = new Task(scope, tasks[i]);
+            else
+                throw new Error('Batch tasks must be functions or Task, Hold or Batch objects');
+
+            this.tasks.push(task);
+        }
+    }
+
+    process() {
+        throw new GObject.NotImplementedError(`process in ${this.constructor.name}`);
+    }
+
+    runTask() {
+        if (!(this._currentTaskIndex in this.tasks))
+            return null;
+
+        return this.tasks[this._currentTaskIndex].run();
+    }
+
+    _finish() {
+        this.hold.release();
+    }
+
+    nextTask() {
+        this._currentTaskIndex++;
+
+        // if the entire batch of tasks is finished, release
+        // the hold and notify anyone waiting on the batch
+        if (this._currentTaskIndex >= this.tasks.length) {
+            this._finish();
+            return;
+        }
+
+        this.process();
+    }
+
+    _start() {
+        // acquire a hold to get released when the entire
+        // batch of tasks is finished
+        this.hold = new Hold();
+        this._currentTaskIndex = 0;
+        this.process();
+    }
+
+    run() {
+        this._start();
+
+        // hold may be destroyed at this point
+        // if we're already done running
+        return this.hold;
+    }
+
+    cancel() {
+        this.tasks = this.tasks.splice(0, this._currentTaskIndex + 1);
+    }
+};
+Signals.addSignalMethods(Batch.prototype);
+
+var ConcurrentBatch = class extends Batch {
+    process() {
+        let hold = this.runTask();
+
+        if (hold)
+            this.hold.acquireUntilAfter(hold);
+
+        // Regardless of the state of the just run task,
+        // fire off the next one, so all the tasks can run
+        // concurrently.
+        this.nextTask();
+    }
+};
+Signals.addSignalMethods(ConcurrentBatch.prototype);
+
+var ConsecutiveBatch = class extends Batch {
+    process() {
+        let hold = this.runTask();
+
+        if (hold && hold.isAcquired()) {
+            // This task is inhibiting the batch. Wait on it
+            // before processing the next one.
+            let signalId = hold.connect('release', () => {
+                hold.disconnect(signalId);
+                this.nextTask();
+            });
+        } else {
+            // This task finished, process the next one
+            this.nextTask();
+        }
+    }
+};
+Signals.addSignalMethods(ConsecutiveBatch.prototype);

js/gdm/fingerprint.js

@@ -0,0 +1,33 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported FprintManager */
+
+const Gio = imports.gi.Gio;
+
+const FprintManagerIface = `
+<node>
+<interface name="net.reactivated.Fprint.Manager">
+<method name="GetDefaultDevice">
+    <arg type="o" direction="out" />
+</method>
+</interface>
+</node>`;
+
+const FprintManagerInfo = Gio.DBusInterfaceInfo.new_for_xml(FprintManagerIface);
+
+function FprintManager() {
+    var self = new Gio.DBusProxy({ g_connection: Gio.DBus.system,
+                                   g_interface_name: FprintManagerInfo.name,
+                                   g_interface_info: FprintManagerInfo,
+                                   g_name: 'net.reactivated.Fprint',
+                                   g_object_path: '/net/reactivated/Fprint/Manager',
+                                   g_flags: Gio.DBusProxyFlags.DO_NOT_LOAD_PROPERTIES });
+
+    try {
+        self.init(null);
+    } catch (e) {
+        log(`Failed to connect to Fprint service: ${e.message}`);
+        return null;
+    }
+
+    return self;
+}

js/gdm/oVirt.js

@@ -0,0 +1,64 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported getOVirtCredentialsManager */
+
+const Gio = imports.gi.Gio;
+const Signals = imports.signals;
+
+const OVirtCredentialsIface = `
+<node>
+<interface name="org.ovirt.vdsm.Credentials">
+<signal name="UserAuthenticated">
+    <arg type="s" name="token"/>
+</signal>
+</interface>
+</node>`;
+
+const OVirtCredentialsInfo = Gio.DBusInterfaceInfo.new_for_xml(OVirtCredentialsIface);
+
+let _oVirtCredentialsManager = null;
+
+function OVirtCredentials() {
+    var self = new Gio.DBusProxy({ g_connection: Gio.DBus.system,
+                                   g_interface_name: OVirtCredentialsInfo.name,
+                                   g_interface_info: OVirtCredentialsInfo,
+                                   g_name: 'org.ovirt.vdsm.Credentials',
+                                   g_object_path: '/org/ovirt/vdsm/Credentials',
+                                   g_flags: Gio.DBusProxyFlags.DO_NOT_LOAD_PROPERTIES });
+    self.init(null);
+    return self;
+}
+
+var OVirtCredentialsManager = class {
+    constructor() {
+        this._token = null;
+
+        this._credentials = new OVirtCredentials();
+        this._credentials.connectSignal('UserAuthenticated',
+                                        this._onUserAuthenticated.bind(this));
+    }
+
+    _onUserAuthenticated(proxy, sender, [token]) {
+        this._token = token;
+        this.emit('user-authenticated', token);
+    }
+
+    hasToken() {
+        return this._token != null;
+    }
+
+    getToken() {
+        return this._token;
+    }
+
+    resetToken() {
+        this._token = null;
+    }
+};
+Signals.addSignalMethods(OVirtCredentialsManager.prototype);
+
+function getOVirtCredentialsManager() {
+    if (!_oVirtCredentialsManager)
+        _oVirtCredentialsManager = new OVirtCredentialsManager();
+
+    return _oVirtCredentialsManager;
+}

js/gdm/realmd.js

@@ -0,0 +1,108 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+
+const Gio = imports.gi.Gio;
+const Signals = imports.signals;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const ProviderIface = loadInterfaceXML("org.freedesktop.realmd.Provider");
+const Provider = Gio.DBusProxy.makeProxyWrapper(ProviderIface);
+
+const ServiceIface = loadInterfaceXML("org.freedesktop.realmd.Service");
+const Service = Gio.DBusProxy.makeProxyWrapper(ServiceIface);
+
+const RealmIface = loadInterfaceXML("org.freedesktop.realmd.Realm");
+const Realm = Gio.DBusProxy.makeProxyWrapper(RealmIface);
+
+var Manager = class {
+    constructor() {
+        this._aggregateProvider = Provider(Gio.DBus.system,
+                                           'org.freedesktop.realmd',
+                                           '/org/freedesktop/realmd',
+                                           this._reloadRealms.bind(this));
+        this._realms = {};
+        this._loginFormat = null;
+
+        this._signalId = this._aggregateProvider.connect('g-properties-changed',
+            (proxy, properties) => {
+                if ('Realms' in properties.deep_unpack())
+                    this._reloadRealms();
+            });
+    }
+
+    _reloadRealms() {
+        let realmPaths = this._aggregateProvider.Realms;
+
+        if (!realmPaths)
+            return;
+
+        for (let i = 0; i < realmPaths.length; i++) {
+            Realm(Gio.DBus.system,
+                  'org.freedesktop.realmd',
+                  realmPaths[i],
+                  this._onRealmLoaded.bind(this));
+        }
+    }
+
+    _reloadRealm(realm) {
+        if (!realm.Configured) {
+            if (this._realms[realm.get_object_path()])
+                delete this._realms[realm.get_object_path()];
+
+            return;
+        }
+
+        this._realms[realm.get_object_path()] = realm;
+
+        this._updateLoginFormat();
+    }
+
+    _onRealmLoaded(realm, error) {
+        if (error)
+            return;
+
+        this._reloadRealm(realm);
+
+        realm.connect('g-properties-changed', (proxy, properties) => {
+            if ('Configured' in properties.deep_unpack())
+                this._reloadRealm(realm);
+        });
+    }
+
+    _updateLoginFormat() {
+        let newLoginFormat;
+
+        for (let realmPath in this._realms) {
+            let realm = this._realms[realmPath];
+            if (realm.LoginFormats && realm.LoginFormats.length > 0) {
+                newLoginFormat = realm.LoginFormats[0];
+                break;
+            }
+        }
+
+        if (this._loginFormat != newLoginFormat) {
+            this._loginFormat = newLoginFormat;
+            this.emit('login-format-changed', newLoginFormat);
+        }
+    }
+
+    get loginFormat() {
+        if (this._loginFormat)
+            return this._loginFormat;
+
+        this._updateLoginFormat();
+
+        return this._loginFormat;
+    }
+
+    release() {
+        Service(Gio.DBus.system,
+                'org.freedesktop.realmd',
+                '/org/freedesktop/realmd',
+                service => service.ReleaseRemote());
+        this._aggregateProvider.disconnect(this._signalId);
+        this._realms = { };
+        this._updateLoginFormat();
+    }
+};
+Signals.addSignalMethods(Manager.prototype);

js/gdm/util.js

@@ -0,0 +1,579 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported BANNER_MESSAGE_KEY, BANNER_MESSAGE_TEXT_KEY, LOGO_KEY,
+            DISABLE_USER_LIST_KEY, fadeInActor, fadeOutActor, cloneAndFadeOutActor */
+
+const { Clutter, Gio, GLib } = imports.gi;
+const Signals = imports.signals;
+
+const Batch = imports.gdm.batch;
+const Fprint = imports.gdm.fingerprint;
+const OVirt = imports.gdm.oVirt;
+const Main = imports.ui.main;
+const Params = imports.misc.params;
+const SmartcardManager = imports.misc.smartcardManager;
+
+var PASSWORD_SERVICE_NAME = 'gdm-password';
+var FINGERPRINT_SERVICE_NAME = 'gdm-fingerprint';
+var SMARTCARD_SERVICE_NAME = 'gdm-smartcard';
+var OVIRT_SERVICE_NAME = 'gdm-ovirtcred';
+var FADE_ANIMATION_TIME = 160;
+var CLONE_FADE_ANIMATION_TIME = 250;
+
+var LOGIN_SCREEN_SCHEMA = 'org.gnome.login-screen';
+var PASSWORD_AUTHENTICATION_KEY = 'enable-password-authentication';
+var FINGERPRINT_AUTHENTICATION_KEY = 'enable-fingerprint-authentication';
+var SMARTCARD_AUTHENTICATION_KEY = 'enable-smartcard-authentication';
+var BANNER_MESSAGE_KEY = 'banner-message-enable';
+var BANNER_MESSAGE_TEXT_KEY = 'banner-message-text';
+var ALLOWED_FAILURES_KEY = 'allowed-failures';
+
+var LOGO_KEY = 'logo';
+var DISABLE_USER_LIST_KEY = 'disable-user-list';
+
+// Give user 48ms to read each character of a PAM message
+var USER_READ_TIME = 48;
+
+var MessageType = {
+    NONE: 0,
+    ERROR: 1,
+    INFO: 2,
+    HINT: 3,
+};
+
+function fadeInActor(actor) {
+    if (actor.opacity == 255 && actor.visible)
+        return null;
+
+    let hold = new Batch.Hold();
+    actor.show();
+    let [, naturalHeight] = actor.get_preferred_height(-1);
+
+    actor.opacity = 0;
+    actor.set_height(0);
+    actor.ease({
+        opacity: 255,
+        height: naturalHeight,
+        duration: FADE_ANIMATION_TIME,
+        mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        onComplete: () => {
+            this.set_height(-1);
+            hold.release();
+        },
+    });
+
+    return hold;
+}
+
+function fadeOutActor(actor) {
+    if (!actor.visible || actor.opacity == 0) {
+        actor.opacity = 0;
+        actor.hide();
+        return null;
+    }
+
+    let hold = new Batch.Hold();
+    actor.ease({
+        opacity: 0,
+        height: 0,
+        duration: FADE_ANIMATION_TIME,
+        mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        onComplete: () => {
+            this.hide();
+            this.set_height(-1);
+            hold.release();
+        },
+    });
+    return hold;
+}
+
+function cloneAndFadeOutActor(actor) {
+    // Immediately hide actor so its sibling can have its space
+    // and position, but leave a non-reactive clone on-screen,
+    // so from the user's point of view it smoothly fades away
+    // and reveals its sibling.
+    actor.hide();
+
+    let clone = new Clutter.Clone({ source: actor,
+                                    reactive: false });
+
+    Main.uiGroup.add_child(clone);
+
+    let [x, y] = actor.get_transformed_position();
+    clone.set_position(x, y);
+
+    let hold = new Batch.Hold();
+    clone.ease({
+        opacity: 0,
+        duration: CLONE_FADE_ANIMATION_TIME,
+        mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        onComplete: () => {
+            clone.destroy();
+            hold.release();
+        },
+    });
+    return hold;
+}
+
+var ShellUserVerifier = class {
+    constructor(client, params) {
+        params = Params.parse(params, { reauthenticationOnly: false });
+        this._reauthOnly = params.reauthenticationOnly;
+
+        this._client = client;
+
+        this._defaultService = null;
+        this._preemptingService = null;
+
+        this._settings = new Gio.Settings({ schema_id: LOGIN_SCREEN_SCHEMA });
+        this._settings.connect('changed',
+                               this._updateDefaultService.bind(this));
+        this._updateDefaultService();
+
+        this._fprintManager = Fprint.FprintManager();
+        this._smartcardManager = SmartcardManager.getSmartcardManager();
+
+        // We check for smartcards right away, since an inserted smartcard
+        // at startup should result in immediately initiating authentication.
+        // This is different than fingerprint readers, where we only check them
+        // after a user has been picked.
+        this.smartcardDetected = false;
+        this._checkForSmartcard();
+
+        this._smartcardInsertedId = this._smartcardManager.connect('smartcard-inserted',
+                                                                   this._checkForSmartcard.bind(this));
+        this._smartcardRemovedId = this._smartcardManager.connect('smartcard-removed',
+                                                                  this._checkForSmartcard.bind(this));
+
+        this._messageQueue = [];
+        this._messageQueueTimeoutId = 0;
+        this.hasPendingMessages = false;
+        this.reauthenticating = false;
+
+        this._failCounter = 0;
+
+        this._oVirtCredentialsManager = OVirt.getOVirtCredentialsManager();
+
+        if (this._oVirtCredentialsManager.hasToken())
+            this._oVirtUserAuthenticated(this._oVirtCredentialsManager.getToken());
+
+        this._oVirtUserAuthenticatedId = this._oVirtCredentialsManager.connect('user-authenticated',
+                                                                               this._oVirtUserAuthenticated.bind(this));
+    }
+
+    begin(userName, hold) {
+        this._cancellable = new Gio.Cancellable();
+        this._hold = hold;
+        this._userName = userName;
+        this.reauthenticating = false;
+
+        this._checkForFingerprintReader();
+
+        if (userName) {
+            // If possible, reauthenticate an already running session,
+            // so any session specific credentials get updated appropriately
+            this._client.open_reauthentication_channel(userName, this._cancellable,
+                                                       this._reauthenticationChannelOpened.bind(this));
+        } else {
+            this._client.get_user_verifier(this._cancellable, this._userVerifierGot.bind(this));
+        }
+    }
+
+    cancel() {
+        if (this._cancellable)
+            this._cancellable.cancel();
+
+        if (this._userVerifier) {
+            this._userVerifier.call_cancel_sync(null);
+            this.clear();
+        }
+    }
+
+    _clearUserVerifier() {
+        if (this._userVerifier) {
+            this._userVerifier.run_dispose();
+            this._userVerifier = null;
+        }
+    }
+
+    clear() {
+        if (this._cancellable) {
+            this._cancellable.cancel();
+            this._cancellable = null;
+        }
+
+        this._clearUserVerifier();
+        this._clearMessageQueue();
+    }
+
+    destroy() {
+        this.clear();
+
+        this._settings.run_dispose();
+        this._settings = null;
+
+        this._smartcardManager.disconnect(this._smartcardInsertedId);
+        this._smartcardManager.disconnect(this._smartcardRemovedId);
+        this._smartcardManager = null;
+
+        this._oVirtCredentialsManager.disconnect(this._oVirtUserAuthenticatedId);
+        this._oVirtCredentialsManager = null;
+    }
+
+    answerQuery(serviceName, answer) {
+        if (!this.hasPendingMessages) {
+            this._userVerifier.call_answer_query(serviceName, answer, this._cancellable, null);
+        } else {
+            let signalId = this.connect('no-more-messages', () => {
+                this.disconnect(signalId);
+                this._userVerifier.call_answer_query(serviceName, answer, this._cancellable, null);
+            });
+        }
+    }
+
+    _getIntervalForMessage(message) {
+        // We probably could be smarter here
+        return message.length * USER_READ_TIME;
+    }
+
+    finishMessageQueue() {
+        if (!this.hasPendingMessages)
+            return;
+
+        this._messageQueue = [];
+
+        this.hasPendingMessages = false;
+        this.emit('no-more-messages');
+    }
+
+    _queueMessageTimeout() {
+        if (this._messageQueue.length == 0) {
+            this.finishMessageQueue();
+            return;
+        }
+
+        if (this._messageQueueTimeoutId != 0)
+            return;
+
+        let message = this._messageQueue.shift();
+
+        this.emit('show-message', message.text, message.type);
+
+        this._messageQueueTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT,
+                                                       message.interval,
+                                                       () => {
+                                                           this._messageQueueTimeoutId = 0;
+                                                           this._queueMessageTimeout();
+                                                           return GLib.SOURCE_REMOVE;
+                                                       });
+        GLib.Source.set_name_by_id(this._messageQueueTimeoutId, '[gnome-shell] this._queueMessageTimeout');
+    }
+
+    _queueMessage(message, messageType) {
+        let interval = this._getIntervalForMessage(message);
+
+        this.hasPendingMessages = true;
+        this._messageQueue.push({ text: message, type: messageType, interval });
+        this._queueMessageTimeout();
+    }
+
+    _clearMessageQueue() {
+        this.finishMessageQueue();
+
+        if (this._messageQueueTimeoutId != 0) {
+            GLib.source_remove(this._messageQueueTimeoutId);
+            this._messageQueueTimeoutId = 0;
+        }
+        this.emit('show-message', null, MessageType.NONE);
+    }
+
+    _checkForFingerprintReader() {
+        this._haveFingerprintReader = false;
+
+        if (!this._settings.get_boolean(FINGERPRINT_AUTHENTICATION_KEY) ||
+            this._fprintManager == null) {
+            this._updateDefaultService();
+            return;
+        }
+
+        this._fprintManager.GetDefaultDeviceRemote(Gio.DBusCallFlags.NONE, this._cancellable,
+            (device, error) => {
+                if (!error && device) {
+                    this._haveFingerprintReader = true;
+                    this._updateDefaultService();
+                }
+            });
+    }
+
+    _oVirtUserAuthenticated(_token) {
+        this._preemptingService = OVIRT_SERVICE_NAME;
+        this.emit('ovirt-user-authenticated');
+    }
+
+    _checkForSmartcard() {
+        let smartcardDetected;
+
+        if (!this._settings.get_boolean(SMARTCARD_AUTHENTICATION_KEY))
+            smartcardDetected = false;
+        else if (this._reauthOnly)
+            smartcardDetected = this._smartcardManager.hasInsertedLoginToken();
+        else
+            smartcardDetected = this._smartcardManager.hasInsertedTokens();
+
+        if (smartcardDetected != this.smartcardDetected) {
+            this.smartcardDetected = smartcardDetected;
+
+            if (this.smartcardDetected)
+                this._preemptingService = SMARTCARD_SERVICE_NAME;
+            else if (this._preemptingService == SMARTCARD_SERVICE_NAME)
+                this._preemptingService = null;
+
+            this.emit('smartcard-status-changed');
+        }
+    }
+
+    _reportInitError(where, error) {
+        logError(error, where);
+        this._hold.release();
+
+        this._queueMessage(_("Authentication error"), MessageType.ERROR);
+        this._verificationFailed(false);
+    }
+
+    _reauthenticationChannelOpened(client, result) {
+        try {
+            this._clearUserVerifier();
+            this._userVerifier = client.open_reauthentication_channel_finish(result);
+        } catch (e) {
+            if (e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+                return;
+            if (e.matches(Gio.DBusError, Gio.DBusError.ACCESS_DENIED) &&
+                !this._reauthOnly) {
+                // Gdm emits org.freedesktop.DBus.Error.AccessDenied when there
+                // is no session to reauthenticate. Fall back to performing
+                // verification from this login session
+                client.get_user_verifier(this._cancellable,
+                                         this._userVerifierGot.bind(this));
+                return;
+            }
+
+            this._reportInitError('Failed to open reauthentication channel', e);
+            return;
+        }
+
+        this.reauthenticating = true;
+        this._connectSignals();
+        this._beginVerification();
+        this._hold.release();
+    }
+
+    _userVerifierGot(client, result) {
+        try {
+            this._clearUserVerifier();
+            this._userVerifier = client.get_user_verifier_finish(result);
+        } catch (e) {
+            if (e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+                return;
+            this._reportInitError('Failed to obtain user verifier', e);
+            return;
+        }
+
+        this._connectSignals();
+        this._beginVerification();
+        this._hold.release();
+    }
+
+    _connectSignals() {
+        this._userVerifier.connect('info', this._onInfo.bind(this));
+        this._userVerifier.connect('problem', this._onProblem.bind(this));
+        this._userVerifier.connect('info-query', this._onInfoQuery.bind(this));
+        this._userVerifier.connect('secret-info-query', this._onSecretInfoQuery.bind(this));
+        this._userVerifier.connect('conversation-stopped', this._onConversationStopped.bind(this));
+        this._userVerifier.connect('reset', this._onReset.bind(this));
+        this._userVerifier.connect('verification-complete', this._onVerificationComplete.bind(this));
+    }
+
+    _getForegroundService() {
+        if (this._preemptingService)
+            return this._preemptingService;
+
+        return this._defaultService;
+    }
+
+    serviceIsForeground(serviceName) {
+        return serviceName == this._getForegroundService();
+    }
+
+    serviceIsDefault(serviceName) {
+        return serviceName == this._defaultService;
+    }
+
+    _updateDefaultService() {
+        if (this._settings.get_boolean(PASSWORD_AUTHENTICATION_KEY))
+            this._defaultService = PASSWORD_SERVICE_NAME;
+        else if (this._settings.get_boolean(SMARTCARD_AUTHENTICATION_KEY))
+            this._defaultService = SMARTCARD_SERVICE_NAME;
+        else if (this._haveFingerprintReader)
+            this._defaultService = FINGERPRINT_SERVICE_NAME;
+
+        if (!this._defaultService) {
+            log("no authentication service is enabled, using password authentication");
+            this._defaultService = PASSWORD_SERVICE_NAME;
+        }
+    }
+
+    _startService(serviceName) {
+        this._hold.acquire();
+        if (this._userName) {
+            this._userVerifier.call_begin_verification_for_user(serviceName, this._userName, this._cancellable, (obj, result) => {
+                try {
+                    obj.call_begin_verification_for_user_finish(result);
+                } catch (e) {
+                    if (e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+                        return;
+                    this._reportInitError('Failed to start verification for user', e);
+                    return;
+                }
+
+                this._hold.release();
+            });
+        } else {
+            this._userVerifier.call_begin_verification(serviceName, this._cancellable, (obj, result) => {
+                try {
+                    obj.call_begin_verification_finish(result);
+                } catch (e) {
+                    if (e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+                        return;
+                    this._reportInitError('Failed to start verification', e);
+                    return;
+                }
+
+                this._hold.release();
+            });
+        }
+    }
+
+    _beginVerification() {
+        this._startService(this._getForegroundService());
+
+        if (this._userName && this._haveFingerprintReader && !this.serviceIsForeground(FINGERPRINT_SERVICE_NAME))
+            this._startService(FINGERPRINT_SERVICE_NAME);
+    }
+
+    _onInfo(client, serviceName, info) {
+        if (this.serviceIsForeground(serviceName)) {
+            this._queueMessage(info, MessageType.INFO);
+        } else if (serviceName == FINGERPRINT_SERVICE_NAME &&
+            this._haveFingerprintReader) {
+            // We don't show fingerprint messages directly since it's
+            // not the main auth service. Instead we use the messages
+            // as a cue to display our own message.
+
+            // Translators: this message is shown below the password entry field
+            // to indicate the user can swipe their finger instead
+            this._queueMessage(_("(or swipe finger)"), MessageType.HINT);
+        }
+    }
+
+    _onProblem(client, serviceName, problem) {
+        if (!this.serviceIsForeground(serviceName))
+            return;
+
+        this._queueMessage(problem, MessageType.ERROR);
+    }
+
+    _onInfoQuery(client, serviceName, question) {
+        if (!this.serviceIsForeground(serviceName))
+            return;
+
+        this.emit('ask-question', serviceName, question, false);
+    }
+
+    _onSecretInfoQuery(client, serviceName, secretQuestion) {
+        if (!this.serviceIsForeground(serviceName))
+            return;
+
+        if (serviceName == OVIRT_SERVICE_NAME) {
+            // The only question asked by this service is "Token?"
+            this.answerQuery(serviceName, this._oVirtCredentialsManager.getToken());
+            return;
+        }
+
+        this.emit('ask-question', serviceName, secretQuestion, true);
+    }
+
+    _onReset() {
+        // Clear previous attempts to authenticate
+        this._failCounter = 0;
+        this._updateDefaultService();
+
+        this.emit('reset');
+    }
+
+    _onVerificationComplete() {
+        this.emit('verification-complete');
+    }
+
+    _cancelAndReset() {
+        this.cancel();
+        this._onReset();
+    }
+
+    _retry() {
+        this.begin(this._userName, new Batch.Hold());
+    }
+
+    _verificationFailed(retry) {
+        // For Not Listed / enterprise logins, immediately reset
+        // the dialog
+        // Otherwise, when in login mode we allow ALLOWED_FAILURES attempts.
+        // After that, we go back to the welcome screen.
+
+        this._failCounter++;
+        let canRetry = retry && this._userName &&
+            (this._reauthOnly ||
+             this._failCounter < this._settings.get_int(ALLOWED_FAILURES_KEY));
+
+        if (canRetry) {
+            if (!this.hasPendingMessages) {
+                this._retry();
+            } else {
+                let signalId = this.connect('no-more-messages', () => {
+                    this.disconnect(signalId);
+                    if (this._cancellable && !this._cancellable.is_cancelled())
+                        this._retry();
+                });
+            }
+        } else {
+            // eslint-disable-next-line no-lonely-if
+            if (!this.hasPendingMessages) {
+                this._cancelAndReset();
+            } else {
+                let signalId = this.connect('no-more-messages', () => {
+                    this.disconnect(signalId);
+                    this._cancelAndReset();
+                });
+            }
+        }
+
+        this.emit('verification-failed', canRetry);
+    }
+
+    _onConversationStopped(client, serviceName) {
+        // If the login failed with the preauthenticated oVirt credentials
+        // then discard the credentials and revert to default authentication
+        // mechanism.
+        if (this.serviceIsForeground(OVIRT_SERVICE_NAME)) {
+            this._oVirtCredentialsManager.resetToken();
+            this._preemptingService = null;
+            this._verificationFailed(false);
+            return;
+        }
+
+        // if the password service fails, then cancel everything.
+        // But if, e.g., fingerprint fails, still give
+        // password authentication a chance to succeed
+        if (this.serviceIsForeground(serviceName))
+            this._verificationFailed(true);
+    }
+};
+Signals.addSignalMethods(ShellUserVerifier.prototype);

js/js-resources.gresource.xml

@@ -0,0 +1,141 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gresources>
+  <gresource prefix="/org/gnome/shell">
+    <file>gdm/authPrompt.js</file>
+    <file>gdm/batch.js</file>
+    <file>gdm/fingerprint.js</file>
+    <file>gdm/loginDialog.js</file>
+    <file>gdm/oVirt.js</file>
+    <file>gdm/realmd.js</file>
+    <file>gdm/util.js</file>
+
+    <file>misc/config.js</file>
+    <file>misc/extensionUtils.js</file>
+    <file>misc/fileUtils.js</file>
+    <file>misc/gnomeSession.js</file>
+    <file>misc/history.js</file>
+    <file>misc/ibusManager.js</file>
+    <file>misc/inputMethod.js</file>
+    <file>misc/introspect.js</file>
+    <file>misc/jsParse.js</file>
+    <file>misc/keyboardManager.js</file>
+    <file>misc/loginManager.js</file>
+    <file>misc/modemManager.js</file>
+    <file>misc/objectManager.js</file>
+    <file>misc/params.js</file>
+    <file>misc/permissionStore.js</file>
+    <file>misc/smartcardManager.js</file>
+    <file>misc/systemActions.js</file>
+    <file>misc/util.js</file>
+    <file>misc/weather.js</file>
+
+    <file>perf/core.js</file>
+    <file>perf/hwtest.js</file>
+
+    <file>ui/accessDialog.js</file>
+    <file>ui/altTab.js</file>
+    <file>ui/animation.js</file>
+    <file>ui/appDisplay.js</file>
+    <file>ui/appFavorites.js</file>
+    <file>ui/audioDeviceSelection.js</file>
+    <file>ui/backgroundMenu.js</file>
+    <file>ui/background.js</file>
+    <file>ui/barLevel.js</file>
+    <file>ui/boxpointer.js</file>
+    <file>ui/calendar.js</file>
+    <file>ui/checkBox.js</file>
+    <file>ui/closeDialog.js</file>
+    <file>ui/ctrlAltTab.js</file>
+    <file>ui/dash.js</file>
+    <file>ui/dateMenu.js</file>
+    <file>ui/dialog.js</file>
+    <file>ui/dnd.js</file>
+    <file>ui/edgeDragAction.js</file>
+    <file>ui/endSessionDialog.js</file>
+    <file>ui/environment.js</file>
+    <file>ui/extensionDownloader.js</file>
+    <file>ui/extensionSystem.js</file>
+    <file>ui/focusCaretTracker.js</file>
+    <file>ui/grabHelper.js</file>
+    <file>ui/ibusCandidatePopup.js</file>
+    <file>ui/iconGrid.js</file>
+    <file>ui/inhibitShortcutsDialog.js</file>
+    <file>ui/kbdA11yDialog.js</file>
+    <file>ui/keyboard.js</file>
+    <file>ui/layout.js</file>
+    <file>ui/lightbox.js</file>
+    <file>ui/locatePointer.js</file>
+    <file>ui/lookingGlass.js</file>
+    <file>ui/magnifier.js</file>
+    <file>ui/magnifierDBus.js</file>
+    <file>ui/main.js</file>
+    <file>ui/messageTray.js</file>
+    <file>ui/messageList.js</file>
+    <file>ui/modalDialog.js</file>
+    <file>ui/mpris.js</file>
+    <file>ui/notificationDaemon.js</file>
+    <file>ui/osdWindow.js</file>
+    <file>ui/osdMonitorLabeler.js</file>
+    <file>ui/overview.js</file>
+    <file>ui/overviewControls.js</file>
+    <file>ui/padOsd.js</file>
+    <file>ui/pageIndicators.js</file>
+    <file>ui/panel.js</file>
+    <file>ui/panelMenu.js</file>
+    <file>ui/pointerA11yTimeout.js</file>
+    <file>ui/pointerWatcher.js</file>
+    <file>ui/popupMenu.js</file>
+    <file>ui/remoteSearch.js</file>
+    <file>ui/ripples.js</file>
+    <file>ui/runDialog.js</file>
+    <file>ui/screenShield.js</file>
+    <file>ui/screencast.js</file>
+    <file>ui/screenshot.js</file>
+    <file>ui/scripting.js</file>
+    <file>ui/search.js</file>
+    <file>ui/sessionMode.js</file>
+    <file>ui/shellDBus.js</file>
+    <file>ui/shellEntry.js</file>
+    <file>ui/shellMountOperation.js</file>
+    <file>ui/slider.js</file>
+    <file>ui/swipeTracker.js</file>
+    <file>ui/switcherPopup.js</file>
+    <file>ui/switchMonitor.js</file>
+    <file>ui/tweener.js</file>
+    <file>ui/unlockDialog.js</file>
+    <file>ui/userWidget.js</file>
+    <file>ui/viewSelector.js</file>
+    <file>ui/windowAttentionHandler.js</file>
+    <file>ui/windowMenu.js</file>
+    <file>ui/windowManager.js</file>
+    <file>ui/workspace.js</file>
+    <file>ui/workspaceSwitcherPopup.js</file>
+    <file>ui/workspaceThumbnail.js</file>
+    <file>ui/workspacesView.js</file>
+    <file>ui/xdndHandler.js</file>
+
+    <file>ui/components/__init__.js</file>
+    <file>ui/components/autorunManager.js</file>
+    <file>ui/components/automountManager.js</file>
+    <file>ui/components/networkAgent.js</file>
+    <file>ui/components/polkitAgent.js</file>
+    <file>ui/components/telepathyClient.js</file>
+    <file>ui/components/keyring.js</file>
+
+    <file>ui/status/accessibility.js</file>
+    <file>ui/status/brightness.js</file>
+    <file>ui/status/dwellClick.js</file>
+    <file>ui/status/location.js</file>
+    <file>ui/status/keyboard.js</file>
+    <file>ui/status/nightLight.js</file>
+    <file>ui/status/network.js</file>
+    <file>ui/status/power.js</file>
+    <file>ui/status/rfkill.js</file>
+    <file>ui/status/volume.js</file>
+    <file>ui/status/bluetooth.js</file>
+    <file>ui/status/remoteAccess.js</file>
+    <file>ui/status/screencast.js</file>
+    <file>ui/status/system.js</file>
+    <file>ui/status/thunderbolt.js</file>
+  </gresource>
+</gresources>

js/meson.build

@@ -0,0 +1,22 @@
+subdir('misc')
+
+js_resources = gnome.compile_resources(
+  'js-resources', 'js-resources.gresource.xml',
+  source_dir: ['.', meson.current_build_dir()],
+  c_name: 'shell_js_resources',
+  dependencies: [config_js]
+)
+
+portal_resources = gnome.compile_resources(
+  'portal-resources', 'portal-resources.gresource.xml',
+  source_dir: ['.', meson.current_build_dir()],
+  c_name: 'portal_js_resources',
+  dependencies: [config_js]
+)
+
+prefs_resources = gnome.compile_resources(
+  'prefs-resources', 'prefs-resources.gresource.xml',
+  source_dir: ['.', meson.current_build_dir()],
+  c_name: 'prefs_js_resources',
+  dependencies: [config_js]
+)

js/misc/config.js.in

@@ -0,0 +1,20 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+
+/* The name of this package (not localized) */
+var PACKAGE_NAME = '@PACKAGE_NAME@';
+/* The version of this package */
+var PACKAGE_VERSION = '@PACKAGE_VERSION@';
+/* 1 if gnome-bluetooth is available, 0 otherwise */
+var HAVE_BLUETOOTH = @HAVE_BLUETOOTH@;
+/* 1 if networkmanager is available, 0 otherwise */
+var HAVE_NETWORKMANAGER = @HAVE_NETWORKMANAGER@;
+/* gettext package */
+var GETTEXT_PACKAGE = '@GETTEXT_PACKAGE@';
+/* locale dir */
+var LOCALEDIR = '@datadir@/locale';
+/* other standard directories */
+var LIBEXECDIR = '@libexecdir@';
+var PKGDATADIR = '@datadir@/@PACKAGE_NAME@';
+var VPNDIR = '@vpndir@';
+/* g-i package versions */
+var LIBMUTTER_API_VERSION = '@LIBMUTTER_API_VERSION@'

js/misc/extensionUtils.js

@@ -0,0 +1,247 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported ExtensionState, ExtensionType, getCurrentExtension,
+   getSettings, initTranslations, isOutOfDate, installImporter,
+   serializeExtension, deserializeExtension */
+
+// Common utils for the extension system and the extension
+// preferences tool
+
+const { Gio, GLib } = imports.gi;
+
+const Gettext = imports.gettext;
+const Lang = imports.lang;
+
+const Config = imports.misc.config;
+
+var ExtensionType = {
+    SYSTEM: 1,
+    PER_USER: 2,
+};
+
+var ExtensionState = {
+    ENABLED: 1,
+    DISABLED: 2,
+    ERROR: 3,
+    OUT_OF_DATE: 4,
+    DOWNLOADING: 5,
+    INITIALIZED: 6,
+
+    // Used as an error state for operations on unknown extensions,
+    // should never be in a real extensionMeta object.
+    UNINSTALLED: 99,
+};
+
+const SERIALIZED_PROPERTIES = [
+    'type',
+    'state',
+    'path',
+    'error',
+    'hasPrefs',
+    'hasUpdate',
+    'canChange',
+];
+
+/**
+ * getCurrentExtension:
+ *
+ * @returns {?object} - The current extension, or null if not called from
+ * an extension.
+ */
+function getCurrentExtension() {
+    let stack = new Error().stack.split('\n');
+    let extensionStackLine;
+
+    // Search for an occurrence of an extension stack frame
+    // Start at 1 because 0 is the stack frame of this function
+    for (let i = 1; i < stack.length; i++) {
+        if (stack[i].includes('/gnome-shell/extensions/')) {
+            extensionStackLine = stack[i];
+            break;
+        }
+    }
+    if (!extensionStackLine)
+        return null;
+
+    // The stack line is like:
+    //   init([object Object])@/home/user/data/gnome-shell/extensions/u@u.id/prefs.js:8
+    //
+    // In the case that we're importing from
+    // module scope, the first field is blank:
+    //   @/home/user/data/gnome-shell/extensions/u@u.id/prefs.js:8
+    let match = new RegExp('@(.+):\\d+').exec(extensionStackLine);
+    if (!match)
+        return null;
+
+    // local import, as the module is used from outside the gnome-shell process
+    // as well (not this function though)
+    let extensionManager = imports.ui.main.extensionManager;
+
+    let path = match[1];
+    let file = Gio.File.new_for_path(path);
+
+    // Walk up the directory tree, looking for an extension with
+    // the same UUID as a directory name.
+    while (file != null) {
+        let extension = extensionManager.lookup(file.get_basename());
+        if (extension !== undefined)
+            return extension;
+        file = file.get_parent();
+    }
+
+    return null;
+}
+
+/**
+ * initTranslations:
+ * @param {string=} domain - the gettext domain to use
+ *
+ * Initialize Gettext to load translations from extensionsdir/locale.
+ * If @domain is not provided, it will be taken from metadata['gettext-domain']
+ */
+function initTranslations(domain) {
+    let extension = getCurrentExtension();
+
+    if (!extension)
+        throw new Error('initTranslations() can only be called from extensions');
+
+    domain = domain || extension.metadata['gettext-domain'];
+
+    // Expect USER extensions to have a locale/ subfolder, otherwise assume a
+    // SYSTEM extension that has been installed in the same prefix as the shell
+    let localeDir = extension.dir.get_child('locale');
+    if (localeDir.query_exists(null))
+        Gettext.bindtextdomain(domain, localeDir.get_path());
+    else
+        Gettext.bindtextdomain(domain, Config.LOCALEDIR);
+}
+
+/**
+ * getSettings:
+ * @param {string=} schema - the GSettings schema id
+ * @returns {Gio.Settings} - a new settings object for @schema
+ *
+ * Builds and returns a GSettings schema for @schema, using schema files
+ * in extensionsdir/schemas. If @schema is omitted, it is taken from
+ * metadata['settings-schema'].
+ */
+function getSettings(schema) {
+    let extension = getCurrentExtension();
+
+    if (!extension)
+        throw new Error('getSettings() can only be called from extensions');
+
+    schema = schema || extension.metadata['settings-schema'];
+
+    const GioSSS = Gio.SettingsSchemaSource;
+
+    // Expect USER extensions to have a schemas/ subfolder, otherwise assume a
+    // SYSTEM extension that has been installed in the same prefix as the shell
+    let schemaDir = extension.dir.get_child('schemas');
+    let schemaSource;
+    if (schemaDir.query_exists(null)) {
+        schemaSource = GioSSS.new_from_directory(schemaDir.get_path(),
+                                                 GioSSS.get_default(),
+                                                 false);
+    } else {
+        schemaSource = GioSSS.get_default();
+    }
+
+    let schemaObj = schemaSource.lookup(schema, true);
+    if (!schemaObj)
+        throw new Error(`Schema ${schema} could not be found for extension ${extension.metadata.uuid}. Please check your installation`);
+
+    return new Gio.Settings({ settings_schema: schemaObj });
+}
+
+/**
+ * versionCheck:
+ * @param {string[]} required - an array of versions we're compatible with
+ * @param {string} current - the version we have
+ * @returns {bool} - true if @current is compatible with @required
+ *
+ * Check if a component is compatible for an extension.
+ * @required is an array, and at least one version must match.
+ * @current must be in the format <major>.<minor>.<point>.<micro>
+ * <micro> is always ignored
+ * <point> is ignored if <minor> is even (so you can target the
+ * whole stable release)
+ * <minor> and <major> must match
+ * Each target version must be at least <major> and <minor>
+ */
+function versionCheck(required, current) {
+    let currentArray = current.split('.');
+    let major = currentArray[0];
+    let minor = currentArray[1];
+    let point = currentArray[2];
+    for (let i = 0; i < required.length; i++) {
+        let requiredArray = required[i].split('.');
+        if (requiredArray[0] == major &&
+            requiredArray[1] == minor &&
+            ((requiredArray[2] === undefined && parseInt(minor) % 2 == 0) ||
+             requiredArray[2] == point))
+            return true;
+    }
+    return false;
+}
+
+function isOutOfDate(extension) {
+    if (!versionCheck(extension.metadata['shell-version'], Config.PACKAGE_VERSION))
+        return true;
+
+    return false;
+}
+
+function serializeExtension(extension) {
+    let obj = {};
+    Lang.copyProperties(extension.metadata, obj);
+
+    SERIALIZED_PROPERTIES.forEach(prop => {
+        obj[prop] = extension[prop];
+    });
+
+    let res = {};
+    for (let key in obj) {
+        let val = obj[key];
+        let type;
+        switch (typeof val) {
+        case 'string':
+            type = 's';
+            break;
+        case 'number':
+            type = 'd';
+            break;
+        case 'boolean':
+            type = 'b';
+            break;
+        default:
+            continue;
+        }
+        res[key] = GLib.Variant.new(type, val);
+    }
+
+    return res;
+}
+
+function deserializeExtension(variant) {
+    let res = { metadata: {} };
+    for (let prop in variant) {
+        let val = variant[prop].unpack();
+        if (SERIALIZED_PROPERTIES.includes(prop))
+            res[prop] = val;
+        else
+            res.metadata[prop] = val;
+    }
+    // add the 2 additional properties to create a valid extension object, as createExtensionObject()
+    res.uuid = res.metadata.uuid;
+    res.dir = Gio.File.new_for_path(res.path);
+    return res;
+}
+
+function installImporter(extension) {
+    let oldSearchPath = imports.searchPath.slice();  // make a copy
+    imports.searchPath = [extension.dir.get_parent().get_path()];
+    // importing a "subdir" creates a new importer object that doesn't affect
+    // the global one
+    extension.imports = imports[extension.uuid];
+    imports.searchPath = oldSearchPath;
+}

js/misc/fileUtils.js

@@ -0,0 +1,94 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported collectFromDatadirs, recursivelyDeleteDir,
+            recursivelyMoveDir, loadInterfaceXML */
+
+const { Gio, GLib } = imports.gi;
+const Config = imports.misc.config;
+
+function collectFromDatadirs(subdir, includeUserDir, processFile) {
+    let dataDirs = GLib.get_system_data_dirs();
+    if (includeUserDir)
+        dataDirs.unshift(GLib.get_user_data_dir());
+
+    for (let i = 0; i < dataDirs.length; i++) {
+        let path = GLib.build_filenamev([dataDirs[i], 'gnome-shell', subdir]);
+        let dir = Gio.File.new_for_path(path);
+
+        let fileEnum;
+        try {
+            fileEnum = dir.enumerate_children('standard::name,standard::type',
+                                              Gio.FileQueryInfoFlags.NONE, null);
+        } catch (e) {
+            fileEnum = null;
+        }
+        if (fileEnum != null) {
+            let info;
+            while ((info = fileEnum.next_file(null)))
+                processFile(fileEnum.get_child(info), info);
+        }
+    }
+}
+
+function recursivelyDeleteDir(dir, deleteParent) {
+    let children = dir.enumerate_children('standard::name,standard::type',
+                                          Gio.FileQueryInfoFlags.NONE, null);
+
+    let info;
+    while ((info = children.next_file(null)) != null) {
+        let type = info.get_file_type();
+        let child = dir.get_child(info.get_name());
+        if (type == Gio.FileType.REGULAR)
+            child.delete(null);
+        else if (type == Gio.FileType.DIRECTORY)
+            recursivelyDeleteDir(child, true);
+    }
+
+    if (deleteParent)
+        dir.delete(null);
+}
+
+function recursivelyMoveDir(srcDir, destDir) {
+    let children = srcDir.enumerate_children('standard::name,standard::type',
+                                             Gio.FileQueryInfoFlags.NONE, null);
+
+    if (!destDir.query_exists(null))
+        destDir.make_directory_with_parents(null);
+
+    let info;
+    while ((info = children.next_file(null)) != null) {
+        let type = info.get_file_type();
+        let srcChild = srcDir.get_child(info.get_name());
+        let destChild = destDir.get_child(info.get_name());
+        if (type == Gio.FileType.REGULAR)
+            srcChild.move(destChild, Gio.FileCopyFlags.NONE, null, null);
+        else if (type == Gio.FileType.DIRECTORY)
+            recursivelyMoveDir(srcChild, destChild);
+    }
+}
+
+let _ifaceResource = null;
+function loadInterfaceXML(iface) {
+    if (!_ifaceResource) {
+        // don't use global.datadir so the method is usable from tests/tools
+        let dir = GLib.getenv('GNOME_SHELL_DATADIR') || Config.PKGDATADIR;
+        let path = `${dir}/gnome-shell-dbus-interfaces.gresource`;
+        _ifaceResource = Gio.Resource.load(path);
+        _ifaceResource._register();
+    }
+
+    let xml = null;
+    let uri = `resource:///org/gnome/shell/dbus-interfaces/${iface}.xml`;
+    let f = Gio.File.new_for_uri(uri);
+
+    try {
+        let [ok_, bytes] = f.load_contents(null);
+        if (bytes instanceof Uint8Array)
+            xml = imports.byteArray.toString(bytes);
+        else
+            xml = bytes.toString();
+    } catch (e) {
+        log(`Failed to load D-Bus interface ${iface}`);
+    }
+
+    return xml;
+}

js/misc/gnomeSession.js

@@ -0,0 +1,37 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported PresenceStatus, Presence, Inhibitor, SessionManager */
+
+const Gio = imports.gi.Gio;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const PresenceIface = loadInterfaceXML('org.gnome.SessionManager.Presence');
+
+var PresenceStatus = {
+    AVAILABLE: 0,
+    INVISIBLE: 1,
+    BUSY: 2,
+    IDLE: 3,
+};
+
+var PresenceProxy = Gio.DBusProxy.makeProxyWrapper(PresenceIface);
+function Presence(initCallback, cancellable) {
+    return new PresenceProxy(Gio.DBus.session, 'org.gnome.SessionManager',
+                             '/org/gnome/SessionManager/Presence', initCallback, cancellable);
+}
+
+// Note inhibitors are immutable objects, so they don't
+// change at runtime (changes always come in the form
+// of new inhibitors)
+const InhibitorIface = loadInterfaceXML('org.gnome.SessionManager.Inhibitor');
+var InhibitorProxy = Gio.DBusProxy.makeProxyWrapper(InhibitorIface);
+function Inhibitor(objectPath, initCallback, cancellable) {
+    return new InhibitorProxy(Gio.DBus.session, 'org.gnome.SessionManager', objectPath, initCallback, cancellable);
+}
+
+// Not the full interface, only the methods we use
+const SessionManagerIface = loadInterfaceXML('org.gnome.SessionManager');
+var SessionManagerProxy = Gio.DBusProxy.makeProxyWrapper(SessionManagerIface);
+function SessionManager(initCallback, cancellable) {
+    return new SessionManagerProxy(Gio.DBus.session, 'org.gnome.SessionManager', '/org/gnome/SessionManager', initCallback, cancellable);
+}

js/misc/history.js

@@ -0,0 +1,109 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+
+const Signals = imports.signals;
+const Clutter = imports.gi.Clutter;
+const Params = imports.misc.params;
+
+var DEFAULT_LIMIT = 512;
+
+var HistoryManager = class {
+    constructor(params) {
+        params = Params.parse(params, { gsettingsKey: null,
+                                        limit: DEFAULT_LIMIT,
+                                        entry: null });
+
+        this._key = params.gsettingsKey;
+        this._limit = params.limit;
+
+        this._historyIndex = 0;
+        if (this._key) {
+            this._history = global.settings.get_strv(this._key);
+            global.settings.connect(`changed::${this._key}`,
+                                    this._historyChanged.bind(this));
+
+        } else {
+            this._history = [];
+        }
+
+        this._entry = params.entry;
+
+        if (this._entry) {
+            this._entry.connect('key-press-event',
+                                this._onEntryKeyPress.bind(this));
+        }
+    }
+
+    _historyChanged() {
+        this._history = global.settings.get_strv(this._key);
+        this._historyIndex = this._history.length;
+    }
+
+    _setPrevItem(text) {
+        if (this._historyIndex <= 0)
+            return false;
+
+        if (text)
+            this._history[this._historyIndex] = text;
+        this._historyIndex--;
+        this._indexChanged();
+        return true;
+    }
+
+    _setNextItem(text) {
+        if (this._historyIndex >= this._history.length)
+            return false;
+
+        if (text)
+            this._history[this._historyIndex] = text;
+        this._historyIndex++;
+        this._indexChanged();
+        return true;
+    }
+
+    lastItem() {
+        if (this._historyIndex != this._history.length) {
+            this._historyIndex = this._history.length;
+            this._indexChanged();
+        }
+
+        return this._historyIndex ? this._history[this._historyIndex - 1] : null;
+    }
+
+    addItem(input) {
+        if (this._history.length == 0 ||
+            this._history[this._history.length - 1] != input) {
+
+            this._history = this._history.filter(entry => entry != input);
+            this._history.push(input);
+            this._save();
+        }
+        this._historyIndex = this._history.length;
+    }
+
+    _onEntryKeyPress(entry, event) {
+        let symbol = event.get_key_symbol();
+        if (symbol == Clutter.KEY_Up)
+            return this._setPrevItem(entry.get_text());
+        else if (symbol == Clutter.KEY_Down)
+            return this._setNextItem(entry.get_text());
+
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    _indexChanged() {
+        let current = this._history[this._historyIndex] || '';
+        this.emit('changed', current);
+
+        if (this._entry)
+            this._entry.set_text(current);
+    }
+
+    _save() {
+        if (this._history.length > this._limit)
+            this._history.splice(0, this._history.length - this._limit);
+
+        if (this._key)
+            global.settings.set_strv(this._key, this._history);
+    }
+};
+Signals.addSignalMethods(HistoryManager.prototype);

js/misc/ibusManager.js

@@ -0,0 +1,275 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported getIBusManager */
+
+const { Gio, GLib, IBus } = imports.gi;
+const Signals = imports.signals;
+
+const IBusCandidatePopup = imports.ui.ibusCandidatePopup;
+
+// Ensure runtime version matches
+_checkIBusVersion(1, 5, 2);
+
+let _ibusManager = null;
+
+function _checkIBusVersion(requiredMajor, requiredMinor, requiredMicro) {
+    if ((IBus.MAJOR_VERSION > requiredMajor) ||
+        (IBus.MAJOR_VERSION == requiredMajor && IBus.MINOR_VERSION > requiredMinor) ||
+        (IBus.MAJOR_VERSION == requiredMajor && IBus.MINOR_VERSION == requiredMinor &&
+         IBus.MICRO_VERSION >= requiredMicro))
+        return;
+
+    throw "Found IBus version %d.%d.%d but required is %d.%d.%d"
+        .format(IBus.MAJOR_VERSION, IBus.MINOR_VERSION, IBus.MINOR_VERSION,
+                requiredMajor, requiredMinor, requiredMicro);
+}
+
+function getIBusManager() {
+    if (_ibusManager == null)
+        _ibusManager = new IBusManager();
+    return _ibusManager;
+}
+
+var IBusManager = class {
+    constructor() {
+        IBus.init();
+
+        // This is the longest we'll keep the keyboard frozen until an input
+        // source is active.
+        this._MAX_INPUT_SOURCE_ACTIVATION_TIME = 4000; // ms
+        this._PRELOAD_ENGINES_DELAY_TIME = 30; // sec
+
+
+        this._candidatePopup = new IBusCandidatePopup.CandidatePopup();
+
+        this._panelService = null;
+        this._engines = new Map();
+        this._ready = false;
+        this._registerPropertiesId = 0;
+        this._currentEngineName = null;
+        this._preloadEnginesId = 0;
+
+        this._ibus = IBus.Bus.new_async();
+        this._ibus.connect('connected', this._onConnected.bind(this));
+        this._ibus.connect('disconnected', this._clear.bind(this));
+        // Need to set this to get 'global-engine-changed' emitions
+        this._ibus.set_watch_ibus_signal(true);
+        this._ibus.connect('global-engine-changed', this._engineChanged.bind(this));
+
+        this._spawn();
+    }
+
+    _spawn(extraArgs = []) {
+        try {
+            let cmdLine = ['ibus-daemon', '--panel', 'disable', ...extraArgs];
+            let launcher = Gio.SubprocessLauncher.new(Gio.SubprocessFlags.NONE);
+            // Forward the right X11 Display for ibus-x11
+            let display = GLib.getenv('GNOME_SETUP_DISPLAY');
+            if (display)
+                launcher.setenv('DISPLAY', display, true);
+            launcher.launch(cmdLine);
+        } catch (e) {
+            log(`Failed to launch ibus-daemon: ${e.message}`);
+        }
+    }
+
+    restartDaemon(extraArgs = []) {
+        this._spawn(['-r', ...extraArgs]);
+    }
+
+    _clear() {
+        if (this._cancellable) {
+            this._cancellable.cancel();
+            this._cancellable = null;
+        }
+
+        if (this._preloadEnginesId) {
+            GLib.source_remove(this._preloadEnginesId);
+            this._preloadEnginesId = 0;
+        }
+
+        if (this._panelService)
+            this._panelService.destroy();
+
+        this._panelService = null;
+        this._candidatePopup.setPanelService(null);
+        this._engines.clear();
+        this._ready = false;
+        this._registerPropertiesId = 0;
+        this._currentEngineName = null;
+
+        this.emit('ready', false);
+    }
+
+    _onConnected() {
+        this._cancellable = new Gio.Cancellable();
+        this._ibus.list_engines_async(-1, this._cancellable,
+            this._initEngines.bind(this));
+        this._ibus.request_name_async(IBus.SERVICE_PANEL,
+            IBus.BusNameFlag.REPLACE_EXISTING, -1, this._cancellable,
+            this._initPanelService.bind(this));
+    }
+
+    _initEngines(ibus, result) {
+        try {
+            let enginesList = this._ibus.list_engines_async_finish(result);
+            for (let i = 0; i < enginesList.length; ++i) {
+                let name = enginesList[i].get_name();
+                this._engines.set(name, enginesList[i]);
+            }
+            this._updateReadiness();
+        } catch (e) {
+            if (e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+                return;
+
+            logError(e);
+            this._clear();
+        }
+    }
+
+    _initPanelService(ibus, result) {
+        let success = false;
+        try {
+            success = !!this._ibus.request_name_async_finish(result);
+        } catch (e) {
+            if (e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+                return;
+            logError(e);
+        }
+
+        if (success) {
+            this._panelService = new IBus.PanelService({ connection: this._ibus.get_connection(),
+                                                         object_path: IBus.PATH_PANEL });
+            this._candidatePopup.setPanelService(this._panelService);
+            this._panelService.connect('update-property', this._updateProperty.bind(this));
+            this._panelService.connect('set-cursor-location', (ps, x, y, w, h) => {
+                let cursorLocation = { x, y, width: w, height: h };
+                this.emit('set-cursor-location', cursorLocation);
+            });
+            this._panelService.connect('focus-in', (panel, path) => {
+                if (!GLib.str_has_suffix(path, '/InputContext_1'))
+                    this.emit('focus-in');
+            });
+            this._panelService.connect('focus-out', () => this.emit('focus-out'));
+
+            try {
+                // IBus versions older than 1.5.10 have a bug which
+                // causes spurious set-content-type emissions when
+                // switching input focus that temporarily lose purpose
+                // and hints defeating its intended semantics and
+                // confusing users. We thus don't use it in that case.
+                _checkIBusVersion(1, 5, 10);
+                this._panelService.connect('set-content-type', this._setContentType.bind(this));
+            } catch (e) {
+            }
+            // If an engine is already active we need to get its properties
+            this._ibus.get_global_engine_async(-1, this._cancellable, (_bus, res) => {
+                let engine;
+                try {
+                    engine = this._ibus.get_global_engine_async_finish(res);
+                    if (!engine)
+                        return;
+                } catch (e) {
+                    return;
+                }
+                this._engineChanged(this._ibus, engine.get_name());
+            });
+            this._updateReadiness();
+        } else {
+            this._clear();
+        }
+    }
+
+    _updateReadiness() {
+        this._ready = this._engines.size > 0 && this._panelService != null;
+        this.emit('ready', this._ready);
+    }
+
+    _engineChanged(bus, engineName) {
+        if (!this._ready)
+            return;
+
+        this._currentEngineName = engineName;
+
+        if (this._registerPropertiesId != 0)
+            return;
+
+        this._registerPropertiesId =
+            this._panelService.connect('register-properties', (p, props) => {
+                if (!props.get(0))
+                    return;
+
+                this._panelService.disconnect(this._registerPropertiesId);
+                this._registerPropertiesId = 0;
+
+                this.emit('properties-registered', this._currentEngineName, props);
+            });
+    }
+
+    _updateProperty(panel, prop) {
+        this.emit('property-updated', this._currentEngineName, prop);
+    }
+
+    _setContentType(panel, purpose, hints) {
+        this.emit('set-content-type', purpose, hints);
+    }
+
+    activateProperty(key, state) {
+        this._panelService.property_activate(key, state);
+    }
+
+    getEngineDesc(id) {
+        if (!this._ready || !this._engines.has(id))
+            return null;
+
+        return this._engines.get(id);
+    }
+
+    setEngine(id, callback) {
+        // Send id even if id == this._currentEngineName
+        // because 'properties-registered' signal can be emitted
+        // while this._ibusSources == null on a lock screen.
+        if (!this._ready) {
+            if (callback)
+                callback();
+            return;
+        }
+
+        this._ibus.set_global_engine_async(id,
+            this._MAX_INPUT_SOURCE_ACTIVATION_TIME,
+            this._cancellable, (_bus, res) => {
+                try {
+                    this._ibus.set_global_engine_async_finish(res);
+                } catch (e) {
+                    if (!e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+                        logError(e);
+                }
+                if (callback)
+                    callback();
+            });
+    }
+
+    preloadEngines(ids) {
+        if (!this._ibus || ids.length == 0)
+            return;
+
+        if (this._preloadEnginesId != 0) {
+            GLib.source_remove(this._preloadEnginesId);
+            this._preloadEnginesId = 0;
+        }
+
+        this._preloadEnginesId =
+            GLib.timeout_add_seconds(
+                GLib.PRIORITY_DEFAULT,
+                this._PRELOAD_ENGINES_DELAY_TIME,
+                () => {
+                    this._ibus.preload_engines_async(
+                        ids,
+                        -1,
+                        this._cancellable,
+                        null);
+                    this._preloadEnginesId = 0;
+                    return GLib.SOURCE_REMOVE;
+                });
+    }
+};
+Signals.addSignalMethods(IBusManager.prototype);

js/misc/inputMethod.js

@@ -0,0 +1,281 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported InputMethod */
+const { Clutter, GLib, Gio, GObject, IBus } = imports.gi;
+
+const Keyboard = imports.ui.status.keyboard;
+
+var HIDE_PANEL_TIME = 50;
+
+var InputMethod = GObject.registerClass(
+class InputMethod extends Clutter.InputMethod {
+    _init() {
+        super._init();
+        this._hints = 0;
+        this._purpose = 0;
+        this._currentFocus = null;
+        this._preeditStr = '';
+        this._preeditPos = 0;
+        this._preeditVisible = false;
+        this._hidePanelId = 0;
+        this._ibus = IBus.Bus.new_async();
+        this._ibus.connect('connected', this._onConnected.bind(this));
+        this._ibus.connect('disconnected', this._clear.bind(this));
+        this.connect('notify::can-show-preedit', this._updateCapabilities.bind(this));
+
+        this._inputSourceManager = Keyboard.getInputSourceManager();
+        this._sourceChangedId = this._inputSourceManager.connect('current-source-changed',
+                                                                 this._onSourceChanged.bind(this));
+        this._currentSource = this._inputSourceManager.currentSource;
+
+        if (this._ibus.is_connected())
+            this._onConnected();
+    }
+
+    get currentFocus() {
+        return this._currentFocus;
+    }
+
+    _updateCapabilities() {
+        let caps = IBus.Capabilite.PREEDIT_TEXT | IBus.Capabilite.FOCUS | IBus.Capabilite.SURROUNDING_TEXT;
+
+        if (this._context)
+            this._context.set_capabilities(caps);
+    }
+
+    _onSourceChanged() {
+        this._currentSource = this._inputSourceManager.currentSource;
+    }
+
+    _onConnected() {
+        this._cancellable = new Gio.Cancellable();
+        this._ibus.create_input_context_async('gnome-shell', -1,
+            this._cancellable, this._setContext.bind(this));
+    }
+
+    _setContext(bus, res) {
+        try {
+            this._context = this._ibus.create_input_context_async_finish(res);
+        } catch (e) {
+            if (!e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED)) {
+                logError(e);
+                this._clear();
+            }
+            return;
+        }
+
+        this._context.connect('commit-text', this._onCommitText.bind(this));
+        this._context.connect('delete-surrounding-text', this._onDeleteSurroundingText.bind(this));
+        this._context.connect('update-preedit-text', this._onUpdatePreeditText.bind(this));
+        this._context.connect('show-preedit-text', this._onShowPreeditText.bind(this));
+        this._context.connect('hide-preedit-text', this._onHidePreeditText.bind(this));
+        this._context.connect('forward-key-event', this._onForwardKeyEvent.bind(this));
+        this._context.connect('destroy', this._clear.bind(this));
+
+        this._updateCapabilities();
+    }
+
+    _clear() {
+        if (this._cancellable) {
+            this._cancellable.cancel();
+            this._cancellable = null;
+        }
+
+        this._context = null;
+        this._hints = 0;
+        this._purpose = 0;
+        this._preeditStr = '';
+        this._preeditPos = 0;
+        this._preeditVisible = false;
+    }
+
+    _emitRequestSurrounding() {
+        if (this._context.needs_surrounding_text())
+            this.emit('request-surrounding');
+    }
+
+    _onCommitText(_context, text) {
+        this.commit(text.get_text());
+    }
+
+    _onDeleteSurroundingText() {
+        this.delete_surrounding();
+    }
+
+    _onUpdatePreeditText(_context, text, pos, visible) {
+        if (text == null)
+            return;
+
+        let preedit = text.get_text();
+
+        if (visible)
+            this.set_preedit_text(preedit, pos);
+        else if (this._preeditVisible)
+            this.set_preedit_text(null, pos);
+
+        this._preeditStr = preedit;
+        this._preeditPos = pos;
+        this._preeditVisible = visible;
+    }
+
+    _onShowPreeditText() {
+        this._preeditVisible = true;
+        this.set_preedit_text(this._preeditStr, this._preeditPos);
+    }
+
+    _onHidePreeditText() {
+        this.set_preedit_text(null, this._preeditPos);
+        this._preeditVisible = false;
+    }
+
+    _onForwardKeyEvent(_context, keyval, keycode, state) {
+        let press = (state & IBus.ModifierType.RELEASE_MASK) == 0;
+        state &= ~IBus.ModifierType.RELEASE_MASK;
+
+        let curEvent = Clutter.get_current_event();
+        let time;
+        if (curEvent)
+            time = curEvent.get_time();
+        else
+            time = global.display.get_current_time_roundtrip();
+
+        this.forward_key(keyval, keycode + 8, state & Clutter.ModifierType.MODIFIER_MASK, time, press);
+    }
+
+    vfunc_focus_in(focus) {
+        this._currentFocus = focus;
+        if (this._context) {
+            this._context.focus_in();
+            this._emitRequestSurrounding();
+        }
+
+        if (this._hidePanelId) {
+            GLib.source_remove(this._hidePanelId);
+            this._hidePanelId = 0;
+        }
+    }
+
+    vfunc_focus_out() {
+        this._currentFocus = null;
+        if (this._context)
+            this._context.focus_out();
+
+        if (this._preeditStr) {
+            // Unset any preedit text
+            this.set_preedit_text(null, 0);
+            this._preeditStr = null;
+        }
+
+        this._hidePanelId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, HIDE_PANEL_TIME, () => {
+            this.set_input_panel_state(Clutter.InputPanelState.OFF);
+            this._hidePanelId = 0;
+            return GLib.SOURCE_REMOVE;
+        });
+    }
+
+    vfunc_reset() {
+        if (this._context) {
+            this._context.reset();
+            this._emitRequestSurrounding();
+        }
+
+        if (this._preeditStr) {
+            // Unset any preedit text
+            this.set_preedit_text(null, 0);
+            this._preeditStr = null;
+        }
+    }
+
+    vfunc_set_cursor_location(rect) {
+        if (this._context) {
+            this._context.set_cursor_location(rect.get_x(), rect.get_y(),
+                                              rect.get_width(), rect.get_height());
+            this._emitRequestSurrounding();
+        }
+    }
+
+    vfunc_set_surrounding(text, cursor, anchor) {
+        if (!this._context || !text)
+            return;
+
+        let ibusText = IBus.Text.new_from_string(text);
+        this._context.set_surrounding_text(ibusText, cursor, anchor);
+    }
+
+    vfunc_update_content_hints(hints) {
+        let ibusHints = 0;
+        if (hints & Clutter.InputContentHintFlags.COMPLETION)
+            ibusHints |= IBus.InputHints.WORD_COMPLETION;
+        if (hints & Clutter.InputContentHintFlags.SPELLCHECK)
+            ibusHints |= IBus.InputHints.SPELLCHECK;
+        if (hints & Clutter.InputContentHintFlags.AUTO_CAPITALIZATION)
+            ibusHints |= IBus.InputHints.UPPERCASE_SENTENCES;
+        if (hints & Clutter.InputContentHintFlags.LOWERCASE)
+            ibusHints |= IBus.InputHints.LOWERCASE;
+        if (hints & Clutter.InputContentHintFlags.UPPERCASE)
+            ibusHints |= IBus.InputHints.UPPERCASE_CHARS;
+        if (hints & Clutter.InputContentHintFlags.TITLECASE)
+            ibusHints |= IBus.InputHints.UPPERCASE_WORDS;
+
+        this._hints = ibusHints;
+        if (this._context)
+            this._context.set_content_type(this._purpose, this._hints);
+    }
+
+    vfunc_update_content_purpose(purpose) {
+        let ibusPurpose = 0;
+        if (purpose == Clutter.InputContentPurpose.NORMAL)
+            ibusPurpose = IBus.InputPurpose.FREE_FORM;
+        else if (purpose == Clutter.InputContentPurpose.ALPHA)
+            ibusPurpose = IBus.InputPurpose.ALPHA;
+        else if (purpose == Clutter.InputContentPurpose.DIGITS)
+            ibusPurpose = IBus.InputPurpose.DIGITS;
+        else if (purpose == Clutter.InputContentPurpose.NUMBER)
+            ibusPurpose = IBus.InputPurpose.NUMBER;
+        else if (purpose == Clutter.InputContentPurpose.PHONE)
+            ibusPurpose = IBus.InputPurpose.PHONE;
+        else if (purpose == Clutter.InputContentPurpose.URL)
+            ibusPurpose = IBus.InputPurpose.URL;
+        else if (purpose == Clutter.InputContentPurpose.EMAIL)
+            ibusPurpose = IBus.InputPurpose.EMAIL;
+        else if (purpose == Clutter.InputContentPurpose.NAME)
+            ibusPurpose = IBus.InputPurpose.NAME;
+        else if (purpose == Clutter.InputContentPurpose.PASSWORD)
+            ibusPurpose = IBus.InputPurpose.PASSWORD;
+
+        this._purpose = ibusPurpose;
+        if (this._context)
+            this._context.set_content_type(this._purpose, this._hints);
+    }
+
+    vfunc_filter_key_event(event) {
+        if (!this._context)
+            return false;
+        if (!this._currentSource)
+            return false;
+
+        let state = event.get_state();
+        if (state & IBus.ModifierType.IGNORED_MASK)
+            return false;
+
+        if (event.type() == Clutter.EventType.KEY_RELEASE)
+            state |= IBus.ModifierType.RELEASE_MASK;
+
+        this._context.process_key_event_async(
+            event.get_key_symbol(),
+            event.get_key_code() - 8, // Convert XKB keycodes to evcodes
+            state, -1, this._cancellable,
+            (context, res) => {
+                if (context != this._context)
+                    return;
+
+                try {
+                    let retval = context.process_key_event_async_finish(res);
+                    this.notify_key_event(event, retval);
+                } catch (e) {
+                    if (!e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+                        log(`Error processing key on IM: ${e.message}`);
+                }
+            });
+        return true;
+    }
+});

js/misc/introspect.js

@@ -0,0 +1,219 @@
+/* exported IntrospectService */
+const { Gio, GLib, Meta, Shell, St } = imports.gi;
+
+const INTROSPECT_SCHEMA = 'org.gnome.shell';
+const INTROSPECT_KEY = 'introspect';
+const APP_WHITELIST = ['org.freedesktop.impl.portal.desktop.gtk'];
+
+const INTROSPECT_DBUS_API_VERSION = 2;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const IntrospectDBusIface = loadInterfaceXML('org.gnome.Shell.Introspect');
+
+var IntrospectService = class {
+    constructor() {
+        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(IntrospectDBusIface,
+                                                             this);
+        this._dbusImpl.export(Gio.DBus.session, '/org/gnome/Shell/Introspect');
+        Gio.DBus.session.own_name('org.gnome.Shell.Introspect',
+                                  Gio.BusNameOwnerFlags.REPLACE,
+                                  null, null);
+
+        this._runningApplications = {};
+        this._runningApplicationsDirty = true;
+        this._activeApplication = null;
+        this._activeApplicationDirty = true;
+        this._animationsEnabled = true;
+
+        this._appSystem = Shell.AppSystem.get_default();
+        this._appSystem.connect('app-state-changed',
+                                () => {
+                                    this._runningApplicationsDirty = true;
+                                    this._syncRunningApplications();
+                                });
+
+        this._introspectSettings = new Gio.Settings({
+            schema_id: INTROSPECT_SCHEMA,
+        });
+
+        let tracker = Shell.WindowTracker.get_default();
+        tracker.connect('notify::focus-app',
+                        () => {
+                            this._activeApplicationDirty = true;
+                            this._syncRunningApplications();
+                        });
+
+        this._syncRunningApplications();
+
+        this._whitelistMap = new Map();
+        APP_WHITELIST.forEach(appName => {
+            Gio.DBus.watch_name(Gio.BusType.SESSION,
+                appName,
+                Gio.BusNameWatcherFlags.NONE,
+                (conn, name, owner) => this._whitelistMap.set(name, owner),
+                (conn, name) => this._whitelistMap.delete(name));
+        });
+
+        this._settings = St.Settings.get();
+        this._settings.connect('notify::enable-animations',
+            this._syncAnimationsEnabled.bind(this));
+        this._syncAnimationsEnabled();
+    }
+
+    _isStandaloneApp(app) {
+        return app.get_windows().some(w => w.transient_for == null);
+    }
+
+    _isIntrospectEnabled() {
+        return this._introspectSettings.get_boolean(INTROSPECT_KEY);
+    }
+
+    _isSenderWhitelisted(sender) {
+        return [...this._whitelistMap.values()].includes(sender);
+    }
+
+    _getSandboxedAppId(app) {
+        let ids = app.get_windows().map(w => w.get_sandboxed_app_id());
+        return ids.find(id => id != null);
+    }
+
+    _syncRunningApplications() {
+        let tracker = Shell.WindowTracker.get_default();
+        let apps = this._appSystem.get_running();
+        let seatName = "seat0";
+        let newRunningApplications = {};
+
+        let newActiveApplication = null;
+        let focusedApp = tracker.focus_app;
+
+        for (let app of apps) {
+            let appInfo = {};
+            let isAppActive = focusedApp == app;
+
+            if (!this._isStandaloneApp(app))
+                continue;
+
+            if (isAppActive) {
+                appInfo['active-on-seats'] = new GLib.Variant('as', [seatName]);
+                newActiveApplication = app.get_id();
+            }
+
+            let sandboxedAppId = this._getSandboxedAppId(app);
+            if (sandboxedAppId)
+                appInfo['sandboxed-app-id'] = new GLib.Variant('s', sandboxedAppId);
+
+            newRunningApplications[app.get_id()] = appInfo;
+        }
+
+        if (this._runningApplicationsDirty ||
+            (this._activeApplicationDirty &&
+             this._activeApplication != newActiveApplication)) {
+            this._runningApplications = newRunningApplications;
+            this._activeApplication = newActiveApplication;
+
+            this._dbusImpl.emit_signal('RunningApplicationsChanged', null);
+        }
+        this._runningApplicationsDirty = false;
+        this._activeApplicationDirty = false;
+    }
+
+    _isEligibleWindow(window) {
+        if (window.is_override_redirect())
+            return false;
+
+        let type = window.get_window_type();
+        return type == Meta.WindowType.NORMAL ||
+                type == Meta.WindowType.DIALOG ||
+                type == Meta.WindowType.MODAL_DIALOG ||
+                type == Meta.WindowType.UTILITY;
+    }
+
+    _isInvocationAllowed(invocation) {
+        if (this._isIntrospectEnabled())
+            return true;
+
+        if (this._isSenderWhitelisted(invocation.get_sender()))
+            return true;
+
+        return false;
+    }
+
+    GetRunningApplicationsAsync(params, invocation) {
+        if (!this._isInvocationAllowed(invocation)) {
+            invocation.return_error_literal(Gio.DBusError,
+                                            Gio.DBusError.ACCESS_DENIED,
+                                            'App introspection not allowed');
+            return;
+        }
+
+        invocation.return_value(new GLib.Variant('(a{sa{sv}})', [this._runningApplications]));
+    }
+
+    GetWindowsAsync(params, invocation) {
+        let focusWindow = global.display.get_focus_window();
+        let apps = this._appSystem.get_running();
+        let windowsList = {};
+
+        if (!this._isInvocationAllowed(invocation)) {
+            invocation.return_error_literal(Gio.DBusError,
+                                            Gio.DBusError.ACCESS_DENIED,
+                                            'App introspection not allowed');
+            return;
+        }
+
+        for (let app of apps) {
+            let windows = app.get_windows();
+            for (let window of windows) {
+
+                if (!this._isEligibleWindow(window))
+                    continue;
+
+                let windowId = window.get_id();
+                let frameRect = window.get_frame_rect();
+                let title = window.get_title();
+                let wmClass = window.get_wm_class();
+                let sandboxedAppId = window.get_sandboxed_app_id();
+
+                windowsList[windowId] = {
+                    'app-id': GLib.Variant.new('s', app.get_id()),
+                    'client-type': GLib.Variant.new('u', window.get_client_type()),
+                    'is-hidden': GLib.Variant.new('b', window.is_hidden()),
+                    'has-focus': GLib.Variant.new('b', window == focusWindow),
+                    'width': GLib.Variant.new('u', frameRect.width),
+                    'height': GLib.Variant.new('u', frameRect.height),
+                };
+
+                // These properties may not be available for all windows:
+                if (title != null)
+                    windowsList[windowId]['title'] = GLib.Variant.new('s', title);
+
+                if (wmClass != null)
+                    windowsList[windowId]['wm-class'] = GLib.Variant.new('s', wmClass);
+
+                if (sandboxedAppId != null) {
+                    windowsList[windowId]['sandboxed-app-id'] =
+                        GLib.Variant.new('s', sandboxedAppId);
+                }
+            }
+        }
+        invocation.return_value(new GLib.Variant('(a{ta{sv}})', [windowsList]));
+    }
+
+    _syncAnimationsEnabled() {
+        let wasAnimationsEnabled = this._animationsEnabled;
+        this._animationsEnabled = this._settings.enable_animations;
+        if (wasAnimationsEnabled !== this._animationsEnabled) {
+            let variant = new GLib.Variant('b', this._animationsEnabled);
+            this._dbusImpl.emit_property_changed('AnimationsEnabled', variant);
+        }
+    }
+
+    get AnimationsEnabled() {
+        return this._animationsEnabled;
+    }
+
+    get version() {
+        return INTROSPECT_DBUS_API_VERSION;
+    }
+};

js/misc/jsParse.js

@@ -0,0 +1,239 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* exported getCompletions, getCommonPrefix, getDeclaredConstants */
+
+// Returns a list of potential completions for text. Completions either
+// follow a dot (e.g. foo.ba -> bar) or they are picked from globalCompletionList (e.g. fo -> foo)
+// commandHeader is prefixed on any expression before it is eval'ed.  It will most likely
+// consist of global constants that might not carry over from the calling environment.
+//
+// This function is likely the one you want to call from external modules
+function getCompletions(text, commandHeader, globalCompletionList) {
+    let methods = [];
+    let expr_, base;
+    let attrHead = '';
+    if (globalCompletionList == null)
+        globalCompletionList = [];
+
+    let offset = getExpressionOffset(text, text.length - 1);
+    if (offset >= 0) {
+        text = text.slice(offset);
+
+        // Look for expressions like "Main.panel.foo" and match Main.panel and foo
+        let matches = text.match(/(.*)\.(.*)/);
+        if (matches) {
+            [expr_, base, attrHead] = matches;
+
+            methods = getPropertyNamesFromExpression(base, commandHeader).filter(
+                attr => attr.slice(0, attrHead.length) == attrHead
+            );
+        }
+
+        // Look for the empty expression or partially entered words
+        // not proceeded by a dot and match them against global constants
+        matches = text.match(/^(\w*)$/);
+        if (text == '' || matches) {
+            [expr_, attrHead] = matches;
+            methods = globalCompletionList.filter(
+                attr => attr.slice(0, attrHead.length) == attrHead
+            );
+        }
+    }
+
+    return [methods, attrHead];
+}
+
+
+//
+// A few functions for parsing strings of javascript code.
+//
+
+// Identify characters that delimit an expression.  That is,
+// if we encounter anything that isn't a letter, '.', ')', or ']',
+// we should stop parsing.
+function isStopChar(c) {
+    return !c.match(/[\w.)\]]/);
+}
+
+// Given the ending position of a quoted string, find where it starts
+function findMatchingQuote(expr, offset) {
+    let quoteChar = expr.charAt(offset);
+    for (let i = offset - 1; i >= 0; --i) {
+        if (expr.charAt(i) == quoteChar && expr.charAt(i - 1) != '\\')
+            return i;
+    }
+    return -1;
+}
+
+// Given the ending position of a regex, find where it starts
+function findMatchingSlash(expr, offset) {
+    for (let i = offset - 1; i >= 0; --i) {
+        if (expr.charAt(i) == '/' && expr.charAt(i - 1) != '\\')
+            return i;
+    }
+    return -1;
+}
+
+// If expr.charAt(offset) is ')' or ']',
+// return the position of the corresponding '(' or '[' bracket.
+// This function does not check for syntactic correctness.  e.g.,
+// findMatchingBrace("[(])", 3) returns 1.
+function findMatchingBrace(expr, offset) {
+    let closeBrace = expr.charAt(offset);
+    let openBrace = { ')': '(', ']': '[' }[closeBrace];
+
+    return findTheBrace(expr, offset - 1, openBrace, closeBrace);
+}
+
+function findTheBrace(expr, offset, ...braces) {
+    let [openBrace, closeBrace] = braces;
+
+    if (offset < 0)
+        return -1;
+
+    if (expr.charAt(offset) == openBrace)
+        return offset;
+
+    if (expr.charAt(offset).match(/['"]/))
+        return findTheBrace(expr, findMatchingQuote(expr, offset) - 1, ...braces);
+
+    if (expr.charAt(offset) == '/')
+        return findTheBrace(expr, findMatchingSlash(expr, offset) - 1, ...braces);
+
+    if (expr.charAt(offset) == closeBrace)
+        return findTheBrace(expr, findTheBrace(expr, offset - 1, ...braces) - 1, ...braces);
+
+    return findTheBrace(expr, offset - 1, ...braces);
+}
+
+// Walk expr backwards from offset looking for the beginning of an
+// expression suitable for passing to eval.
+// There is no guarantee of correct javascript syntax between the return
+// value and offset.  This function is meant to take a string like
+// "foo(Obj.We.Are.Completing" and allow you to extract "Obj.We.Are.Completing"
+function getExpressionOffset(expr, offset) {
+    while (offset >= 0) {
+        let currChar = expr.charAt(offset);
+
+        if (isStopChar(currChar))
+            return offset + 1;
+
+        if (currChar.match(/[)\]]/))
+            offset = findMatchingBrace(expr, offset);
+
+        --offset;
+    }
+
+    return offset + 1;
+}
+
+// Things with non-word characters or that start with a number
+// are not accessible via .foo notation and so aren't returned
+function isValidPropertyName(w) {
+    return !(w.match(/\W/) || w.match(/^\d/));
+}
+
+// To get all properties (enumerable and not), we need to walk
+// the prototype chain ourselves
+function getAllProps(obj) {
+    if (obj === null || obj === undefined)
+        return [];
+
+    return Object.getOwnPropertyNames(obj).concat(getAllProps(Object.getPrototypeOf(obj)));
+}
+
+// Given a string _expr_, returns all methods
+// that can be accessed via '.' notation.
+// e.g., expr="({ foo: null, bar: null, 4: null })" will
+// return ["foo", "bar", ...] but the list will not include "4",
+// since methods accessed with '.' notation must star with a letter or _.
+function getPropertyNamesFromExpression(expr, commandHeader = '') {
+    let obj = {};
+    if (!isUnsafeExpression(expr)) {
+        try {
+            obj = eval(commandHeader + expr);
+        } catch (e) {
+            return [];
+        }
+    } else {
+        return [];
+    }
+
+    let propsUnique = {};
+    if (typeof obj === 'object') {
+        let allProps = getAllProps(obj);
+        // Get only things we are allowed to complete following a '.'
+        allProps = allProps.filter(isValidPropertyName);
+
+        // Make sure propsUnique contains one key for every
+        // property so we end up with a unique list of properties
+        allProps.map(p => (propsUnique[p] = null));
+    }
+    return Object.keys(propsUnique).sort();
+}
+
+// Given a list of words, returns the longest prefix they all have in common
+function getCommonPrefix(words) {
+    let word = words[0];
+    for (let i = 0; i < word.length; i++) {
+        for (let w = 1; w < words.length; w++) {
+            if (words[w].charAt(i) != word.charAt(i))
+                return word.slice(0, i);
+        }
+    }
+    return word;
+}
+
+// Remove any blocks that are quoted or are in a regex
+function removeLiterals(str) {
+    if (str.length == 0)
+        return '';
+
+    let currChar = str.charAt(str.length - 1);
+    if (currChar == '"' || currChar == '\'') {
+        return removeLiterals(
+            str.slice(0, findMatchingQuote(str, str.length - 1)));
+    } else if (currChar == '/') {
+        return removeLiterals(
+            str.slice(0, findMatchingSlash(str, str.length - 1)));
+    }
+
+    return removeLiterals(str.slice(0, str.length - 1)) + currChar;
+}
+
+// Returns true if there is reason to think that eval(str)
+// will modify the global scope
+function isUnsafeExpression(str) {
+
+    // Check for any sort of assignment
+    // The strategy used is dumb: remove any quotes
+    // or regexs and comparison operators and see if there is an '=' character.
+    // If there is, it might be an unsafe assignment.
+
+    let prunedStr = removeLiterals(str);
+    prunedStr = prunedStr.replace(/[=!]==/g, '');    // replace === and !== with nothing
+    prunedStr = prunedStr.replace(/[=<>!]=/g, '');    // replace ==, <=, >=, != with nothing
+
+    if (prunedStr.match(/[=]/)) {
+        return true;
+    } else if (prunedStr.match(/;/)) {
+        // If we contain a semicolon not inside of a quote/regex, assume we're unsafe as well
+        return true;
+    }
+
+    return false;
+}
+
+// Returns a list of global keywords derived from str
+function getDeclaredConstants(str) {
+    let ret = [];
+    str.split(';').forEach(s => {
+        let base_, keyword;
+        let match = s.match(/const\s+(\w+)\s*=/);
+        if (match) {
+            [base_, keyword] = match;
+            ret.push(keyword);
+        }
+    });
+
+    return ret;
+}

js/misc/keyboardManager.js

@@ -0,0 +1,159 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported getKeyboardManager, holdKeyboard, releaseKeyboard */
+
+const { GLib, GnomeDesktop, Meta } = imports.gi;
+
+const Main = imports.ui.main;
+
+var DEFAULT_LOCALE = 'en_US';
+var DEFAULT_LAYOUT = 'us';
+var DEFAULT_VARIANT = '';
+
+let _xkbInfo = null;
+
+function getXkbInfo() {
+    if (_xkbInfo == null)
+        _xkbInfo = new GnomeDesktop.XkbInfo();
+    return _xkbInfo;
+}
+
+let _keyboardManager = null;
+
+function getKeyboardManager() {
+    if (_keyboardManager == null)
+        _keyboardManager = new KeyboardManager();
+    return _keyboardManager;
+}
+
+function releaseKeyboard() {
+    if (Main.modalCount > 0)
+        global.display.unfreeze_keyboard(global.get_current_time());
+    else
+        global.display.ungrab_keyboard(global.get_current_time());
+}
+
+function holdKeyboard() {
+    global.display.freeze_keyboard(global.get_current_time());
+}
+
+var KeyboardManager = class {
+    constructor() {
+        // The XKB protocol doesn't allow for more that 4 layouts in a
+        // keymap. Wayland doesn't impose this limit and libxkbcommon can
+        // handle up to 32 layouts but since we need to support X clients
+        // even as a Wayland compositor, we can't bump this.
+        this.MAX_LAYOUTS_PER_GROUP = 4;
+
+        this._xkbInfo = getXkbInfo();
+        this._current = null;
+        this._localeLayoutInfo = this._getLocaleLayout();
+        this._layoutInfos = {};
+        this._currentKeymap = null;
+    }
+
+    _applyLayoutGroup(group) {
+        let options = this._buildOptionsString();
+        let [layouts, variants] = this._buildGroupStrings(group);
+
+        if (this._currentKeymap &&
+            this._currentKeymap.layouts == layouts &&
+            this._currentKeymap.variants == variants &&
+            this._currentKeymap.options == options)
+            return;
+
+        this._currentKeymap = { layouts, variants, options };
+        Meta.get_backend().set_keymap(layouts, variants, options);
+    }
+
+    _applyLayoutGroupIndex(idx) {
+        Meta.get_backend().lock_layout_group(idx);
+    }
+
+    apply(id) {
+        let info = this._layoutInfos[id];
+        if (!info)
+            return;
+
+        if (this._current && this._current.group == info.group) {
+            if (this._current.groupIndex != info.groupIndex)
+                this._applyLayoutGroupIndex(info.groupIndex);
+        } else {
+            this._applyLayoutGroup(info.group);
+            this._applyLayoutGroupIndex(info.groupIndex);
+        }
+
+        this._current = info;
+    }
+
+    reapply() {
+        if (!this._current)
+            return;
+
+        this._applyLayoutGroup(this._current.group);
+        this._applyLayoutGroupIndex(this._current.groupIndex);
+    }
+
+    setUserLayouts(ids) {
+        this._current = null;
+        this._layoutInfos = {};
+
+        for (let i = 0; i < ids.length; ++i) {
+            let [found, , , _layout, _variant] = this._xkbInfo.get_layout_info(ids[i]);
+            if (found)
+                this._layoutInfos[ids[i]] = { id: ids[i], layout: _layout, variant: _variant };
+        }
+
+        let i = 0;
+        let group = [];
+        for (let id in this._layoutInfos) {
+            // We need to leave one slot on each group free so that we
+            // can add a layout containing the symbols for the
+            // language used in UI strings to ensure that toolkits can
+            // handle mnemonics like Alt+Ф even if the user is
+            // actually typing in a different layout.
+            let groupIndex = i % (this.MAX_LAYOUTS_PER_GROUP - 1);
+            if (groupIndex == 0)
+                group = [];
+
+            let info = this._layoutInfos[id];
+            group[groupIndex] = info;
+            info.group = group;
+            info.groupIndex = groupIndex;
+
+            i += 1;
+        }
+    }
+
+    _getLocaleLayout() {
+        let locale = GLib.get_language_names()[0];
+        if (!locale.includes('_'))
+            locale = DEFAULT_LOCALE;
+
+        let [found, , id] = GnomeDesktop.get_input_source_from_locale(locale);
+        if (!found)
+            [, , id] = GnomeDesktop.get_input_source_from_locale(DEFAULT_LOCALE);
+
+        let _layout, _variant;
+        [found, , , _layout, _variant] = this._xkbInfo.get_layout_info(id);
+        if (found)
+            return { layout: _layout, variant: _variant };
+        else
+            return { layout: DEFAULT_LAYOUT, variant: DEFAULT_VARIANT };
+    }
+
+    _buildGroupStrings(_group) {
+        let group = _group.concat(this._localeLayoutInfo);
+        let layouts = group.map(g => g.layout).join(',');
+        let variants = group.map(g => g.variant).join(',');
+        return [layouts, variants];
+    }
+
+    setKeyboardOptions(options) {
+        this._xkbOptions = options;
+    }
+
+    _buildOptionsString() {
+        let options = this._xkbOptions.join(',');
+        return options;
+    }
+};

js/misc/loginManager.js

@@ -0,0 +1,227 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported canLock, getLoginManager, registerSessionWithGDM */
+
+const { GLib, Gio } = imports.gi;
+const Signals = imports.signals;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const SystemdLoginManagerIface = loadInterfaceXML('org.freedesktop.login1.Manager');
+const SystemdLoginSessionIface = loadInterfaceXML('org.freedesktop.login1.Session');
+const SystemdLoginUserIface = loadInterfaceXML('org.freedesktop.login1.User');
+
+const SystemdLoginManager = Gio.DBusProxy.makeProxyWrapper(SystemdLoginManagerIface);
+const SystemdLoginSession = Gio.DBusProxy.makeProxyWrapper(SystemdLoginSessionIface);
+const SystemdLoginUser = Gio.DBusProxy.makeProxyWrapper(SystemdLoginUserIface);
+
+function haveSystemd() {
+    return GLib.access("/run/systemd/seats", 0) >= 0;
+}
+
+function versionCompare(required, reference) {
+    required = required.split('.');
+    reference = reference.split('.');
+
+    for (let i = 0; i < required.length; i++) {
+        let requiredInt = parseInt(required[i]);
+        let referenceInt = parseInt(reference[i]);
+        if (requiredInt != referenceInt)
+            return requiredInt < referenceInt;
+    }
+
+    return true;
+}
+
+function canLock() {
+    try {
+        let params = GLib.Variant.new('(ss)', ['org.gnome.DisplayManager.Manager', 'Version']);
+        let result = Gio.DBus.system.call_sync('org.gnome.DisplayManager',
+                                               '/org/gnome/DisplayManager/Manager',
+                                               'org.freedesktop.DBus.Properties',
+                                               'Get', params, null,
+                                               Gio.DBusCallFlags.NONE,
+                                               -1, null);
+
+        let version = result.deep_unpack()[0].deep_unpack();
+        return haveSystemd() && versionCompare('3.5.91', version);
+    } catch (e) {
+        return false;
+    }
+}
+
+
+function registerSessionWithGDM() {
+    log("Registering session with GDM");
+    Gio.DBus.system.call('org.gnome.DisplayManager',
+                         '/org/gnome/DisplayManager/Manager',
+                         'org.gnome.DisplayManager.Manager',
+                         'RegisterSession',
+                         GLib.Variant.new('(a{sv})', [{}]), null,
+                         Gio.DBusCallFlags.NONE, -1, null,
+        (source, result) => {
+            try {
+                source.call_finish(result);
+            } catch (e) {
+                if (!e.matches(Gio.DBusError, Gio.DBusError.UNKNOWN_METHOD))
+                    log(`Error registering session with GDM: ${e.message}`);
+                else
+                    log("Not calling RegisterSession(): method not exported, GDM too old?");
+            }
+        }
+    );
+}
+
+let _loginManager = null;
+
+/**
+ * getLoginManager:
+ * An abstraction over systemd/logind and ConsoleKit.
+ * @returns {object} - the LoginManager singleton
+ *
+ */
+function getLoginManager() {
+    if (_loginManager == null) {
+        if (haveSystemd())
+            _loginManager = new LoginManagerSystemd();
+        else
+            _loginManager = new LoginManagerDummy();
+    }
+
+    return _loginManager;
+}
+
+var LoginManagerSystemd = class {
+    constructor() {
+        this._proxy = new SystemdLoginManager(Gio.DBus.system,
+                                              'org.freedesktop.login1',
+                                              '/org/freedesktop/login1');
+        this._userProxy = new SystemdLoginUser(Gio.DBus.system,
+                                               'org.freedesktop.login1',
+                                               '/org/freedesktop/login1/user/self');
+        this._proxy.connectSignal('PrepareForSleep',
+                                  this._prepareForSleep.bind(this));
+    }
+
+    getCurrentSessionProxy(callback) {
+        if (this._currentSession) {
+            callback(this._currentSession);
+            return;
+        }
+
+        let sessionId = GLib.getenv('XDG_SESSION_ID');
+        if (!sessionId) {
+            log('Unset XDG_SESSION_ID, getCurrentSessionProxy() called outside a user session. Asking logind directly.');
+            let [session, objectPath] = this._userProxy.Display;
+            if (session) {
+                log(`Will monitor session ${session}`);
+                sessionId = session;
+            } else {
+                log('Failed to find "Display" session; are we the greeter?');
+
+                for ([session, objectPath] of this._userProxy.Sessions) {
+                    let sessionProxy = new SystemdLoginSession(Gio.DBus.system,
+                                                               'org.freedesktop.login1',
+                                                               objectPath);
+                    log(`Considering ${session}, class=${sessionProxy.Class}`);
+                    if (sessionProxy.Class == 'greeter') {
+                        log(`Yes, will monitor session ${session}`);
+                        sessionId = session;
+                        break;
+                    }
+                }
+
+                if (!sessionId) {
+                    log('No, failed to get session from logind.');
+                    return;
+                }
+            }
+        }
+
+        this._proxy.GetSessionRemote(sessionId, (result, error) => {
+            if (error) {
+                logError(error, 'Could not get a proxy for the current session');
+            } else {
+                this._currentSession = new SystemdLoginSession(Gio.DBus.system,
+                                                               'org.freedesktop.login1',
+                                                               result[0]);
+                callback(this._currentSession);
+            }
+        });
+    }
+
+    canSuspend(asyncCallback) {
+        this._proxy.CanSuspendRemote((result, error) => {
+            if (error) {
+                asyncCallback(false, false);
+            } else {
+                let needsAuth = result[0] == 'challenge';
+                let canSuspend = needsAuth || result[0] == 'yes';
+                asyncCallback(canSuspend, needsAuth);
+            }
+        });
+    }
+
+    listSessions(asyncCallback) {
+        this._proxy.ListSessionsRemote((result, error) => {
+            if (error)
+                asyncCallback([]);
+            else
+                asyncCallback(result[0]);
+        });
+    }
+
+    suspend() {
+        this._proxy.SuspendRemote(true);
+    }
+
+    inhibit(reason, callback) {
+        let inVariant = GLib.Variant.new('(ssss)',
+                                         ['sleep',
+                                          'GNOME Shell',
+                                          reason,
+                                          'delay']);
+        this._proxy.call_with_unix_fd_list('Inhibit', inVariant, 0, -1, null, null,
+            (proxy, result) => {
+                let fd = -1;
+                try {
+                    let [outVariant_, fdList] = proxy.call_with_unix_fd_list_finish(result);
+                    fd = fdList.steal_fds()[0];
+                    callback(new Gio.UnixInputStream({ fd }));
+                } catch (e) {
+                    logError(e, "Error getting systemd inhibitor");
+                    callback(null);
+                }
+            });
+    }
+
+    _prepareForSleep(proxy, sender, [aboutToSuspend]) {
+        this.emit('prepare-for-sleep', aboutToSuspend);
+    }
+};
+Signals.addSignalMethods(LoginManagerSystemd.prototype);
+
+var LoginManagerDummy = class {
+    getCurrentSessionProxy(_callback) {
+        // we could return a DummySession object that fakes whatever callers
+        // expect (at the time of writing: connect() and connectSignal()
+        // methods), but just never calling the callback should be safer
+    }
+
+    canSuspend(asyncCallback) {
+        asyncCallback(false, false);
+    }
+
+    listSessions(asyncCallback) {
+        asyncCallback([]);
+    }
+
+    suspend() {
+        this.emit('prepare-for-sleep', true);
+        this.emit('prepare-for-sleep', false);
+    }
+
+    inhibit(reason, callback) {
+        callback(null);
+    }
+};
+Signals.addSignalMethods(LoginManagerDummy.prototype);

js/misc/meson.build

@@ -0,0 +1,16 @@
+jsconf = configuration_data()
+jsconf.set('PACKAGE_NAME', meson.project_name())
+jsconf.set('PACKAGE_VERSION', meson.project_version())
+jsconf.set('GETTEXT_PACKAGE', meson.project_name())
+jsconf.set('LIBMUTTER_API_VERSION', mutter_api_version)
+jsconf.set10('HAVE_BLUETOOTH', bt_dep.found())
+jsconf.set10('HAVE_NETWORKMANAGER', have_networkmanager)
+jsconf.set('datadir', datadir)
+jsconf.set('libexecdir', libexecdir)
+jsconf.set('vpndir', vpndir)
+
+config_js = configure_file(
+  input: 'config.js.in',
+  output: 'config.js',
+  configuration: jsconf
+)

js/misc/modemManager.js

@@ -0,0 +1,282 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported ModemBase, ModemGsm, ModemCdma, BroadbandModem  */
+
+const { Gio, GObject, NM, NMA } = imports.gi;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+// _getMobileProvidersDatabase:
+//
+// Gets the database of mobile providers, with references between MCCMNC/SID and
+// operator name
+//
+let _mpd;
+function _getMobileProvidersDatabase() {
+    if (_mpd == null) {
+        try {
+            _mpd = new NMA.MobileProvidersDatabase();
+            _mpd.init(null);
+        } catch (e) {
+            log(e.message);
+            _mpd = null;
+        }
+    }
+
+    return _mpd;
+}
+
+// _findProviderForMccMnc:
+// @operatorName: operator name
+// @operatorCode: operator code
+//
+// Given an operator name string (which may not be a real operator name) and an
+// operator code string, tries to find a proper operator name to display.
+//
+function _findProviderForMccMnc(operatorName, operatorCode) {
+    if (operatorName) {
+        if (operatorName.length != 0 &&
+            (operatorName.length > 6 || operatorName.length < 5)) {
+            // this looks like a valid name, i.e. not an MCCMNC (that some
+            // devices return when not yet connected
+            return operatorName;
+        }
+
+        if (isNaN(parseInt(operatorName))) {
+            // name is definitely not a MCCMNC, so it may be a name
+            // after all; return that
+            return operatorName;
+        }
+    }
+
+    let needle;
+    if ((!operatorName || operatorName.length == 0) && operatorCode)
+        needle = operatorCode;
+    else if (operatorName && (operatorName.length == 6 || operatorName.length == 5))
+        needle = operatorName;
+    else // nothing to search
+        return null;
+
+    let mpd = _getMobileProvidersDatabase();
+    if (mpd) {
+        let provider = mpd.lookup_3gpp_mcc_mnc(needle);
+        if (provider)
+            return provider.get_name();
+    }
+    return null;
+}
+
+// _findProviderForSid:
+// @sid: System Identifier of the serving CDMA network
+//
+// Tries to find the operator name corresponding to the given SID
+//
+function _findProviderForSid(sid) {
+    if (!sid)
+        return null;
+
+    let mpd = _getMobileProvidersDatabase();
+    if (mpd) {
+        let provider = mpd.lookup_cdma_sid(sid);
+        if (provider)
+            return provider.get_name();
+    }
+    return null;
+}
+
+
+// ----------------------------------------------------- //
+// Support for the old ModemManager interface (MM < 0.7) //
+// ----------------------------------------------------- //
+
+
+// The following are not the complete interfaces, just the methods we need
+// (or may need in the future)
+
+const ModemGsmNetworkInterface = loadInterfaceXML('org.freedesktop.ModemManager.Modem.Gsm.Network');
+const ModemGsmNetworkProxy = Gio.DBusProxy.makeProxyWrapper(ModemGsmNetworkInterface);
+
+const ModemCdmaInterface = loadInterfaceXML('org.freedesktop.ModemManager.Modem.Cdma');
+const ModemCdmaProxy = Gio.DBusProxy.makeProxyWrapper(ModemCdmaInterface);
+
+var ModemBase = GObject.registerClass({
+    GTypeFlags: GObject.TypeFlags.ABSTRACT,
+    Properties: {
+        'operator-name': GObject.ParamSpec.string(
+            'operator-name', 'operator-name', 'operator-name',
+            GObject.ParamFlags.READABLE,
+            null),
+        'signal-quality': GObject.ParamSpec.int(
+            'signal-quality', 'signal-quality', 'signal-quality',
+            GObject.ParamFlags.READABLE,
+            0, 100, 0),
+    },
+}, class ModemBase extends GObject.Object {
+    _setOperatorName(operatorName) {
+        if (this.operator_name == operatorName)
+            return;
+        this.operator_name = operatorName;
+        this.notify('operator-name');
+    }
+
+    _setSignalQuality(signalQuality) {
+        if (this.signal_quality == signalQuality)
+            return;
+        this.signal_quality = signalQuality;
+        this.notify('signal-quality');
+    }
+});
+
+var ModemGsm = GObject.registerClass(
+class ModemGsm extends ModemBase {
+    _init(path) {
+        super._init();
+        this._proxy = new ModemGsmNetworkProxy(Gio.DBus.system, 'org.freedesktop.ModemManager', path);
+
+        // Code is duplicated because the function have different signatures
+        this._proxy.connectSignal('SignalQuality', (proxy, sender, [quality]) => {
+            this._setSignalQuality(quality);
+        });
+        this._proxy.connectSignal('RegistrationInfo', (proxy, sender, [_status, code, name]) => {
+            this._setOperatorName(_findProviderForMccMnc(name, code));
+        });
+        this._proxy.GetRegistrationInfoRemote(([result], err) => {
+            if (err) {
+                log(err);
+                return;
+            }
+
+            let [status_, code, name] = result;
+            this._setOperatorName(_findProviderForMccMnc(name, code));
+        });
+        this._proxy.GetSignalQualityRemote((result, err) => {
+            if (err) {
+                // it will return an error if the device is not connected
+                this._setSignalQuality(0);
+            } else {
+                let [quality] = result;
+                this._setSignalQuality(quality);
+            }
+        });
+    }
+});
+
+var ModemCdma = GObject.registerClass(
+class ModemCdma extends ModemBase {
+    _init(path) {
+        super._init();
+        this._proxy = new ModemCdmaProxy(Gio.DBus.system, 'org.freedesktop.ModemManager', path);
+
+        this._proxy.connectSignal('SignalQuality', (proxy, sender, params) => {
+            this._setSignalQuality(params[0]);
+
+            // receiving this signal means the device got activated
+            // and we can finally call GetServingSystem
+            if (this.operator_name == null)
+                this._refreshServingSystem();
+        });
+        this._proxy.GetSignalQualityRemote((result, err) => {
+            if (err) {
+                // it will return an error if the device is not connected
+                this._setSignalQuality(0);
+            } else {
+                let [quality] = result;
+                this._setSignalQuality(quality);
+            }
+        });
+    }
+
+    _refreshServingSystem() {
+        this._proxy.GetServingSystemRemote(([result], err) => {
+            if (err) {
+                // it will return an error if the device is not connected
+                this._setOperatorName(null);
+            } else {
+                let [bandClass_, band_, sid] = result;
+                this._setOperatorName(_findProviderForSid(sid));
+            }
+        });
+    }
+});
+
+
+// ------------------------------------------------------- //
+// Support for the new ModemManager1 interface (MM >= 0.7) //
+// ------------------------------------------------------- //
+
+const BroadbandModemInterface = loadInterfaceXML('org.freedesktop.ModemManager1.Modem');
+const BroadbandModemProxy = Gio.DBusProxy.makeProxyWrapper(BroadbandModemInterface);
+
+const BroadbandModem3gppInterface = loadInterfaceXML('org.freedesktop.ModemManager1.Modem.Modem3gpp');
+const BroadbandModem3gppProxy = Gio.DBusProxy.makeProxyWrapper(BroadbandModem3gppInterface);
+
+const BroadbandModemCdmaInterface = loadInterfaceXML('org.freedesktop.ModemManager1.Modem.ModemCdma');
+const BroadbandModemCdmaProxy = Gio.DBusProxy.makeProxyWrapper(BroadbandModemCdmaInterface);
+
+var BroadbandModem = GObject.registerClass({
+    Properties: {
+        'capabilities': GObject.ParamSpec.flags(
+            'capabilities', 'capabilities', 'capabilities',
+            GObject.ParamFlags.READWRITE | GObject.ParamFlags.CONSTRUCT_ONLY,
+            NM.DeviceModemCapabilities.$gtype,
+            NM.DeviceModemCapabilities.NONE),
+    },
+}, class BroadbandModem extends ModemBase {
+    _init(path, capabilities) {
+        super._init({ capabilities });
+        this._proxy = new BroadbandModemProxy(Gio.DBus.system, 'org.freedesktop.ModemManager', path);
+        this._proxy_3gpp = new BroadbandModem3gppProxy(Gio.DBus.system, 'org.freedesktop.ModemManager1', path);
+        this._proxy_cdma = new BroadbandModemCdmaProxy(Gio.DBus.system, 'org.freedesktop.ModemManager1', path);
+
+        this._proxy.connect('g-properties-changed', (proxy, properties) => {
+            if ('SignalQuality' in properties.deep_unpack())
+                this._reloadSignalQuality();
+        });
+        this._reloadSignalQuality();
+
+        this._proxy_3gpp.connect('g-properties-changed', (proxy, properties) => {
+            let unpacked = properties.deep_unpack();
+            if ('OperatorName' in unpacked || 'OperatorCode' in unpacked)
+                this._reload3gppOperatorName();
+        });
+        this._reload3gppOperatorName();
+
+        this._proxy_cdma.connect('g-properties-changed', (proxy, properties) => {
+            let unpacked = properties.deep_unpack();
+            if ('Nid' in unpacked || 'Sid' in unpacked)
+                this._reloadCdmaOperatorName();
+        });
+        this._reloadCdmaOperatorName();
+    }
+
+    _reloadSignalQuality() {
+        let [quality, recent_] = this.SignalQuality;
+        this._setSignalQuality(quality);
+    }
+
+    _reloadOperatorName() {
+        let newName = "";
+        if (this.operator_name_3gpp && this.operator_name_3gpp.length > 0)
+            newName += this.operator_name_3gpp;
+
+        if (this.operator_name_cdma && this.operator_name_cdma.length > 0) {
+            if (newName != "")
+                newName += ", ";
+            newName += this.operator_name_cdma;
+        }
+
+        this._setOperatorName(newName);
+    }
+
+    _reload3gppOperatorName() {
+        let name = this._proxy_3gpp.OperatorName;
+        let code = this._proxy_3gpp.OperatorCode;
+        this.operator_name_3gpp = _findProviderForMccMnc(name, code);
+        this._reloadOperatorName();
+    }
+
+    _reloadCdmaOperatorName() {
+        let sid = this._proxy_cdma.Sid;
+        this.operator_name_cdma = _findProviderForSid(sid);
+        this._reloadOperatorName();
+    }
+});

js/misc/objectManager.js

@@ -0,0 +1,288 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+
+const { Gio, GLib } = imports.gi;
+const Params = imports.misc.params;
+const Signals = imports.signals;
+
+// Specified in the D-Bus specification here:
+// http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager
+const ObjectManagerIface = `
+<node>
+<interface name="org.freedesktop.DBus.ObjectManager">
+  <method name="GetManagedObjects">
+    <arg name="objects" type="a{oa{sa{sv}}}" direction="out"/>
+  </method>
+  <signal name="InterfacesAdded">
+    <arg name="objectPath" type="o"/>
+    <arg name="interfaces" type="a{sa{sv}}" />
+  </signal>
+  <signal name="InterfacesRemoved">
+    <arg name="objectPath" type="o"/>
+    <arg name="interfaces" type="as" />
+  </signal>
+</interface>
+</node>`;
+
+const ObjectManagerInfo = Gio.DBusInterfaceInfo.new_for_xml(ObjectManagerIface);
+
+var ObjectManager = class {
+    constructor(params) {
+        params = Params.parse(params, { connection: null,
+                                        name: null,
+                                        objectPath: null,
+                                        knownInterfaces: null,
+                                        cancellable: null,
+                                        onLoaded: null });
+
+        this._connection = params.connection;
+        this._serviceName = params.name;
+        this._managerPath = params.objectPath;
+        this._cancellable = params.cancellable;
+
+        this._managerProxy = new Gio.DBusProxy({ g_connection: this._connection,
+                                                 g_interface_name: ObjectManagerInfo.name,
+                                                 g_interface_info: ObjectManagerInfo,
+                                                 g_name: this._serviceName,
+                                                 g_object_path: this._managerPath,
+                                                 g_flags: Gio.DBusProxyFlags.DO_NOT_AUTO_START });
+
+        this._interfaceInfos = {};
+        this._objects = {};
+        this._interfaces = {};
+        this._onLoaded = params.onLoaded;
+
+        if (params.knownInterfaces)
+            this._registerInterfaces(params.knownInterfaces);
+
+        // Start out inhibiting load until at least the proxy
+        // manager is loaded and the remote objects are fetched
+        this._numLoadInhibitors = 1;
+        this._managerProxy.init_async(GLib.PRIORITY_DEFAULT,
+                                      this._cancellable,
+                                      this._onManagerProxyLoaded.bind(this));
+    }
+
+    _tryToCompleteLoad() {
+        if (this._numLoadInhibitors == 0)
+            return;
+
+        this._numLoadInhibitors--;
+        if (this._numLoadInhibitors == 0) {
+            if (this._onLoaded)
+                this._onLoaded();
+        }
+    }
+
+    _addInterface(objectPath, interfaceName, onFinished) {
+        let info = this._interfaceInfos[interfaceName];
+
+        if (!info) {
+            if (onFinished)
+                onFinished();
+            return;
+        }
+
+        let proxy = new Gio.DBusProxy({ g_connection: this._connection,
+                                        g_name: this._serviceName,
+                                        g_object_path: objectPath,
+                                        g_interface_name: interfaceName,
+                                        g_interface_info: info,
+                                        g_flags: Gio.DBusProxyFlags.DO_NOT_AUTO_START });
+
+        proxy.init_async(GLib.PRIORITY_DEFAULT, this._cancellable, (initable, result) => {
+            try {
+                initable.init_finish(result);
+            } catch (e) {
+                logError(e, `could not initialize proxy for interface ${interfaceName}`);
+
+                if (onFinished)
+                    onFinished();
+                return;
+            }
+
+            let isNewObject;
+            if (!this._objects[objectPath]) {
+                this._objects[objectPath] = {};
+                isNewObject = true;
+            } else {
+                isNewObject = false;
+            }
+
+            this._objects[objectPath][interfaceName] = proxy;
+
+            if (!this._interfaces[interfaceName])
+                this._interfaces[interfaceName] = [];
+
+            this._interfaces[interfaceName].push(proxy);
+
+            if (isNewObject)
+                this.emit('object-added', objectPath);
+
+            this.emit('interface-added', interfaceName, proxy);
+
+            if (onFinished)
+                onFinished();
+        });
+    }
+
+    _removeInterface(objectPath, interfaceName) {
+        if (!this._objects[objectPath])
+            return;
+
+        let proxy = this._objects[objectPath][interfaceName];
+
+        if (this._interfaces[interfaceName]) {
+            let index = this._interfaces[interfaceName].indexOf(proxy);
+
+            if (index >= 0)
+                this._interfaces[interfaceName].splice(index, 1);
+
+            if (this._interfaces[interfaceName].length == 0)
+                delete this._interfaces[interfaceName];
+        }
+
+        this.emit('interface-removed', interfaceName, proxy);
+
+        this._objects[objectPath][interfaceName] = null;
+
+        if (Object.keys(this._objects[objectPath]).length == 0) {
+            delete this._objects[objectPath];
+            this.emit('object-removed', objectPath);
+        }
+    }
+
+    _onManagerProxyLoaded(initable, result) {
+        try {
+            initable.init_finish(result);
+        } catch (e) {
+            logError(e, `could not initialize object manager for object ${this._serviceName}`);
+
+            this._tryToCompleteLoad();
+            return;
+        }
+
+        this._managerProxy.connectSignal('InterfacesAdded',
+                                         (objectManager, sender, [objectPath, interfaces]) => {
+                                             let interfaceNames = Object.keys(interfaces);
+                                             for (let i = 0; i < interfaceNames.length; i++)
+                                                 this._addInterface(objectPath, interfaceNames[i]);
+                                         });
+        this._managerProxy.connectSignal('InterfacesRemoved',
+                                         (objectManager, sender, [objectPath, interfaceNames]) => {
+                                             for (let i = 0; i < interfaceNames.length; i++)
+                                                 this._removeInterface(objectPath, interfaceNames[i]);
+                                         });
+
+        if (Object.keys(this._interfaceInfos).length == 0) {
+            this._tryToCompleteLoad();
+            return;
+        }
+
+        this._managerProxy.connect('notify::g-name-owner', () => {
+            if (this._managerProxy.g_name_owner)
+                this._onNameAppeared();
+            else
+                this._onNameVanished();
+        });
+
+        if (this._managerProxy.g_name_owner)
+            this._onNameAppeared();
+    }
+
+    _onNameAppeared() {
+        this._managerProxy.GetManagedObjectsRemote((result, error) => {
+            if (!result) {
+                if (error)
+                    logError(error, `could not get remote objects for service ${this._serviceName} path ${this._managerPath}`);
+
+                this._tryToCompleteLoad();
+                return;
+            }
+
+            let [objects] = result;
+
+            if (!objects) {
+                this._tryToCompleteLoad();
+                return;
+            }
+
+            let objectPaths = Object.keys(objects);
+            for (let i = 0; i < objectPaths.length; i++) {
+                let objectPath = objectPaths[i];
+                let object = objects[objectPath];
+
+                let interfaceNames = Object.getOwnPropertyNames(object);
+                for (let j = 0; j < interfaceNames.length; j++) {
+                    let interfaceName = interfaceNames[j];
+
+                    // Prevent load from completing until the interface is loaded
+                    this._numLoadInhibitors++;
+                    this._addInterface(objectPath,
+                                       interfaceName,
+                                       this._tryToCompleteLoad.bind(this));
+                }
+            }
+            this._tryToCompleteLoad();
+        });
+    }
+
+    _onNameVanished() {
+        let objectPaths = Object.keys(this._objects);
+        for (let i = 0; i < objectPaths.length; i++) {
+            let objectPath = objectPaths[i];
+            let object = this._objects[objectPath];
+
+            let interfaceNames = Object.keys(object);
+            for (let j = 0; j < interfaceNames.length; j++) {
+                let interfaceName = interfaceNames[j];
+
+                if (object[interfaceName])
+                    this._removeInterface(objectPath, interfaceName);
+            }
+        }
+    }
+
+    _registerInterfaces(interfaces) {
+        for (let i = 0; i < interfaces.length; i++) {
+            let info = Gio.DBusInterfaceInfo.new_for_xml(interfaces[i]);
+            this._interfaceInfos[info.name] = info;
+        }
+    }
+
+    getProxy(objectPath, interfaceName) {
+        let object = this._objects[objectPath];
+
+        if (!object)
+            return null;
+
+        return object[interfaceName];
+    }
+
+    getProxiesForInterface(interfaceName) {
+        let proxyList = this._interfaces[interfaceName];
+
+        if (!proxyList)
+            return [];
+
+        return proxyList;
+    }
+
+    getAllProxies() {
+        let proxies = [];
+
+        let objectPaths = Object.keys(this._objects);
+        for (let i = 0; i < objectPaths.length; i++) {
+            let object = this._objects[objectPaths];
+
+            let interfaceNames = Object.keys(object);
+            for (let j = 0; j < interfaceNames.length; j++) {
+                let interfaceName = interfaceNames[j];
+                if (object[interfaceName])
+                    proxies.push(object(interfaceName));
+            }
+        }
+
+        return proxies;
+    }
+};
+Signals.addSignalMethods(ObjectManager.prototype);

js/misc/params.js

@@ -0,0 +1,28 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported parse */
+
+// parse:
+// @params: caller-provided parameter object, or %null
+// @defaults-provided defaults object
+// @allowExtras: whether or not to allow properties not in @default
+//
+// Examines @params and fills in default values from @defaults for
+// any properties in @defaults that don't appear in @params. If
+// @allowExtras is not %true, it will throw an error if @params
+// contains any properties that aren't in @defaults.
+//
+// If @params is %null, this returns the values from @defaults.
+//
+// Return value: a new object, containing the merged parameters from
+// @params and @defaults
+function parse(params = {}, defaults, allowExtras) {
+    if (!allowExtras) {
+        for (let prop in params) {
+            if (!(prop in defaults))
+                throw new Error(`Unrecognized parameter "${prop}"`);
+        }
+    }
+
+    let defaultsCopy = Object.assign({}, defaults);
+    return Object.assign(defaultsCopy, params);
+}

js/misc/permissionStore.js

@@ -0,0 +1,16 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported PermissionStore */
+
+const Gio = imports.gi.Gio;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const PermissionStoreIface = loadInterfaceXML('org.freedesktop.impl.portal.PermissionStore');
+const PermissionStoreProxy = Gio.DBusProxy.makeProxyWrapper(PermissionStoreIface);
+
+function PermissionStore(initCallback, cancellable) {
+    return new PermissionStoreProxy(Gio.DBus.session,
+                                    'org.freedesktop.impl.portal.PermissionStore',
+                                    '/org/freedesktop/impl/portal/PermissionStore',
+                                    initCallback, cancellable);
+}

js/misc/smartcardManager.js

@@ -0,0 +1,116 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported getSmartcardManager */
+
+const Gio = imports.gi.Gio;
+const Signals = imports.signals;
+
+const ObjectManager = imports.misc.objectManager;
+
+const SmartcardTokenIface = `
+<node>
+<interface name="org.gnome.SettingsDaemon.Smartcard.Token">
+  <property name="Name" type="s" access="read"/>
+  <property name="Driver" type="o" access="read"/>
+  <property name="IsInserted" type="b" access="read"/>
+  <property name="UsedToLogin" type="b" access="read"/>
+</interface>
+</node>`;
+
+let _smartcardManager = null;
+
+function getSmartcardManager() {
+    if (_smartcardManager == null)
+        _smartcardManager = new SmartcardManager();
+
+    return _smartcardManager;
+}
+
+var SmartcardManager = class {
+    constructor() {
+        this._objectManager = new ObjectManager.ObjectManager({ connection: Gio.DBus.session,
+                                                                name: "org.gnome.SettingsDaemon.Smartcard",
+                                                                objectPath: '/org/gnome/SettingsDaemon/Smartcard',
+                                                                knownInterfaces: [SmartcardTokenIface],
+                                                                onLoaded: this._onLoaded.bind(this) });
+        this._insertedTokens = {};
+        this._loginToken = null;
+    }
+
+    _onLoaded() {
+        let tokens = this._objectManager.getProxiesForInterface('org.gnome.SettingsDaemon.Smartcard.Token');
+
+        for (let i = 0; i < tokens.length; i++)
+            this._addToken(tokens[i]);
+
+        this._objectManager.connect('interface-added', (objectManager, interfaceName, proxy) => {
+            if (interfaceName == 'org.gnome.SettingsDaemon.Smartcard.Token')
+                this._addToken(proxy);
+        });
+
+        this._objectManager.connect('interface-removed', (objectManager, interfaceName, proxy) => {
+            if (interfaceName == 'org.gnome.SettingsDaemon.Smartcard.Token')
+                this._removeToken(proxy);
+        });
+    }
+
+    _updateToken(token) {
+        let objectPath = token.get_object_path();
+
+        delete this._insertedTokens[objectPath];
+
+        if (token.IsInserted)
+            this._insertedTokens[objectPath] = token;
+
+        if (token.UsedToLogin)
+            this._loginToken = token;
+    }
+
+    _addToken(token) {
+        this._updateToken(token);
+
+        token.connect('g-properties-changed', (proxy, properties) => {
+            if ('IsInserted' in properties.deep_unpack()) {
+                this._updateToken(token);
+
+                if (token.IsInserted)
+                    this.emit('smartcard-inserted', token);
+                else
+                    this.emit('smartcard-removed', token);
+            }
+        });
+
+        // Emit a smartcard-inserted at startup if it's already plugged in
+        if (token.IsInserted)
+            this.emit('smartcard-inserted', token);
+    }
+
+    _removeToken(token) {
+        let objectPath = token.get_object_path();
+
+        if (this._insertedTokens[objectPath] == token) {
+            delete this._insertedTokens[objectPath];
+            this.emit('smartcard-removed', token);
+        }
+
+        if (this._loginToken == token)
+            this._loginToken = null;
+
+        token.disconnectAll();
+    }
+
+    hasInsertedTokens() {
+        return Object.keys(this._insertedTokens).length > 0;
+    }
+
+    hasInsertedLoginToken() {
+        if (!this._loginToken)
+            return false;
+
+        if (!this._loginToken.IsInserted)
+            return false;
+
+        return true;
+    }
+
+};
+Signals.addSignalMethods(SmartcardManager.prototype);

js/misc/systemActions.js

@@ -0,0 +1,450 @@
+/* exported getDefault */
+const { AccountsService, Clutter, Gdm, Gio, GLib, GObject, Meta } = imports.gi;
+
+const GnomeSession = imports.misc.gnomeSession;
+const LoginManager = imports.misc.loginManager;
+const Main = imports.ui.main;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const LOCKDOWN_SCHEMA = 'org.gnome.desktop.lockdown';
+const LOGIN_SCREEN_SCHEMA = 'org.gnome.login-screen';
+const DISABLE_USER_SWITCH_KEY = 'disable-user-switching';
+const DISABLE_LOCK_SCREEN_KEY = 'disable-lock-screen';
+const DISABLE_LOG_OUT_KEY = 'disable-log-out';
+const DISABLE_RESTART_KEY = 'disable-restart-buttons';
+const ALWAYS_SHOW_LOG_OUT_KEY = 'always-show-log-out';
+
+const SENSOR_BUS_NAME = 'net.hadess.SensorProxy';
+const SENSOR_OBJECT_PATH = '/net/hadess/SensorProxy';
+
+const SensorProxyInterface = loadInterfaceXML('net.hadess.SensorProxy');
+
+const POWER_OFF_ACTION_ID        = 'power-off';
+const LOCK_SCREEN_ACTION_ID      = 'lock-screen';
+const LOGOUT_ACTION_ID           = 'logout';
+const SUSPEND_ACTION_ID          = 'suspend';
+const SWITCH_USER_ACTION_ID      = 'switch-user';
+const LOCK_ORIENTATION_ACTION_ID = 'lock-orientation';
+
+const SensorProxy = Gio.DBusProxy.makeProxyWrapper(SensorProxyInterface);
+
+let _singleton = null;
+
+function getDefault() {
+    if (_singleton == null)
+        _singleton = new SystemActions();
+
+    return _singleton;
+}
+
+const SystemActions = GObject.registerClass({
+    Properties: {
+        'can-power-off': GObject.ParamSpec.boolean('can-power-off',
+                                                   'can-power-off',
+                                                   'can-power-off',
+                                                   GObject.ParamFlags.READABLE,
+                                                   false),
+        'can-suspend': GObject.ParamSpec.boolean('can-suspend',
+                                                 'can-suspend',
+                                                 'can-suspend',
+                                                 GObject.ParamFlags.READABLE,
+                                                 false),
+        'can-lock-screen': GObject.ParamSpec.boolean('can-lock-screen',
+                                                     'can-lock-screen',
+                                                     'can-lock-screen',
+                                                     GObject.ParamFlags.READABLE,
+                                                     false),
+        'can-switch-user': GObject.ParamSpec.boolean('can-switch-user',
+                                                     'can-switch-user',
+                                                     'can-switch-user',
+                                                     GObject.ParamFlags.READABLE,
+                                                     false),
+        'can-logout': GObject.ParamSpec.boolean('can-logout',
+                                                'can-logout',
+                                                'can-logout',
+                                                GObject.ParamFlags.READABLE,
+                                                false),
+        'can-lock-orientation': GObject.ParamSpec.boolean('can-lock-orientation',
+                                                          'can-lock-orientation',
+                                                          'can-lock-orientation',
+                                                          GObject.ParamFlags.READABLE,
+                                                          false),
+        'orientation-lock-icon': GObject.ParamSpec.string('orientation-lock-icon',
+                                                          'orientation-lock-icon',
+                                                          'orientation-lock-icon',
+                                                          GObject.ParamFlags.READWRITE,
+                                                          null),
+    },
+}, class SystemActions extends GObject.Object {
+    _init() {
+        super._init();
+
+        this._canHavePowerOff = true;
+        this._canHaveSuspend = true;
+
+        this._actions = new Map();
+        this._actions.set(POWER_OFF_ACTION_ID, {
+            // Translators: The name of the power-off action in search
+            name: C_("search-result", "Power Off"),
+            iconName: 'system-shutdown-symbolic',
+            // Translators: A list of keywords that match the power-off action, separated by semicolons
+            keywords: _('power off;shutdown;reboot;restart;halt;stop').split(/[; ]/),
+            available: false,
+        });
+        this._actions.set(LOCK_SCREEN_ACTION_ID, {
+            // Translators: The name of the lock screen action in search
+            name: C_("search-result", "Lock Screen"),
+            iconName: 'system-lock-screen-symbolic',
+            // Translators: A list of keywords that match the lock screen action, separated by semicolons
+            keywords: _("lock screen").split(/[; ]/),
+            available: false,
+        });
+        this._actions.set(LOGOUT_ACTION_ID, {
+            // Translators: The name of the logout action in search
+            name: C_("search-result", "Log Out"),
+            iconName: 'application-exit-symbolic',
+            // Translators: A list of keywords that match the logout action, separated by semicolons
+            keywords: _("logout;log out;sign off").split(/[; ]/),
+            available: false,
+        });
+        this._actions.set(SUSPEND_ACTION_ID, {
+            // Translators: The name of the suspend action in search
+            name: C_("search-result", "Suspend"),
+            iconName: 'media-playback-pause-symbolic',
+            // Translators: A list of keywords that match the suspend action, separated by semicolons
+            keywords: _("suspend;sleep").split(/[; ]/),
+            available: false,
+        });
+        this._actions.set(SWITCH_USER_ACTION_ID, {
+            // Translators: The name of the switch user action in search
+            name: C_("search-result", "Switch User"),
+            iconName: 'system-switch-user-symbolic',
+            // Translators: A list of keywords that match the switch user action, separated by semicolons
+            keywords: _("switch user").split(/[; ]/),
+            available: false,
+        });
+        this._actions.set(LOCK_ORIENTATION_ACTION_ID, {
+            name: '',
+            iconName: '',
+            // Translators: A list of keywords that match the lock orientation action, separated by semicolons
+            keywords: _("lock orientation;unlock orientation;screen;rotation").split(/[; ]/),
+            available: false,
+        });
+
+        this._loginScreenSettings = new Gio.Settings({ schema_id: LOGIN_SCREEN_SCHEMA });
+        this._lockdownSettings = new Gio.Settings({ schema_id: LOCKDOWN_SCHEMA });
+        this._orientationSettings = new Gio.Settings({ schema_id: 'org.gnome.settings-daemon.peripherals.touchscreen' });
+
+        this._session = new GnomeSession.SessionManager();
+        this._loginManager = LoginManager.getLoginManager();
+        this._monitorManager = Meta.MonitorManager.get();
+
+        this._userManager = AccountsService.UserManager.get_default();
+
+        this._userManager.connect('notify::is-loaded',
+                                  () => this._updateMultiUser());
+        this._userManager.connect('notify::has-multiple-users',
+                                  () => this._updateMultiUser());
+        this._userManager.connect('user-added',
+                                  () => this._updateMultiUser());
+        this._userManager.connect('user-removed',
+                                  () => this._updateMultiUser());
+
+        this._lockdownSettings.connect('changed::%s'.format(DISABLE_USER_SWITCH_KEY),
+                                       () => this._updateSwitchUser());
+        this._lockdownSettings.connect('changed::%s'.format(DISABLE_LOG_OUT_KEY),
+                                       () => this._updateLogout());
+        global.settings.connect('changed::%s'.format(ALWAYS_SHOW_LOG_OUT_KEY),
+                                () => this._updateLogout());
+
+        this._lockdownSettings.connect('changed::%s'.format(DISABLE_LOCK_SCREEN_KEY),
+                                       () => this._updateLockScreen());
+
+        this._lockdownSettings.connect('changed::%s'.format(DISABLE_LOG_OUT_KEY),
+                                       () => this._updateHaveShutdown());
+
+        this.forceUpdate();
+
+        this._orientationSettings.connect('changed::orientation-lock', () => {
+            this._updateOrientationLock();
+            this._updateOrientationLockStatus();
+        });
+        Main.layoutManager.connect('monitors-changed',
+                                   () => this._updateOrientationLock());
+        this._sensorProxy = new SensorProxy(Gio.DBus.system,
+            SENSOR_BUS_NAME,
+            SENSOR_OBJECT_PATH,
+            (proxy, error)  => {
+                if (error)
+                    log(error.message);
+            },
+            null,
+            Gio.DBusProxyFlags.DO_NOT_AUTO_START);
+        this._sensorProxy.connect('g-properties-changed', () => {
+            this._updateOrientationLock();
+        });
+        this._sensorProxy.connect('notify::g-name-owner', () => {
+            this._updateOrientationLock();
+        });
+        this._updateOrientationLock();
+        this._updateOrientationLockStatus();
+
+        Main.sessionMode.connect('updated', () => this._sessionUpdated());
+        this._sessionUpdated();
+    }
+
+    // eslint-disable-next-line camelcase
+    get can_power_off() {
+        return this._actions.get(POWER_OFF_ACTION_ID).available;
+    }
+
+    // eslint-disable-next-line camelcase
+    get can_suspend() {
+        return this._actions.get(SUSPEND_ACTION_ID).available;
+    }
+
+    // eslint-disable-next-line camelcase
+    get can_lock_screen() {
+        return this._actions.get(LOCK_SCREEN_ACTION_ID).available;
+    }
+
+    // eslint-disable-next-line camelcase
+    get can_switch_user() {
+        return this._actions.get(SWITCH_USER_ACTION_ID).available;
+    }
+
+    // eslint-disable-next-line camelcase
+    get can_logout() {
+        return this._actions.get(LOGOUT_ACTION_ID).available;
+    }
+
+    // eslint-disable-next-line camelcase
+    get can_lock_orientation() {
+        return this._actions.get(LOCK_ORIENTATION_ACTION_ID).available;
+    }
+
+    // eslint-disable-next-line camelcase
+    get orientation_lock_icon() {
+        return this._actions.get(LOCK_ORIENTATION_ACTION_ID).iconName;
+    }
+
+    _updateOrientationLock() {
+        let available = false;
+        if (this._sensorProxy.g_name_owner) {
+            available = this._sensorProxy.HasAccelerometer &&
+                        this._monitorManager.get_is_builtin_display_on();
+        }
+
+        this._actions.get(LOCK_ORIENTATION_ACTION_ID).available = available;
+
+        this.notify('can-lock-orientation');
+    }
+
+    _updateOrientationLockStatus() {
+        let locked = this._orientationSettings.get_boolean('orientation-lock');
+        let action = this._actions.get(LOCK_ORIENTATION_ACTION_ID);
+
+        // Translators: The name of the lock orientation action in search
+        // and in the system status menu
+        let name = locked
+            ? C_('search-result', 'Unlock Screen Rotation')
+            : C_('search-result', 'Lock Screen Rotation');
+        let iconName = locked
+            ? 'rotation-locked-symbolic'
+            : 'rotation-allowed-symbolic';
+
+        action.name = name;
+        action.iconName = iconName;
+
+        this.notify('orientation-lock-icon');
+    }
+
+    _sessionUpdated() {
+        this._updateLockScreen();
+        this._updatePowerOff();
+        this._updateSuspend();
+        this._updateMultiUser();
+    }
+
+    forceUpdate() {
+        // Whether those actions are available or not depends on both lockdown
+        // settings and Polkit policy - we don't get change notifications for the
+        // latter, so their value may be outdated; force an update now
+        this._updateHaveShutdown();
+        this._updateHaveSuspend();
+    }
+
+    getMatchingActions(terms) {
+        // terms is a list of strings
+        terms = terms.map(term => term.toLowerCase());
+
+        let results = [];
+
+        for (let [key, { available, keywords }] of this._actions) {
+            if (available && terms.every(t => keywords.some(k => k.startsWith(t))))
+                results.push(key);
+        }
+
+        return results;
+    }
+
+    getName(id) {
+        return this._actions.get(id).name;
+    }
+
+    getIconName(id) {
+        return this._actions.get(id).iconName;
+    }
+
+    activateAction(id) {
+        switch (id) {
+        case POWER_OFF_ACTION_ID:
+            this.activatePowerOff();
+            break;
+        case LOCK_SCREEN_ACTION_ID:
+            this.activateLockScreen();
+            break;
+        case LOGOUT_ACTION_ID:
+            this.activateLogout();
+            break;
+        case SUSPEND_ACTION_ID:
+            this.activateSuspend();
+            break;
+        case SWITCH_USER_ACTION_ID:
+            this.activateSwitchUser();
+            break;
+        case LOCK_ORIENTATION_ACTION_ID:
+            this.activateLockOrientation();
+            break;
+        }
+    }
+
+    _updateLockScreen() {
+        let showLock = !Main.sessionMode.isLocked && !Main.sessionMode.isGreeter;
+        let allowLockScreen = !this._lockdownSettings.get_boolean(DISABLE_LOCK_SCREEN_KEY);
+        this._actions.get(LOCK_SCREEN_ACTION_ID).available = showLock && allowLockScreen && LoginManager.canLock();
+        this.notify('can-lock-screen');
+    }
+
+    _updateHaveShutdown() {
+        this._session.CanShutdownRemote((result, error) => {
+            if (error)
+                return;
+
+            this._canHavePowerOff = result[0];
+            this._updatePowerOff();
+        });
+    }
+
+    _updatePowerOff() {
+        let disabled = Main.sessionMode.isLocked ||
+                       (Main.sessionMode.isGreeter &&
+                        this._loginScreenSettings.get_boolean(DISABLE_RESTART_KEY));
+        this._actions.get(POWER_OFF_ACTION_ID).available = this._canHavePowerOff && !disabled;
+        this.notify('can-power-off');
+    }
+
+    _updateHaveSuspend() {
+        this._loginManager.canSuspend(
+            (canSuspend, needsAuth) => {
+                this._canHaveSuspend = canSuspend;
+                this._suspendNeedsAuth = needsAuth;
+                this._updateSuspend();
+            });
+    }
+
+    _updateSuspend() {
+        let disabled = (Main.sessionMode.isLocked &&
+                        this._suspendNeedsAuth) ||
+                       (Main.sessionMode.isGreeter &&
+                        this._loginScreenSettings.get_boolean(DISABLE_RESTART_KEY));
+        this._actions.get(SUSPEND_ACTION_ID).available = this._canHaveSuspend && !disabled;
+        this.notify('can-suspend');
+    }
+
+    _updateMultiUser() {
+        this._updateLogout();
+        this._updateSwitchUser();
+    }
+
+    _updateSwitchUser() {
+        let allowSwitch = !this._lockdownSettings.get_boolean(DISABLE_USER_SWITCH_KEY);
+        let multiUser = this._userManager.can_switch() && this._userManager.has_multiple_users;
+        let shouldShowInMode = !Main.sessionMode.isLocked && !Main.sessionMode.isGreeter;
+
+        let visible = allowSwitch && multiUser && shouldShowInMode;
+        this._actions.get(SWITCH_USER_ACTION_ID).available = visible;
+        this.notify('can-switch-user');
+
+        return visible;
+    }
+
+    _updateLogout() {
+        let user = this._userManager.get_user(GLib.get_user_name());
+
+        let allowLogout = !this._lockdownSettings.get_boolean(DISABLE_LOG_OUT_KEY);
+        let alwaysShow = global.settings.get_boolean(ALWAYS_SHOW_LOG_OUT_KEY);
+        let systemAccount = user.system_account;
+        let localAccount = user.local_account;
+        let multiUser = this._userManager.has_multiple_users;
+        let multiSession = Gdm.get_session_ids().length > 1;
+        let shouldShowInMode = !Main.sessionMode.isLocked && !Main.sessionMode.isGreeter;
+
+        let visible = allowLogout && (alwaysShow || multiUser || multiSession || systemAccount || !localAccount) && shouldShowInMode;
+        this._actions.get(LOGOUT_ACTION_ID).available = visible;
+        this.notify('can-logout');
+
+        return visible;
+    }
+
+    activateLockOrientation() {
+        if (!this._actions.get(LOCK_ORIENTATION_ACTION_ID).available)
+            throw new Error('The lock-orientation action is not available!');
+
+        let locked = this._orientationSettings.get_boolean('orientation-lock');
+        this._orientationSettings.set_boolean('orientation-lock', !locked);
+    }
+
+    activateLockScreen() {
+        if (!this._actions.get(LOCK_SCREEN_ACTION_ID).available)
+            throw new Error('The lock-screen action is not available!');
+
+        Main.screenShield.lock(true);
+    }
+
+    activateSwitchUser() {
+        if (!this._actions.get(SWITCH_USER_ACTION_ID).available)
+            throw new Error('The switch-user action is not available!');
+
+        if (Main.screenShield)
+            Main.screenShield.lock(false);
+
+        Clutter.threads_add_repaint_func_full(Clutter.RepaintFlags.POST_PAINT, () => {
+            Gdm.goto_login_session_sync(null);
+            return false;
+        });
+    }
+
+    activateLogout() {
+        if (!this._actions.get(LOGOUT_ACTION_ID).available)
+            throw new Error('The logout action is not available!');
+
+        Main.overview.hide();
+        this._session.LogoutRemote(0);
+    }
+
+    activatePowerOff() {
+        if (!this._actions.get(POWER_OFF_ACTION_ID).available)
+            throw new Error('The power-off action is not available!');
+
+        this._session.ShutdownRemote(0);
+    }
+
+    activateSuspend() {
+        if (!this._actions.get(SUSPEND_ACTION_ID).available)
+            throw new Error('The suspend action is not available!');
+
+        this._loginManager.suspend();
+    }
+});

js/misc/util.js

@@ -0,0 +1,482 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported findUrls, spawn, spawnCommandLine, spawnApp, trySpawnCommandLine,
+            formatTime, formatTimeSpan, createTimeLabel, insertSorted,
+            makeCloseButton, ensureActorVisibleInScrollView, wiggle */
+
+const { Clutter, Gio, GLib, GObject, Shell, St, GnomeDesktop } = imports.gi;
+const Gettext = imports.gettext;
+
+const Main = imports.ui.main;
+const Params = imports.misc.params;
+
+var SCROLL_TIME = 100;
+
+const WIGGLE_OFFSET = 6;
+const WIGGLE_DURATION = 65;
+const N_WIGGLES = 3;
+
+// http://daringfireball.net/2010/07/improved_regex_for_matching_urls
+const _balancedParens = '\\([^\\s()<>]+\\)';
+const _leadingJunk = '[\\s`(\\[{\'\\"<\u00AB\u201C\u2018]';
+const _notTrailingJunk = '[^\\s`!()\\[\\]{};:\'\\".,<>?\u00AB\u00BB\u200E\u200F\u201C\u201D\u2018\u2019\u202A\u202C]';
+
+const _urlRegexp = new RegExp(
+    '(^|%s)'.format(_leadingJunk) +
+    '(' +
+        '(?:' +
+            '(?:http|https|ftp)://' +             // scheme://
+            '|' +
+            'www\\d{0,3}[.]' +                    // www.
+            '|' +
+            '[a-z0-9.\\-]+[.][a-z]{2,4}/' +       // foo.xx/
+        ')' +
+        '(?:' +                                   // one or more:
+            '[^\\s()<>]+' +                       // run of non-space non-()
+            '|' +                                 // or
+            '%s'.format(_balancedParens) +        // balanced parens
+        ')+' +
+        '(?:' +                                   // end with:
+            '%s'.format(_balancedParens) +        // balanced parens
+            '|' +                                 // or
+            '%s'.format(_notTrailingJunk) +       // last non-junk char
+        ')' +
+    ')', 'gi');
+
+let _desktopSettings = null;
+
+// findUrls:
+// @str: string to find URLs in
+//
+// Searches @str for URLs and returns an array of objects with %url
+// properties showing the matched URL string, and %pos properties indicating
+// the position within @str where the URL was found.
+//
+// Return value: the list of match objects, as described above
+function findUrls(str) {
+    let res = [], match;
+    while ((match = _urlRegexp.exec(str)))
+        res.push({ url: match[2], pos: match.index + match[1].length });
+    return res;
+}
+
+// spawn:
+// @argv: an argv array
+//
+// Runs @argv in the background, handling any errors that occur
+// when trying to start the program.
+function spawn(argv) {
+    try {
+        trySpawn(argv);
+    } catch (err) {
+        _handleSpawnError(argv[0], err);
+    }
+}
+
+// spawnCommandLine:
+// @commandLine: a command line
+//
+// Runs @commandLine in the background, handling any errors that
+// occur when trying to parse or start the program.
+function spawnCommandLine(commandLine) {
+    try {
+        let [success_, argv] = GLib.shell_parse_argv(commandLine);
+        trySpawn(argv);
+    } catch (err) {
+        _handleSpawnError(commandLine, err);
+    }
+}
+
+// spawnApp:
+// @argv: an argv array
+//
+// Runs @argv as if it was an application, handling startup notification
+function spawnApp(argv) {
+    try {
+        let app = Gio.AppInfo.create_from_commandline(argv.join(' '), null,
+                                                      Gio.AppInfoCreateFlags.SUPPORTS_STARTUP_NOTIFICATION);
+
+        let context = global.create_app_launch_context(0, -1);
+        app.launch([], context);
+    } catch (err) {
+        _handleSpawnError(argv[0], err);
+    }
+}
+
+// trySpawn:
+// @argv: an argv array
+//
+// Runs @argv in the background. If launching @argv fails,
+// this will throw an error.
+function trySpawn(argv) {
+    var success_, pid;
+    try {
+        [success_, pid] = GLib.spawn_async(null, argv, null,
+                                           GLib.SpawnFlags.SEARCH_PATH | GLib.SpawnFlags.DO_NOT_REAP_CHILD,
+                                           null);
+    } catch (err) {
+        /* Rewrite the error in case of ENOENT */
+        if (err.matches(GLib.SpawnError, GLib.SpawnError.NOENT)) {
+            throw new GLib.SpawnError({ code: GLib.SpawnError.NOENT,
+                                        message: _("Command not found") });
+        } else if (err instanceof GLib.Error) {
+            // The exception from gjs contains an error string like:
+            //   Error invoking GLib.spawn_command_line_async: Failed to
+            //   execute child process "foo" (No such file or directory)
+            // We are only interested in the part in the parentheses. (And
+            // we can't pattern match the text, since it gets localized.)
+            let message = err.message.replace(/.*\((.+)\)/, '$1');
+            throw new err.constructor({ code: err.code, message });
+        } else {
+            throw err;
+        }
+    }
+
+    // Async call, we don't need the reply though
+    GnomeDesktop.start_systemd_scope(argv[0], pid, null, null, null, () => {});
+
+    // Dummy child watch; we don't want to double-fork internally
+    // because then we lose the parent-child relationship, which
+    // can break polkit.  See https://bugzilla.redhat.com//show_bug.cgi?id=819275
+    GLib.child_watch_add(GLib.PRIORITY_DEFAULT, pid, () => {});
+}
+
+// trySpawnCommandLine:
+// @commandLine: a command line
+//
+// Runs @commandLine in the background. If launching @commandLine
+// fails, this will throw an error.
+function trySpawnCommandLine(commandLine) {
+    let success_, argv;
+
+    try {
+        [success_, argv] = GLib.shell_parse_argv(commandLine);
+    } catch (err) {
+        // Replace "Error invoking GLib.shell_parse_argv: " with
+        // something nicer
+        err.message = err.message.replace(/[^:]*: /, '%s\n'.format(_('Could not parse command:')));
+        throw err;
+    }
+
+    trySpawn(argv);
+}
+
+function _handleSpawnError(command, err) {
+    let title = _("Execution of “%s” failed:").format(command);
+    Main.notifyError(title, err.message);
+}
+
+function formatTimeSpan(date) {
+    let now = GLib.DateTime.new_now_local();
+
+    let timespan = now.difference(date);
+
+    let minutesAgo = timespan / GLib.TIME_SPAN_MINUTE;
+    let hoursAgo = timespan / GLib.TIME_SPAN_HOUR;
+    let daysAgo = timespan / GLib.TIME_SPAN_DAY;
+    let weeksAgo = daysAgo / 7;
+    let monthsAgo = daysAgo / 30;
+    let yearsAgo = weeksAgo / 52;
+
+    if (minutesAgo < 5)
+        return _("Just now");
+    if (hoursAgo < 1) {
+        return Gettext.ngettext("%d minute ago",
+                                "%d minutes ago", minutesAgo).format(minutesAgo);
+    }
+    if (daysAgo < 1) {
+        return Gettext.ngettext("%d hour ago",
+                                "%d hours ago", hoursAgo).format(hoursAgo);
+    }
+    if (daysAgo < 2)
+        return _("Yesterday");
+    if (daysAgo < 15) {
+        return Gettext.ngettext("%d day ago",
+                                "%d days ago", daysAgo).format(daysAgo);
+    }
+    if (weeksAgo < 8) {
+        return Gettext.ngettext("%d week ago",
+                                "%d weeks ago", weeksAgo).format(weeksAgo);
+    }
+    if (yearsAgo < 1) {
+        return Gettext.ngettext("%d month ago",
+                                "%d months ago", monthsAgo).format(monthsAgo);
+    }
+    return Gettext.ngettext("%d year ago",
+                            "%d years ago", yearsAgo).format(yearsAgo);
+}
+
+function formatTime(time, params) {
+    let date;
+    // HACK: The built-in Date type sucks at timezones, which we need for the
+    //       world clock; it's often more convenient though, so allow either
+    //       Date or GLib.DateTime as parameter
+    if (time instanceof Date)
+        date = GLib.DateTime.new_from_unix_local(time.getTime() / 1000);
+    else
+        date = time;
+
+    let now = GLib.DateTime.new_now_local();
+
+    let daysAgo = now.difference(date) / (24 * 60 * 60 * 1000 * 1000);
+
+    let format;
+
+    if (_desktopSettings == null)
+        _desktopSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.interface' });
+    let clockFormat = _desktopSettings.get_string('clock-format');
+
+    params = Params.parse(params, {
+        timeOnly: false,
+        ampm: true,
+    });
+
+    if (clockFormat == '24h') {
+        // Show only the time if date is on today
+        if (daysAgo < 1 || params.timeOnly)
+            /* Translators: Time in 24h format */
+            format = N_("%H\u2236%M");
+        // Show the word "Yesterday" and time if date is on yesterday
+        else if (daysAgo < 2)
+            /* Translators: this is the word "Yesterday" followed by a
+             time string in 24h format. i.e. "Yesterday, 14:30" */
+            // xgettext:no-c-format
+            format = N_("Yesterday, %H\u2236%M");
+        // Show a week day and time if date is in the last week
+        else if (daysAgo < 7)
+            /* Translators: this is the week day name followed by a time
+             string in 24h format. i.e. "Monday, 14:30" */
+            // xgettext:no-c-format
+            format = N_("%A, %H\u2236%M");
+        else if (date.get_year() == now.get_year())
+            /* Translators: this is the month name and day number
+             followed by a time string in 24h format.
+             i.e. "May 25, 14:30" */
+            // xgettext:no-c-format
+            format = N_("%B %-d, %H\u2236%M");
+        else
+            /* Translators: this is the month name, day number, year
+             number followed by a time string in 24h format.
+             i.e. "May 25 2012, 14:30" */
+            // xgettext:no-c-format
+            format = N_("%B %-d %Y, %H\u2236%M");
+    } else {
+        // Show only the time if date is on today
+        if (daysAgo < 1 || params.timeOnly) // eslint-disable-line no-lonely-if
+            /* Translators: Time in 12h format */
+            format = N_("%l\u2236%M %p");
+        // Show the word "Yesterday" and time if date is on yesterday
+        else if (daysAgo < 2)
+            /* Translators: this is the word "Yesterday" followed by a
+             time string in 12h format. i.e. "Yesterday, 2:30 pm" */
+            // xgettext:no-c-format
+            format = N_("Yesterday, %l\u2236%M %p");
+        // Show a week day and time if date is in the last week
+        else if (daysAgo < 7)
+            /* Translators: this is the week day name followed by a time
+             string in 12h format. i.e. "Monday, 2:30 pm" */
+            // xgettext:no-c-format
+            format = N_("%A, %l\u2236%M %p");
+        else if (date.get_year() == now.get_year())
+            /* Translators: this is the month name and day number
+             followed by a time string in 12h format.
+             i.e. "May 25, 2:30 pm" */
+            // xgettext:no-c-format
+            format = N_("%B %-d, %l\u2236%M %p");
+        else
+            /* Translators: this is the month name, day number, year
+             number followed by a time string in 12h format.
+             i.e. "May 25 2012, 2:30 pm"*/
+            // xgettext:no-c-format
+            format = N_("%B %-d %Y, %l\u2236%M %p");
+    }
+
+    // Time in short 12h format, without the equivalent of "AM" or "PM"; used
+    // when it is clear from the context
+    if (!params.ampm)
+        format = format.replace(/\s*%p/g, '');
+
+    let formattedTime = date.format(Shell.util_translate_time_string(format));
+    // prepend LTR-mark to colon/ratio to force a text direction on times
+    return formattedTime.replace(/([:\u2236])/g, '\u200e$1');
+}
+
+function createTimeLabel(date, params) {
+    if (_desktopSettings == null)
+        _desktopSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.interface' });
+
+    let label = new St.Label({ text: formatTime(date, params) });
+    let id = _desktopSettings.connect('changed::clock-format', () => {
+        label.text = formatTime(date, params);
+    });
+    label.connect('destroy', () => _desktopSettings.disconnect(id));
+    return label;
+}
+
+// lowerBound:
+// @array: an array or array-like object, already sorted
+//         according to @cmp
+// @val: the value to add
+// @cmp: a comparator (or undefined to compare as numbers)
+//
+// Returns the position of the first element that is not
+// lower than @val, according to @cmp.
+// That is, returns the first position at which it
+// is possible to insert @val without violating the
+// order.
+// This is quite like an ordinary binary search, except
+// that it doesn't stop at first element comparing equal.
+
+function lowerBound(array, val, cmp) {
+    let min, max, mid, v;
+    cmp = cmp || ((a, b) => a - b);
+
+    if (array.length == 0)
+        return 0;
+
+    min = 0;
+    max = array.length;
+    while (min < (max - 1)) {
+        mid = Math.floor((min + max) / 2);
+        v = cmp(array[mid], val);
+
+        if (v < 0)
+            min = mid + 1;
+        else
+            max = mid;
+    }
+
+    return min == max || cmp(array[min], val) < 0 ? max : min;
+}
+
+// insertSorted:
+// @array: an array sorted according to @cmp
+// @val: a value to insert
+// @cmp: the sorting function
+//
+// Inserts @val into @array, preserving the
+// sorting invariants.
+// Returns the position at which it was inserted
+function insertSorted(array, val, cmp) {
+    let pos = lowerBound(array, val, cmp);
+    array.splice(pos, 0, val);
+
+    return pos;
+}
+
+var CloseButton = GObject.registerClass(
+class CloseButton extends St.Button {
+    _init(boxpointer) {
+        super._init({
+            style_class: 'notification-close',
+            x_expand: true,
+            y_expand: true,
+            x_align: Clutter.ActorAlign.END,
+            y_align: Clutter.ActorAlign.START,
+        });
+
+        this._boxPointer = boxpointer;
+        if (boxpointer)
+            this._boxPointer.connect('arrow-side-changed', this._sync.bind(this));
+    }
+
+    _computeBoxPointerOffset() {
+        if (!this._boxPointer || !this._boxPointer.get_stage())
+            return 0;
+
+        let side = this._boxPointer.arrowSide;
+        if (side == St.Side.TOP)
+            return this._boxPointer.getArrowHeight();
+        else
+            return 0;
+    }
+
+    _sync() {
+        let themeNode = this.get_theme_node();
+
+        let offY = this._computeBoxPointerOffset();
+        this.translation_x = themeNode.get_length('-shell-close-overlap-x');
+        this.translation_y = themeNode.get_length('-shell-close-overlap-y') + offY;
+    }
+
+    vfunc_style_changed() {
+        this._sync();
+        super.vfunc_style_changed();
+    }
+});
+
+function makeCloseButton(boxpointer) {
+    return new CloseButton(boxpointer);
+}
+
+function ensureActorVisibleInScrollView(scrollView, actor) {
+    let adjustment = scrollView.vscroll.adjustment;
+    let [value, lower_, upper, stepIncrement_, pageIncrement_, pageSize] = adjustment.get_values();
+
+    let offset = 0;
+    let vfade = scrollView.get_effect("fade");
+    if (vfade)
+        offset = vfade.vfade_offset;
+
+    let box = actor.get_allocation_box();
+    let y1 = box.y1, y2 = box.y2;
+
+    let parent = actor.get_parent();
+    while (parent != scrollView) {
+        if (!parent)
+            throw new Error("actor not in scroll view");
+
+        box = parent.get_allocation_box();
+        y1 += box.y1;
+        y2 += box.y1;
+        parent = parent.get_parent();
+    }
+
+    if (y1 < value + offset)
+        value = Math.max(0, y1 - offset);
+    else if (y2 > value + pageSize - offset)
+        value = Math.min(upper, y2 + offset - pageSize);
+    else
+        return;
+
+    adjustment.ease(value, {
+        mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        duration: SCROLL_TIME,
+    });
+}
+
+function wiggle(actor, params) {
+    if (!St.Settings.get().enable_animations)
+        return;
+
+    params = Params.parse(params, {
+        offset: WIGGLE_OFFSET,
+        duration: WIGGLE_DURATION,
+        wiggleCount: N_WIGGLES,
+    });
+    actor.translation_x = 0;
+
+    // Accelerate before wiggling
+    actor.ease({
+        translation_x: -params.offset,
+        duration: params.duration,
+        mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        onComplete: () => {
+            // Wiggle
+            actor.ease({
+                translation_x: params.offset,
+                duration: params.duration,
+                mode: Clutter.AnimationMode.LINEAR,
+                repeatCount: params.wiggleCount,
+                autoReverse: true,
+                onComplete: () => {
+                    // Decelerate and return to the original position
+                    actor.ease({
+                        translation_x: 0,
+                        duration: params.duration,
+                        mode: Clutter.AnimationMode.EASE_IN_QUAD,
+                    });
+                },
+            });
+        },
+    });
+}

js/misc/weather.js

@@ -0,0 +1,321 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+
+const { Geoclue, Gio, GLib, GWeather, Shell } = imports.gi;
+const Signals = imports.signals;
+
+const PermissionStore = imports.misc.permissionStore;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const WeatherIntegrationIface = loadInterfaceXML('org.gnome.Shell.WeatherIntegration');
+
+const WEATHER_BUS_NAME = 'org.gnome.Weather';
+const WEATHER_OBJECT_PATH = '/org/gnome/Weather';
+const WEATHER_INTEGRATION_IFACE = 'org.gnome.Shell.WeatherIntegration';
+
+const WEATHER_APP_ID = 'org.gnome.Weather.desktop';
+
+// Minimum time between updates to show loading indication
+var UPDATE_THRESHOLD = 10 * GLib.TIME_SPAN_MINUTE;
+
+var WeatherClient = class {
+    constructor() {
+        this._loading = false;
+        this._locationValid = false;
+        this._lastUpdate = GLib.DateTime.new_from_unix_local(0);
+
+        this._autoLocationRequested = false;
+        this._mostRecentLocation = null;
+
+        this._gclueService = null;
+        this._gclueStarted = false;
+        this._gclueStarting = false;
+        this._gclueLocationChangedId = 0;
+
+        this._needsAuth = true;
+        this._weatherAuthorized = false;
+        this._permStore = new PermissionStore.PermissionStore((proxy, error) => {
+            if (error) {
+                log(`Failed to connect to permissionStore: ${error.message}`);
+                return;
+            }
+
+            if (this._permStore.g_name_owner == null) {
+                // Failed to auto-start, likely because xdg-desktop-portal
+                // isn't installed; don't restrict access to location service
+                this._weatherAuthorized = true;
+                this._updateAutoLocation();
+                return;
+            }
+
+            this._permStore.LookupRemote('gnome', 'geolocation', (res, err) => {
+                if (err)
+                    log(`Error looking up permission: ${err.message}`);
+
+                let [perms, data] = err ? [{}, null] : res;
+                let  params = ['gnome', 'geolocation', false, data, perms];
+                this._onPermStoreChanged(this._permStore, '', params);
+            });
+        });
+        this._permStore.connectSignal('Changed',
+                                      this._onPermStoreChanged.bind(this));
+
+        this._locationSettings = new Gio.Settings({ schema_id: 'org.gnome.system.location' });
+        this._locationSettings.connect('changed::enabled',
+                                       this._updateAutoLocation.bind(this));
+
+        this._world = GWeather.Location.get_world();
+
+        this._providers = GWeather.Provider.METAR |
+                          GWeather.Provider.YR_NO |
+                          GWeather.Provider.OWM;
+
+        this._weatherInfo = new GWeather.Info({ enabled_providers: 0 });
+        this._weatherInfo.connect_after('updated', () => {
+            this._lastUpdate = GLib.DateTime.new_now_local();
+            this.emit('changed');
+        });
+
+        this._weatherApp = null;
+        this._weatherProxy = null;
+
+        let nodeInfo = Gio.DBusNodeInfo.new_for_xml(WeatherIntegrationIface);
+        Gio.DBusProxy.new(
+            Gio.DBus.session,
+            Gio.DBusProxyFlags.DO_NOT_AUTO_START | Gio.DBusProxyFlags.GET_INVALIDATED_PROPERTIES,
+            nodeInfo.lookup_interface(WEATHER_INTEGRATION_IFACE),
+            WEATHER_BUS_NAME,
+            WEATHER_OBJECT_PATH,
+            WEATHER_INTEGRATION_IFACE,
+            null,
+            this._onWeatherProxyReady.bind(this));
+
+        this._settings = new Gio.Settings({
+            schema_id: 'org.gnome.shell.weather',
+        });
+        this._settings.connect('changed::automatic-location',
+            this._onAutomaticLocationChanged.bind(this));
+        this._onAutomaticLocationChanged();
+        this._settings.connect('changed::locations',
+            this._onLocationsChanged.bind(this));
+        this._onLocationsChanged();
+
+        this._appSystem = Shell.AppSystem.get_default();
+        this._appSystem.connect('installed-changed',
+            this._onInstalledChanged.bind(this));
+        this._onInstalledChanged();
+    }
+
+    get available() {
+        return this._weatherApp != null;
+    }
+
+    get loading() {
+        return this._loading;
+    }
+
+    get hasLocation() {
+        return this._locationValid;
+    }
+
+    get info() {
+        return this._weatherInfo;
+    }
+
+    activateApp() {
+        if (this._weatherApp)
+            this._weatherApp.activate();
+    }
+
+    update() {
+        if (!this._locationValid)
+            return;
+
+        let now = GLib.DateTime.new_now_local();
+        // Update without loading indication if the current info is recent enough
+        if (this._weatherInfo.is_valid() &&
+            now.difference(this._lastUpdate) < UPDATE_THRESHOLD)
+            this._weatherInfo.update();
+        else
+            this._loadInfo();
+    }
+
+    get _useAutoLocation() {
+        return this._autoLocationRequested &&
+               this._locationSettings.get_boolean('enabled') &&
+               (!this._needsAuth || this._weatherAuthorized);
+    }
+
+    _onWeatherProxyReady(o, res) {
+        try {
+            this._weatherProxy = Gio.DBusProxy.new_finish(res);
+        } catch (e) {
+            log(`Failed to create GNOME Weather proxy: ${e}`);
+            return;
+        }
+
+        this._weatherProxy.connect('g-properties-changed',
+            this._onWeatherPropertiesChanged.bind(this));
+        this._onWeatherPropertiesChanged();
+    }
+
+    _onWeatherPropertiesChanged() {
+        if (this._weatherProxy.g_name_owner == null)
+            return;
+
+        this._settings.set_boolean('automatic-location',
+            this._weatherProxy.AutomaticLocation);
+        this._settings.set_value('locations',
+            new GLib.Variant('av', this._weatherProxy.Locations));
+    }
+
+    _onInstalledChanged() {
+        let hadApp = this._weatherApp != null;
+        this._weatherApp = this._appSystem.lookup_app(WEATHER_APP_ID);
+        let haveApp = this._weatherApp != null;
+
+        if (hadApp !== haveApp)
+            this.emit('changed');
+
+        let neededAuth = this._needsAuth;
+        this._needsAuth = this._weatherApp === null ||
+                          this._weatherApp.app_info.has_key('X-Flatpak');
+
+        if (neededAuth !== this._needsAuth)
+            this._updateAutoLocation();
+    }
+
+    _loadInfo() {
+        let id = this._weatherInfo.connect('updated', () => {
+            this._weatherInfo.disconnect(id);
+            this._loading = false;
+        });
+
+        this._loading = true;
+        this.emit('changed');
+
+        this._weatherInfo.update();
+    }
+
+    _locationsEqual(loc1, loc2) {
+        if (loc1 == loc2)
+            return true;
+
+        if (loc1 == null || loc2 == null)
+            return false;
+
+        return loc1.equal(loc2);
+    }
+
+    _setLocation(location) {
+        if (this._locationsEqual(this._weatherInfo.location, location))
+            return;
+
+        this._weatherInfo.abort();
+        this._weatherInfo.set_location(location);
+        this._locationValid = location != null;
+
+        this._weatherInfo.set_enabled_providers(location ? this._providers : 0);
+
+        if (location)
+            this._loadInfo();
+        else
+            this.emit('changed');
+    }
+
+    _updateLocationMonitoring() {
+        if (this._useAutoLocation) {
+            if (this._gclueLocationChangedId != 0 || this._gclueService == null)
+                return;
+
+            this._gclueLocationChangedId =
+                this._gclueService.connect('notify::location',
+                                           this._onGClueLocationChanged.bind(this));
+            this._onGClueLocationChanged();
+        } else {
+            if (this._gclueLocationChangedId)
+                this._gclueService.disconnect(this._gclueLocationChangedId);
+            this._gclueLocationChangedId = 0;
+        }
+    }
+
+    _startGClueService() {
+        if (this._gclueStarting)
+            return;
+
+        this._gclueStarting = true;
+
+        Geoclue.Simple.new('org.gnome.Shell', Geoclue.AccuracyLevel.CITY, null,
+            (o, res) => {
+                try {
+                    this._gclueService = Geoclue.Simple.new_finish(res);
+                } catch (e) {
+                    log(`Failed to connect to Geoclue2 service: ${e.message}`);
+                    this._setLocation(this._mostRecentLocation);
+                    return;
+                }
+                this._gclueStarted = true;
+                this._gclueService.get_client().distance_threshold = 100;
+                this._updateLocationMonitoring();
+            });
+    }
+
+    _onGClueLocationChanged() {
+        let geoLocation = this._gclueService.location;
+        let location = GWeather.Location.new_detached(geoLocation.description,
+                                                      null,
+                                                      geoLocation.latitude,
+                                                      geoLocation.longitude);
+        this._setLocation(location);
+    }
+
+    _onAutomaticLocationChanged() {
+        let useAutoLocation = this._settings.get_boolean('automatic-location');
+        if (this._autoLocationRequested == useAutoLocation)
+            return;
+
+        this._autoLocationRequested = useAutoLocation;
+
+        this._updateAutoLocation();
+    }
+
+    _updateAutoLocation() {
+        this._updateLocationMonitoring();
+
+        if (this._useAutoLocation)
+            this._startGClueService();
+        else
+            this._setLocation(this._mostRecentLocation);
+    }
+
+    _onLocationsChanged() {
+        let locations = this._settings.get_value('locations').deep_unpack();
+        let serialized = locations.shift();
+        let mostRecentLocation = null;
+
+        if (serialized)
+            mostRecentLocation = this._world.deserialize(serialized);
+
+        if (this._locationsEqual(this._mostRecentLocation, mostRecentLocation))
+            return;
+
+        this._mostRecentLocation = mostRecentLocation;
+
+        if (!this._useAutoLocation || !this._gclueStarted)
+            this._setLocation(this._mostRecentLocation);
+    }
+
+    _onPermStoreChanged(proxy, sender, params) {
+        let [table, id, deleted_, data_, perms] = params;
+
+        if (table != 'gnome' || id != 'geolocation')
+            return;
+
+        let permission = perms['org.gnome.Weather'] || ['NONE'];
+        let [accuracy] = permission;
+        this._weatherAuthorized = accuracy != 'NONE';
+
+        this._updateAutoLocation();
+    }
+};
+Signals.addSignalMethods(WeatherClient.prototype);

js/perf/core.js

@@ -0,0 +1,240 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported run, script_overviewShowStart, script_overviewShowDone,
+            script_applicationsShowStart, script_applicationsShowDone,
+            script_afterShowHide, malloc_usedSize, glx_swapComplete,
+            clutter_stagePaintDone */
+/* eslint camelcase: ["error", { properties: "never", allow: ["^script_", "^malloc", "^glx", "^clutter"] }] */
+
+const System = imports.system;
+
+const Main = imports.ui.main;
+const Scripting = imports.ui.scripting;
+
+// This performance script measure the most important (core) performance
+// metrics for the shell. By looking at the output metrics of this script
+// someone should be able to get an idea of how well the shell is performing
+// on a particular system.
+
+var METRICS = {
+    overviewLatencyFirst:
+    { description: "Time to first frame after triggering overview, first time",
+      units: "us" },
+    overviewFpsFirst:
+    { description: "Frame rate when going to the overview, first time",
+      units: "frames / s" },
+    overviewLatencySubsequent:
+    { description: "Time to first frame after triggering overview, second time",
+      units: "us" },
+    overviewFpsSubsequent:
+    { description: "Frames rate when going to the overview, second time",
+      units: "frames / s" },
+    overviewFps5Windows:
+    { description: "Frames rate when going to the overview, 5 windows open",
+      units: "frames / s" },
+    overviewFps10Windows:
+    { description: "Frames rate when going to the overview, 10 windows open",
+      units: "frames / s" },
+    overviewFps5Maximized:
+    { description: "Frames rate when going to the overview, 5 maximized windows open",
+      units: "frames / s" },
+    overviewFps10Maximized:
+    { description: "Frames rate when going to the overview, 10 maximized windows open",
+      units: "frames / s" },
+    overviewFps5Alpha:
+    { description: "Frames rate when going to the overview, 5 alpha-transparent windows open",
+      units: "frames / s" },
+    overviewFps10Alpha:
+    { description: "Frames rate when going to the overview, 10 alpha-transparent windows open",
+      units: "frames / s" },
+    usedAfterOverview:
+    { description: "Malloc'ed bytes after the overview is shown once",
+      units: "B" },
+    leakedAfterOverview:
+    { description: "Additional malloc'ed bytes the second time the overview is shown",
+      units: "B" },
+    applicationsShowTimeFirst:
+    { description: "Time to switch to applications view, first time",
+      units: "us" },
+    applicationsShowTimeSubsequent:
+    { description: "Time to switch to applications view, second time",
+      units: "us" },
+};
+
+let WINDOW_CONFIGS = [
+    { width: 640, height: 480, alpha: false, maximized: false, count: 1,  metric: 'overviewFpsSubsequent' },
+    { width: 640, height: 480, alpha: false, maximized: false, count: 5,  metric: 'overviewFps5Windows'  },
+    { width: 640, height: 480, alpha: false, maximized: false, count: 10, metric: 'overviewFps10Windows'  },
+    { width: 640, height: 480, alpha: false, maximized: true,  count: 5,  metric: 'overviewFps5Maximized' },
+    { width: 640, height: 480, alpha: false, maximized: true,  count: 10, metric: 'overviewFps10Maximized' },
+    { width: 640, height: 480, alpha: true,  maximized: false, count: 5,  metric: 'overviewFps5Alpha' },
+    { width: 640, height: 480, alpha: true,  maximized: false, count: 10, metric: 'overviewFps10Alpha' },
+];
+
+function *run() {
+    Scripting.defineScriptEvent("overviewShowStart", "Starting to show the overview");
+    Scripting.defineScriptEvent("overviewShowDone", "Overview finished showing");
+    Scripting.defineScriptEvent("afterShowHide", "After a show/hide cycle for the overview");
+    Scripting.defineScriptEvent("applicationsShowStart", "Starting to switch to applications view");
+    Scripting.defineScriptEvent("applicationsShowDone", "Done switching to applications view");
+
+    // Enable recording of timestamps for different points in the frame cycle
+    global.frame_timestamps = true;
+
+    Main.overview.connect('shown', () => {
+        Scripting.scriptEvent('overviewShowDone');
+    });
+
+    yield Scripting.sleep(1000);
+
+    for (let i = 0; i < 2 * WINDOW_CONFIGS.length; i++) {
+        // We go to the overview twice for each configuration; the first time
+        // to calculate the mipmaps for the windows, the second time to get
+        // a clean set of numbers.
+        if ((i % 2) == 0) {
+            let config = WINDOW_CONFIGS[i / 2];
+            yield Scripting.destroyTestWindows();
+
+            for (let k = 0; k < config.count; k++) {
+                yield Scripting.createTestWindow({ width: config.width,
+                                                   height: config.height,
+                                                   alpha: config.alpha,
+                                                   maximized: config.maximized });
+            }
+
+            yield Scripting.waitTestWindows();
+            yield Scripting.sleep(1000);
+            yield Scripting.waitLeisure();
+        }
+
+        Scripting.scriptEvent('overviewShowStart');
+        Main.overview.show();
+
+        yield Scripting.waitLeisure();
+        Main.overview.hide();
+        yield Scripting.waitLeisure();
+
+        System.gc();
+        yield Scripting.sleep(1000);
+        Scripting.collectStatistics();
+        Scripting.scriptEvent('afterShowHide');
+    }
+
+    yield Scripting.destroyTestWindows();
+    yield Scripting.sleep(1000);
+
+    Main.overview.show();
+    yield Scripting.waitLeisure();
+
+    for (let i = 0; i < 2; i++) {
+        Scripting.scriptEvent('applicationsShowStart');
+        // eslint-disable-next-line require-atomic-updates
+        Main.overview.dash.showAppsButton.checked = true;
+        yield Scripting.waitLeisure();
+        Scripting.scriptEvent('applicationsShowDone');
+        // eslint-disable-next-line require-atomic-updates
+        Main.overview.dash.showAppsButton.checked = false;
+        yield Scripting.waitLeisure();
+    }
+}
+
+let showingOverview = false;
+let finishedShowingOverview = false;
+let overviewShowStart;
+let overviewFrames;
+let overviewLatency;
+let mallocUsedSize = 0;
+let overviewShowCount = 0;
+let haveSwapComplete = false;
+let applicationsShowStart;
+let applicationsShowCount = 0;
+
+function script_overviewShowStart(time) {
+    showingOverview = true;
+    finishedShowingOverview = false;
+    overviewShowStart = time;
+    overviewFrames = 0;
+}
+
+function script_overviewShowDone(_time) {
+    // We've set up the state at the end of the zoom out, but we
+    // need to wait for one more frame to paint before we count
+    // ourselves as done.
+    finishedShowingOverview = true;
+}
+
+function script_applicationsShowStart(time) {
+    applicationsShowStart = time;
+}
+
+function script_applicationsShowDone(time) {
+    applicationsShowCount++;
+    if (applicationsShowCount == 1)
+        METRICS.applicationsShowTimeFirst.value = time - applicationsShowStart;
+    else
+        METRICS.applicationsShowTimeSubsequent.value = time - applicationsShowStart;
+}
+
+function script_afterShowHide(_time) {
+    if (overviewShowCount == 1)
+        METRICS.usedAfterOverview.value = mallocUsedSize;
+    else
+        METRICS.leakedAfterOverview.value = mallocUsedSize - METRICS.usedAfterOverview.value;
+}
+
+function malloc_usedSize(time, bytes) {
+    mallocUsedSize = bytes;
+}
+
+function _frameDone(time) {
+    if (showingOverview) {
+        if (overviewFrames == 0)
+            overviewLatency = time - overviewShowStart;
+
+        overviewFrames++;
+    }
+
+    if (finishedShowingOverview) {
+        showingOverview = false;
+        finishedShowingOverview = false;
+        overviewShowCount++;
+
+        let dt = (time - (overviewShowStart + overviewLatency)) / 1000000;
+
+        // If we see a start frame and an end frame, that would
+        // be 1 frame for a FPS computation, hence the '- 1'
+        let fps = (overviewFrames - 1) / dt;
+
+        if (overviewShowCount == 1) {
+            METRICS.overviewLatencyFirst.value = overviewLatency;
+            METRICS.overviewFpsFirst.value = fps;
+        } else if (overviewShowCount == 2) {
+            METRICS.overviewLatencySubsequent.value = overviewLatency;
+        }
+
+        // Other than overviewFpsFirst, we collect FPS metrics the second
+        // we show each window configuration. overviewShowCount is 1,2,3...
+        if (overviewShowCount % 2 == 0) {
+            let config = WINDOW_CONFIGS[(overviewShowCount / 2) - 1];
+            METRICS[config.metric].value = fps;
+        }
+    }
+}
+
+function glx_swapComplete(time, swapTime) {
+    haveSwapComplete = true;
+
+    _frameDone(swapTime);
+}
+
+function clutter_stagePaintDone(time) {
+    // If we aren't receiving GLXBufferSwapComplete events, then we approximate
+    // the time the user sees a frame with the time we finished doing drawing
+    // commands for the frame. This doesn't take into account the time for
+    // the GPU to finish painting, and the time for waiting for the buffer
+    // swap, but if this are uniform - every frame takes the same time to draw -
+    // then it won't upset our FPS calculation, though the latency value
+    // will be slightly too low.
+
+    if (!haveSwapComplete)
+        _frameDone(time);
+}

js/perf/hwtest.js

@@ -0,0 +1,307 @@
+/* exported run, script_desktopShown, script_overviewShowStart,
+            script_overviewShowDone, script_applicationsShowStart,
+            script_applicationsShowDone, script_mainViewDrawStart,
+            script_mainViewDrawDone, script_overviewDrawStart,
+            script_overviewDrawDone, script_redrawTestStart,
+            script_redrawTestDone, script_collectTimings,
+            script_geditLaunch, script_geditFirstFrame,
+            clutter_stagePaintStart, clutter_paintCompletedTimestamp */
+/* eslint camelcase: ["error", { properties: "never", allow: ["^script_", "^clutter"] }] */
+const { Clutter, Gio, Shell } = imports.gi;
+const Main = imports.ui.main;
+const Scripting = imports.ui.scripting;
+
+var METRICS = {
+    timeToDesktop:
+    { description: "Time from starting graphical.target to desktop showing",
+      units: "us" },
+
+    overviewShowTime:
+    { description: "Time to switch to overview view, first time",
+      units: "us" },
+
+    applicationsShowTime:
+    { description: "Time to switch to applications view, first time",
+      units: "us" },
+
+    mainViewRedrawTime:
+    { description: "Time to redraw the main view, full screen",
+      units: "us" },
+
+    overviewRedrawTime:
+    { description: "Time to redraw the overview, full screen, 5 windows",
+      units: "us" },
+
+    applicationRedrawTime:
+    { description: "Time to redraw frame with a maximized application update",
+      units: "us" },
+
+    geditStartTime:
+    { description: "Time from gedit launch to window drawn",
+      units: "us" },
+};
+
+function waitAndDraw(milliseconds) {
+    let cb;
+
+    let timeline = new Clutter.Timeline({ duration: milliseconds });
+    timeline.start();
+
+    timeline.connect('new-frame', (_timeline, _frame) => {
+        global.stage.queue_redraw();
+    });
+
+    timeline.connect('completed', () => {
+        timeline.stop();
+        if (cb)
+            cb();
+    });
+
+    return callback => (cb = callback);
+}
+
+function waitSignal(object, signal) {
+    let cb;
+
+    let id = object.connect(signal, () => {
+        object.disconnect(id);
+        if (cb)
+            cb();
+    });
+
+    return callback => (cb = callback);
+}
+
+function extractBootTimestamp() {
+    let sp = Gio.Subprocess.new(['journalctl', '-b',
+                                 'MESSAGE_ID=7d4958e842da4a758f6c1cdc7b36dcc5',
+                                 'UNIT=graphical.target',
+                                 '-o',
+                                 'json'],
+                                Gio.SubprocessFlags.STDOUT_PIPE);
+    let result = null;
+
+    let datastream = Gio.DataInputStream.new(sp.get_stdout_pipe());
+    while (true) { // eslint-disable-line no-constant-condition
+        let [line, length_] = datastream.read_line_utf8(null);
+        if (line === null)
+            break;
+
+        let fields = JSON.parse(line);
+        result = Number(fields['__MONOTONIC_TIMESTAMP']);
+    }
+    datastream.close(null);
+    return result;
+}
+
+function *run() {
+    Scripting.defineScriptEvent("desktopShown", "Finished initial animation");
+    Scripting.defineScriptEvent("overviewShowStart", "Starting to show the overview");
+    Scripting.defineScriptEvent("overviewShowDone", "Overview finished showing");
+    Scripting.defineScriptEvent("applicationsShowStart", "Starting to switch to applications view");
+    Scripting.defineScriptEvent("applicationsShowDone", "Done switching to applications view");
+    Scripting.defineScriptEvent("mainViewDrawStart", "Drawing main view");
+    Scripting.defineScriptEvent("mainViewDrawDone", "Ending timing main view drawing");
+    Scripting.defineScriptEvent("overviewDrawStart", "Drawing overview");
+    Scripting.defineScriptEvent("overviewDrawDone", "Ending timing overview drawing");
+    Scripting.defineScriptEvent("redrawTestStart", "Drawing application window");
+    Scripting.defineScriptEvent("redrawTestDone", "Ending timing application window drawing");
+    Scripting.defineScriptEvent("collectTimings", "Accumulate frame timings from redraw tests");
+    Scripting.defineScriptEvent("geditLaunch", "gedit application launch");
+    Scripting.defineScriptEvent("geditFirstFrame", "first frame of gedit window drawn");
+
+    yield Scripting.waitLeisure();
+    Scripting.scriptEvent('desktopShown');
+
+    let interfaceSettings = new Gio.Settings({
+        schema_id: 'org.gnome.desktop.interface',
+    });
+    interfaceSettings.set_boolean('enable-animations', false);
+
+    Scripting.scriptEvent('overviewShowStart');
+    Main.overview.show();
+    yield Scripting.waitLeisure();
+    Scripting.scriptEvent('overviewShowDone');
+
+    yield Scripting.sleep(1000);
+
+    Scripting.scriptEvent('applicationsShowStart');
+    // eslint-disable-next-line require-atomic-updates
+    Main.overview.dash.showAppsButton.checked = true;
+
+    yield Scripting.waitLeisure();
+    Scripting.scriptEvent('applicationsShowDone');
+
+    yield Scripting.sleep(1000);
+
+    Main.overview.hide();
+    yield Scripting.waitLeisure();
+
+    // --------------------- //
+    // Tests of redraw speed //
+    // --------------------- //
+
+    global.frame_timestamps = true;
+    global.frame_finish_timestamp = true;
+
+    for (let k = 0; k < 5; k++)
+        yield Scripting.createTestWindow({ maximized: true });
+    yield Scripting.waitTestWindows();
+
+    yield Scripting.sleep(1000);
+
+    Scripting.scriptEvent('mainViewDrawStart');
+    yield waitAndDraw(1000);
+    Scripting.scriptEvent('mainViewDrawDone');
+
+    Main.overview.show();
+    Scripting.waitLeisure();
+
+    yield Scripting.sleep(1500);
+
+    Scripting.scriptEvent('overviewDrawStart');
+    yield waitAndDraw(1000);
+    Scripting.scriptEvent('overviewDrawDone');
+
+    yield Scripting.destroyTestWindows();
+    Main.overview.hide();
+
+    yield Scripting.createTestWindow({ maximized: true,
+                                       redraws: true });
+    yield Scripting.waitTestWindows();
+
+    yield Scripting.sleep(1000);
+
+    Scripting.scriptEvent('redrawTestStart');
+    yield Scripting.sleep(1000);
+    Scripting.scriptEvent('redrawTestDone');
+
+    yield Scripting.sleep(1000);
+    Scripting.scriptEvent('collectTimings');
+
+    yield Scripting.destroyTestWindows();
+
+    global.frame_timestamps = false;
+    global.frame_finish_timestamp = false;
+
+    yield Scripting.sleep(1000);
+
+    let appSys = Shell.AppSystem.get_default();
+    let app = appSys.lookup_app('org.gnome.gedit.desktop');
+
+    Scripting.scriptEvent('geditLaunch');
+    app.activate();
+
+    let windows = app.get_windows();
+    if (windows.length > 0)
+        throw new Error('gedit was already running');
+
+    while (windows.length == 0) {
+        yield waitSignal(global.display, 'window-created');
+        windows = app.get_windows();
+    }
+
+    let actor = windows[0].get_compositor_private();
+    yield waitSignal(actor, 'first-frame');
+    Scripting.scriptEvent('geditFirstFrame');
+
+    yield Scripting.sleep(1000);
+
+    windows[0].delete(global.get_current_time());
+
+    yield Scripting.sleep(1000);
+
+    interfaceSettings.set_boolean('enable-animations', true);
+}
+
+let overviewShowStart;
+let applicationsShowStart;
+let stagePaintStart;
+let redrawTiming;
+let redrawTimes = {};
+let geditLaunchTime;
+
+function script_desktopShown(time) {
+    let bootTimestamp = extractBootTimestamp();
+    METRICS.timeToDesktop.value = time - bootTimestamp;
+}
+
+function script_overviewShowStart(time) {
+    overviewShowStart = time;
+}
+
+function script_overviewShowDone(time) {
+    METRICS.overviewShowTime.value = time - overviewShowStart;
+}
+
+function script_applicationsShowStart(time) {
+    applicationsShowStart = time;
+}
+
+function script_applicationsShowDone(time) {
+    METRICS.applicationsShowTime.value = time - applicationsShowStart;
+}
+
+function script_mainViewDrawStart(_time) {
+    redrawTiming = 'mainView';
+}
+
+function script_mainViewDrawDone(_time) {
+    redrawTiming = null;
+}
+
+function script_overviewDrawStart(_time) {
+    redrawTiming = 'overview';
+}
+
+function script_overviewDrawDone(_time) {
+    redrawTiming = null;
+}
+
+function script_redrawTestStart(_time) {
+    redrawTiming = 'application';
+}
+
+function script_redrawTestDone(_time) {
+    redrawTiming = null;
+}
+
+function script_collectTimings(_time) {
+    for (let timing in redrawTimes) {
+        let times = redrawTimes[timing];
+        times.sort((a, b) => a - b);
+
+        let len = times.length;
+        let median;
+
+        if (len == 0)
+            median = -1;
+        else if (len % 2 == 1)
+            median = times[(len - 1) / 2];
+        else
+            median = Math.round((times[len / 2 - 1] + times[len / 2]) / 2);
+
+        METRICS[`${timing}RedrawTime`].value = median;
+    }
+}
+
+function script_geditLaunch(time) {
+    geditLaunchTime = time;
+}
+
+function script_geditFirstFrame(time) {
+    METRICS.geditStartTime.value = time - geditLaunchTime;
+}
+
+function clutter_stagePaintStart(time) {
+    stagePaintStart = time;
+}
+
+function clutter_paintCompletedTimestamp(time) {
+    if (redrawTiming != null && stagePaintStart != null) {
+        if (!(redrawTiming in redrawTimes))
+            redrawTimes[redrawTiming] = [];
+        redrawTimes[redrawTiming].push(time - stagePaintStart);
+    }
+    stagePaintStart = null;
+}

js/portal-resources.gresource.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gresources>
+  <gresource prefix="/org/gnome/shell">
+    <file>portalHelper/main.js</file>
+
+    <file>misc/config.js</file>
+    <file>misc/fileUtils.js</file>
+    <file>misc/params.js</file>
+  </gresource>
+</gresources>

js/portalHelper/main.js

@@ -0,0 +1,358 @@
+/* exported main */
+imports.gi.versions.Gtk = '3.0';
+
+const Format = imports.format;
+const Gettext = imports.gettext;
+const { Gio, GLib, GObject, Gtk, Pango, Soup, WebKit2: WebKit } = imports.gi;
+
+const _ = Gettext.gettext;
+
+const Config = imports.misc.config;
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const PortalHelperResult = {
+    CANCELLED: 0,
+    COMPLETED: 1,
+    RECHECK: 2,
+};
+
+const PortalHelperSecurityLevel = {
+    NOT_YET_DETERMINED: 0,
+    SECURE: 1,
+    INSECURE: 2,
+};
+
+const CONNECTIVITY_CHECK_HOST = 'nmcheck.gnome.org';
+const CONNECTIVITY_RECHECK_RATELIMIT_TIMEOUT = 30 * GLib.USEC_PER_SEC;
+
+const HelperDBusInterface = loadInterfaceXML('org.gnome.Shell.PortalHelper');
+
+var PortalHeaderBar = GObject.registerClass(
+class PortalHeaderBar extends Gtk.HeaderBar {
+    _init() {
+        super._init({ show_close_button: true });
+
+        // See ephy-title-box.c in epiphany for the layout
+        let vbox = new Gtk.Box({ orientation: Gtk.Orientation.VERTICAL,
+                                 spacing: 0 });
+        this.set_custom_title(vbox);
+
+        /* TRANSLATORS: this is the title of the wifi captive portal login window */
+        let titleLabel = new Gtk.Label({ label: _("Hotspot Login"),
+                                         wrap: false,
+                                         single_line_mode: true,
+                                         ellipsize: Pango.EllipsizeMode.END });
+        titleLabel.get_style_context().add_class('title');
+        vbox.add(titleLabel);
+
+        let hbox = new Gtk.Box({ orientation: Gtk.Orientation.HORIZONTAL,
+                                 spacing: 4,
+                                 halign: Gtk.Align.CENTER,
+                                 valign: Gtk.Align.BASELINE });
+        hbox.get_style_context().add_class('subtitle');
+        vbox.add(hbox);
+
+        this._lockImage = new Gtk.Image({ icon_size: Gtk.IconSize.MENU,
+                                          valign: Gtk.Align.BASELINE });
+        hbox.add(this._lockImage);
+
+        this.subtitleLabel = new Gtk.Label({ wrap: false,
+                                             single_line_mode: true,
+                                             ellipsize: Pango.EllipsizeMode.END,
+                                             valign: Gtk.Align.BASELINE,
+                                             selectable: true });
+        this.subtitleLabel.get_style_context().add_class('subtitle');
+        hbox.add(this.subtitleLabel);
+
+        vbox.show_all();
+    }
+
+    setSubtitle(label) {
+        this.subtitleLabel.set_text(label);
+    }
+
+    setSecurityIcon(securityLevel) {
+        switch (securityLevel) {
+        case PortalHelperSecurityLevel.NOT_YET_DETERMINED:
+            this._lockImage.hide();
+            break;
+        case PortalHelperSecurityLevel.SECURE:
+            this._lockImage.show();
+            this._lockImage.set_from_icon_name("channel-secure-symbolic", Gtk.IconSize.MENU);
+            this._lockImage.set_tooltip_text(null);
+            break;
+        case PortalHelperSecurityLevel.INSECURE:
+            this._lockImage.show();
+            this._lockImage.set_from_icon_name("channel-insecure-symbolic", Gtk.IconSize.MENU);
+            this._lockImage.set_tooltip_text(_('Your connection to this hotspot login is not secure. Passwords or other information you enter on this page can be viewed by people nearby.'));
+            break;
+        }
+    }
+});
+
+var PortalWindow = GObject.registerClass(
+class PortalWindow extends Gtk.ApplicationWindow {
+    _init(application, url, timestamp, doneCallback) {
+        super._init({ application });
+
+        this.connect('delete-event', this.destroyWindow.bind(this));
+        this._headerBar = new PortalHeaderBar();
+        this._headerBar.setSecurityIcon(PortalHelperSecurityLevel.NOT_YET_DETERMINED);
+        this.set_titlebar(this._headerBar);
+        this._headerBar.show();
+
+        if (!url) {
+            url = 'http://%s'.format(CONNECTIVITY_CHECK_HOST);
+            this._originalUrlWasGnome = true;
+        } else {
+            this._originalUrlWasGnome = false;
+        }
+        this._uri = new Soup.URI(url);
+        this._everSeenRedirect = false;
+        this._originalUrl = url;
+        this._doneCallback = doneCallback;
+        this._lastRecheck = 0;
+        this._recheckAtExit = false;
+
+        this._webContext = WebKit.WebContext.new_ephemeral();
+        this._webContext.set_cache_model(WebKit.CacheModel.DOCUMENT_VIEWER);
+        this._webContext.set_network_proxy_settings(WebKit.NetworkProxyMode.NO_PROXY, null);
+        if (this._webContext.set_sandbox_enabled) {
+            // We have WebKitGTK 2.26 or newer.
+            this._webContext.set_sandbox_enabled(true);
+        }
+
+        this._webView = WebKit.WebView.new_with_context(this._webContext);
+        this._webView.connect('decide-policy', this._onDecidePolicy.bind(this));
+        this._webView.connect('load-changed', this._onLoadChanged.bind(this));
+        this._webView.connect('insecure-content-detected', this._onInsecureContentDetected.bind(this));
+        this._webView.connect('load-failed-with-tls-errors', this._onLoadFailedWithTlsErrors.bind(this));
+        this._webView.load_uri(url);
+        this._webView.connect('notify::uri', this._syncUri.bind(this));
+        this._syncUri();
+
+        this.add(this._webView);
+        this._webView.show();
+        this.set_size_request(600, 450);
+        this.maximize();
+        this.present_with_time(timestamp);
+
+        this.application.set_accels_for_action('app.quit', ['<Primary>q', '<Primary>w']);
+    }
+
+    destroyWindow() {
+        this.destroy();
+    }
+
+    _syncUri() {
+        let uri = this._webView.uri;
+        if (uri)
+            this._headerBar.setSubtitle(GLib.uri_unescape_string(uri, null));
+        else
+            this._headerBar.setSubtitle('');
+    }
+
+    refresh() {
+        this._everSeenRedirect = false;
+        this._webView.load_uri(this._originalUrl);
+    }
+
+    vfunc_delete_event(_event) {
+        if (this._recheckAtExit)
+            this._doneCallback(PortalHelperResult.RECHECK);
+        else
+            this._doneCallback(PortalHelperResult.CANCELLED);
+        return false;
+    }
+
+    _onLoadChanged(view, loadEvent) {
+        if (loadEvent == WebKit.LoadEvent.STARTED) {
+            this._headerBar.setSecurityIcon(PortalHelperSecurityLevel.NOT_YET_DETERMINED);
+        } else if (loadEvent == WebKit.LoadEvent.COMMITTED) {
+            let tlsInfo = this._webView.get_tls_info();
+            let ret = tlsInfo[0];
+            let flags = tlsInfo[2];
+            if (ret && flags == 0)
+                this._headerBar.setSecurityIcon(PortalHelperSecurityLevel.SECURE);
+            else
+                this._headerBar.setSecurityIcon(PortalHelperSecurityLevel.INSECURE);
+        }
+    }
+
+    _onInsecureContentDetected() {
+        this._headerBar.setSecurityIcon(PortalHelperSecurityLevel.INSECURE);
+    }
+
+    _onLoadFailedWithTlsErrors(view, failingURI, certificate, _errors) {
+        this._headerBar.setSecurityIcon(PortalHelperSecurityLevel.INSECURE);
+        let uri = new Soup.URI(failingURI);
+        this._webContext.allow_tls_certificate_for_host(certificate, uri.get_host());
+        this._webView.load_uri(failingURI);
+        return true;
+    }
+
+    _onDecidePolicy(view, decision, type) {
+        if (type == WebKit.PolicyDecisionType.NEW_WINDOW_ACTION) {
+            let navigationAction = decision.get_navigation_action();
+            if (navigationAction.is_user_gesture()) {
+                // Even though the portal asks for a new window,
+                // perform the navigation in the current one. Some
+                // portals open a window as their last login step and
+                // ignoring that window causes them to not let the
+                // user go through. We don't risk popups taking over
+                // the page because we check that the navigation is
+                // user initiated.
+                this._webView.load_request(navigationAction.get_request());
+            }
+
+            decision.ignore();
+            return true;
+        }
+
+        if (type != WebKit.PolicyDecisionType.NAVIGATION_ACTION)
+            return false;
+
+        let request = decision.get_request();
+        let uri = new Soup.URI(request.get_uri());
+
+        if (!uri.host_equal(this._uri) && this._originalUrlWasGnome) {
+            if (uri.get_host() == CONNECTIVITY_CHECK_HOST && this._everSeenRedirect) {
+                // Yay, we got to gnome!
+                decision.ignore();
+                this._doneCallback(PortalHelperResult.COMPLETED);
+                return true;
+            } else if (uri.get_host() != CONNECTIVITY_CHECK_HOST) {
+                this._everSeenRedirect = true;
+            }
+        }
+
+        // We *may* have finished here, but we don't know for
+        // sure. Tell gnome-shell to run another connectivity check
+        // (but ratelimit the checks, we don't want to spam
+        // nmcheck.gnome.org for portals that have 10 or more internal
+        // redirects - and unfortunately they exist)
+        // If we hit the rate limit, we also queue a recheck
+        // when the window is closed, just in case we miss the
+        // final check and don't realize we're connected
+        // This should not be a problem in the cancelled logic,
+        // because if the user doesn't want to start the login,
+        // we should not see any redirect at all, outside this._uri
+
+        let now = GLib.get_monotonic_time();
+        let shouldRecheck = (now - this._lastRecheck) >
+            CONNECTIVITY_RECHECK_RATELIMIT_TIMEOUT;
+
+        if (shouldRecheck) {
+            this._lastRecheck = now;
+            this._recheckAtExit = false;
+            this._doneCallback(PortalHelperResult.RECHECK);
+        } else {
+            this._recheckAtExit = true;
+        }
+
+        // Update the URI, in case of chained redirects, so we still
+        // think we're doing the login until gnome-shell kills us
+        this._uri = uri;
+
+        decision.use();
+        return true;
+    }
+});
+
+var WebPortalHelper = GObject.registerClass(
+class WebPortalHelper extends Gtk.Application {
+    _init() {
+        super._init({ application_id: 'org.gnome.Shell.PortalHelper',
+                      flags: Gio.ApplicationFlags.IS_SERVICE,
+                      inactivity_timeout: 30000 });
+
+        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(HelperDBusInterface, this);
+        this._queue = [];
+
+        let action = new Gio.SimpleAction({ name: 'quit' });
+        action.connect('activate', () => this.active_window.destroyWindow());
+        this.add_action(action);
+    }
+
+    vfunc_dbus_register(connection, path) {
+        this._dbusImpl.export(connection, path);
+        super.vfunc_dbus_register(connection, path);
+        return true;
+    }
+
+    vfunc_dbus_unregister(connection, path) {
+        this._dbusImpl.unexport_from_connection(connection);
+        super.vfunc_dbus_unregister(connection, path);
+    }
+
+    vfunc_activate() {
+        // If launched manually (for example for testing), force a dummy authentication
+        // session with the default url
+        this.Authenticate('/org/gnome/dummy', '', 0);
+    }
+
+    Authenticate(connection, url, timestamp) {
+        this._queue.push({ connection, url, timestamp });
+
+        this._processQueue();
+    }
+
+    Close(connection) {
+        for (let i = 0; i < this._queue.length; i++) {
+            let obj = this._queue[i];
+
+            if (obj.connection == connection) {
+                if (obj.window)
+                    obj.window.destroyWindow();
+                this._queue.splice(i, 1);
+                break;
+            }
+        }
+
+        this._processQueue();
+    }
+
+    Refresh(connection) {
+        for (let i = 0; i < this._queue.length; i++) {
+            let obj = this._queue[i];
+
+            if (obj.connection == connection) {
+                if (obj.window)
+                    obj.window.refresh();
+                break;
+            }
+        }
+    }
+
+    _processQueue() {
+        if (this._queue.length == 0)
+            return;
+
+        let top = this._queue[0];
+        if (top.window != null)
+            return;
+
+        top.window = new PortalWindow(this, top.url, top.timestamp, result => {
+            this._dbusImpl.emit_signal('Done', new GLib.Variant('(ou)', [top.connection, result]));
+        });
+    }
+});
+
+function initEnvironment() {
+    String.prototype.format = Format.format;
+}
+
+function main(argv) {
+    initEnvironment();
+
+    if (!WebKit.WebContext.new_ephemeral) {
+        log('WebKitGTK 2.16 is required for the portal-helper, see https://bugzilla.gnome.org/show_bug.cgi?id=780453');
+        return 1;
+    }
+
+    Gettext.bindtextdomain(Config.GETTEXT_PACKAGE, Config.LOCALEDIR);
+    Gettext.textdomain(Config.GETTEXT_PACKAGE);
+
+    let app = new WebPortalHelper();
+    return app.run(argv);
+}

js/prefs-resources.gresource.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gresources>
+  <gresource prefix="/org/gnome/shell">
+    <file>extensionPrefs/main.js</file>
+
+    <file>misc/config.js</file>
+    <file>misc/extensionUtils.js</file>
+    <file>misc/fileUtils.js</file>
+    <file>misc/params.js</file>
+
+    <file alias="css/application.css">extensionPrefs/css/application.css</file>
+
+    <file alias="ui/extension-row.ui">extensionPrefs/ui/extension-row.ui</file>
+    <file alias="ui/extensions-window.ui">extensionPrefs/ui/extensions-window.ui</file>
+  </gresource>
+</gresources>

js/ui/accessDialog.js

@@ -0,0 +1,156 @@
+/* exported AccessDialogDBus */
+const { Clutter, Gio, GLib, GObject, Shell, St } = imports.gi;
+
+const CheckBox = imports.ui.checkBox;
+const Dialog = imports.ui.dialog;
+const ModalDialog = imports.ui.modalDialog;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const RequestIface = loadInterfaceXML('org.freedesktop.impl.portal.Request');
+const AccessIface = loadInterfaceXML('org.freedesktop.impl.portal.Access');
+
+var DialogResponse = {
+    OK: 0,
+    CANCEL: 1,
+    CLOSED: 2,
+};
+
+var AccessDialog = GObject.registerClass(
+class AccessDialog extends ModalDialog.ModalDialog {
+    _init(invocation, handle, title, description, body, options) {
+        super._init({ styleClass: 'access-dialog' });
+
+        this._invocation = invocation;
+        this._handle = handle;
+
+        this._requestExported = false;
+        this._request = Gio.DBusExportedObject.wrapJSObject(RequestIface, this);
+
+        for (let option in options)
+            options[option] = options[option].deep_unpack();
+
+        this._buildLayout(title, description, body, options);
+    }
+
+    _buildLayout(title, description, body, options) {
+        // No support for non-modal system dialogs, so ignore the option
+        // let modal = options['modal'] || true;
+        let denyLabel = options['deny_label'] || _("Deny Access");
+        let grantLabel = options['grant_label'] || _("Grant Access");
+        let choices = options['choices'] || [];
+
+        let content = new Dialog.MessageDialogContent({ title, description });
+        this.contentLayout.add_actor(content);
+
+        this._choices = new Map();
+
+        for (let i = 0; i < choices.length; i++) {
+            let [id, name, opts, selected] = choices[i];
+            if (opts.length > 0)
+                continue; // radio buttons, not implemented
+
+            let check = new CheckBox.CheckBox();
+            check.getLabelActor().text = name;
+            check.checked = selected == "true";
+            content.add_child(check);
+
+            this._choices.set(id, check);
+        }
+
+        let bodyLabel = new St.Label({
+            text: body,
+            x_align: Clutter.ActorAlign.CENTER,
+        });
+        content.add_child(bodyLabel);
+
+        this.addButton({ label: denyLabel,
+                         action: () => {
+                             this._sendResponse(DialogResponse.CANCEL);
+                         },
+                         key: Clutter.KEY_Escape });
+        this.addButton({ label: grantLabel,
+                         action: () => {
+                             this._sendResponse(DialogResponse.OK);
+                         } });
+    }
+
+    open() {
+        super.open();
+
+        let connection = this._invocation.get_connection();
+        this._requestExported = this._request.export(connection, this._handle);
+    }
+
+    CloseAsync(invocation, _params) {
+        if (this._invocation.get_sender() != invocation.get_sender()) {
+            invocation.return_error_literal(Gio.DBusError,
+                                            Gio.DBusError.ACCESS_DENIED,
+                                            '');
+            return;
+        }
+
+        this._sendResponse(DialogResponse.CLOSED);
+    }
+
+    _sendResponse(response) {
+        if (this._requestExported)
+            this._request.unexport();
+        this._requestExported = false;
+
+        let results = {};
+        if (response == DialogResponse.OK) {
+            for (let [id, check] of this._choices) {
+                let checked = check.checked ? 'true' : 'false';
+                results[id] = new GLib.Variant('s', checked);
+            }
+        }
+
+        // Delay actual response until the end of the close animation (if any)
+        this.connect('closed', () => {
+            this._invocation.return_value(new GLib.Variant('(ua{sv})',
+                                                           [response, results]));
+        });
+        this.close();
+    }
+});
+
+var AccessDialogDBus = class {
+    constructor() {
+        this._accessDialog = null;
+
+        this._windowTracker = Shell.WindowTracker.get_default();
+
+        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(AccessIface, this);
+        this._dbusImpl.export(Gio.DBus.session, '/org/freedesktop/portal/desktop');
+
+        Gio.DBus.session.own_name('org.freedesktop.impl.portal.desktop.gnome', Gio.BusNameOwnerFlags.REPLACE, null, null);
+    }
+
+    AccessDialogAsync(params, invocation) {
+        if (this._accessDialog) {
+            invocation.return_error_literal(Gio.DBusError,
+                                            Gio.DBusError.LIMITS_EXCEEDED,
+                                            'Already showing a system access dialog');
+            return;
+        }
+
+        let [handle, appId, parentWindow_, title, description, body, options] = params;
+        // We probably want to use parentWindow and global.display.focus_window
+        // for this check in the future
+        if (appId && '%s.desktop'.format(appId) != this._windowTracker.focus_app.id) {
+            invocation.return_error_literal(Gio.DBusError,
+                                            Gio.DBusError.ACCESS_DENIED,
+                                            'Only the focused app is allowed to show a system access dialog');
+            return;
+        }
+
+        let dialog = new AccessDialog(
+            invocation, handle, title, description, body, options);
+        dialog.open();
+
+        dialog.connect('closed', () => (this._accessDialog = null));
+
+        this._accessDialog = dialog;
+    }
+};

js/ui/animation.js

@@ -0,0 +1,208 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Animation, AnimatedIcon, Spinner */
+
+const { Clutter, GLib, GObject, Gio, St } = imports.gi;
+
+const Params = imports.misc.params;
+
+var ANIMATED_ICON_UPDATE_TIMEOUT = 16;
+var SPINNER_ANIMATION_TIME = 300;
+var SPINNER_ANIMATION_DELAY = 1000;
+
+var Animation = GObject.registerClass(
+class Animation extends St.Bin {
+    _init(file, width, height, speed) {
+        const themeContext = St.ThemeContext.get_for_stage(global.stage);
+
+        super._init({
+            width: width * themeContext.scale_factor,
+            height: height * themeContext.scale_factor,
+        });
+
+        this.connect('destroy', this._onDestroy.bind(this));
+        this.connect('resource-scale-changed',
+            this._loadFile.bind(this, file, width, height));
+
+        this._scaleChangedId = themeContext.connect('notify::scale-factor',
+            () => {
+                this._loadFile(file, width, height);
+                this.set_size(width * themeContext.scale_factor, height * themeContext.scale_factor);
+            });
+
+        this._speed = speed;
+
+        this._isLoaded = false;
+        this._isPlaying = false;
+        this._timeoutId = 0;
+        this._frame = 0;
+
+        this._loadFile(file, width, height);
+    }
+
+    play() {
+        if (this._isLoaded && this._timeoutId == 0) {
+            if (this._frame == 0)
+                this._showFrame(0);
+
+            this._timeoutId = GLib.timeout_add(GLib.PRIORITY_LOW, this._speed, this._update.bind(this));
+            GLib.Source.set_name_by_id(this._timeoutId, '[gnome-shell] this._update');
+        }
+
+        this._isPlaying = true;
+    }
+
+    stop() {
+        if (this._timeoutId > 0) {
+            GLib.source_remove(this._timeoutId);
+            this._timeoutId = 0;
+        }
+
+        this._isPlaying = false;
+    }
+
+    _loadFile(file, width, height) {
+        let [validResourceScale, resourceScale] = this.get_resource_scale();
+        let wasPlaying = this._isPlaying;
+
+        if (this._isPlaying)
+            this.stop();
+
+        this._isLoaded = false;
+        this.destroy_all_children();
+
+        if (!validResourceScale) {
+            if (wasPlaying)
+                this.play();
+            return;
+        }
+
+        let textureCache = St.TextureCache.get_default();
+        let scaleFactor = St.ThemeContext.get_for_stage(global.stage).scale_factor;
+        this._animations = textureCache.load_sliced_image(file, width, height,
+                                                          scaleFactor, resourceScale,
+                                                          this._animationsLoaded.bind(this));
+        this._animations.set({
+            x_align: Clutter.ActorAlign.CENTER,
+            y_align: Clutter.ActorAlign.CENTER,
+        });
+        this.set_child(this._animations);
+
+        if (wasPlaying)
+            this.play();
+    }
+
+    _showFrame(frame) {
+        let oldFrameActor = this._animations.get_child_at_index(this._frame);
+        if (oldFrameActor)
+            oldFrameActor.hide();
+
+        this._frame = frame % this._animations.get_n_children();
+
+        let newFrameActor = this._animations.get_child_at_index(this._frame);
+        if (newFrameActor)
+            newFrameActor.show();
+    }
+
+    _update() {
+        this._showFrame(this._frame + 1);
+        return GLib.SOURCE_CONTINUE;
+    }
+
+    _syncAnimationSize() {
+        if (!this._isLoaded)
+            return;
+
+        let [width, height] = this.get_size();
+
+        for (let i = 0; i < this._animations.get_n_children(); ++i)
+            this._animations.get_child_at_index(i).set_size(width, height);
+    }
+
+    _animationsLoaded() {
+        this._isLoaded = this._animations.get_n_children() > 0;
+
+        this._syncAnimationSize();
+
+        if (this._isPlaying)
+            this.play();
+    }
+
+    _onDestroy() {
+        this.stop();
+
+        let themeContext = St.ThemeContext.get_for_stage(global.stage);
+        if (this._scaleChangedId)
+            themeContext.disconnect(this._scaleChangedId);
+        this._scaleChangedId = 0;
+    }
+});
+
+var AnimatedIcon = GObject.registerClass(
+class AnimatedIcon extends Animation {
+    _init(file, size) {
+        super._init(file, size, size, ANIMATED_ICON_UPDATE_TIMEOUT);
+    }
+});
+
+var Spinner = GObject.registerClass(
+class Spinner extends AnimatedIcon {
+    _init(size, params) {
+        params = Params.parse(params, {
+            animate: false,
+            hideOnStop: false,
+        });
+        let file = Gio.File.new_for_uri('resource:///org/gnome/shell/theme/process-working.svg');
+        super._init(file, size);
+
+        this.opacity = 0;
+        this._animate = params.animate;
+        this._hideOnStop = params.hideOnStop;
+        this.visible = !this._hideOnStop;
+    }
+
+    _onDestroy() {
+        this._animate = false;
+        super._onDestroy();
+    }
+
+    play() {
+        this.remove_all_transitions();
+        this.show();
+
+        if (this._animate) {
+            super.play();
+            this.ease({
+                opacity: 255,
+                delay: SPINNER_ANIMATION_DELAY,
+                duration: SPINNER_ANIMATION_TIME,
+                mode: Clutter.AnimationMode.LINEAR,
+            });
+        } else {
+            this.opacity = 255;
+            super.play();
+        }
+    }
+
+    stop() {
+        this.remove_all_transitions();
+
+        if (this._animate) {
+            this.ease({
+                opacity: 0,
+                duration: SPINNER_ANIMATION_TIME,
+                mode: Clutter.AnimationMode.LINEAR,
+                onComplete: () => {
+                    super.stop();
+                    if (this._hideOnStop)
+                        this.hide();
+                },
+            });
+        } else {
+            this.opacity = 0;
+            super.stop();
+
+            if (this._hideOnStop)
+                this.hide();
+        }
+    }
+});

js/ui/appFavorites.js

@@ -0,0 +1,199 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported getAppFavorites */
+
+const Shell = imports.gi.Shell;
+const Signals = imports.signals;
+
+const Main = imports.ui.main;
+
+// In alphabetical order
+const RENAMED_DESKTOP_IDS = {
+    'baobab.desktop': 'org.gnome.baobab.desktop',
+    'cheese.desktop': 'org.gnome.Cheese.desktop',
+    'dconf-editor.desktop': 'ca.desrt.dconf-editor.desktop',
+    'empathy.desktop': 'org.gnome.Empathy.desktop',
+    'epiphany.desktop': 'org.gnome.Epiphany.desktop',
+    'evolution.desktop': 'org.gnome.Evolution.desktop',
+    'file-roller.desktop': 'org.gnome.FileRoller.desktop',
+    'five-or-more.desktop': 'org.gnome.five-or-more.desktop',
+    'four-in-a-row.desktop': 'org.gnome.Four-in-a-row.desktop',
+    'gcalctool.desktop': 'org.gnome.Calculator.desktop',
+    'geary.desktop': 'org.gnome.Geary.desktop',
+    'gedit.desktop': 'org.gnome.gedit.desktop',
+    'glchess.desktop': 'org.gnome.Chess.desktop',
+    'glines.desktop': 'org.gnome.five-or-more.desktop',
+    'gnect.desktop': 'org.gnome.Four-in-a-row.desktop',
+    'gnibbles.desktop': 'org.gnome.Nibbles.desktop',
+    'gnobots2.desktop': 'org.gnome.Robots.desktop',
+    'gnome-boxes.desktop': 'org.gnome.Boxes.desktop',
+    'gnome-calculator.desktop': 'org.gnome.Calculator.desktop',
+    'gnome-chess.desktop': 'org.gnome.Chess.desktop',
+    'gnome-clocks.desktop': 'org.gnome.clocks.desktop',
+    'gnome-contacts.desktop': 'org.gnome.Contacts.desktop',
+    'gnome-documents.desktop': 'org.gnome.Documents.desktop',
+    'gnome-font-viewer.desktop': 'org.gnome.font-viewer.desktop',
+    'gnome-klotski.desktop': 'org.gnome.Klotski.desktop',
+    'gnome-nibbles.desktop': 'org.gnome.Nibbles.desktop',
+    'gnome-mahjongg.desktop': 'org.gnome.Mahjongg.desktop',
+    'gnome-mines.desktop': 'org.gnome.Mines.desktop',
+    'gnome-music.desktop': 'org.gnome.Music.desktop',
+    'gnome-photos.desktop': 'org.gnome.Photos.desktop',
+    'gnome-robots.desktop': 'org.gnome.Robots.desktop',
+    'gnome-screenshot.desktop': 'org.gnome.Screenshot.desktop',
+    'gnome-software.desktop': 'org.gnome.Software.desktop',
+    'gnome-terminal.desktop': 'org.gnome.Terminal.desktop',
+    'gnome-tetravex.desktop': 'org.gnome.Tetravex.desktop',
+    'gnome-tweaks.desktop': 'org.gnome.tweaks.desktop',
+    'gnome-weather.desktop': 'org.gnome.Weather.desktop',
+    'gnomine.desktop': 'org.gnome.Mines.desktop',
+    'gnotravex.desktop': 'org.gnome.Tetravex.desktop',
+    'gnotski.desktop': 'org.gnome.Klotski.desktop',
+    'gtali.desktop': 'org.gnome.Tali.desktop',
+    'iagno.desktop': 'org.gnome.Reversi.desktop',
+    'nautilus.desktop': 'org.gnome.Nautilus.desktop',
+    'org.gnome.gnome-2048.desktop': 'org.gnome.TwentyFortyEight.desktop',
+    'org.gnome.taquin.desktop': 'org.gnome.Taquin.desktop',
+    'org.gnome.Weather.Application.desktop': 'org.gnome.Weather.desktop',
+    'polari.desktop': 'org.gnome.Polari.desktop',
+    'seahorse.desktop': 'org.gnome.seahorse.Application.desktop',
+    'shotwell.desktop': 'org.gnome.Shotwell.desktop',
+    'tali.desktop': 'org.gnome.Tali.desktop',
+    'totem.desktop': 'org.gnome.Totem.desktop',
+    'evince.desktop': 'org.gnome.Evince.desktop',
+};
+
+class AppFavorites {
+    constructor() {
+        this.FAVORITE_APPS_KEY = 'favorite-apps';
+        this._favorites = {};
+        global.settings.connect('changed::%s'.format(this.FAVORITE_APPS_KEY), this._onFavsChanged.bind(this));
+        this.reload();
+    }
+
+    _onFavsChanged() {
+        this.reload();
+        this.emit('changed');
+    }
+
+    reload() {
+        let ids = global.settings.get_strv(this.FAVORITE_APPS_KEY);
+        let appSys = Shell.AppSystem.get_default();
+
+        // Map old desktop file names to the current ones
+        let updated = false;
+        ids = ids.map(id => {
+            let newId = RENAMED_DESKTOP_IDS[id];
+            if (newId !== undefined &&
+                appSys.lookup_app(newId) != null) {
+                updated = true;
+                return newId;
+            }
+            return id;
+        });
+        // ... and write back the updated desktop file names
+        if (updated)
+            global.settings.set_strv(this.FAVORITE_APPS_KEY, ids);
+
+        let apps = ids.map(id => appSys.lookup_app(id))
+                      .filter(app => app != null);
+        this._favorites = {};
+        for (let i = 0; i < apps.length; i++) {
+            let app = apps[i];
+            this._favorites[app.get_id()] = app;
+        }
+    }
+
+    _getIds() {
+        let ret = [];
+        for (let id in this._favorites)
+            ret.push(id);
+        return ret;
+    }
+
+    getFavoriteMap() {
+        return this._favorites;
+    }
+
+    getFavorites() {
+        let ret = [];
+        for (let id in this._favorites)
+            ret.push(this._favorites[id]);
+        return ret;
+    }
+
+    isFavorite(appId) {
+        return appId in this._favorites;
+    }
+
+    _addFavorite(appId, pos) {
+        if (appId in this._favorites)
+            return false;
+
+        let app = Shell.AppSystem.get_default().lookup_app(appId);
+
+        if (!app)
+            return false;
+
+        let ids = this._getIds();
+        if (pos == -1)
+            ids.push(appId);
+        else
+            ids.splice(pos, 0, appId);
+        global.settings.set_strv(this.FAVORITE_APPS_KEY, ids);
+        return true;
+    }
+
+    addFavoriteAtPos(appId, pos) {
+        if (!this._addFavorite(appId, pos))
+            return;
+
+        let app = Shell.AppSystem.get_default().lookup_app(appId);
+
+        let msg = _("%s has been added to your favorites.").format(app.get_name());
+        Main.overview.setMessage(msg, {
+            forFeedback: true,
+            undoCallback: () => this._removeFavorite(appId),
+        });
+    }
+
+    addFavorite(appId) {
+        this.addFavoriteAtPos(appId, -1);
+    }
+
+    moveFavoriteToPos(appId, pos) {
+        this._removeFavorite(appId);
+        this._addFavorite(appId, pos);
+    }
+
+    _removeFavorite(appId) {
+        if (!(appId in this._favorites))
+            return false;
+
+        let ids = this._getIds().filter(id => id != appId);
+        global.settings.set_strv(this.FAVORITE_APPS_KEY, ids);
+        return true;
+    }
+
+    removeFavorite(appId) {
+        let ids = this._getIds();
+        let pos = ids.indexOf(appId);
+
+        let app = this._favorites[appId];
+        if (!this._removeFavorite(appId))
+            return;
+
+        let msg = _("%s has been removed from your favorites.").format(app.get_name());
+        Main.overview.setMessage(msg, {
+            forFeedback: true,
+            undoCallback: () => this._addFavorite(appId, pos),
+        });
+    }
+}
+Signals.addSignalMethods(AppFavorites.prototype);
+
+var appFavoritesInstance = null;
+function getAppFavorites() {
+    if (appFavoritesInstance == null)
+        appFavoritesInstance = new AppFavorites();
+    return appFavoritesInstance;
+}

js/ui/audioDeviceSelection.js

@@ -0,0 +1,195 @@
+/* exported AudioDeviceSelectionDBus */
+const { Clutter, Gio, GLib, GObject, Meta, Shell, St } = imports.gi;
+
+const Dialog = imports.ui.dialog;
+const Main = imports.ui.main;
+const ModalDialog = imports.ui.modalDialog;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+var AudioDevice = {
+    HEADPHONES: 1 << 0,
+    HEADSET:    1 << 1,
+    MICROPHONE: 1 << 2,
+};
+
+const AudioDeviceSelectionIface = loadInterfaceXML('org.gnome.Shell.AudioDeviceSelection');
+
+var AudioDeviceSelectionDialog = GObject.registerClass({
+    Signals: { 'device-selected': { param_types: [GObject.TYPE_UINT] } },
+}, class AudioDeviceSelectionDialog extends ModalDialog.ModalDialog {
+    _init(devices) {
+        super._init({ styleClass: 'audio-device-selection-dialog' });
+
+        this._deviceItems = {};
+
+        this._buildLayout();
+
+        if (devices & AudioDevice.HEADPHONES)
+            this._addDevice(AudioDevice.HEADPHONES);
+        if (devices & AudioDevice.HEADSET)
+            this._addDevice(AudioDevice.HEADSET);
+        if (devices & AudioDevice.MICROPHONE)
+            this._addDevice(AudioDevice.MICROPHONE);
+
+        if (this._selectionBox.get_n_children() < 2)
+            throw new Error('Too few devices for a selection');
+    }
+
+    _buildLayout() {
+        let content = new Dialog.MessageDialogContent({
+            title: _('Select Audio Device'),
+        });
+
+        this._selectionBox = new St.BoxLayout({
+            style_class: 'audio-selection-box',
+            x_expand: true,
+        });
+        content.add_child(this._selectionBox);
+
+        this.contentLayout.add_child(content);
+
+        if (Main.sessionMode.allowSettings) {
+            this.addButton({ action: this._openSettings.bind(this),
+                             label: _("Sound Settings") });
+        }
+        this.addButton({ action: this.close.bind(this),
+                         label: _("Cancel"),
+                         key: Clutter.KEY_Escape });
+    }
+
+    _getDeviceLabel(device) {
+        switch (device) {
+        case AudioDevice.HEADPHONES:
+            return _("Headphones");
+        case AudioDevice.HEADSET:
+            return _("Headset");
+        case AudioDevice.MICROPHONE:
+            return _("Microphone");
+        default:
+            return null;
+        }
+    }
+
+    _getDeviceIcon(device) {
+        switch (device) {
+        case AudioDevice.HEADPHONES:
+            return 'audio-headphones-symbolic';
+        case AudioDevice.HEADSET:
+            return 'audio-headset-symbolic';
+        case AudioDevice.MICROPHONE:
+            return 'audio-input-microphone-symbolic';
+        default:
+            return null;
+        }
+    }
+
+    _addDevice(device) {
+        let box = new St.BoxLayout({ style_class: 'audio-selection-device-box',
+                                     vertical: true });
+        box.connect('notify::height', () => {
+            Meta.later_add(Meta.LaterType.BEFORE_REDRAW, () => {
+                box.width = box.height;
+                return GLib.SOURCE_REMOVE;
+            });
+        });
+
+        let icon = new St.Icon({ style_class: 'audio-selection-device-icon',
+                                 icon_name: this._getDeviceIcon(device) });
+        box.add(icon);
+
+        let label = new St.Label({ style_class: 'audio-selection-device-label',
+                                   text: this._getDeviceLabel(device),
+                                   x_align: Clutter.ActorAlign.CENTER });
+        box.add(label);
+
+        let button = new St.Button({ style_class: 'audio-selection-device',
+                                     can_focus: true,
+                                     child: box });
+        this._selectionBox.add(button);
+
+        button.connect('clicked', () => {
+            this.emit('device-selected', device);
+            this.close();
+            Main.overview.hide();
+        });
+    }
+
+    _openSettings() {
+        let desktopFile = 'gnome-sound-panel.desktop';
+        let app = Shell.AppSystem.get_default().lookup_app(desktopFile);
+
+        if (!app) {
+            log('Settings panel for desktop file %s could not be loaded!'.format(desktopFile));
+            return;
+        }
+
+        this.close();
+        Main.overview.hide();
+        app.activate();
+    }
+});
+
+var AudioDeviceSelectionDBus = class AudioDeviceSelectionDBus {
+    constructor() {
+        this._audioSelectionDialog = null;
+
+        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(AudioDeviceSelectionIface, this);
+        this._dbusImpl.export(Gio.DBus.session, '/org/gnome/Shell/AudioDeviceSelection');
+
+        Gio.DBus.session.own_name('org.gnome.Shell.AudioDeviceSelection', Gio.BusNameOwnerFlags.REPLACE, null, null);
+    }
+
+    _onDialogClosed() {
+        this._audioSelectionDialog = null;
+    }
+
+    _onDeviceSelected(dialog, device) {
+        let connection = this._dbusImpl.get_connection();
+        let info = this._dbusImpl.get_info();
+        let deviceName = Object.keys(AudioDevice).filter(
+            dev => AudioDevice[dev] == device
+        )[0].toLowerCase();
+        connection.emit_signal(this._audioSelectionDialog._sender,
+                               this._dbusImpl.get_object_path(),
+                               info ? info.name : null,
+                               'DeviceSelected',
+                               GLib.Variant.new('(s)', [deviceName]));
+    }
+
+    OpenAsync(params, invocation) {
+        if (this._audioSelectionDialog) {
+            invocation.return_value(null);
+            return;
+        }
+
+        let [deviceNames] = params;
+        let devices = 0;
+        deviceNames.forEach(n => (devices |= AudioDevice[n.toUpperCase()]));
+
+        let dialog;
+        try {
+            dialog = new AudioDeviceSelectionDialog(devices);
+        } catch (e) {
+            invocation.return_value(null);
+            return;
+        }
+        dialog._sender = invocation.get_sender();
+
+        dialog.connect('closed', this._onDialogClosed.bind(this));
+        dialog.connect('device-selected',
+                       this._onDeviceSelected.bind(this));
+        dialog.open();
+
+        this._audioSelectionDialog = dialog;
+        invocation.return_value(null);
+    }
+
+    CloseAsync(params, invocation) {
+        if (this._audioSelectionDialog &&
+            this._audioSelectionDialog._sender == invocation.get_sender())
+            this._audioSelectionDialog.close();
+
+        invocation.return_value(null);
+    }
+};

js/ui/background.js

@@ -0,0 +1,772 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported SystemBackground */
+
+// READ THIS FIRST
+// Background handling is a maze of objects, both objects in this file, and
+// also objects inside Mutter. They all have a role.
+//
+// BackgroundManager
+//   The only object that other parts of GNOME Shell deal with; a
+//   BackgroundManager creates background actors and adds them to
+//   the specified container. When the background is changed by the
+//   user it will fade out the old actor and fade in the new actor.
+//   (This is separate from the fading for an animated background,
+//   since using two actors is quite inefficient.)
+//
+// MetaBackgroundImage
+//   An object represented an image file that will be used for drawing
+//   the background. MetaBackgroundImage objects asynchronously load,
+//   so they are first created in an unloaded state, then later emit
+//   a ::loaded signal when the Cogl object becomes available.
+//
+// MetaBackgroundImageCache
+//   A cache from filename to MetaBackgroundImage.
+//
+// BackgroundSource
+//   An object that is created for each GSettings schema (separate
+//   settings schemas are used for the lock screen and main background),
+//   and holds a reference to shared Background objects.
+//
+// MetaBackground
+//   Holds the specification of a background - a background color
+//   or gradient and one or two images blended together.
+//
+// Background
+//   JS delegate object that Connects a MetaBackground to the GSettings
+//   schema for the background.
+//
+// Animation
+//   A helper object that handles loading a XML-based animation; it is a
+//   wrapper for GnomeDesktop.BGSlideShow
+//
+// MetaBackgroundActor
+//   An actor that draws the background for a single monitor
+//
+// BackgroundCache
+//   A cache of Settings schema => BackgroundSource and of a single Animation.
+//   Also used to share file monitors.
+//
+// A static image, background color or gradient is relatively straightforward. The
+// calling code creates a separate BackgroundManager for each monitor. Since they
+// are created for the same GSettings schema, they will use the same BackgroundSource
+// object, which provides a single Background and correspondingly a single
+// MetaBackground object.
+//
+// BackgroundManager               BackgroundManager
+//        |        \               /        |
+//        |         BackgroundSource        |        looked up in BackgroundCache
+//        |                |                |
+//        |            Background           |
+//        |                |                |
+//   MetaBackgroundActor   |    MetaBackgroundActor
+//         \               |               /
+//          `------- MetaBackground ------'
+//                         |
+//                MetaBackgroundImage            looked up in MetaBackgroundImageCache
+//
+// The animated case is tricker because the animation XML file can specify different
+// files for different monitor resolutions and aspect ratios. For this reason,
+// the BackgroundSource provides different Background share a single Animation object,
+// which tracks the animation, but use different MetaBackground objects. In the
+// common case, the different MetaBackground objects will be created for the
+// same filename and look up the *same* MetaBackgroundImage object, so there is
+// little wasted memory:
+//
+// BackgroundManager               BackgroundManager
+//        |        \               /        |
+//        |         BackgroundSource        |        looked up in BackgroundCache
+//        |             /      \            |
+//        |     Background   Background     |
+//        |       |     \      /   |        |
+//        |       |    Animation   |        |        looked up in BackgroundCache
+// MetaBackgroundA|tor           Me|aBackgroundActor
+//         \      |                |       /
+//      MetaBackground           MetaBackground
+//                 \                 /
+//                MetaBackgroundImage            looked up in MetaBackgroundImageCache
+//                MetaBackgroundImage
+//
+// But the case of different filenames and different background images
+// is possible as well:
+//                        ....
+//      MetaBackground              MetaBackground
+//             |                          |
+//     MetaBackgroundImage         MetaBackgroundImage
+//     MetaBackgroundImage         MetaBackgroundImage
+
+const { Clutter, GDesktopEnums, Gio, GLib, GObject, GnomeDesktop, Meta } = imports.gi;
+const Signals = imports.signals;
+
+const LoginManager = imports.misc.loginManager;
+const Main = imports.ui.main;
+const Params = imports.misc.params;
+
+var DEFAULT_BACKGROUND_COLOR = Clutter.Color.from_pixel(0x2e3436ff);
+
+const BACKGROUND_SCHEMA = 'org.gnome.desktop.background';
+const PRIMARY_COLOR_KEY = 'primary-color';
+const SECONDARY_COLOR_KEY = 'secondary-color';
+const COLOR_SHADING_TYPE_KEY = 'color-shading-type';
+const BACKGROUND_STYLE_KEY = 'picture-options';
+const PICTURE_URI_KEY = 'picture-uri';
+
+var FADE_ANIMATION_TIME = 1000;
+
+// These parameters affect how often we redraw.
+// The first is how different (percent crossfaded) the slide show
+// has to look before redrawing and the second is the minimum
+// frequency (in seconds) we're willing to wake up
+var ANIMATION_OPACITY_STEP_INCREMENT = 4.0;
+var ANIMATION_MIN_WAKEUP_INTERVAL = 1.0;
+
+let _backgroundCache = null;
+
+function _fileEqual0(file1, file2) {
+    if (file1 == file2)
+        return true;
+
+    if (!file1 || !file2)
+        return false;
+
+    return file1.equal(file2);
+}
+
+var BackgroundCache = class BackgroundCache {
+    constructor() {
+        this._fileMonitors = {};
+        this._backgroundSources = {};
+        this._animations = {};
+    }
+
+    monitorFile(file) {
+        let key = file.hash();
+        if (this._fileMonitors[key])
+            return;
+
+        let monitor = file.monitor(Gio.FileMonitorFlags.NONE, null);
+        monitor.connect('changed',
+                        (obj, theFile, otherFile, eventType) => {
+                            // Ignore CHANGED and CREATED events, since in both cases
+                            // we'll get a CHANGES_DONE_HINT event when done.
+                            if (eventType != Gio.FileMonitorEvent.CHANGED &&
+                                eventType != Gio.FileMonitorEvent.CREATED)
+                                this.emit('file-changed', file);
+                        });
+
+        this._fileMonitors[key] = monitor;
+    }
+
+    getAnimation(params) {
+        params = Params.parse(params, { file: null,
+                                        settingsSchema: null,
+                                        onLoaded: null });
+
+        let animation = this._animations[params.settingsSchema];
+        if (animation && _fileEqual0(animation.file, params.file)) {
+            if (params.onLoaded) {
+                let id = GLib.idle_add(GLib.PRIORITY_DEFAULT, () => {
+                    params.onLoaded(this._animations[params.settingsSchema]);
+                    return GLib.SOURCE_REMOVE;
+                });
+                GLib.Source.set_name_by_id(id, '[gnome-shell] params.onLoaded');
+            }
+            return;
+        }
+
+        animation = new Animation({ file: params.file });
+
+        animation.load(() => {
+            this._animations[params.settingsSchema] = animation;
+
+            if (params.onLoaded) {
+                let id = GLib.idle_add(GLib.PRIORITY_DEFAULT, () => {
+                    params.onLoaded(this._animations[params.settingsSchema]);
+                    return GLib.SOURCE_REMOVE;
+                });
+                GLib.Source.set_name_by_id(id, '[gnome-shell] params.onLoaded');
+            }
+        });
+    }
+
+    getBackgroundSource(layoutManager, settingsSchema) {
+        // The layoutManager is always the same one; we pass in it since
+        // Main.layoutManager may not be set yet
+
+        if (!(settingsSchema in this._backgroundSources)) {
+            this._backgroundSources[settingsSchema] = new BackgroundSource(layoutManager, settingsSchema);
+            this._backgroundSources[settingsSchema]._useCount = 1;
+        } else {
+            this._backgroundSources[settingsSchema]._useCount++;
+        }
+
+        return this._backgroundSources[settingsSchema];
+    }
+
+    releaseBackgroundSource(settingsSchema) {
+        if (settingsSchema in this._backgroundSources) {
+            let source = this._backgroundSources[settingsSchema];
+            source._useCount--;
+            if (source._useCount == 0) {
+                delete this._backgroundSources[settingsSchema];
+                source.destroy();
+            }
+        }
+    }
+};
+Signals.addSignalMethods(BackgroundCache.prototype);
+
+function getBackgroundCache() {
+    if (!_backgroundCache)
+        _backgroundCache = new BackgroundCache();
+    return _backgroundCache;
+}
+
+var Background = GObject.registerClass({
+    Signals: { 'loaded': {}, 'bg-changed': {} },
+}, class Background extends Meta.Background {
+    _init(params) {
+        params = Params.parse(params, { monitorIndex: 0,
+                                        layoutManager: Main.layoutManager,
+                                        settings: null,
+                                        file: null,
+                                        style: null });
+
+        super._init({ meta_display: global.display });
+
+        this._settings = params.settings;
+        this._file = params.file;
+        this._style = params.style;
+        this._monitorIndex = params.monitorIndex;
+        this._layoutManager = params.layoutManager;
+        this._fileWatches = {};
+        this._cancellable = new Gio.Cancellable();
+        this.isLoaded = false;
+
+        this._clock = new GnomeDesktop.WallClock();
+        this._timezoneChangedId = this._clock.connect('notify::timezone',
+            () => {
+                if (this._animation)
+                    this._loadAnimation(this._animation.file);
+            });
+
+        let loginManager = LoginManager.getLoginManager();
+        this._prepareForSleepId = loginManager.connect('prepare-for-sleep',
+            (lm, aboutToSuspend) => {
+                if (aboutToSuspend)
+                    return;
+                this._refreshAnimation();
+            });
+
+        this._settingsChangedSignalId =
+            this._settings.connect('changed', this._emitChangedSignal.bind(this));
+
+        this._load();
+    }
+
+    destroy() {
+        this._cancellable.cancel();
+        this._removeAnimationTimeout();
+
+        let i;
+        let keys = Object.keys(this._fileWatches);
+        for (i = 0; i < keys.length; i++)
+            this._cache.disconnect(this._fileWatches[keys[i]]);
+
+        this._fileWatches = null;
+
+        if (this._timezoneChangedId != 0)
+            this._clock.disconnect(this._timezoneChangedId);
+        this._timezoneChangedId = 0;
+
+        this._clock = null;
+
+        if (this._prepareForSleepId != 0)
+            LoginManager.getLoginManager().disconnect(this._prepareForSleepId);
+        this._prepareForSleepId = 0;
+
+        if (this._settingsChangedSignalId != 0)
+            this._settings.disconnect(this._settingsChangedSignalId);
+        this._settingsChangedSignalId = 0;
+
+        if (this._changedIdleId) {
+            GLib.source_remove(this._changedIdleId);
+            this._changedIdleId = 0;
+        }
+    }
+
+    _emitChangedSignal() {
+        if (this._changedIdleId)
+            return;
+
+        this._changedIdleId = GLib.idle_add(GLib.PRIORITY_DEFAULT, () => {
+            this._changedIdleId = 0;
+            this.emit('bg-changed');
+            return GLib.SOURCE_REMOVE;
+        });
+        GLib.Source.set_name_by_id(this._changedIdleId,
+            '[gnome-shell] Background._emitChangedSignal');
+    }
+
+    updateResolution() {
+        if (this._animation)
+            this._refreshAnimation();
+    }
+
+    _refreshAnimation() {
+        if (!this._animation)
+            return;
+
+        this._removeAnimationTimeout();
+        this._updateAnimation();
+    }
+
+    _setLoaded() {
+        if (this.isLoaded)
+            return;
+
+        this.isLoaded = true;
+
+        let id = GLib.idle_add(GLib.PRIORITY_DEFAULT, () => {
+            this.emit('loaded');
+            return GLib.SOURCE_REMOVE;
+        });
+        GLib.Source.set_name_by_id(id, '[gnome-shell] Background._setLoaded Idle');
+    }
+
+    _loadPattern() {
+        let colorString, res_, color, secondColor;
+
+        colorString = this._settings.get_string(PRIMARY_COLOR_KEY);
+        [res_, color] = Clutter.Color.from_string(colorString);
+        colorString = this._settings.get_string(SECONDARY_COLOR_KEY);
+        [res_, secondColor] = Clutter.Color.from_string(colorString);
+
+        let shadingType = this._settings.get_enum(COLOR_SHADING_TYPE_KEY);
+
+        if (shadingType == GDesktopEnums.BackgroundShading.SOLID)
+            this.set_color(color);
+        else
+            this.set_gradient(shadingType, color, secondColor);
+    }
+
+    _watchFile(file) {
+        let key = file.hash();
+        if (this._fileWatches[key])
+            return;
+
+        this._cache.monitorFile(file);
+        let signalId = this._cache.connect('file-changed',
+                                           (cache, changedFile) => {
+                                               if (changedFile.equal(file)) {
+                                                   let imageCache = Meta.BackgroundImageCache.get_default();
+                                                   imageCache.purge(changedFile);
+                                                   this._emitChangedSignal();
+                                               }
+                                           });
+        this._fileWatches[key] = signalId;
+    }
+
+    _removeAnimationTimeout() {
+        if (this._updateAnimationTimeoutId) {
+            GLib.source_remove(this._updateAnimationTimeoutId);
+            this._updateAnimationTimeoutId = 0;
+        }
+    }
+
+    _updateAnimation() {
+        this._updateAnimationTimeoutId = 0;
+
+        this._animation.update(this._layoutManager.monitors[this._monitorIndex]);
+        let files = this._animation.keyFrameFiles;
+
+        let finish = () => {
+            this._setLoaded();
+            if (files.length > 1) {
+                this.set_blend(files[0], files[1],
+                               this._animation.transitionProgress,
+                               this._style);
+            } else if (files.length > 0) {
+                this.set_file(files[0], this._style);
+            } else {
+                this.set_file(null, this._style);
+            }
+            this._queueUpdateAnimation();
+        };
+
+        let cache = Meta.BackgroundImageCache.get_default();
+        let numPendingImages = files.length;
+        for (let i = 0; i < files.length; i++) {
+            this._watchFile(files[i]);
+            let image = cache.load(files[i]);
+            if (image.is_loaded()) {
+                numPendingImages--;
+                if (numPendingImages == 0)
+                    finish();
+            } else {
+                // eslint-disable-next-line no-loop-func
+                let id = image.connect('loaded', () => {
+                    image.disconnect(id);
+                    numPendingImages--;
+                    if (numPendingImages == 0)
+                        finish();
+                });
+            }
+        }
+    }
+
+    _queueUpdateAnimation() {
+        if (this._updateAnimationTimeoutId != 0)
+            return;
+
+        if (!this._cancellable || this._cancellable.is_cancelled())
+            return;
+
+        if (!this._animation.transitionDuration)
+            return;
+
+        let nSteps = 255 / ANIMATION_OPACITY_STEP_INCREMENT;
+        let timePerStep = (this._animation.transitionDuration * 1000) / nSteps;
+
+        let interval = Math.max(ANIMATION_MIN_WAKEUP_INTERVAL * 1000,
+                                timePerStep);
+
+        if (interval > GLib.MAXUINT32)
+            return;
+
+        this._updateAnimationTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT,
+                                                          interval,
+                                                          () => {
+                                                              this._updateAnimationTimeoutId = 0;
+                                                              this._updateAnimation();
+                                                              return GLib.SOURCE_REMOVE;
+                                                          });
+        GLib.Source.set_name_by_id(this._updateAnimationTimeoutId, '[gnome-shell] this._updateAnimation');
+    }
+
+    _loadAnimation(file) {
+        this._cache.getAnimation({
+            file,
+            settingsSchema: this._settings.schema_id,
+            onLoaded: animation => {
+                this._animation = animation;
+
+                if (!this._animation || this._cancellable.is_cancelled()) {
+                    this._setLoaded();
+                    return;
+                }
+
+                this._updateAnimation();
+                this._watchFile(file);
+            },
+        });
+    }
+
+    _loadImage(file) {
+        this.set_file(file, this._style);
+        this._watchFile(file);
+
+        let cache = Meta.BackgroundImageCache.get_default();
+        let image = cache.load(file);
+        if (image.is_loaded()) {
+            this._setLoaded();
+        } else {
+            let id = image.connect('loaded', () => {
+                this._setLoaded();
+                image.disconnect(id);
+            });
+        }
+    }
+
+    _loadFile(file) {
+        if (file.get_basename().endsWith('.xml'))
+            this._loadAnimation(file);
+        else
+            this._loadImage(file);
+    }
+
+    _load() {
+        this._cache = getBackgroundCache();
+
+        this._loadPattern();
+
+        if (!this._file) {
+            this._setLoaded();
+            return;
+        }
+
+        this._loadFile(this._file);
+    }
+});
+
+let _systemBackground;
+
+var SystemBackground = GObject.registerClass({
+    Signals: { 'loaded': {} },
+}, class SystemBackground extends Meta.BackgroundActor {
+    _init() {
+        if (_systemBackground == null) {
+            _systemBackground = new Meta.Background({ meta_display: global.display });
+            _systemBackground.set_color(DEFAULT_BACKGROUND_COLOR);
+        }
+
+        super._init({
+            meta_display: global.display,
+            monitor: 0,
+            background: _systemBackground,
+        });
+
+        let id = GLib.idle_add(GLib.PRIORITY_DEFAULT, () => {
+            this.emit('loaded');
+            return GLib.SOURCE_REMOVE;
+        });
+        GLib.Source.set_name_by_id(id, '[gnome-shell] SystemBackground.loaded');
+    }
+});
+
+var BackgroundSource = class BackgroundSource {
+    constructor(layoutManager, settingsSchema) {
+        // Allow override the background image setting for performance testing
+        this._layoutManager = layoutManager;
+        this._overrideImage = GLib.getenv('SHELL_BACKGROUND_IMAGE');
+        this._settings = new Gio.Settings({ schema_id: settingsSchema });
+        this._backgrounds = [];
+
+        let monitorManager = Meta.MonitorManager.get();
+        this._monitorsChangedId =
+            monitorManager.connect('monitors-changed',
+                                   this._onMonitorsChanged.bind(this));
+    }
+
+    _onMonitorsChanged() {
+        for (let monitorIndex in this._backgrounds) {
+            let background = this._backgrounds[monitorIndex];
+
+            if (monitorIndex < this._layoutManager.monitors.length) {
+                background.updateResolution();
+            } else {
+                background.disconnect(background._changedId);
+                background.destroy();
+                delete this._backgrounds[monitorIndex];
+            }
+        }
+    }
+
+    getBackground(monitorIndex) {
+        let file = null;
+        let style;
+
+        // We don't watch changes to settings here,
+        // instead we rely on Background to watch those
+        // and emit 'bg-changed' at the right time
+
+        if (this._overrideImage != null) {
+            file = Gio.File.new_for_path(this._overrideImage);
+            style = GDesktopEnums.BackgroundStyle.ZOOM; // Hardcode
+        } else {
+            style = this._settings.get_enum(BACKGROUND_STYLE_KEY);
+            if (style != GDesktopEnums.BackgroundStyle.NONE) {
+                let uri = this._settings.get_string(PICTURE_URI_KEY);
+                file = Gio.File.new_for_commandline_arg(uri);
+            }
+        }
+
+        // Animated backgrounds are (potentially) per-monitor, since
+        // they can have variants that depend on the aspect ratio and
+        // size of the monitor; for other backgrounds we can use the
+        // same background object for all monitors.
+        if (file == null || !file.get_basename().endsWith('.xml'))
+            monitorIndex = 0;
+
+        if (!(monitorIndex in this._backgrounds)) {
+            let background = new Background({
+                monitorIndex,
+                layoutManager: this._layoutManager,
+                settings: this._settings,
+                file,
+                style,
+            });
+
+            background._changedId = background.connect('bg-changed', () => {
+                background.disconnect(background._changedId);
+                background.destroy();
+                delete this._backgrounds[monitorIndex];
+            });
+
+            this._backgrounds[monitorIndex] = background;
+        }
+
+        return this._backgrounds[monitorIndex];
+    }
+
+    destroy() {
+        let monitorManager = Meta.MonitorManager.get();
+        monitorManager.disconnect(this._monitorsChangedId);
+
+        for (let monitorIndex in this._backgrounds) {
+            let background = this._backgrounds[monitorIndex];
+            background.disconnect(background._changedId);
+            background.destroy();
+        }
+
+        this._backgrounds = null;
+    }
+};
+
+var Animation = GObject.registerClass(
+class Animation extends GnomeDesktop.BGSlideShow {
+    _init(params) {
+        super._init(params);
+
+        this.keyFrameFiles = [];
+        this.transitionProgress = 0.0;
+        this.transitionDuration = 0.0;
+        this.loaded = false;
+    }
+
+    load(callback) {
+        this.load_async(null, () => {
+            this.loaded = true;
+            if (callback)
+                callback();
+        });
+    }
+
+    update(monitor) {
+        this.keyFrameFiles = [];
+
+        if (this.get_num_slides() < 1)
+            return;
+
+        let [progress, duration, isFixed_, filename1, filename2] =
+            this.get_current_slide(monitor.width, monitor.height);
+
+        this.transitionDuration = duration;
+        this.transitionProgress = progress;
+
+        if (filename1)
+            this.keyFrameFiles.push(Gio.File.new_for_path(filename1));
+
+        if (filename2)
+            this.keyFrameFiles.push(Gio.File.new_for_path(filename2));
+    }
+});
+
+var BackgroundManager = class BackgroundManager {
+    constructor(params) {
+        params = Params.parse(params, { container: null,
+                                        layoutManager: Main.layoutManager,
+                                        monitorIndex: null,
+                                        vignette: false,
+                                        controlPosition: true,
+                                        settingsSchema: BACKGROUND_SCHEMA });
+
+        let cache = getBackgroundCache();
+        this._settingsSchema = params.settingsSchema;
+        this._backgroundSource = cache.getBackgroundSource(params.layoutManager, params.settingsSchema);
+
+        this._container = params.container;
+        this._layoutManager = params.layoutManager;
+        this._vignette = params.vignette;
+        this._monitorIndex = params.monitorIndex;
+        this._controlPosition = params.controlPosition;
+
+        this.backgroundActor = this._createBackgroundActor();
+        this._newBackgroundActor = null;
+    }
+
+    destroy() {
+        let cache = getBackgroundCache();
+        cache.releaseBackgroundSource(this._settingsSchema);
+        this._backgroundSource = null;
+
+        if (this._newBackgroundActor) {
+            this._newBackgroundActor.destroy();
+            this._newBackgroundActor = null;
+        }
+
+        if (this.backgroundActor) {
+            this.backgroundActor.destroy();
+            this.backgroundActor = null;
+        }
+    }
+
+    _swapBackgroundActor() {
+        let oldBackgroundActor = this.backgroundActor;
+        this.backgroundActor = this._newBackgroundActor;
+        this._newBackgroundActor = null;
+        this.emit('changed');
+
+        oldBackgroundActor.ease({
+            opacity: 0,
+            duration: FADE_ANIMATION_TIME,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            onComplete: () => oldBackgroundActor.destroy(),
+        });
+    }
+
+    _updateBackgroundActor() {
+        if (this._newBackgroundActor) {
+            /* Skip displaying existing background queued for load */
+            this._newBackgroundActor.destroy();
+            this._newBackgroundActor = null;
+        }
+
+        let newBackgroundActor = this._createBackgroundActor();
+        newBackgroundActor.vignette_sharpness = this.backgroundActor.vignette_sharpness;
+        newBackgroundActor.brightness = this.backgroundActor.brightness;
+        newBackgroundActor.visible = this.backgroundActor.visible;
+
+        this._newBackgroundActor = newBackgroundActor;
+
+        let background = newBackgroundActor.background;
+
+        if (background.isLoaded) {
+            this._swapBackgroundActor();
+        } else {
+            newBackgroundActor.loadedSignalId = background.connect('loaded',
+                () => {
+                    background.disconnect(newBackgroundActor.loadedSignalId);
+                    newBackgroundActor.loadedSignalId = 0;
+
+                    this._swapBackgroundActor();
+                });
+        }
+    }
+
+    _createBackgroundActor() {
+        let background = this._backgroundSource.getBackground(this._monitorIndex);
+        let backgroundActor = new Meta.BackgroundActor({
+            meta_display: global.display,
+            monitor: this._monitorIndex,
+            background,
+            vignette: this._vignette,
+            vignette_sharpness: 0.5,
+            brightness: 0.5,
+        });
+
+        this._container.add_child(backgroundActor);
+
+        if (this._controlPosition) {
+            let monitor = this._layoutManager.monitors[this._monitorIndex];
+            backgroundActor.set_position(monitor.x, monitor.y);
+            this._container.set_child_below_sibling(backgroundActor, null);
+        }
+
+        let changeSignalId = background.connect('bg-changed', () => {
+            background.disconnect(changeSignalId);
+            changeSignalId = null;
+            this._updateBackgroundActor();
+        });
+
+        backgroundActor.connect('destroy', () => {
+            if (changeSignalId)
+                background.disconnect(changeSignalId);
+
+            if (backgroundActor.loadedSignalId)
+                background.disconnect(backgroundActor.loadedSignalId);
+        });
+
+        return backgroundActor;
+    }
+};
+Signals.addSignalMethods(BackgroundManager.prototype);

js/ui/backgroundMenu.js

@@ -0,0 +1,69 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported addBackgroundMenu */
+
+const { Clutter, St } = imports.gi;
+
+const BoxPointer = imports.ui.boxpointer;
+const Main = imports.ui.main;
+const PopupMenu = imports.ui.popupMenu;
+
+var BackgroundMenu = class BackgroundMenu extends PopupMenu.PopupMenu {
+    constructor(layoutManager) {
+        super(layoutManager.dummyCursor, 0, St.Side.TOP);
+
+        this.addSettingsAction(_("Change Background…"), 'gnome-background-panel.desktop');
+        this.addMenuItem(new PopupMenu.PopupSeparatorMenuItem());
+        this.addSettingsAction(_("Display Settings"), 'gnome-display-panel.desktop');
+        this.addSettingsAction(_("Settings"), 'gnome-control-center.desktop');
+
+        this.actor.add_style_class_name('background-menu');
+
+        layoutManager.uiGroup.add_actor(this.actor);
+        this.actor.hide();
+    }
+};
+
+function addBackgroundMenu(actor, layoutManager) {
+    actor.reactive = true;
+    actor._backgroundMenu = new BackgroundMenu(layoutManager);
+    actor._backgroundManager = new PopupMenu.PopupMenuManager(actor);
+    actor._backgroundManager.addMenu(actor._backgroundMenu);
+
+    function openMenu(x, y) {
+        Main.layoutManager.setDummyCursorGeometry(x, y, 0, 0);
+        actor._backgroundMenu.open(BoxPointer.PopupAnimation.FULL);
+    }
+
+    let clickAction = new Clutter.ClickAction();
+    clickAction.connect('long-press', (action, theActor, state) => {
+        if (state == Clutter.LongPressState.QUERY) {
+            return (action.get_button() == 0 ||
+                     action.get_button() == 1) &&
+                    !actor._backgroundMenu.isOpen;
+        }
+        if (state == Clutter.LongPressState.ACTIVATE) {
+            let [x, y] = action.get_coords();
+            openMenu(x, y);
+            actor._backgroundManager.ignoreRelease();
+        }
+        return true;
+    });
+    clickAction.connect('clicked', action => {
+        if (action.get_button() == 3) {
+            let [x, y] = action.get_coords();
+            openMenu(x, y);
+        }
+    });
+    actor.add_action(clickAction);
+
+    let grabOpBeginId = global.display.connect('grab-op-begin', () => {
+        clickAction.release();
+    });
+
+    actor.connect('destroy', () => {
+        actor._backgroundMenu.destroy();
+        actor._backgroundMenu = null;
+        actor._backgroundManager = null;
+        global.display.disconnect(grabOpBeginId);
+    });
+}

js/ui/barLevel.js

@@ -0,0 +1,234 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* exported BarLevel */
+
+const { Atk, Clutter, GObject, St } = imports.gi;
+
+var BarLevel = GObject.registerClass({
+    Properties: {
+        'value': GObject.ParamSpec.double(
+            'value', 'value', 'value',
+            GObject.ParamFlags.READWRITE,
+            0, 2, 0),
+        'maximum-value': GObject.ParamSpec.double(
+            'maximum-value', 'maximum-value', 'maximum-value',
+            GObject.ParamFlags.READWRITE,
+            1, 2, 1),
+        'overdrive-start': GObject.ParamSpec.double(
+            'overdrive-start', 'overdrive-start', 'overdrive-start',
+            GObject.ParamFlags.READWRITE,
+            1, 2, 1),
+    },
+}, class BarLevel extends St.DrawingArea {
+    _init(params) {
+        this._maxValue = 1;
+        this._value = 0;
+        this._overdriveStart = 1;
+        this._barLevelWidth = 0;
+
+        let defaultParams = {
+            style_class: 'barlevel',
+            accessible_role: Atk.Role.LEVEL_BAR,
+        };
+        super._init(Object.assign(defaultParams, params));
+        this.connect('allocation-changed', (actor, box) => {
+            this._barLevelWidth = box.get_width();
+        });
+
+        this._customAccessible = St.GenericAccessible.new_for_actor(this);
+        this.set_accessible(this._customAccessible);
+
+        this._customAccessible.connect('get-current-value', this._getCurrentValue.bind(this));
+        this._customAccessible.connect('get-minimum-value', this._getMinimumValue.bind(this));
+        this._customAccessible.connect('get-maximum-value', this._getMaximumValue.bind(this));
+        this._customAccessible.connect('set-current-value', this._setCurrentValue.bind(this));
+
+        this.connect('notify::value', this._valueChanged.bind(this));
+    }
+
+    get value() {
+        return this._value;
+    }
+
+    set value(value) {
+        value = Math.max(Math.min(value, this._maxValue), 0);
+
+        if (this._value == value)
+            return;
+
+        this._value = value;
+        this.notify('value');
+        this.queue_repaint();
+    }
+
+    // eslint-disable-next-line camelcase
+    get maximum_value() {
+        return this._maxValue;
+    }
+
+    // eslint-disable-next-line camelcase
+    set maximum_value(value) {
+        value = Math.max(value, 1);
+
+        if (this._maxValue == value)
+            return;
+
+        this._maxValue = value;
+        this._overdriveStart = Math.min(this._overdriveStart, this._maxValue);
+        this.notify('maximum-value');
+        this.queue_repaint();
+    }
+
+    // eslint-disable-next-line camelcase
+    get overdrive_start() {
+        return this._overdriveStart;
+    }
+
+    // eslint-disable-next-line camelcase
+    set overdrive_start(value) {
+        if (this._overdriveStart == value)
+            return;
+
+        if (value > this._maxValue) {
+            throw new Error(`Tried to set overdrive value to ${value}, ` +
+                `which is a number greater than the maximum allowed value ${this._maxValue}`);
+        }
+
+        this._overdriveStart = value;
+        this.notify('overdrive-start');
+        this.queue_repaint();
+    }
+
+    vfunc_repaint() {
+        let cr = this.get_context();
+        let themeNode = this.get_theme_node();
+        let [width, height] = this.get_surface_size();
+
+        let barLevelHeight = themeNode.get_length('-barlevel-height');
+        let barLevelBorderRadius = Math.min(width, barLevelHeight) / 2;
+        let fgColor = themeNode.get_foreground_color();
+
+        let barLevelColor = themeNode.get_color('-barlevel-background-color');
+        let barLevelActiveColor = themeNode.get_color('-barlevel-active-background-color');
+        let barLevelOverdriveColor = themeNode.get_color('-barlevel-overdrive-color');
+
+        let barLevelBorderWidth = Math.min(themeNode.get_length('-barlevel-border-width'), 1);
+        let [hasBorderColor, barLevelBorderColor] =
+            themeNode.lookup_color('-barlevel-border-color', false);
+        if (!hasBorderColor)
+            barLevelBorderColor = barLevelColor;
+        let [hasActiveBorderColor, barLevelActiveBorderColor] =
+            themeNode.lookup_color('-barlevel-active-border-color', false);
+        if (!hasActiveBorderColor)
+            barLevelActiveBorderColor = barLevelActiveColor;
+        let [hasOverdriveBorderColor, barLevelOverdriveBorderColor] =
+            themeNode.lookup_color('-barlevel-overdrive-border-color', false);
+        if (!hasOverdriveBorderColor)
+            barLevelOverdriveBorderColor = barLevelOverdriveColor;
+
+        const TAU = Math.PI * 2;
+
+        let endX = 0;
+        if (this._maxValue > 0)
+            endX = barLevelBorderRadius + (width - 2 * barLevelBorderRadius) * this._value / this._maxValue;
+
+        let overdriveSeparatorX = barLevelBorderRadius + (width - 2 * barLevelBorderRadius) * this._overdriveStart / this._maxValue;
+        let overdriveActive = this._overdriveStart !== this._maxValue;
+        let overdriveSeparatorWidth = 0;
+        if (overdriveActive)
+            overdriveSeparatorWidth = themeNode.get_length('-barlevel-overdrive-separator-width');
+
+        /* background bar */
+        cr.arc(width - barLevelBorderRadius - barLevelBorderWidth, height / 2, barLevelBorderRadius, TAU * (3 / 4), TAU * (1 / 4));
+        cr.lineTo(endX, (height + barLevelHeight) / 2);
+        cr.lineTo(endX, (height - barLevelHeight) / 2);
+        cr.lineTo(width - barLevelBorderRadius - barLevelBorderWidth, (height - barLevelHeight) / 2);
+        Clutter.cairo_set_source_color(cr, barLevelColor);
+        cr.fillPreserve();
+        Clutter.cairo_set_source_color(cr, barLevelBorderColor);
+        cr.setLineWidth(barLevelBorderWidth);
+        cr.stroke();
+
+        /* normal progress bar */
+        let x = Math.min(endX, overdriveSeparatorX - overdriveSeparatorWidth / 2);
+        cr.arc(barLevelBorderRadius + barLevelBorderWidth, height / 2, barLevelBorderRadius, TAU * (1 / 4), TAU * (3 / 4));
+        cr.lineTo(x, (height - barLevelHeight) / 2);
+        cr.lineTo(x, (height + barLevelHeight) / 2);
+        cr.lineTo(barLevelBorderRadius + barLevelBorderWidth, (height + barLevelHeight) / 2);
+        if (this._value > 0)
+            Clutter.cairo_set_source_color(cr, barLevelActiveColor);
+        cr.fillPreserve();
+        Clutter.cairo_set_source_color(cr, barLevelActiveBorderColor);
+        cr.setLineWidth(barLevelBorderWidth);
+        cr.stroke();
+
+        /* overdrive progress barLevel */
+        x = Math.min(endX, overdriveSeparatorX) + overdriveSeparatorWidth / 2;
+        if (this._value > this._overdriveStart) {
+            cr.moveTo(x, (height - barLevelHeight) / 2);
+            cr.lineTo(endX, (height - barLevelHeight) / 2);
+            cr.lineTo(endX, (height + barLevelHeight) / 2);
+            cr.lineTo(x, (height + barLevelHeight) / 2);
+            cr.lineTo(x, (height - barLevelHeight) / 2);
+            Clutter.cairo_set_source_color(cr, barLevelOverdriveColor);
+            cr.fillPreserve();
+            Clutter.cairo_set_source_color(cr, barLevelOverdriveBorderColor);
+            cr.setLineWidth(barLevelBorderWidth);
+            cr.stroke();
+        }
+
+        /* end progress bar arc */
+        if (this._value > 0) {
+            if (this._value <= this._overdriveStart)
+                Clutter.cairo_set_source_color(cr, barLevelActiveColor);
+            else
+                Clutter.cairo_set_source_color(cr, barLevelOverdriveColor);
+            cr.arc(endX, height / 2, barLevelBorderRadius, TAU * (3 / 4), TAU * (1 / 4));
+            cr.lineTo(Math.floor(endX), (height + barLevelHeight) / 2);
+            cr.lineTo(Math.floor(endX), (height - barLevelHeight) / 2);
+            cr.lineTo(endX, (height - barLevelHeight) / 2);
+            cr.fillPreserve();
+            cr.setLineWidth(barLevelBorderWidth);
+            cr.stroke();
+        }
+
+        /* draw overdrive separator */
+        if (overdriveActive) {
+            cr.moveTo(overdriveSeparatorX - overdriveSeparatorWidth / 2, (height - barLevelHeight) / 2);
+            cr.lineTo(overdriveSeparatorX + overdriveSeparatorWidth / 2, (height - barLevelHeight) / 2);
+            cr.lineTo(overdriveSeparatorX + overdriveSeparatorWidth / 2, (height + barLevelHeight) / 2);
+            cr.lineTo(overdriveSeparatorX - overdriveSeparatorWidth / 2, (height + barLevelHeight) / 2);
+            cr.lineTo(overdriveSeparatorX - overdriveSeparatorWidth / 2, (height - barLevelHeight) / 2);
+            if (this._value <= this._overdriveStart)
+                Clutter.cairo_set_source_color(cr, fgColor);
+            else
+                Clutter.cairo_set_source_color(cr, barLevelColor);
+            cr.fill();
+        }
+
+        cr.$dispose();
+    }
+
+    _getCurrentValue() {
+        return this._value;
+    }
+
+    _getOverdriveStart() {
+        return this._overdriveStart;
+    }
+
+    _getMinimumValue() {
+        return 0;
+    }
+
+    _getMaximumValue() {
+        return this._maxValue;
+    }
+
+    _setCurrentValue(_actor, value) {
+        this._value = value;
+    }
+
+    _valueChanged() {
+        this._customAccessible.notify("accessible-value");
+    }
+});

js/ui/boxpointer.js

@@ -0,0 +1,644 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported BoxPointer */
+
+const { Clutter, GObject, Shell, St } = imports.gi;
+
+const Main = imports.ui.main;
+
+var PopupAnimation = {
+    NONE:  0,
+    SLIDE: 1 << 0,
+    FADE:  1 << 1,
+    FULL:  ~0,
+};
+
+var POPUP_ANIMATION_TIME = 150;
+
+/**
+ * BoxPointer:
+ * @side: side to draw the arrow on
+ * @binProperties: Properties to set on contained bin
+ *
+ * An actor which displays a triangle "arrow" pointing to a given
+ * side.  The .bin property is a container in which content can be
+ * placed.  The arrow position may be controlled via
+ * setArrowOrigin(). The arrow side might be temporarily flipped
+ * depending on the box size and source position to keep the box
+ * totally inside the monitor workarea if possible.
+ *
+ */
+var BoxPointer = GObject.registerClass({
+    Signals: { 'arrow-side-changed': {} },
+}, class BoxPointer extends St.Widget {
+    _init(arrowSide, binProperties) {
+        super._init();
+
+        this.set_offscreen_redirect(Clutter.OffscreenRedirect.ALWAYS);
+
+        this._arrowSide = arrowSide;
+        this._userArrowSide = arrowSide;
+        this._arrowOrigin = 0;
+        this._arrowActor = null;
+        this.bin = new St.Bin(binProperties);
+        this.add_actor(this.bin);
+        this._border = new St.DrawingArea();
+        this._border.connect('repaint', this._drawBorder.bind(this));
+        this.add_actor(this._border);
+        this.set_child_above_sibling(this.bin, this._border);
+        this._sourceAlignment = 0.5;
+        this._muteInput = true;
+
+        this.connect('destroy', this._onDestroy.bind(this));
+    }
+
+    vfunc_captured_event() {
+        if (this._muteInput)
+            return Clutter.EVENT_STOP;
+
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    _onDestroy() {
+        if (this._sourceActorDestroyId) {
+            this._sourceActor.disconnect(this._sourceActorDestroyId);
+            delete this._sourceActorDestroyId;
+        }
+    }
+
+    get arrowSide() {
+        return this._arrowSide;
+    }
+
+    open(animate, onComplete) {
+        let themeNode = this.get_theme_node();
+        let rise = themeNode.get_length('-arrow-rise');
+        let animationTime = animate & PopupAnimation.FULL ? POPUP_ANIMATION_TIME : 0;
+
+        if (animate & PopupAnimation.FADE)
+            this.opacity = 0;
+        else
+            this.opacity = 255;
+
+        this.show();
+
+        if (animate & PopupAnimation.SLIDE) {
+            switch (this._arrowSide) {
+            case St.Side.TOP:
+                this.translation_y = -rise;
+                break;
+            case St.Side.BOTTOM:
+                this.translation_y = rise;
+                break;
+            case St.Side.LEFT:
+                this.translation_x = -rise;
+                break;
+            case St.Side.RIGHT:
+                this.translation_x = rise;
+                break;
+            }
+        }
+
+        this.ease({
+            opacity: 255,
+            translation_x: 0,
+            translation_y: 0,
+            duration: animationTime,
+            mode: Clutter.AnimationMode.LINEAR,
+            onComplete: () => {
+                this._muteInput = false;
+                if (onComplete)
+                    onComplete();
+            },
+        });
+    }
+
+    close(animate, onComplete) {
+        if (!this.visible)
+            return;
+
+        let translationX = 0;
+        let translationY = 0;
+        let themeNode = this.get_theme_node();
+        let rise = themeNode.get_length('-arrow-rise');
+        let fade = animate & PopupAnimation.FADE;
+        let animationTime = animate & PopupAnimation.FULL ? POPUP_ANIMATION_TIME : 0;
+
+        if (animate & PopupAnimation.SLIDE) {
+            switch (this._arrowSide) {
+            case St.Side.TOP:
+                translationY = rise;
+                break;
+            case St.Side.BOTTOM:
+                translationY = -rise;
+                break;
+            case St.Side.LEFT:
+                translationX = rise;
+                break;
+            case St.Side.RIGHT:
+                translationX = -rise;
+                break;
+            }
+        }
+
+        this._muteInput = true;
+
+        this.remove_all_transitions();
+        this.ease({
+            opacity: fade ? 0 : 255,
+            translation_x: translationX,
+            translation_y: translationY,
+            duration: animationTime,
+            mode: Clutter.AnimationMode.LINEAR,
+            onComplete: () => {
+                this.hide();
+                this.opacity = 0;
+                this.translation_x = 0;
+                this.translation_y = 0;
+                if (onComplete)
+                    onComplete();
+            },
+        });
+    }
+
+    _adjustAllocationForArrow(isWidth, minSize, natSize) {
+        let themeNode = this.get_theme_node();
+        let borderWidth = themeNode.get_length('-arrow-border-width');
+        minSize += borderWidth * 2;
+        natSize += borderWidth * 2;
+        if ((!isWidth && (this._arrowSide == St.Side.TOP || this._arrowSide == St.Side.BOTTOM)) ||
+            (isWidth && (this._arrowSide == St.Side.LEFT || this._arrowSide == St.Side.RIGHT))) {
+            let rise = themeNode.get_length('-arrow-rise');
+            minSize += rise;
+            natSize += rise;
+        }
+
+        return [minSize, natSize];
+    }
+
+    vfunc_get_preferred_width(forHeight) {
+        let themeNode = this.get_theme_node();
+        forHeight = themeNode.adjust_for_height(forHeight);
+
+        let width = this.bin.get_preferred_width(forHeight);
+        width = this._adjustAllocationForArrow(true, ...width);
+
+        return themeNode.adjust_preferred_width(...width);
+    }
+
+    vfunc_get_preferred_height(forWidth) {
+        let themeNode = this.get_theme_node();
+        let borderWidth = themeNode.get_length('-arrow-border-width');
+        forWidth = themeNode.adjust_for_width(forWidth);
+
+        let height = this.bin.get_preferred_height(forWidth - 2 * borderWidth);
+        height = this._adjustAllocationForArrow(false, ...height);
+
+        return themeNode.adjust_preferred_height(...height);
+    }
+
+    vfunc_allocate(box, flags) {
+        this.set_allocation(box, flags);
+
+        let themeNode = this.get_theme_node();
+        let borderWidth = themeNode.get_length('-arrow-border-width');
+        let rise = themeNode.get_length('-arrow-rise');
+        let childBox = new Clutter.ActorBox();
+        let [availWidth, availHeight] = themeNode.get_content_box(box).get_size();
+
+        childBox.x1 = 0;
+        childBox.y1 = 0;
+        childBox.x2 = availWidth;
+        childBox.y2 = availHeight;
+        this._border.allocate(childBox, flags);
+
+        childBox.x1 = borderWidth;
+        childBox.y1 = borderWidth;
+        childBox.x2 = availWidth - borderWidth;
+        childBox.y2 = availHeight - borderWidth;
+        switch (this._arrowSide) {
+        case St.Side.TOP:
+            childBox.y1 += rise;
+            break;
+        case St.Side.BOTTOM:
+            childBox.y2 -= rise;
+            break;
+        case St.Side.LEFT:
+            childBox.x1 += rise;
+            break;
+        case St.Side.RIGHT:
+            childBox.x2 -= rise;
+            break;
+        }
+        this.bin.allocate(childBox, flags);
+
+        if (this._sourceActor && this._sourceActor.mapped) {
+            this._reposition(box);
+            this._updateFlip(box);
+            this.set_allocation(box, flags);
+        }
+    }
+
+    _drawBorder(area) {
+        let themeNode = this.get_theme_node();
+
+        if (this._arrowActor) {
+            let [sourceX, sourceY] = this._arrowActor.get_transformed_position();
+            let [sourceWidth, sourceHeight] = this._arrowActor.get_transformed_size();
+            let [absX, absY] = this.get_transformed_position();
+
+            if (this._arrowSide == St.Side.TOP ||
+                this._arrowSide == St.Side.BOTTOM)
+                this._arrowOrigin = sourceX - absX + sourceWidth / 2;
+            else
+                this._arrowOrigin = sourceY - absY + sourceHeight / 2;
+        }
+
+        let borderWidth = themeNode.get_length('-arrow-border-width');
+        let base = themeNode.get_length('-arrow-base');
+        let rise = themeNode.get_length('-arrow-rise');
+        let borderRadius = themeNode.get_length('-arrow-border-radius');
+
+        let halfBorder = borderWidth / 2;
+        let halfBase = Math.floor(base / 2);
+
+        let backgroundColor = themeNode.get_color('-arrow-background-color');
+
+        let [width, height] = area.get_surface_size();
+        let [boxWidth, boxHeight] = [width, height];
+        if (this._arrowSide == St.Side.TOP || this._arrowSide == St.Side.BOTTOM)
+            boxHeight -= rise;
+        else
+            boxWidth -= rise;
+
+        let cr = area.get_context();
+
+        // Translate so that box goes from 0,0 to boxWidth,boxHeight,
+        // with the arrow poking out of that
+        if (this._arrowSide == St.Side.TOP)
+            cr.translate(0, rise);
+        else if (this._arrowSide == St.Side.LEFT)
+            cr.translate(rise, 0);
+
+        let [x1, y1] = [halfBorder, halfBorder];
+        let [x2, y2] = [boxWidth - halfBorder, boxHeight - halfBorder];
+
+        let skipTopLeft = false;
+        let skipTopRight = false;
+        let skipBottomLeft = false;
+        let skipBottomRight = false;
+
+        if (rise) {
+            switch (this._arrowSide) {
+            case St.Side.TOP:
+                if (this._arrowOrigin == x1)
+                    skipTopLeft = true;
+                else if (this._arrowOrigin == x2)
+                    skipTopRight = true;
+                break;
+
+            case St.Side.RIGHT:
+                if (this._arrowOrigin == y1)
+                    skipTopRight = true;
+                else if (this._arrowOrigin == y2)
+                    skipBottomRight = true;
+                break;
+
+            case St.Side.BOTTOM:
+                if (this._arrowOrigin == x1)
+                    skipBottomLeft = true;
+                else if (this._arrowOrigin == x2)
+                    skipBottomRight = true;
+                break;
+
+            case St.Side.LEFT:
+                if (this._arrowOrigin == y1)
+                    skipTopLeft = true;
+                else if (this._arrowOrigin == y2)
+                    skipBottomLeft = true;
+                break;
+            }
+        }
+
+        cr.moveTo(x1 + borderRadius, y1);
+        if (this._arrowSide == St.Side.TOP && rise) {
+            if (skipTopLeft) {
+                cr.moveTo(x1, y2 - borderRadius);
+                cr.lineTo(x1, y1 - rise);
+                cr.lineTo(x1 + halfBase, y1);
+            } else if (skipTopRight) {
+                cr.lineTo(x2 - halfBase, y1);
+                cr.lineTo(x2, y1 - rise);
+                cr.lineTo(x2, y1 + borderRadius);
+            } else {
+                cr.lineTo(this._arrowOrigin - halfBase, y1);
+                cr.lineTo(this._arrowOrigin, y1 - rise);
+                cr.lineTo(this._arrowOrigin + halfBase, y1);
+            }
+        }
+
+        if (!skipTopRight) {
+            cr.lineTo(x2 - borderRadius, y1);
+            cr.arc(x2 - borderRadius, y1 + borderRadius, borderRadius,
+                   3 * Math.PI / 2, Math.PI * 2);
+        }
+
+        if (this._arrowSide == St.Side.RIGHT && rise) {
+            if (skipTopRight) {
+                cr.lineTo(x2 + rise, y1);
+                cr.lineTo(x2 + rise, y1 + halfBase);
+            } else if (skipBottomRight) {
+                cr.lineTo(x2, y2 - halfBase);
+                cr.lineTo(x2 + rise, y2);
+                cr.lineTo(x2 - borderRadius, y2);
+            } else {
+                cr.lineTo(x2, this._arrowOrigin - halfBase);
+                cr.lineTo(x2 + rise, this._arrowOrigin);
+                cr.lineTo(x2, this._arrowOrigin + halfBase);
+            }
+        }
+
+        if (!skipBottomRight) {
+            cr.lineTo(x2, y2 - borderRadius);
+            cr.arc(x2 - borderRadius, y2 - borderRadius, borderRadius,
+                   0, Math.PI / 2);
+        }
+
+        if (this._arrowSide == St.Side.BOTTOM && rise) {
+            if (skipBottomLeft) {
+                cr.lineTo(x1 + halfBase, y2);
+                cr.lineTo(x1, y2 + rise);
+                cr.lineTo(x1, y2 - borderRadius);
+            } else if (skipBottomRight) {
+                cr.lineTo(x2, y2 + rise);
+                cr.lineTo(x2 - halfBase, y2);
+            } else {
+                cr.lineTo(this._arrowOrigin + halfBase, y2);
+                cr.lineTo(this._arrowOrigin, y2 + rise);
+                cr.lineTo(this._arrowOrigin - halfBase, y2);
+            }
+        }
+
+        if (!skipBottomLeft) {
+            cr.lineTo(x1 + borderRadius, y2);
+            cr.arc(x1 + borderRadius, y2 - borderRadius, borderRadius,
+                   Math.PI / 2, Math.PI);
+        }
+
+        if (this._arrowSide == St.Side.LEFT && rise) {
+            if (skipTopLeft) {
+                cr.lineTo(x1, y1 + halfBase);
+                cr.lineTo(x1 - rise, y1);
+                cr.lineTo(x1 + borderRadius, y1);
+            } else if (skipBottomLeft) {
+                cr.lineTo(x1 - rise, y2);
+                cr.lineTo(x1 - rise, y2 - halfBase);
+            } else {
+                cr.lineTo(x1, this._arrowOrigin + halfBase);
+                cr.lineTo(x1 - rise, this._arrowOrigin);
+                cr.lineTo(x1, this._arrowOrigin - halfBase);
+            }
+        }
+
+        if (!skipTopLeft) {
+            cr.lineTo(x1, y1 + borderRadius);
+            cr.arc(x1 + borderRadius, y1 + borderRadius, borderRadius,
+                   Math.PI, 3 * Math.PI / 2);
+        }
+
+        Clutter.cairo_set_source_color(cr, backgroundColor);
+        cr.fillPreserve();
+
+        if (borderWidth > 0) {
+            let borderColor = themeNode.get_color('-arrow-border-color');
+            Clutter.cairo_set_source_color(cr, borderColor);
+            cr.setLineWidth(borderWidth);
+            cr.stroke();
+        }
+
+        cr.$dispose();
+    }
+
+    setPosition(sourceActor, alignment) {
+        if (!this._sourceActor || sourceActor != this._sourceActor) {
+            if (this._sourceActorDestroyId) {
+                this._sourceActor.disconnect(this._sourceActorDestroyId);
+                delete this._sourceActorDestroyId;
+            }
+
+            this._sourceActor = sourceActor;
+
+            if (this._sourceActor) {
+                this._sourceActorDestroyId = this._sourceActor.connect('destroy', () => {
+                    this._sourceActor = null;
+                    delete this._sourceActorDestroyId;
+                });
+            }
+        }
+
+        this._arrowAlignment = alignment;
+
+        this.queue_relayout();
+    }
+
+    setSourceAlignment(alignment) {
+        this._sourceAlignment = alignment;
+
+        if (!this._sourceActor)
+            return;
+
+        this.setPosition(this._sourceActor, this._arrowAlignment);
+    }
+
+    _reposition(allocationBox) {
+        let sourceActor = this._sourceActor;
+        let alignment = this._arrowAlignment;
+        let monitorIndex = Main.layoutManager.findIndexForActor(sourceActor);
+
+        this._sourceAllocation = Shell.util_get_transformed_allocation(sourceActor);
+        this._workArea = Main.layoutManager.getWorkAreaForMonitor(monitorIndex);
+
+        // Position correctly relative to the sourceActor
+        let sourceNode = sourceActor.get_theme_node();
+        let sourceContentBox = sourceNode.get_content_box(sourceActor.get_allocation_box());
+        let sourceAllocation = this._sourceAllocation;
+        let sourceCenterX = sourceAllocation.x1 + sourceContentBox.x1 + (sourceContentBox.x2 - sourceContentBox.x1) * this._sourceAlignment;
+        let sourceCenterY = sourceAllocation.y1 + sourceContentBox.y1 + (sourceContentBox.y2 - sourceContentBox.y1) * this._sourceAlignment;
+        let [, , natWidth, natHeight] = this.get_preferred_size();
+
+        // We also want to keep it onscreen, and separated from the
+        // edge by the same distance as the main part of the box is
+        // separated from its sourceActor
+        let workarea = this._workArea;
+        let themeNode = this.get_theme_node();
+        let borderWidth = themeNode.get_length('-arrow-border-width');
+        let arrowBase = themeNode.get_length('-arrow-base');
+        let borderRadius = themeNode.get_length('-arrow-border-radius');
+        let margin = 4 * borderRadius + borderWidth + arrowBase;
+
+        let gap = themeNode.get_length('-boxpointer-gap');
+        let padding = themeNode.get_length('-arrow-rise');
+
+        let resX, resY;
+
+        switch (this._arrowSide) {
+        case St.Side.TOP:
+            resY = sourceAllocation.y2 + gap;
+            break;
+        case St.Side.BOTTOM:
+            resY = sourceAllocation.y1 - natHeight - gap;
+            break;
+        case St.Side.LEFT:
+            resX = sourceAllocation.x2 + gap;
+            break;
+        case St.Side.RIGHT:
+            resX = sourceAllocation.x1 - natWidth - gap;
+            break;
+        }
+
+        // Now align and position the pointing axis, making sure it fits on
+        // screen. If the arrowOrigin is so close to the edge that the arrow
+        // will not be isosceles, we try to compensate as follows:
+        //   - We skip the rounded corner and settle for a right angled arrow
+        //     as shown below. See _drawBorder for further details.
+        //     |\_____
+        //     |
+        //     |
+        //   - If the arrow was going to be acute angled, we move the position
+        //     of the box to maintain the arrow's accuracy.
+
+        let arrowOrigin;
+        let halfBase = Math.floor(arrowBase / 2);
+        let halfBorder = borderWidth / 2;
+        let halfMargin = margin / 2;
+        let [x1, y1] = [halfBorder, halfBorder];
+        let [x2, y2] = [natWidth - halfBorder, natHeight - halfBorder];
+
+        switch (this._arrowSide) {
+        case St.Side.TOP:
+        case St.Side.BOTTOM:
+            resX = sourceCenterX - (halfMargin + (natWidth - margin) * alignment);
+
+            resX = Math.max(resX, workarea.x + padding);
+            resX = Math.min(resX, workarea.x + workarea.width - (padding + natWidth));
+
+            arrowOrigin = sourceCenterX - resX;
+            if (arrowOrigin <= (x1 + (borderRadius + halfBase))) {
+                if (arrowOrigin > x1)
+                    resX += arrowOrigin - x1;
+                arrowOrigin = x1;
+            } else if (arrowOrigin >= (x2 - (borderRadius + halfBase))) {
+                if (arrowOrigin < x2)
+                    resX -= x2 - arrowOrigin;
+                arrowOrigin = x2;
+            }
+            break;
+
+        case St.Side.LEFT:
+        case St.Side.RIGHT:
+            resY = sourceCenterY - (halfMargin + (natHeight - margin) * alignment);
+
+            resY = Math.max(resY, workarea.y + padding);
+            resY = Math.min(resY, workarea.y + workarea.height - (padding + natHeight));
+
+            arrowOrigin = sourceCenterY - resY;
+            if (arrowOrigin <= (y1 + (borderRadius + halfBase))) {
+                if (arrowOrigin > y1)
+                    resY += arrowOrigin - y1;
+                arrowOrigin = y1;
+            } else if (arrowOrigin >= (y2 - (borderRadius + halfBase))) {
+                if (arrowOrigin < y2)
+                    resX -= y2 - arrowOrigin;
+                arrowOrigin = y2;
+            }
+            break;
+        }
+
+        this.setArrowOrigin(arrowOrigin);
+
+        let parent = this.get_parent();
+        let success, x, y;
+        while (!success) {
+            [success, x, y] = parent.transform_stage_point(resX, resY);
+            parent = parent.get_parent();
+        }
+
+        // Actually set the position
+        allocationBox.set_origin(Math.floor(x), Math.floor(y));
+    }
+
+    // @origin: Coordinate specifying middle of the arrow, along
+    // the Y axis for St.Side.LEFT, St.Side.RIGHT from the top and X axis from
+    // the left for St.Side.TOP and St.Side.BOTTOM.
+    setArrowOrigin(origin) {
+        if (this._arrowOrigin != origin) {
+            this._arrowOrigin = origin;
+            this._border.queue_repaint();
+        }
+    }
+
+    // @actor: an actor relative to which the arrow is positioned.
+    // Differently from setPosition, this will not move the boxpointer itself,
+    // on the arrow
+    setArrowActor(actor) {
+        if (this._arrowActor != actor) {
+            this._arrowActor = actor;
+            this._border.queue_repaint();
+        }
+    }
+
+    _calculateArrowSide(arrowSide) {
+        let sourceAllocation = this._sourceAllocation;
+        let [, , boxWidth, boxHeight] = this.get_preferred_size();
+        let workarea = this._workArea;
+
+        switch (arrowSide) {
+        case St.Side.TOP:
+            if (sourceAllocation.y2 + boxHeight > workarea.y + workarea.height &&
+                boxHeight < sourceAllocation.y1 - workarea.y)
+                return St.Side.BOTTOM;
+            break;
+        case St.Side.BOTTOM:
+            if (sourceAllocation.y1 - boxHeight < workarea.y &&
+                boxHeight < workarea.y + workarea.height - sourceAllocation.y2)
+                return St.Side.TOP;
+            break;
+        case St.Side.LEFT:
+            if (sourceAllocation.x2 + boxWidth > workarea.x + workarea.width &&
+                boxWidth < sourceAllocation.x1 - workarea.x)
+                return St.Side.RIGHT;
+            break;
+        case St.Side.RIGHT:
+            if (sourceAllocation.x1 - boxWidth < workarea.x &&
+                boxWidth < workarea.x + workarea.width - sourceAllocation.x2)
+                return St.Side.LEFT;
+            break;
+        }
+
+        return arrowSide;
+    }
+
+    _updateFlip(allocationBox) {
+        let arrowSide = this._calculateArrowSide(this._userArrowSide);
+        if (this._arrowSide != arrowSide) {
+            this._arrowSide = arrowSide;
+            this._reposition(allocationBox);
+
+            this.emit('arrow-side-changed');
+        }
+    }
+
+    updateArrowSide(side) {
+        this._arrowSide = side;
+        this._border.queue_repaint();
+
+        this.emit('arrow-side-changed');
+    }
+
+    getPadding(side) {
+        return this.bin.get_theme_node().get_padding(side);
+    }
+
+    getArrowHeight() {
+        return this.get_theme_node().get_length('-arrow-rise');
+    }
+});

js/ui/checkBox.js

@@ -0,0 +1,38 @@
+/* exported CheckBox */
+const { Clutter, GObject, Pango, St } = imports.gi;
+
+var CheckBox = GObject.registerClass(
+class CheckBox extends St.Button {
+    _init(label) {
+        let container = new St.BoxLayout({
+            x_expand: true,
+            y_expand: true,
+        });
+        super._init({
+            style_class: 'check-box',
+            child: container,
+            button_mask: St.ButtonMask.ONE,
+            toggle_mode: true,
+            can_focus: true,
+        });
+
+        this._box = new St.Bin({ y_align: Clutter.ActorAlign.START });
+        container.add_actor(this._box);
+
+        this._label = new St.Label({ y_align: Clutter.ActorAlign.CENTER });
+        this._label.clutter_text.set_line_wrap(true);
+        this._label.clutter_text.set_ellipsize(Pango.EllipsizeMode.NONE);
+        container.add_actor(this._label);
+
+        if (label)
+            this.setLabel(label);
+    }
+
+    setLabel(label) {
+        this._label.set_text(label);
+    }
+
+    getLabelActor() {
+        return this._label;
+    }
+});

js/ui/closeDialog.js

@@ -0,0 +1,208 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported CloseDialog */
+
+const { Clutter, GLib, GObject, Meta, Shell, St } = imports.gi;
+
+const Dialog = imports.ui.dialog;
+const Main = imports.ui.main;
+
+var FROZEN_WINDOW_BRIGHTNESS = -0.3;
+var DIALOG_TRANSITION_TIME = 150;
+var ALIVE_TIMEOUT = 5000;
+
+var CloseDialog = GObject.registerClass({
+    Implements: [Meta.CloseDialog],
+    Properties: {
+        'window': GObject.ParamSpec.override('window', Meta.CloseDialog),
+    },
+}, class CloseDialog extends GObject.Object {
+    _init(window) {
+        super._init();
+        this._window = window;
+        this._dialog = null;
+        this._tracked = undefined;
+        this._timeoutId = 0;
+        this._windowFocusChangedId = 0;
+        this._keyFocusChangedId = 0;
+    }
+
+    get window() {
+        return this._window;
+    }
+
+    set window(window) {
+        this._window = window;
+    }
+
+    _createDialogContent() {
+        let tracker = Shell.WindowTracker.get_default();
+        let windowApp = tracker.get_window_app(this._window);
+
+        /* Translators: %s is an application name */
+        let title = _("“%s” is not responding.").format(windowApp.get_name());
+        let description = _('You may choose to wait a short while for it to ' +
+                            'continue or force the application to quit entirely.');
+        return new Dialog.MessageDialogContent({ title, description });
+    }
+
+    _updateScale() {
+        // Since this is a child of MetaWindowActor (which, for Wayland clients,
+        // applies the geometry scale factor to its children itself, see
+        // meta_window_actor_set_geometry_scale()), make sure we don't apply
+        // the factor twice in the end.
+        if (this._window.get_client_type() !== Meta.WindowClientType.WAYLAND)
+            return;
+
+        let { scaleFactor } = St.ThemeContext.get_for_stage(global.stage);
+        this._dialog.set_scale(1 / scaleFactor, 1 / scaleFactor);
+    }
+
+    _initDialog() {
+        if (this._dialog)
+            return;
+
+        let windowActor = this._window.get_compositor_private();
+        this._dialog = new Dialog.Dialog(windowActor, 'close-dialog');
+        this._dialog.width = windowActor.width;
+        this._dialog.height = windowActor.height;
+
+        this._dialog.contentLayout.add_child(this._createDialogContent());
+        this._dialog.addButton({ label: _('Force Quit'),
+                                 action: this._onClose.bind(this),
+                                 default: true });
+        this._dialog.addButton({ label: _('Wait'),
+                                 action: this._onWait.bind(this),
+                                 key: Clutter.KEY_Escape });
+
+        global.focus_manager.add_group(this._dialog);
+
+        let themeContext = St.ThemeContext.get_for_stage(global.stage);
+        themeContext.connect('notify::scale-factor', this._updateScale.bind(this));
+
+        this._updateScale();
+    }
+
+    _addWindowEffect() {
+        // We set the effect on the surface actor, so the dialog itself
+        // (which is a child of the MetaWindowActor) does not get the
+        // effect applied itself.
+        let windowActor = this._window.get_compositor_private();
+        let surfaceActor = windowActor.get_first_child();
+        let effect = new Clutter.BrightnessContrastEffect();
+        effect.set_brightness(FROZEN_WINDOW_BRIGHTNESS);
+        surfaceActor.add_effect_with_name("gnome-shell-frozen-window", effect);
+    }
+
+    _removeWindowEffect() {
+        let windowActor = this._window.get_compositor_private();
+        let surfaceActor = windowActor.get_first_child();
+        surfaceActor.remove_effect_by_name("gnome-shell-frozen-window");
+    }
+
+    _onWait() {
+        this.response(Meta.CloseDialogResponse.WAIT);
+    }
+
+    _onClose() {
+        this.response(Meta.CloseDialogResponse.FORCE_CLOSE);
+    }
+
+    _onFocusChanged() {
+        if (Meta.is_wayland_compositor())
+            return;
+
+        let focusWindow = global.display.focus_window;
+        let keyFocus = global.stage.key_focus;
+
+        let shouldTrack;
+        if (focusWindow != null)
+            shouldTrack = focusWindow == this._window;
+        else
+            shouldTrack = keyFocus && this._dialog.contains(keyFocus);
+
+        if (this._tracked === shouldTrack)
+            return;
+
+        if (shouldTrack) {
+            Main.layoutManager.trackChrome(this._dialog,
+                                           { affectsInputRegion: true });
+        } else {
+            Main.layoutManager.untrackChrome(this._dialog);
+        }
+
+        // The buttons are broken when they aren't added to the input region,
+        // so disable them properly in that case
+        this._dialog.buttonLayout.get_children().forEach(b => {
+            b.reactive = shouldTrack;
+        });
+
+        this._tracked = shouldTrack;
+    }
+
+    vfunc_show() {
+        if (this._dialog != null)
+            return;
+
+        Meta.disable_unredirect_for_display(global.display);
+
+        this._timeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, ALIVE_TIMEOUT,
+            () => {
+                this._window.check_alive(global.display.get_current_time_roundtrip());
+                return GLib.SOURCE_CONTINUE;
+            });
+
+        this._windowFocusChangedId =
+            global.display.connect('notify::focus-window',
+                                   this._onFocusChanged.bind(this));
+
+        this._keyFocusChangedId =
+            global.stage.connect('notify::key-focus',
+                                 this._onFocusChanged.bind(this));
+
+        this._addWindowEffect();
+        this._initDialog();
+
+        this._dialog._dialog.scale_y = 0;
+        this._dialog._dialog.set_pivot_point(0.5, 0.5);
+
+        this._dialog._dialog.ease({
+            scale_y: 1,
+            mode: Clutter.AnimationMode.LINEAR,
+            duration: DIALOG_TRANSITION_TIME,
+            onComplete: this._onFocusChanged.bind(this),
+        });
+    }
+
+    vfunc_hide() {
+        if (this._dialog == null)
+            return;
+
+        Meta.enable_unredirect_for_display(global.display);
+
+        GLib.source_remove(this._timeoutId);
+        this._timeoutId = 0;
+
+        global.display.disconnect(this._windowFocusChangedId);
+        this._windowFocusChangedId = 0;
+
+        global.stage.disconnect(this._keyFocusChangedId);
+        this._keyFocusChangedId = 0;
+
+        let dialog = this._dialog;
+        this._dialog = null;
+        this._removeWindowEffect();
+
+        dialog.makeInactive();
+        dialog._dialog.ease({
+            scale_y: 0,
+            mode: Clutter.AnimationMode.LINEAR,
+            duration: DIALOG_TRANSITION_TIME,
+            onComplete: () => dialog.destroy(),
+        });
+    }
+
+    vfunc_focus() {
+        if (this._dialog)
+            this._dialog.grab_key_focus();
+    }
+});

js/ui/components/__init__.js

@@ -0,0 +1,62 @@
+/* exported ComponentManager */
+const Main = imports.ui.main;
+
+var ComponentManager = class {
+    constructor() {
+        this._allComponents = {};
+        this._enabledComponents = [];
+
+        Main.sessionMode.connect('updated', this._sessionUpdated.bind(this));
+        this._sessionUpdated();
+    }
+
+    _sessionUpdated() {
+        let newEnabledComponents = Main.sessionMode.components;
+
+        newEnabledComponents.filter(
+            name => !this._enabledComponents.includes(name)
+        ).forEach(name => {
+            this._enableComponent(name);
+        });
+
+        this._enabledComponents.filter(
+            name => !newEnabledComponents.includes(name)
+        ).forEach(name => {
+            this._disableComponent(name);
+        });
+
+        this._enabledComponents = newEnabledComponents;
+    }
+
+    _importComponent(name) {
+        let module = imports.ui.components[name];
+        return module.Component;
+    }
+
+    _ensureComponent(name) {
+        let component = this._allComponents[name];
+        if (component)
+            return component;
+
+        if (Main.sessionMode.isLocked)
+            return null;
+
+        let constructor = this._importComponent(name);
+        component = new constructor();
+        this._allComponents[name] = component;
+        return component;
+    }
+
+    _enableComponent(name) {
+        let component = this._ensureComponent(name);
+        if (component)
+            component.enable();
+    }
+
+    _disableComponent(name) {
+        let component = this._allComponents[name];
+        if (component == null)
+            return;
+        component.disable();
+    }
+};

js/ui/components/automountManager.js

@@ -0,0 +1,259 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Component */
+
+const { Gio, GLib } = imports.gi;
+const Params = imports.misc.params;
+
+const GnomeSession = imports.misc.gnomeSession;
+const Main = imports.ui.main;
+const ShellMountOperation = imports.ui.shellMountOperation;
+
+var GNOME_SESSION_AUTOMOUNT_INHIBIT = 16;
+
+// GSettings keys
+const SETTINGS_SCHEMA = 'org.gnome.desktop.media-handling';
+const SETTING_ENABLE_AUTOMOUNT = 'automount';
+
+var AUTORUN_EXPIRE_TIMEOUT_SECS = 10;
+
+var AutomountManager = class {
+    constructor() {
+        this._settings = new Gio.Settings({ schema_id: SETTINGS_SCHEMA });
+        this._volumeQueue = [];
+        this._activeOperations = new Map();
+        this._session = new GnomeSession.SessionManager();
+        this._session.connectSignal('InhibitorAdded',
+                                    this._InhibitorsChanged.bind(this));
+        this._session.connectSignal('InhibitorRemoved',
+                                    this._InhibitorsChanged.bind(this));
+        this._inhibited = false;
+
+        this._volumeMonitor = Gio.VolumeMonitor.get();
+    }
+
+    enable() {
+        this._volumeAddedId = this._volumeMonitor.connect('volume-added', this._onVolumeAdded.bind(this));
+        this._volumeRemovedId = this._volumeMonitor.connect('volume-removed', this._onVolumeRemoved.bind(this));
+        this._driveConnectedId = this._volumeMonitor.connect('drive-connected', this._onDriveConnected.bind(this));
+        this._driveDisconnectedId = this._volumeMonitor.connect('drive-disconnected', this._onDriveDisconnected.bind(this));
+        this._driveEjectButtonId = this._volumeMonitor.connect('drive-eject-button', this._onDriveEjectButton.bind(this));
+
+        this._mountAllId = GLib.idle_add(GLib.PRIORITY_DEFAULT, this._startupMountAll.bind(this));
+        GLib.Source.set_name_by_id(this._mountAllId, '[gnome-shell] this._startupMountAll');
+    }
+
+    disable() {
+        this._volumeMonitor.disconnect(this._volumeAddedId);
+        this._volumeMonitor.disconnect(this._volumeRemovedId);
+        this._volumeMonitor.disconnect(this._driveConnectedId);
+        this._volumeMonitor.disconnect(this._driveDisconnectedId);
+        this._volumeMonitor.disconnect(this._driveEjectButtonId);
+
+        if (this._mountAllId > 0) {
+            GLib.source_remove(this._mountAllId);
+            this._mountAllId = 0;
+        }
+    }
+
+    _InhibitorsChanged(_object, _senderName, [_inhibitor]) {
+        this._session.IsInhibitedRemote(GNOME_SESSION_AUTOMOUNT_INHIBIT,
+            (result, error) => {
+                if (!error)
+                    this._inhibited = result[0];
+            });
+    }
+
+    _startupMountAll() {
+        let volumes = this._volumeMonitor.get_volumes();
+        volumes.forEach(volume => {
+            this._checkAndMountVolume(volume, { checkSession: false,
+                                                useMountOp: false,
+                                                allowAutorun: false });
+        });
+
+        this._mountAllId = 0;
+        return GLib.SOURCE_REMOVE;
+    }
+
+    _onDriveConnected() {
+        // if we're not in the current ConsoleKit session,
+        // or screensaver is active, don't play sounds
+        if (!this._session.SessionIsActive)
+            return;
+
+        let player = global.display.get_sound_player();
+        player.play_from_theme('device-added-media',
+                               _("External drive connected"),
+                               null);
+    }
+
+    _onDriveDisconnected() {
+        // if we're not in the current ConsoleKit session,
+        // or screensaver is active, don't play sounds
+        if (!this._session.SessionIsActive)
+            return;
+
+        let player = global.display.get_sound_player();
+        player.play_from_theme('device-removed-media',
+                               _("External drive disconnected"),
+                               null);
+    }
+
+    _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;
+
+        // 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) => {
+                    try {
+                        drive.stop_finish(res);
+                    } catch (e) {
+                        log('Unable to stop the drive after drive-eject-button %s'.format(e.toString()));
+                    }
+                });
+        } else if (drive.can_eject()) {
+            drive.eject_with_operation(Gio.MountUnmountFlags.FORCE, null, null,
+                (o, res) => {
+                    try {
+                        drive.eject_with_operation_finish(res);
+                    } catch (e) {
+                        log('Unable to eject the drive after drive-eject-button %s'.format(e.toString()));
+                    }
+                });
+        }
+    }
+
+    _onVolumeAdded(monitor, volume) {
+        this._checkAndMountVolume(volume);
+    }
+
+    _checkAndMountVolume(volume, params) {
+        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._inhibited)
+            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);
+
+            return;
+        }
+
+        if (params.useMountOp) {
+            let operation = new ShellMountOperation.ShellMountOperation(volume);
+            this._mountVolume(volume, operation, params.allowAutorun);
+        } else {
+            this._mountVolume(volume, null, params.allowAutorun);
+        }
+    }
+
+    _mountVolume(volume, operation, allowAutorun) {
+        if (allowAutorun)
+            this._allowAutorun(volume);
+
+        let mountOp = operation ? operation.mountOp : null;
+        this._activeOperations.set(volume, operation);
+
+        volume.mount(0, mountOp, null,
+                     this._onVolumeMounted.bind(this));
+    }
+
+    _onVolumeMounted(volume, res) {
+        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
+                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 {
+                if (e.message.includes('Compiled against a version of libcryptsetup that does not support the VeraCrypt PIM setting')) {
+                    Main.notifyError(_("Unable to unlock volume"),
+                        _("The installed udisks version does not support the PIM setting"));
+                }
+
+                if (!e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.FAILED_HANDLED))
+                    log('Unable to mount volume %s: %s'.format(volume.get_name(), e.toString()));
+                this._closeOperation(volume);
+            }
+        }
+    }
+
+    _onVolumeRemoved(monitor, volume) {
+        if (volume._allowAutorunExpireId && volume._allowAutorunExpireId > 0) {
+            GLib.source_remove(volume._allowAutorunExpireId);
+            delete volume._allowAutorunExpireId;
+        }
+        this._volumeQueue =
+            this._volumeQueue.filter(element => element != volume);
+    }
+
+    _reaskPassword(volume) {
+        let prevOperation = this._activeOperations.get(volume);
+        let existingDialog = prevOperation ? prevOperation.borrowDialog() : null;
+        let operation =
+            new ShellMountOperation.ShellMountOperation(volume,
+                                                        { existingDialog });
+        this._mountVolume(volume, operation);
+    }
+
+    _closeOperation(volume) {
+        let operation = this._activeOperations.get(volume);
+        if (!operation)
+            return;
+        operation.close();
+        this._activeOperations.delete(volume);
+    }
+
+    _allowAutorun(volume) {
+        volume.allowAutorun = true;
+    }
+
+    _allowAutorunExpire(volume) {
+        let id = GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, AUTORUN_EXPIRE_TIMEOUT_SECS, () => {
+            volume.allowAutorun = false;
+            delete volume._allowAutorunExpireId;
+            return GLib.SOURCE_REMOVE;
+        });
+        volume._allowAutorunExpireId = id;
+        GLib.Source.set_name_by_id(id, '[gnome-shell] volume.allowAutorun');
+    }
+};
+var Component = AutomountManager;

js/ui/components/autorunManager.js

@@ -0,0 +1,360 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Component */
+
+const { Clutter, Gio, GObject, St } = imports.gi;
+
+const GnomeSession = imports.misc.gnomeSession;
+const Main = imports.ui.main;
+const MessageTray = imports.ui.messageTray;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+// GSettings keys
+const SETTINGS_SCHEMA = 'org.gnome.desktop.media-handling';
+const SETTING_DISABLE_AUTORUN = 'autorun-never';
+const SETTING_START_APP = 'autorun-x-content-start-app';
+const SETTING_IGNORE = 'autorun-x-content-ignore';
+const SETTING_OPEN_FOLDER = 'autorun-x-content-open-folder';
+
+var AutorunSetting = {
+    RUN: 0,
+    IGNORE: 1,
+    FILES: 2,
+    ASK: 3,
+};
+
+// misc utils
+function shouldAutorunMount(mount) {
+    let root = mount.get_root();
+    let volume = mount.get_volume();
+
+    if (!volume || !volume.allowAutorun)
+        return false;
+
+    if (root.is_native() && isMountRootHidden(root))
+        return false;
+
+    return true;
+}
+
+function isMountRootHidden(root) {
+    let path = root.get_path();
+
+    // skip any mounts in hidden directory hierarchies
+    return path.includes('/.');
+}
+
+function isMountNonLocal(mount) {
+    // If the mount doesn't have an associated volume, that means it's
+    // an uninteresting filesystem. Most devices that we care about will
+    // have a mount, like media players and USB sticks.
+    let volume = mount.get_volume();
+    if (volume == null)
+        return true;
+
+    return volume.get_identifier("class") == "network";
+}
+
+function startAppForMount(app, mount) {
+    let files = [];
+    let root = mount.get_root();
+    let retval = false;
+
+    files.push(root);
+
+    try {
+        retval = app.launch(files,
+                            global.create_app_launch_context(0, -1));
+    } catch (e) {
+        log('Unable to launch the application %s: %s'.format(app.get_name(), e.toString()));
+    }
+
+    return retval;
+}
+
+const HotplugSnifferIface = loadInterfaceXML('org.gnome.Shell.HotplugSniffer');
+const HotplugSnifferProxy = Gio.DBusProxy.makeProxyWrapper(HotplugSnifferIface);
+function HotplugSniffer() {
+    return new HotplugSnifferProxy(Gio.DBus.session,
+                                   'org.gnome.Shell.HotplugSniffer',
+                                   '/org/gnome/Shell/HotplugSniffer');
+}
+
+var ContentTypeDiscoverer = class {
+    constructor(callback) {
+        this._callback = callback;
+        this._settings = new Gio.Settings({ schema_id: SETTINGS_SCHEMA });
+    }
+
+    guessContentTypes(mount) {
+        let autorunEnabled = !this._settings.get_boolean(SETTING_DISABLE_AUTORUN);
+        let shouldScan = autorunEnabled && !isMountNonLocal(mount);
+
+        if (shouldScan) {
+            // guess mount's content types using GIO
+            mount.guess_content_type(false, null,
+                                     this._onContentTypeGuessed.bind(this));
+        } else {
+            this._emitCallback(mount, []);
+        }
+    }
+
+    _onContentTypeGuessed(mount, res) {
+        let contentTypes = [];
+
+        try {
+            contentTypes = mount.guess_content_type_finish(res);
+        } catch (e) {
+            log('Unable to guess content types on added mount %s: %s'.format(mount.get_name(), e.toString()));
+        }
+
+        if (contentTypes.length) {
+            this._emitCallback(mount, contentTypes);
+        } else {
+            let root = mount.get_root();
+
+            let hotplugSniffer = new HotplugSniffer();
+            hotplugSniffer.SniffURIRemote(root.get_uri(),
+                result => {
+                    [contentTypes] = result;
+                    this._emitCallback(mount, contentTypes);
+                });
+        }
+    }
+
+    _emitCallback(mount, contentTypes = []) {
+        // we're not interested in win32 software content types here
+        contentTypes = contentTypes.filter(
+            type => type != 'x-content/win32-software'
+        );
+
+        let apps = [];
+        contentTypes.forEach(type => {
+            let app = Gio.app_info_get_default_for_type(type, false);
+
+            if (app)
+                apps.push(app);
+        });
+
+        if (apps.length == 0)
+            apps.push(Gio.app_info_get_default_for_type('inode/directory', false));
+
+        this._callback(mount, apps, contentTypes);
+    }
+};
+
+var AutorunManager = class {
+    constructor() {
+        this._session = new GnomeSession.SessionManager();
+        this._volumeMonitor = Gio.VolumeMonitor.get();
+
+        this._dispatcher = new AutorunDispatcher(this);
+    }
+
+    enable() {
+        this._mountAddedId = this._volumeMonitor.connect('mount-added', this._onMountAdded.bind(this));
+        this._mountRemovedId = this._volumeMonitor.connect('mount-removed', this._onMountRemoved.bind(this));
+    }
+
+    disable() {
+        this._volumeMonitor.disconnect(this._mountAddedId);
+        this._volumeMonitor.disconnect(this._mountRemovedId);
+    }
+
+    _onMountAdded(monitor, mount) {
+        // don't do anything if our session is not the currently
+        // active one
+        if (!this._session.SessionIsActive)
+            return;
+
+        let discoverer = new ContentTypeDiscoverer((m, apps, contentTypes) => {
+            this._dispatcher.addMount(mount, apps, contentTypes);
+        });
+        discoverer.guessContentTypes(mount);
+    }
+
+    _onMountRemoved(monitor, mount) {
+        this._dispatcher.removeMount(mount);
+    }
+};
+
+var AutorunDispatcher = class {
+    constructor(manager) {
+        this._manager = manager;
+        this._sources = [];
+        this._settings = new Gio.Settings({ schema_id: SETTINGS_SCHEMA });
+    }
+
+    _getAutorunSettingForType(contentType) {
+        let runApp = this._settings.get_strv(SETTING_START_APP);
+        if (runApp.includes(contentType))
+            return AutorunSetting.RUN;
+
+        let ignore = this._settings.get_strv(SETTING_IGNORE);
+        if (ignore.includes(contentType))
+            return AutorunSetting.IGNORE;
+
+        let openFiles = this._settings.get_strv(SETTING_OPEN_FOLDER);
+        if (openFiles.includes(contentType))
+            return AutorunSetting.FILES;
+
+        return AutorunSetting.ASK;
+    }
+
+    _getSourceForMount(mount) {
+        let filtered = this._sources.filter(source => source.mount == mount);
+
+        // we always make sure not to add two sources for the same
+        // mount in addMount(), so it's safe to assume filtered.length
+        // is always either 1 or 0.
+        if (filtered.length == 1)
+            return filtered[0];
+
+        return null;
+    }
+
+    _addSource(mount, apps) {
+        // if we already have a source showing for this
+        // mount, return
+        if (this._getSourceForMount(mount))
+            return;
+
+        // add a new source
+        this._sources.push(new AutorunSource(this._manager, mount, apps));
+    }
+
+    addMount(mount, apps, contentTypes) {
+        // if autorun is disabled globally, return
+        if (this._settings.get_boolean(SETTING_DISABLE_AUTORUN))
+            return;
+
+        // if the mount doesn't want to be autorun, return
+        if (!shouldAutorunMount(mount))
+            return;
+
+        let setting;
+        if (contentTypes.length > 0)
+            setting = this._getAutorunSettingForType(contentTypes[0]);
+        else
+            setting = AutorunSetting.ASK;
+
+        // check at the settings for the first content type
+        // to see whether we should ask
+        if (setting == AutorunSetting.IGNORE)
+            return; // return right away
+
+        let success = false;
+        let app = null;
+
+        if (setting == AutorunSetting.RUN)
+            app = Gio.app_info_get_default_for_type(contentTypes[0], false);
+        else if (setting == AutorunSetting.FILES)
+            app = Gio.app_info_get_default_for_type('inode/directory', false);
+
+        if (app)
+            success = startAppForMount(app, mount);
+
+        // we fallback here also in case the settings did not specify 'ask',
+        // but we failed launching the default app or the default file manager
+        if (!success)
+            this._addSource(mount, apps);
+    }
+
+    removeMount(mount) {
+        let source = this._getSourceForMount(mount);
+
+        // if we aren't tracking this mount, don't do anything
+        if (!source)
+            return;
+
+        // destroy the notification source
+        source.destroy();
+    }
+};
+
+var AutorunSource = GObject.registerClass(
+class AutorunSource extends MessageTray.Source {
+    _init(manager, mount, apps) {
+        super._init(mount.get_name());
+
+        this._manager = manager;
+        this.mount = mount;
+        this.apps = apps;
+
+        this._notification = new AutorunNotification(this._manager, this);
+
+        // add ourselves as a source, and popup the notification
+        Main.messageTray.add(this);
+        this.showNotification(this._notification);
+    }
+
+    getIcon() {
+        return this.mount.get_icon();
+    }
+
+    _createPolicy() {
+        return new MessageTray.NotificationApplicationPolicy('org.gnome.Nautilus');
+    }
+});
+
+var AutorunNotification = GObject.registerClass(
+class AutorunNotification extends MessageTray.Notification {
+    _init(manager, source) {
+        super._init(source, source.title);
+
+        this._manager = manager;
+        this._mount = source.mount;
+    }
+
+    createBanner() {
+        let banner = new MessageTray.NotificationBanner(this);
+
+        this.source.apps.forEach(app => {
+            let actor = this._buttonForApp(app);
+
+            if (actor)
+                banner.addButton(actor);
+        });
+
+        return banner;
+    }
+
+    _buttonForApp(app) {
+        let box = new St.BoxLayout({
+            x_expand: true,
+            x_align: Clutter.ActorAlign.START,
+        });
+        let icon = new St.Icon({ gicon: app.get_icon(),
+                                 style_class: 'hotplug-notification-item-icon' });
+        box.add(icon);
+
+        let label = new St.Bin({
+            child: new St.Label({
+                text: _("Open with %s").format(app.get_name()),
+                y_align: Clutter.ActorAlign.CENTER,
+            }),
+        });
+        box.add(label);
+
+        let button = new St.Button({ child: box,
+                                     x_expand: true,
+                                     button_mask: St.ButtonMask.ONE,
+                                     style_class: 'hotplug-notification-item button' });
+
+        button.connect('clicked', () => {
+            startAppForMount(app, this._mount);
+            this.destroy();
+        });
+
+        return button;
+    }
+
+    activate() {
+        super.activate();
+
+        let app = Gio.app_info_get_default_for_type('inode/directory', false);
+        startAppForMount(app, this._mount);
+    }
+});
+
+var Component = AutorunManager;

js/ui/components/keyring.js

@@ -0,0 +1,233 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Component */
+
+const { Clutter, Gcr, Gio, GObject, Pango, Shell, St } = imports.gi;
+
+const Dialog = imports.ui.dialog;
+const ModalDialog = imports.ui.modalDialog;
+const ShellEntry = imports.ui.shellEntry;
+const CheckBox = imports.ui.checkBox;
+const Util = imports.misc.util;
+
+var KeyringDialog = GObject.registerClass(
+class KeyringDialog extends ModalDialog.ModalDialog {
+    _init() {
+        super._init({ styleClass: 'prompt-dialog' });
+
+        this.prompt = new Shell.KeyringPrompt();
+        this.prompt.connect('show-password', this._onShowPassword.bind(this));
+        this.prompt.connect('show-confirm', this._onShowConfirm.bind(this));
+        this.prompt.connect('prompt-close', this._onHidePrompt.bind(this));
+
+        let content = new Dialog.MessageDialogContent();
+
+        this.prompt.bind_property('message',
+            content, 'title', GObject.BindingFlags.SYNC_CREATE);
+        this.prompt.bind_property('description',
+            content, 'description', GObject.BindingFlags.SYNC_CREATE);
+
+        let passwordBox = new St.BoxLayout({
+            style_class: 'prompt-dialog-password-layout',
+            vertical: true,
+        });
+
+        this._passwordEntry = new St.PasswordEntry({
+            style_class: 'prompt-dialog-password-entry',
+            can_focus: true,
+            x_align: Clutter.ActorAlign.CENTER,
+        });
+        ShellEntry.addContextMenu(this._passwordEntry);
+        this._passwordEntry.clutter_text.connect('activate', this._onPasswordActivate.bind(this));
+        this.prompt.bind_property('password-visible',
+            this._passwordEntry, 'visible', GObject.BindingFlags.SYNC_CREATE);
+        passwordBox.add_child(this._passwordEntry);
+
+        this._confirmEntry = new St.PasswordEntry({
+            style_class: 'prompt-dialog-password-entry',
+            can_focus: true,
+            x_align: Clutter.ActorAlign.CENTER,
+        });
+        ShellEntry.addContextMenu(this._confirmEntry);
+        this._confirmEntry.clutter_text.connect('activate', this._onConfirmActivate.bind(this));
+        this.prompt.bind_property('confirm-visible',
+            this._confirmEntry, 'visible', GObject.BindingFlags.SYNC_CREATE);
+        passwordBox.add_child(this._confirmEntry);
+
+        this.prompt.set_password_actor(this._passwordEntry.clutter_text);
+        this.prompt.set_confirm_actor(this._confirmEntry.clutter_text);
+
+        let warningBox = new St.BoxLayout({ vertical: true });
+
+        let capsLockWarning = new ShellEntry.CapsLockWarning();
+        let syncCapsLockWarningVisibility = () => {
+            capsLockWarning.visible =
+                this.prompt.password_visible || this.prompt.confirm_visible;
+        };
+        this.prompt.connect('notify::password-visible', syncCapsLockWarningVisibility);
+        this.prompt.connect('notify::confirm-visible', syncCapsLockWarningVisibility);
+        warningBox.add_child(capsLockWarning);
+
+        let warning = new St.Label({ style_class: 'prompt-dialog-error-label' });
+        warning.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+        warning.clutter_text.line_wrap = true;
+        this.prompt.bind_property('warning',
+            warning, 'text', GObject.BindingFlags.SYNC_CREATE);
+        this.prompt.connect('notify::warning-visible', () => {
+            warning.opacity = this.prompt.warning_visible ? 255 : 0;
+        });
+        this.prompt.connect('notify::warning', () => {
+            if (this._passwordEntry && warning !== '')
+                Util.wiggle(this._passwordEntry);
+        });
+        warningBox.add_child(warning);
+
+        passwordBox.add_child(warningBox);
+        content.add_child(passwordBox);
+
+        this._choice = new CheckBox.CheckBox();
+        this.prompt.bind_property('choice-label', this._choice.getLabelActor(),
+            'text', GObject.BindingFlags.SYNC_CREATE);
+        this.prompt.bind_property('choice-chosen', this._choice,
+            'checked', GObject.BindingFlags.SYNC_CREATE | GObject.BindingFlags.BIDIRECTIONAL);
+        this.prompt.bind_property('choice-visible', this._choice,
+            'visible', GObject.BindingFlags.SYNC_CREATE);
+        content.add_child(this._choice);
+
+        this.contentLayout.add_child(content);
+
+        this._cancelButton = this.addButton({
+            label: '',
+            action: this._onCancelButton.bind(this),
+            key: Clutter.KEY_Escape,
+        });
+        this._continueButton = this.addButton({
+            label: '',
+            action: this._onContinueButton.bind(this),
+            default: true,
+        });
+
+        this.prompt.bind_property('cancel-label', this._cancelButton, 'label', GObject.BindingFlags.SYNC_CREATE);
+        this.prompt.bind_property('continue-label', this._continueButton, 'label', GObject.BindingFlags.SYNC_CREATE);
+    }
+
+    _updateSensitivity(sensitive) {
+        if (this._passwordEntry) {
+            this._passwordEntry.reactive = sensitive;
+            this._passwordEntry.clutter_text.editable = sensitive;
+        }
+
+        if (this._confirmEntry) {
+            this._confirmEntry.reactive = sensitive;
+            this._confirmEntry.clutter_text.editable = sensitive;
+        }
+
+        this._continueButton.can_focus = sensitive;
+        this._continueButton.reactive = sensitive;
+    }
+
+    _ensureOpen() {
+        // NOTE: ModalDialog.open() is safe to call if the dialog is
+        // already open - it just returns true without side-effects
+        if (this.open())
+            return true;
+
+        // The above fail if e.g. unable to get input grab
+        //
+        // In an ideal world this wouldn't happen (because the
+        // Shell is in complete control of the session) but that's
+        // just not how things work right now.
+
+        log('keyringPrompt: Failed to show modal dialog.' +
+            ' Dismissing prompt request');
+        this.prompt.cancel();
+        return false;
+    }
+
+    _onShowPassword() {
+        this._ensureOpen();
+        this._updateSensitivity(true);
+        this._passwordEntry.text = '';
+        this._passwordEntry.grab_key_focus();
+    }
+
+    _onShowConfirm() {
+        this._ensureOpen();
+        this._updateSensitivity(true);
+        this._confirmEntry.text = '';
+        this._continueButton.grab_key_focus();
+    }
+
+    _onHidePrompt() {
+        this.close();
+    }
+
+    _onPasswordActivate() {
+        if (this.prompt.confirm_visible)
+            this._confirmEntry.grab_key_focus();
+        else
+            this._onContinueButton();
+    }
+
+    _onConfirmActivate() {
+        this._onContinueButton();
+    }
+
+    _onContinueButton() {
+        this._updateSensitivity(false);
+        this.prompt.complete();
+    }
+
+    _onCancelButton() {
+        this.prompt.cancel();
+    }
+});
+
+var KeyringDummyDialog = class {
+    constructor() {
+        this.prompt = new Shell.KeyringPrompt();
+        this.prompt.connect('show-password', this._cancelPrompt.bind(this));
+        this.prompt.connect('show-confirm', this._cancelPrompt.bind(this));
+    }
+
+    _cancelPrompt() {
+        this.prompt.cancel();
+    }
+};
+
+var KeyringPrompter = GObject.registerClass(
+class KeyringPrompter extends Gcr.SystemPrompter {
+    _init() {
+        super._init();
+        this.connect('new-prompt', () => {
+            let dialog = this._enabled
+                ? new KeyringDialog()
+                : new KeyringDummyDialog();
+            this._currentPrompt = dialog.prompt;
+            return this._currentPrompt;
+        });
+        this._dbusId = null;
+        this._registered = false;
+        this._enabled = false;
+        this._currentPrompt = null;
+    }
+
+    enable() {
+        if (!this._registered) {
+            this.register(Gio.DBus.session);
+            this._dbusId = Gio.DBus.session.own_name('org.gnome.keyring.SystemPrompter',
+                                                     Gio.BusNameOwnerFlags.ALLOW_REPLACEMENT, null, null);
+            this._registered = true;
+        }
+        this._enabled = true;
+    }
+
+    disable() {
+        this._enabled = false;
+
+        if (this.prompting)
+            this._currentPrompt.cancel();
+        this._currentPrompt = null;
+    }
+});
+
+var Component = KeyringPrompter;

js/ui/components/networkAgent.js

@@ -0,0 +1,823 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Component */
+
+const { Clutter, Gio, GLib, GObject, NM, Pango, Shell, St } = imports.gi;
+const Signals = imports.signals;
+
+const Config = imports.misc.config;
+const Dialog = imports.ui.dialog;
+const Main = imports.ui.main;
+const MessageTray = imports.ui.messageTray;
+const ModalDialog = imports.ui.modalDialog;
+const ShellEntry = imports.ui.shellEntry;
+
+const VPN_UI_GROUP = 'VPN Plugin UI';
+
+var NetworkSecretDialog = GObject.registerClass(
+class NetworkSecretDialog extends ModalDialog.ModalDialog {
+    _init(agent, requestId, connection, settingName, hints, flags, contentOverride) {
+        super._init({ styleClass: 'prompt-dialog' });
+
+        this._agent = agent;
+        this._requestId = requestId;
+        this._connection = connection;
+        this._settingName = settingName;
+        this._hints = hints;
+
+        if (contentOverride)
+            this._content = contentOverride;
+        else
+            this._content = this._getContent();
+
+        let contentBox = new Dialog.MessageDialogContent({
+            title: this._content.title,
+            description: this._content.message,
+        });
+
+        let initialFocusSet = false;
+        for (let i = 0; i < this._content.secrets.length; i++) {
+            let secret = this._content.secrets[i];
+            let reactive = secret.key != null;
+
+            let entryParams = {
+                style_class: 'prompt-dialog-password-entry',
+                hint_text: secret.label,
+                text: secret.value,
+                can_focus: reactive,
+                reactive,
+                x_align: Clutter.ActorAlign.CENTER,
+            };
+            if (secret.password)
+                secret.entry = new St.PasswordEntry(entryParams);
+            else
+                secret.entry = new St.Entry(entryParams);
+            ShellEntry.addContextMenu(secret.entry);
+            contentBox.add_child(secret.entry);
+
+            if (secret.validate)
+                secret.valid = secret.validate(secret);
+            else // no special validation, just ensure it's not empty
+                secret.valid = secret.value.length > 0;
+
+            if (reactive) {
+                if (!initialFocusSet) {
+                    this.setInitialKeyFocus(secret.entry);
+                    initialFocusSet = true;
+                }
+
+                secret.entry.clutter_text.connect('activate', this._onOk.bind(this));
+                secret.entry.clutter_text.connect('text-changed', () => {
+                    secret.value = secret.entry.get_text();
+                    if (secret.validate)
+                        secret.valid = secret.validate(secret);
+                    else
+                        secret.valid = secret.value.length > 0;
+                    this._updateOkButton();
+                });
+            } else {
+                secret.valid = true;
+            }
+        }
+
+        if (this._content.secrets.some(s => s.password)) {
+            let capsLockWarning = new ShellEntry.CapsLockWarning();
+            contentBox.add_child(capsLockWarning);
+        }
+
+        if (flags & NM.SecretAgentGetSecretsFlags.WPS_PBC_ACTIVE) {
+            let descriptionLabel = new St.Label({
+                text: _('Alternatively you can connect by pushing the “WPS” button on your router.'),
+                style_class: 'message-dialog-description',
+            });
+            descriptionLabel.clutter_text.line_wrap = true;
+            descriptionLabel.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+
+            contentBox.add_child(descriptionLabel);
+        }
+
+        this.contentLayout.add_child(contentBox);
+
+        this._okButton = {
+            label: _("Connect"),
+            action: this._onOk.bind(this),
+            default: true,
+        };
+
+        this.setButtons([{
+            label: _("Cancel"),
+            action: this.cancel.bind(this),
+            key: Clutter.KEY_Escape,
+        }, this._okButton]);
+
+        this._updateOkButton();
+    }
+
+    _updateOkButton() {
+        let valid = true;
+        for (let i = 0; i < this._content.secrets.length; i++) {
+            let secret = this._content.secrets[i];
+            valid = valid && secret.valid;
+        }
+
+        this._okButton.button.reactive = valid;
+        this._okButton.button.can_focus = valid;
+    }
+
+    _onOk() {
+        let valid = true;
+        for (let i = 0; i < this._content.secrets.length; i++) {
+            let secret = this._content.secrets[i];
+            valid = valid && secret.valid;
+            if (secret.key != null)
+                this._agent.set_password(this._requestId, secret.key, secret.value);
+        }
+
+        if (valid) {
+            this._agent.respond(this._requestId, Shell.NetworkAgentResponse.CONFIRMED);
+            this.close(global.get_current_time());
+        }
+        // do nothing if not valid
+    }
+
+    cancel() {
+        this._agent.respond(this._requestId, Shell.NetworkAgentResponse.USER_CANCELED);
+        this.close(global.get_current_time());
+    }
+
+    _validateWpaPsk(secret) {
+        let value = secret.value;
+        if (value.length == 64) {
+            // must be composed of hexadecimal digits only
+            for (let i = 0; i < 64; i++) {
+                if (!((value[i] >= 'a' && value[i] <= 'f') ||
+                      (value[i] >= 'A' && value[i] <= 'F') ||
+                      (value[i] >= '0' && value[i] <= '9')))
+                    return false;
+            }
+            return true;
+        }
+
+        return value.length >= 8 && value.length <= 63;
+    }
+
+    _validateStaticWep(secret) {
+        let value = secret.value;
+        if (secret.wep_key_type == NM.WepKeyType.KEY) {
+            if (value.length == 10 || value.length == 26) {
+                for (let i = 0; i < value.length; i++) {
+                    if (!((value[i] >= 'a' && value[i] <= 'f') ||
+                          (value[i] >= 'A' && value[i] <= 'F') ||
+                          (value[i] >= '0' && value[i] <= '9')))
+                        return false;
+                }
+            } else if (value.length == 5 || value.length == 13) {
+                for (let i = 0; i < value.length; i++) {
+                    if (!((value[i] >= 'a' && value[i] <= 'z') ||
+                          (value[i] >= 'A' && value[i] <= 'Z')))
+                        return false;
+                }
+            } else {
+                return false;
+            }
+        } else if (secret.wep_key_type == NM.WepKeyType.PASSPHRASE) {
+            if (value.length < 0 || value.length > 64)
+                return false;
+        }
+        return true;
+    }
+
+    _getWirelessSecrets(secrets, _wirelessSetting) {
+        let wirelessSecuritySetting = this._connection.get_setting_wireless_security();
+
+        if (this._settingName == '802-1x') {
+            this._get8021xSecrets(secrets);
+            return;
+        }
+
+        switch (wirelessSecuritySetting.key_mgmt) {
+        // First the easy ones
+        case 'wpa-none':
+        case 'wpa-psk':
+        case 'sae':
+            secrets.push({ label: _('Password'), key: 'psk',
+                           value: wirelessSecuritySetting.psk || '',
+                           validate: this._validateWpaPsk, password: true });
+            break;
+        case 'none': // static WEP
+            secrets.push({
+                label: _('Key'),
+                key: 'wep-key%s'.format(wirelessSecuritySetting.wep_tx_keyidx),
+                value: wirelessSecuritySetting.get_wep_key(wirelessSecuritySetting.wep_tx_keyidx) || '',
+                wep_key_type: wirelessSecuritySetting.wep_key_type,
+                validate: this._validateStaticWep,
+                password: true,
+            });
+            break;
+        case 'ieee8021x':
+            if (wirelessSecuritySetting.auth_alg == 'leap') { // Cisco LEAP
+                secrets.push({ label: _('Password'), key: 'leap-password',
+                               value: wirelessSecuritySetting.leap_password || '', password: true });
+            } else { // Dynamic (IEEE 802.1x) WEP
+                this._get8021xSecrets(secrets);
+            }
+            break;
+        case 'wpa-eap':
+            this._get8021xSecrets(secrets);
+            break;
+        default:
+            log('Invalid wireless key management: %s'.format(wirelessSecuritySetting.key_mgmt));
+        }
+    }
+
+    _get8021xSecrets(secrets) {
+        let ieee8021xSetting = this._connection.get_setting_802_1x();
+
+        /* If hints were given we know exactly what we need to ask */
+        if (this._settingName == "802-1x" && this._hints.length) {
+            if (this._hints.includes('identity')) {
+                secrets.push({ label: _('Username'), key: 'identity',
+                               value: ieee8021xSetting.identity || '', password: false });
+            }
+            if (this._hints.includes('password')) {
+                secrets.push({ label: _('Password'), key: 'password',
+                               value: ieee8021xSetting.password || '', password: true });
+            }
+            if (this._hints.includes('private-key-password')) {
+                secrets.push({ label: _('Private key password'), key: 'private-key-password',
+                               value: ieee8021xSetting.private_key_password || '', password: true });
+            }
+            return;
+        }
+
+        switch (ieee8021xSetting.get_eap_method(0)) {
+        case 'md5':
+        case 'leap':
+        case 'ttls':
+        case 'peap':
+        case 'fast':
+            // TTLS and PEAP are actually much more complicated, but this complication
+            // is not visible here since we only care about phase2 authentication
+            // (and don't even care of which one)
+            secrets.push({ label: _('Username'), key: null,
+                           value: ieee8021xSetting.identity || '', password: false });
+            secrets.push({ label: _('Password'), key: 'password',
+                           value: ieee8021xSetting.password || '', password: true });
+            break;
+        case 'tls':
+            secrets.push({ label: _('Identity'), key: null,
+                           value: ieee8021xSetting.identity || '', password: false });
+            secrets.push({ label: _('Private key password'), key: 'private-key-password',
+                           value: ieee8021xSetting.private_key_password || '', password: true });
+            break;
+        default:
+            log('Invalid EAP/IEEE802.1x method: %s'.format(ieee8021xSetting.get_eap_method(0)));
+        }
+    }
+
+    _getPPPoESecrets(secrets) {
+        let pppoeSetting = this._connection.get_setting_pppoe();
+        secrets.push({ label: _('Username'), key: 'username',
+                       value: pppoeSetting.username || '', password: false });
+        secrets.push({ label: _('Service'), key: 'service',
+                       value: pppoeSetting.service || '', password: false });
+        secrets.push({ label: _('Password'), key: 'password',
+                       value: pppoeSetting.password || '', password: true });
+    }
+
+    _getMobileSecrets(secrets, connectionType) {
+        let setting;
+        if (connectionType == 'bluetooth')
+            setting = this._connection.get_setting_cdma() || this._connection.get_setting_gsm();
+        else
+            setting = this._connection.get_setting_by_name(connectionType);
+        secrets.push({ label: _('Password'), key: 'password',
+                       value: setting.value || '', password: true });
+    }
+
+    _getContent() {
+        let connectionSetting = this._connection.get_setting_connection();
+        let connectionType = connectionSetting.get_connection_type();
+        let wirelessSetting;
+        let ssid;
+
+        let content = { };
+        content.secrets = [];
+
+        switch (connectionType) {
+        case '802-11-wireless':
+            wirelessSetting = this._connection.get_setting_wireless();
+            ssid = NM.utils_ssid_to_utf8(wirelessSetting.get_ssid().get_data());
+            content.title = _('Authentication required');
+            content.message = _("Passwords or encryption keys are required to access the wireless network “%s”.").format(ssid);
+            this._getWirelessSecrets(content.secrets, wirelessSetting);
+            break;
+        case '802-3-ethernet':
+            content.title = _("Wired 802.1X authentication");
+            content.message = null;
+            content.secrets.push({ label: _('Network name'), key: null,
+                                   value: connectionSetting.get_id(), password: false });
+            this._get8021xSecrets(content.secrets);
+            break;
+        case 'pppoe':
+            content.title = _("DSL authentication");
+            content.message = null;
+            this._getPPPoESecrets(content.secrets);
+            break;
+        case 'gsm':
+            if (this._hints.includes('pin')) {
+                let gsmSetting = this._connection.get_setting_gsm();
+                content.title = _("PIN code required");
+                content.message = _("PIN code is needed for the mobile broadband device");
+                content.secrets.push({ label: _('PIN'), key: 'pin',
+                                       value: gsmSetting.pin || '', password: true });
+                break;
+            }
+            // fall through
+        case 'cdma':
+        case 'bluetooth':
+            content.title = _('Authentication required');
+            content.message = _("A password is required to connect to “%s”.").format(connectionSetting.get_id());
+            this._getMobileSecrets(content.secrets, connectionType);
+            break;
+        default:
+            log('Invalid connection type: %s'.format(connectionType));
+        }
+
+        return content;
+    }
+});
+
+var VPNRequestHandler = class {
+    constructor(agent, requestId, authHelper, serviceType, connection, hints, flags) {
+        this._agent = agent;
+        this._requestId = requestId;
+        this._connection = connection;
+        this._flags = flags;
+        this._pluginOutBuffer = [];
+        this._title = null;
+        this._description = null;
+        this._content = [];
+        this._shellDialog = null;
+
+        let connectionSetting = connection.get_setting_connection();
+
+        let argv = [authHelper.fileName,
+                    '-u', connectionSetting.uuid,
+                    '-n', connectionSetting.id,
+                    '-s', serviceType];
+        if (authHelper.externalUIMode)
+            argv.push('--external-ui-mode');
+        if (flags & NM.SecretAgentGetSecretsFlags.ALLOW_INTERACTION)
+            argv.push('-i');
+        if (flags & NM.SecretAgentGetSecretsFlags.REQUEST_NEW)
+            argv.push('-r');
+        if (authHelper.supportsHints) {
+            for (let i = 0; i < hints.length; i++) {
+                argv.push('-t');
+                argv.push(hints[i]);
+            }
+        }
+
+        this._newStylePlugin = authHelper.externalUIMode;
+
+        try {
+            let [success_, pid, stdin, stdout, stderr] =
+                GLib.spawn_async_with_pipes(null, /* pwd */
+                                            argv,
+                                            null, /* envp */
+                                            GLib.SpawnFlags.DO_NOT_REAP_CHILD,
+                                            null /* child_setup */);
+
+            this._childPid = pid;
+            this._stdin = new Gio.UnixOutputStream({ fd: stdin, close_fd: true });
+            this._stdout = new Gio.UnixInputStream({ fd: stdout, close_fd: true });
+            GLib.close(stderr);
+            this._dataStdout = new Gio.DataInputStream({ base_stream: this._stdout });
+
+            if (this._newStylePlugin)
+                this._readStdoutNewStyle();
+            else
+                this._readStdoutOldStyle();
+
+            this._childWatch = GLib.child_watch_add(GLib.PRIORITY_DEFAULT, pid,
+                                                    this._vpnChildFinished.bind(this));
+
+            this._writeConnection();
+        } catch (e) {
+            logError(e, 'error while spawning VPN auth helper');
+
+            this._agent.respond(requestId, Shell.NetworkAgentResponse.INTERNAL_ERROR);
+        }
+    }
+
+    cancel(respond) {
+        if (respond)
+            this._agent.respond(this._requestId, Shell.NetworkAgentResponse.USER_CANCELED);
+
+        if (this._newStylePlugin && this._shellDialog) {
+            this._shellDialog.close(global.get_current_time());
+            this._shellDialog.destroy();
+        } else {
+            try {
+                this._stdin.write('QUIT\n\n', null);
+            } catch (e) { /* ignore broken pipe errors */ }
+        }
+
+        this.destroy();
+    }
+
+    destroy() {
+        if (this._destroyed)
+            return;
+
+        this.emit('destroy');
+        if (this._childWatch)
+            GLib.source_remove(this._childWatch);
+
+        this._stdin.close(null);
+        // Stdout is closed when we finish reading from it
+
+        this._destroyed = true;
+    }
+
+    _vpnChildFinished(pid, status, _requestObj) {
+        this._childWatch = 0;
+        if (this._newStylePlugin) {
+            // For new style plugin, all work is done in the async reading functions
+            // Just reap the process here
+            return;
+        }
+
+        let [exited, exitStatus] = Shell.util_wifexited(status);
+
+        if (exited) {
+            if (exitStatus != 0)
+                this._agent.respond(this._requestId, Shell.NetworkAgentResponse.USER_CANCELED);
+            else
+                this._agent.respond(this._requestId, Shell.NetworkAgentResponse.CONFIRMED);
+        } else {
+            this._agent.respond(this._requestId, Shell.NetworkAgentResponse.INTERNAL_ERROR);
+        }
+
+        this.destroy();
+    }
+
+    _vpnChildProcessLineOldStyle(line) {
+        if (this._previousLine != undefined) {
+            // Two consecutive newlines mean that the child should be closed
+            // (the actual newlines are eaten by Gio.DataInputStream)
+            // Send a termination message
+            if (line == '' && this._previousLine == '') {
+                try {
+                    this._stdin.write('QUIT\n\n', null);
+                } catch (e) { /* ignore broken pipe errors */ }
+            } else {
+                this._agent.set_password(this._requestId, this._previousLine, line);
+                this._previousLine = undefined;
+            }
+        } else {
+            this._previousLine = line;
+        }
+    }
+
+    _readStdoutOldStyle() {
+        this._dataStdout.read_line_async(GLib.PRIORITY_DEFAULT, null, (stream, result) => {
+            let [line, len_] = this._dataStdout.read_line_finish_utf8(result);
+
+            if (line == null) {
+                // end of file
+                this._stdout.close(null);
+                return;
+            }
+
+            this._vpnChildProcessLineOldStyle(line);
+
+            // try to read more!
+            this._readStdoutOldStyle();
+        });
+    }
+
+    _readStdoutNewStyle() {
+        this._dataStdout.fill_async(-1, GLib.PRIORITY_DEFAULT, null, (stream, result) => {
+            let cnt = this._dataStdout.fill_finish(result);
+
+            if (cnt == 0) {
+                // end of file
+                this._showNewStyleDialog();
+
+                this._stdout.close(null);
+                return;
+            }
+
+            // Try to read more
+            this._dataStdout.set_buffer_size(2 * this._dataStdout.get_buffer_size());
+            this._readStdoutNewStyle();
+        });
+    }
+
+    _showNewStyleDialog() {
+        let keyfile = new GLib.KeyFile();
+        let data;
+        let contentOverride;
+
+        try {
+            data = this._dataStdout.peek_buffer();
+
+            if (data instanceof Uint8Array)
+                data = imports.byteArray.toGBytes(data);
+            else
+                data = data.toGBytes();
+
+            keyfile.load_from_bytes(data, GLib.KeyFileFlags.NONE);
+
+            if (keyfile.get_integer(VPN_UI_GROUP, 'Version') != 2)
+                throw new Error('Invalid plugin keyfile version, is %d');
+
+            contentOverride = { title: keyfile.get_string(VPN_UI_GROUP, 'Title'),
+                                message: keyfile.get_string(VPN_UI_GROUP, 'Description'),
+                                secrets: [] };
+
+            let [groups, len_] = keyfile.get_groups();
+            for (let i = 0; i < groups.length; i++) {
+                if (groups[i] == VPN_UI_GROUP)
+                    continue;
+
+                let value = keyfile.get_string(groups[i], 'Value');
+                let shouldAsk = keyfile.get_boolean(groups[i], 'ShouldAsk');
+
+                if (shouldAsk) {
+                    contentOverride.secrets.push({
+                        label: keyfile.get_string(groups[i], 'Label'),
+                        key: groups[i],
+                        value,
+                        password: keyfile.get_boolean(groups[i], 'IsSecret'),
+                    });
+                } else {
+                    if (!value.length) // Ignore empty secrets
+                        continue;
+
+                    this._agent.set_password(this._requestId, groups[i], value);
+                }
+            }
+        } catch (e) {
+            // No output is a valid case it means "both secrets are stored"
+            if (data.length > 0) {
+                logError(e, 'error while reading VPN plugin output keyfile');
+
+                this._agent.respond(this._requestId, Shell.NetworkAgentResponse.INTERNAL_ERROR);
+                this.destroy();
+                return;
+            }
+        }
+
+        if (contentOverride && contentOverride.secrets.length) {
+            // Only show the dialog if we actually have something to ask
+            this._shellDialog = new NetworkSecretDialog(this._agent, this._requestId, this._connection, 'vpn', [], this._flags, contentOverride);
+            this._shellDialog.open(global.get_current_time());
+        } else {
+            this._agent.respond(this._requestId, Shell.NetworkAgentResponse.CONFIRMED);
+            this.destroy();
+        }
+    }
+
+    _writeConnection() {
+        let vpnSetting = this._connection.get_setting_vpn();
+
+        try {
+            vpnSetting.foreach_data_item((key, value) => {
+                this._stdin.write('DATA_KEY=%s\n'.format(key), null);
+                this._stdin.write('DATA_VAL=%s\n\n'.format(value || ''), null);
+            });
+            vpnSetting.foreach_secret((key, value) => {
+                this._stdin.write('SECRET_KEY=%s\n'.format(key), null);
+                this._stdin.write('SECRET_VAL=%s\n\n'.format(value || ''), null);
+            });
+            this._stdin.write('DONE\n\n', null);
+        } catch (e) {
+            logError(e, 'internal error while writing connection to helper');
+
+            this._agent.respond(this._requestId, Shell.NetworkAgentResponse.INTERNAL_ERROR);
+            this.destroy();
+        }
+    }
+};
+Signals.addSignalMethods(VPNRequestHandler.prototype);
+
+var NetworkAgent = class {
+    constructor() {
+        this._native = new Shell.NetworkAgent({
+            identifier: 'org.gnome.Shell.NetworkAgent',
+            capabilities: NM.SecretAgentCapabilities.VPN_HINTS,
+            auto_register: false,
+        });
+
+        this._dialogs = { };
+        this._vpnRequests = { };
+        this._notifications = { };
+
+        this._pluginDir = Gio.file_new_for_path(Config.VPNDIR);
+        try {
+            let monitor = this._pluginDir.monitor(Gio.FileMonitorFlags.NONE, null);
+            monitor.connect('changed', () => (this._vpnCacheBuilt = false));
+        } catch (e) {
+            log('Failed to create monitor for VPN plugin dir: %s'.format(e.message));
+        }
+
+        this._native.connect('new-request', this._newRequest.bind(this));
+        this._native.connect('cancel-request', this._cancelRequest.bind(this));
+
+        this._initialized = false;
+        this._native.init_async(GLib.PRIORITY_DEFAULT, null, (o, res) => {
+            try {
+                this._native.init_finish(res);
+                this._initialized = true;
+            } catch (e) {
+                this._native = null;
+                logError(e, 'error initializing the NetworkManager Agent');
+            }
+        });
+    }
+
+    enable() {
+        if (!this._native)
+            return;
+
+        this._native.auto_register = true;
+        if (this._initialized && !this._native.registered)
+            this._native.register_async(null, null);
+    }
+
+    disable() {
+        let requestId;
+
+        for (requestId in this._dialogs)
+            this._dialogs[requestId].cancel();
+        this._dialogs = { };
+
+        for (requestId in this._vpnRequests)
+            this._vpnRequests[requestId].cancel(true);
+        this._vpnRequests = { };
+
+        for (requestId in this._notifications)
+            this._notifications[requestId].destroy();
+        this._notifications = { };
+
+        if (!this._native)
+            return;
+
+        this._native.auto_register = false;
+        if (this._initialized && this._native.registered)
+            this._native.unregister_async(null, null);
+    }
+
+    _showNotification(requestId, connection, settingName, hints, flags) {
+        let source = new MessageTray.Source(_("Network Manager"), 'network-transmit-receive');
+        source.policy = new MessageTray.NotificationApplicationPolicy('gnome-network-panel');
+
+        let title, body;
+
+        let connectionSetting = connection.get_setting_connection();
+        let connectionType = connectionSetting.get_connection_type();
+        switch (connectionType) {
+        case '802-11-wireless': {
+            let wirelessSetting = connection.get_setting_wireless();
+            let ssid = NM.utils_ssid_to_utf8(wirelessSetting.get_ssid().get_data());
+            title = _('Authentication required');
+            body = _("Passwords or encryption keys are required to access the wireless network “%s”.").format(ssid);
+            break;
+        }
+        case '802-3-ethernet':
+            title = _("Wired 802.1X authentication");
+            body = _("A password is required to connect to “%s”.".format(connection.get_id()));
+            break;
+        case 'pppoe':
+            title = _("DSL authentication");
+            body = _("A password is required to connect to “%s”.".format(connection.get_id()));
+            break;
+        case 'gsm':
+            if (hints.includes('pin')) {
+                title = _("PIN code required");
+                body = _("PIN code is needed for the mobile broadband device");
+                break;
+            }
+            // fall through
+        case 'cdma':
+        case 'bluetooth':
+            title = _('Authentication required');
+            body = _("A password is required to connect to “%s”.").format(connectionSetting.get_id());
+            break;
+        case 'vpn':
+            title = _("VPN password");
+            body = _("A password is required to connect to “%s”.").format(connectionSetting.get_id());
+            break;
+        default:
+            log('Invalid connection type: %s'.format(connectionType));
+            this._native.respond(requestId, Shell.NetworkAgentResponse.INTERNAL_ERROR);
+            return;
+        }
+
+        let notification = new MessageTray.Notification(source, title, body);
+
+        notification.connect('activated', () => {
+            notification.answered = true;
+            this._handleRequest(requestId, connection, settingName, hints, flags);
+        });
+
+        this._notifications[requestId] = notification;
+        notification.connect('destroy', () => {
+            if (!notification.answered)
+                this._native.respond(requestId, Shell.NetworkAgentResponse.USER_CANCELED);
+            delete this._notifications[requestId];
+        });
+
+        Main.messageTray.add(source);
+        source.showNotification(notification);
+    }
+
+    _newRequest(agent, requestId, connection, settingName, hints, flags) {
+        if (!(flags & NM.SecretAgentGetSecretsFlags.USER_REQUESTED))
+            this._showNotification(requestId, connection, settingName, hints, flags);
+        else
+            this._handleRequest(requestId, connection, settingName, hints, flags);
+    }
+
+    _handleRequest(requestId, connection, settingName, hints, flags) {
+        if (settingName == 'vpn') {
+            this._vpnRequest(requestId, connection, hints, flags);
+            return;
+        }
+
+        let dialog = new NetworkSecretDialog(this._native, requestId, connection, settingName, hints, flags);
+        dialog.connect('destroy', () => {
+            delete this._dialogs[requestId];
+        });
+        this._dialogs[requestId] = dialog;
+        dialog.open(global.get_current_time());
+    }
+
+    _cancelRequest(agent, requestId) {
+        if (this._dialogs[requestId]) {
+            this._dialogs[requestId].close(global.get_current_time());
+            this._dialogs[requestId].destroy();
+            delete this._dialogs[requestId];
+        } else if (this._vpnRequests[requestId]) {
+            this._vpnRequests[requestId].cancel(false);
+            delete this._vpnRequests[requestId];
+        }
+    }
+
+    _vpnRequest(requestId, connection, hints, flags) {
+        let vpnSetting = connection.get_setting_vpn();
+        let serviceType = vpnSetting.service_type;
+
+        this._buildVPNServiceCache();
+
+        let binary = this._vpnBinaries[serviceType];
+        if (!binary) {
+            log('Invalid VPN service type (cannot find authentication binary)');
+
+            /* cancel the auth process */
+            this._native.respond(requestId, Shell.NetworkAgentResponse.INTERNAL_ERROR);
+            return;
+        }
+
+        let vpnRequest = new VPNRequestHandler(this._native, requestId, binary, serviceType, connection, hints, flags);
+        vpnRequest.connect('destroy', () => {
+            delete this._vpnRequests[requestId];
+        });
+        this._vpnRequests[requestId] = vpnRequest;
+    }
+
+    _buildVPNServiceCache() {
+        if (this._vpnCacheBuilt)
+            return;
+
+        this._vpnCacheBuilt = true;
+        this._vpnBinaries = { };
+
+        NM.VpnPluginInfo.list_load().forEach(plugin => {
+            let service = plugin.get_service();
+            let fileName = plugin.get_auth_dialog();
+            let supportsHints = plugin.supports_hints();
+            let externalUIMode = false;
+
+            let prop = plugin.lookup_property('GNOME', 'supports-external-ui-mode');
+            if (prop) {
+                prop = prop.trim().toLowerCase();
+                externalUIMode = ['true', 'yes', 'on', '1'].includes(prop);
+            }
+
+            if (GLib.file_test(fileName, GLib.FileTest.IS_EXECUTABLE)) {
+                let binary = { fileName, externalUIMode, supportsHints };
+                this._vpnBinaries[service] = binary;
+
+                plugin.get_aliases().forEach(alias => {
+                    this._vpnBinaries[alias] = binary;
+                });
+            } else {
+                log('VPN plugin at %s is not executable'.format(fileName));
+            }
+        });
+    }
+};
+var Component = NetworkAgent;

js/ui/components/polkitAgent.js

@@ -0,0 +1,467 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Component */
+
+const { AccountsService, Clutter, GLib,
+        GObject, Pango, PolkitAgent, Polkit, Shell, St } = imports.gi;
+
+const Dialog = imports.ui.dialog;
+const Main = imports.ui.main;
+const ModalDialog = imports.ui.modalDialog;
+const ShellEntry = imports.ui.shellEntry;
+const UserWidget = imports.ui.userWidget;
+const Util = imports.misc.util;
+
+const DialogMode = {
+    AUTH: 0,
+    CONFIRM: 1,
+};
+
+const DIALOG_ICON_SIZE = 64;
+
+const DELAYED_RESET_TIMEOUT = 200;
+
+var AuthenticationDialog = GObject.registerClass({
+    Signals: { 'done': { param_types: [GObject.TYPE_BOOLEAN] } },
+}, class AuthenticationDialog extends ModalDialog.ModalDialog {
+    _init(actionId, description, cookie, userNames) {
+        super._init({ styleClass: 'prompt-dialog' });
+
+        this.actionId = actionId;
+        this.message = description;
+        this.userNames = userNames;
+
+        this._sessionUpdatedId = Main.sessionMode.connect('updated', () => {
+            this.visible = !Main.sessionMode.isLocked;
+        });
+
+        this.connect('closed', this._onDialogClosed.bind(this));
+
+        let title = _("Authentication Required");
+
+        let headerContent = new Dialog.MessageDialogContent({ title, description });
+        this.contentLayout.add_child(headerContent);
+
+        let bodyContent = new Dialog.MessageDialogContent();
+
+        if (userNames.length > 1) {
+            log('polkitAuthenticationAgent: Received %d'.format(userNames.length) +
+                'identities that can be used for authentication. Only ' +
+                'considering one.');
+        }
+
+        let userName = GLib.get_user_name();
+        if (!userNames.includes(userName))
+            userName = 'root';
+        if (!userNames.includes(userName))
+            userName = userNames[0];
+
+        this._user = AccountsService.UserManager.get_default().get_user(userName);
+
+        let userBox = new St.BoxLayout({
+            style_class: 'polkit-dialog-user-layout',
+            vertical: true,
+        });
+        bodyContent.add_child(userBox);
+
+        this._userAvatar = new UserWidget.Avatar(this._user, {
+            iconSize: DIALOG_ICON_SIZE,
+            styleClass: 'polkit-dialog-user-icon',
+        });
+        this._userAvatar.x_align = Clutter.ActorAlign.CENTER;
+        userBox.add_child(this._userAvatar);
+
+        this._userLabel = new St.Label({
+            style_class: userName === 'root'
+                ? 'polkit-dialog-user-root-label'
+                : 'polkit-dialog-user-label',
+        });
+
+        if (userName === 'root')
+            this._userLabel.text = _('Administrator');
+
+        userBox.add_child(this._userLabel);
+
+        let passwordBox = new St.BoxLayout({
+            style_class: 'prompt-dialog-password-layout',
+            vertical: true,
+        });
+
+        this._passwordEntry = new St.PasswordEntry({
+            style_class: 'prompt-dialog-password-entry',
+            text: "",
+            can_focus: true,
+            visible: false,
+            x_align: Clutter.ActorAlign.CENTER,
+        });
+        ShellEntry.addContextMenu(this._passwordEntry);
+        this._passwordEntry.clutter_text.connect('activate', this._onEntryActivate.bind(this));
+        this._passwordEntry.bind_property('reactive',
+            this._passwordEntry.clutter_text, 'editable',
+            GObject.BindingFlags.SYNC_CREATE);
+        passwordBox.add_child(this._passwordEntry);
+
+        let warningBox = new St.BoxLayout({ vertical: true });
+
+        let capsLockWarning = new ShellEntry.CapsLockWarning();
+        this._passwordEntry.bind_property('visible',
+            capsLockWarning, 'visible',
+            GObject.BindingFlags.SYNC_CREATE);
+        warningBox.add_child(capsLockWarning);
+
+        this._errorMessageLabel = new St.Label({
+            style_class: 'prompt-dialog-error-label',
+            visible: false,
+        });
+        this._errorMessageLabel.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+        this._errorMessageLabel.clutter_text.line_wrap = true;
+        warningBox.add_child(this._errorMessageLabel);
+
+        this._infoMessageLabel = new St.Label({
+            style_class: 'prompt-dialog-info-label',
+            visible: false,
+        });
+        this._infoMessageLabel.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+        this._infoMessageLabel.clutter_text.line_wrap = true;
+        warningBox.add_child(this._infoMessageLabel);
+
+        /* text is intentionally non-blank otherwise the height is not the same as for
+         * infoMessage and errorMessageLabel - but it is still invisible because
+         * gnome-shell.css sets the color to be transparent
+         */
+        this._nullMessageLabel = new St.Label({ style_class: 'prompt-dialog-null-label' });
+        this._nullMessageLabel.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+        this._nullMessageLabel.clutter_text.line_wrap = true;
+        warningBox.add_child(this._nullMessageLabel);
+
+        passwordBox.add_child(warningBox);
+        bodyContent.add_child(passwordBox);
+
+        this._cancelButton = this.addButton({ label: _("Cancel"),
+                                              action: this.cancel.bind(this),
+                                              key: Clutter.KEY_Escape });
+        this._okButton = this.addButton({ label: _("Authenticate"),
+                                          action: this._onAuthenticateButtonPressed.bind(this),
+                                          reactive: false });
+        this._okButton.bind_property('reactive',
+            this._okButton, 'can-focus',
+            GObject.BindingFlags.SYNC_CREATE);
+
+        this._passwordEntry.clutter_text.connect('text-changed', text => {
+            this._okButton.reactive = text.get_text().length > 0;
+        });
+
+        this.contentLayout.add_child(bodyContent);
+
+        this._doneEmitted = false;
+
+        this._mode = -1;
+
+        this._identityToAuth = Polkit.UnixUser.new_for_name(userName);
+        this._cookie = cookie;
+
+        this._userLoadedId = this._user.connect('notify::is-loaded',
+            this._onUserChanged.bind(this));
+        this._userChangedId = this._user.connect('changed',
+            this._onUserChanged.bind(this));
+        this._onUserChanged();
+    }
+
+    _initiateSession() {
+        this._destroySession(DELAYED_RESET_TIMEOUT);
+
+        this._session = new PolkitAgent.Session({ identity: this._identityToAuth,
+                                                  cookie: this._cookie });
+        this._sessionCompletedId = this._session.connect('completed', this._onSessionCompleted.bind(this));
+        this._sessionRequestId = this._session.connect('request', this._onSessionRequest.bind(this));
+        this._sessionShowErrorId = this._session.connect('show-error', this._onSessionShowError.bind(this));
+        this._sessionShowInfoId = this._session.connect('show-info', this._onSessionShowInfo.bind(this));
+        this._session.initiate();
+    }
+
+    _ensureOpen() {
+        // NOTE: ModalDialog.open() is safe to call if the dialog is
+        // already open - it just returns true without side-effects
+        if (!this.open(global.get_current_time())) {
+            // This can fail if e.g. unable to get input grab
+            //
+            // In an ideal world this wouldn't happen (because the
+            // Shell is in complete control of the session) but that's
+            // just not how things work right now.
+            //
+            // One way to make this happen is by running 'sleep 3;
+            // pkexec bash' and then opening a popup menu.
+            //
+            // We could add retrying if this turns out to be a problem
+
+            log('polkitAuthenticationAgent: Failed to show modal dialog. ' +
+                'Dismissing authentication request for action-id %s '.format(this.actionId) +
+                'cookie %s'.format(this._cookie));
+            this._emitDone(true);
+        }
+    }
+
+    _emitDone(dismissed) {
+        if (!this._doneEmitted) {
+            this._doneEmitted = true;
+            this.emit('done', dismissed);
+        }
+    }
+
+    _onEntryActivate() {
+        let response = this._passwordEntry.get_text();
+        if (response.length === 0)
+            return;
+
+        this._passwordEntry.reactive = false;
+        this._okButton.reactive = false;
+
+        this._session.response(response);
+        // When the user responds, dismiss already shown info and
+        // error texts (if any)
+        this._errorMessageLabel.hide();
+        this._infoMessageLabel.hide();
+        this._nullMessageLabel.show();
+    }
+
+    _onAuthenticateButtonPressed() {
+        if (this._mode === DialogMode.CONFIRM)
+            this._initiateSession();
+        else
+            this._onEntryActivate();
+    }
+
+    _onSessionCompleted(session, gainedAuthorization) {
+        if (this._completed || this._doneEmitted)
+            return;
+
+        this._completed = true;
+
+        /* Yay, all done */
+        if (gainedAuthorization) {
+            this._emitDone(false);
+
+        } else {
+            /* Unless we are showing an existing error message from the PAM
+             * module (the PAM module could be reporting the authentication
+             * error providing authentication-method specific information),
+             * show "Sorry, that didn't work. Please try again."
+             */
+            if (!this._errorMessageLabel.visible) {
+                /* Translators: "that didn't work" refers to the fact that the
+                 * requested authentication was not gained; this can happen
+                 * because of an authentication error (like invalid password),
+                 * for instance. */
+                this._errorMessageLabel.set_text(_("Sorry, that didn’t work. Please try again."));
+                this._errorMessageLabel.show();
+                this._infoMessageLabel.hide();
+                this._nullMessageLabel.hide();
+
+                Util.wiggle(this._passwordEntry);
+            }
+
+            /* Try and authenticate again */
+            this._initiateSession();
+        }
+    }
+
+    _onSessionRequest(session, request, echoOn) {
+        if (this._sessionRequestTimeoutId) {
+            GLib.source_remove(this._sessionRequestTimeoutId);
+            this._sessionRequestTimeoutId = 0;
+        }
+
+        // Hack: The request string comes directly from PAM, if it's "Password:"
+        // we replace it with our own to allow localization, if it's something
+        // else we remove the last colon and any trailing or leading spaces.
+        if (request === 'Password:' || request === 'Password: ')
+            this._passwordEntry.hint_text = _('Password');
+        else
+            this._passwordEntry.hint_text = request.replace(/: *$/, '').trim();
+
+        this._passwordEntry.password_visible = echoOn;
+
+        this._passwordEntry.show();
+        this._passwordEntry.set_text('');
+        this._passwordEntry.reactive  = true;
+        this._okButton.reactive = false;
+
+        this._ensureOpen();
+        this._passwordEntry.grab_key_focus();
+    }
+
+    _onSessionShowError(session, text) {
+        this._passwordEntry.set_text('');
+        this._errorMessageLabel.set_text(text);
+        this._errorMessageLabel.show();
+        this._infoMessageLabel.hide();
+        this._nullMessageLabel.hide();
+        this._ensureOpen();
+    }
+
+    _onSessionShowInfo(session, text) {
+        this._passwordEntry.set_text('');
+        this._infoMessageLabel.set_text(text);
+        this._infoMessageLabel.show();
+        this._errorMessageLabel.hide();
+        this._nullMessageLabel.hide();
+        this._ensureOpen();
+    }
+
+    _destroySession(delay = 0) {
+        if (this._session) {
+            this._session.disconnect(this._sessionCompletedId);
+            this._session.disconnect(this._sessionRequestId);
+            this._session.disconnect(this._sessionShowErrorId);
+            this._session.disconnect(this._sessionShowInfoId);
+
+            if (!this._completed)
+                this._session.cancel();
+
+            this._completed = false;
+            this._session = null;
+        }
+
+        if (this._sessionRequestTimeoutId) {
+            GLib.source_remove(this._sessionRequestTimeoutId);
+            this._sessionRequestTimeoutId = 0;
+        }
+
+        let resetDialog = () => {
+            if (this.state != ModalDialog.State.OPENED)
+                return;
+
+            this._passwordEntry.hide();
+            this._cancelButton.grab_key_focus();
+            this._okButton.reactive = false;
+        };
+
+        if (delay) {
+            this._sessionRequestTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, delay, resetDialog);
+            GLib.Source.set_name_by_id(this._sessionRequestTimeoutId, '[gnome-shell] this._sessionRequestTimeoutId');
+        } else {
+            resetDialog();
+        }
+    }
+
+    _onUserChanged() {
+        if (!this._user.is_loaded)
+            return;
+
+        let userName = this._user.get_user_name();
+        let realName = this._user.get_real_name();
+
+        if (userName !== 'root')
+            this._userLabel.set_text(realName);
+
+        this._userAvatar.update();
+
+        if (this._user.get_password_mode() === AccountsService.UserPasswordMode.NONE) {
+            if (this._mode === DialogMode.CONFIRM)
+                return;
+
+            this._mode = DialogMode.CONFIRM;
+            this._destroySession();
+
+            this._okButton.reactive = true;
+
+            /* We normally open the dialog when we get a "request" signal, but
+             * since in this case initiating a session would perform the
+             * authentication, only open the dialog and initiate the session
+             * when the user confirmed. */
+            this._ensureOpen();
+        } else {
+            if (this._mode === DialogMode.AUTH)
+                return;
+
+            this._mode = DialogMode.AUTH;
+            this._initiateSession();
+        }
+    }
+
+    cancel() {
+        this.close(global.get_current_time());
+        this._emitDone(true);
+    }
+
+    _onDialogClosed() {
+        if (this._sessionUpdatedId)
+            Main.sessionMode.disconnect(this._sessionUpdatedId);
+
+        if (this._sessionRequestTimeoutId)
+            GLib.source_remove(this._sessionRequestTimeoutId);
+        this._sessionRequestTimeoutId = 0;
+
+        if (this._user) {
+            this._user.disconnect(this._userLoadedId);
+            this._user.disconnect(this._userChangedId);
+            this._user = null;
+        }
+
+        this._destroySession();
+    }
+});
+
+var AuthenticationAgent = GObject.registerClass(
+class AuthenticationAgent extends Shell.PolkitAuthenticationAgent {
+    _init() {
+        super._init();
+
+        this._currentDialog = null;
+        this.connect('initiate', this._onInitiate.bind(this));
+        this.connect('cancel', this._onCancel.bind(this));
+        this._sessionUpdatedId = 0;
+    }
+
+    enable() {
+        try {
+            this.register();
+        } catch (e) {
+            log('Failed to register AuthenticationAgent');
+        }
+    }
+
+    disable() {
+        try {
+            this.unregister();
+        } catch (e) {
+            log('Failed to unregister AuthenticationAgent');
+        }
+    }
+
+    _onInitiate(nativeAgent, actionId, message, iconName, cookie, userNames) {
+        // Don't pop up a dialog while locked
+        if (Main.sessionMode.isLocked) {
+            this._sessionUpdatedId = Main.sessionMode.connect('updated', () => {
+                Main.sessionMode.disconnect(this._sessionUpdatedId);
+                this._sessionUpdatedId = 0;
+
+                this._onInitiate(nativeAgent, actionId, message, iconName, cookie, userNames);
+            });
+            return;
+        }
+
+        this._currentDialog = new AuthenticationDialog(actionId, message, cookie, userNames);
+        this._currentDialog.connect('done', this._onDialogDone.bind(this));
+    }
+
+    _onCancel(_nativeAgent) {
+        this._completeRequest(false);
+    }
+
+    _onDialogDone(_dialog, dismissed) {
+        this._completeRequest(dismissed);
+    }
+
+    _completeRequest(dismissed) {
+        this._currentDialog.close();
+        this._currentDialog = null;
+
+        if (this._sessionUpdatedId)
+            Main.sessionMode.disconnect(this._sessionUpdatedId);
+        this._sessionUpdatedId = 0;
+
+        this.complete(dismissed);
+    }
+});
+
+var Component = AuthenticationAgent;

js/ui/components/telepathyClient.js

@@ -0,0 +1,983 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Component */
+
+const { Clutter, Gio, GLib, GObject, St } = imports.gi;
+const Lang = imports.lang;
+
+var Tpl = null;
+var Tp = null;
+try {
+    ({ TelepathyGLib: Tp, TelepathyLogger: Tpl } = imports.gi);
+} catch (e) {
+    log('Telepathy is not available, chat integration will be disabled.');
+}
+
+const History = imports.misc.history;
+const Main = imports.ui.main;
+const MessageList = imports.ui.messageList;
+const MessageTray = imports.ui.messageTray;
+const Params = imports.misc.params;
+const Util = imports.misc.util;
+
+const HAVE_TP = Tp != null && Tpl != null;
+
+// See Notification.appendMessage
+var SCROLLBACK_IMMEDIATE_TIME = 3 * 60; // 3 minutes
+var SCROLLBACK_RECENT_TIME = 15 * 60; // 15 minutes
+var SCROLLBACK_RECENT_LENGTH = 20;
+var SCROLLBACK_IDLE_LENGTH = 5;
+
+// See Source._displayPendingMessages
+var SCROLLBACK_HISTORY_LINES = 10;
+
+// See Notification._onEntryChanged
+var COMPOSING_STOP_TIMEOUT = 5;
+
+var CHAT_EXPAND_LINES = 12;
+
+var NotificationDirection = {
+    SENT: 'chat-sent',
+    RECEIVED: 'chat-received',
+};
+
+function makeMessageFromTpMessage(tpMessage, direction) {
+    let [text, flags_] = tpMessage.to_text();
+
+    let timestamp = tpMessage.get_sent_timestamp();
+    if (timestamp == 0)
+        timestamp = tpMessage.get_received_timestamp();
+
+    return {
+        messageType: tpMessage.get_message_type(),
+        text,
+        sender: tpMessage.sender.alias,
+        timestamp,
+        direction,
+    };
+}
+
+
+function makeMessageFromTplEvent(event) {
+    let sent = event.get_sender().get_entity_type() == Tpl.EntityType.SELF;
+    let direction = sent ? NotificationDirection.SENT : NotificationDirection.RECEIVED;
+
+    return {
+        messageType: event.get_message_type(),
+        text: event.get_message(),
+        sender: event.get_sender().get_alias(),
+        timestamp: event.get_timestamp(),
+        direction,
+    };
+}
+
+var TelepathyComponent = class {
+    constructor() {
+        this._client = null;
+
+        if (!HAVE_TP)
+            return; // Telepathy isn't available
+
+        this._client = new TelepathyClient();
+    }
+
+    enable() {
+        if (!this._client)
+            return;
+
+        try {
+            this._client.register();
+        } catch (e) {
+            throw new Error('Could not register Telepathy client. Error: %s'.format(e.toString()));
+        }
+
+        if (!this._client.account_manager.is_prepared(Tp.AccountManager.get_feature_quark_core()))
+            this._client.account_manager.prepare_async(null, null);
+    }
+
+    disable() {
+        if (!this._client)
+            return;
+
+        this._client.unregister();
+    }
+};
+
+var TelepathyClient = HAVE_TP ? GObject.registerClass(
+class TelepathyClient extends Tp.BaseClient {
+    _init() {
+        // channel path -> ChatSource
+        this._chatSources = {};
+        this._chatState = Tp.ChannelChatState.ACTIVE;
+
+        // account path -> AccountNotification
+        this._accountNotifications = {};
+
+        // Define features we want
+        this._accountManager = Tp.AccountManager.dup();
+        let factory = this._accountManager.get_factory();
+        factory.add_account_features([Tp.Account.get_feature_quark_connection()]);
+        factory.add_connection_features([Tp.Connection.get_feature_quark_contact_list()]);
+        factory.add_channel_features([Tp.Channel.get_feature_quark_contacts()]);
+        factory.add_contact_features([Tp.ContactFeature.ALIAS,
+                                      Tp.ContactFeature.AVATAR_DATA,
+                                      Tp.ContactFeature.PRESENCE,
+                                      Tp.ContactFeature.SUBSCRIPTION_STATES]);
+
+        // Set up a SimpleObserver, which will call _observeChannels whenever a
+        // channel matching its filters is detected.
+        // The second argument, recover, means _observeChannels will be run
+        // for any existing channel as well.
+        super._init({ name: 'GnomeShell',
+                      account_manager: this._accountManager,
+                      uniquify_name: true });
+
+        // We only care about single-user text-based chats
+        let filter = {};
+        filter[Tp.PROP_CHANNEL_CHANNEL_TYPE] = Tp.IFACE_CHANNEL_TYPE_TEXT;
+        filter[Tp.PROP_CHANNEL_TARGET_HANDLE_TYPE] = Tp.HandleType.CONTACT;
+
+        this.set_observer_recover(true);
+        this.add_observer_filter(filter);
+        this.add_approver_filter(filter);
+        this.add_handler_filter(filter);
+
+        // Allow other clients (such as Empathy) to pre-empt our channels if
+        // needed
+        this.set_delegated_channels_callback(
+            this._delegatedChannelsCb.bind(this));
+    }
+
+    vfunc_observe_channels(...args) {
+        let [account, conn, channels, dispatchOp_, requests_, context] = args;
+        let len = channels.length;
+        for (let i = 0; i < len; i++) {
+            let channel = channels[i];
+            let [targetHandle_, targetHandleType] = channel.get_handle();
+
+            if (channel.get_invalidated())
+                continue;
+
+            /* Only observe contact text channels */
+            if (!(channel instanceof Tp.TextChannel) ||
+               targetHandleType != Tp.HandleType.CONTACT)
+                continue;
+
+            this._createChatSource(account, conn, channel, channel.get_target_contact());
+        }
+
+        context.accept();
+    }
+
+    _createChatSource(account, conn, channel, contact) {
+        if (this._chatSources[channel.get_object_path()])
+            return;
+
+        let source = new ChatSource(account, conn, channel, contact, this);
+
+        this._chatSources[channel.get_object_path()] = source;
+        source.connect('destroy', () => {
+            delete this._chatSources[channel.get_object_path()];
+        });
+    }
+
+    vfunc_handle_channels(...args) {
+        let [account, conn, channels, requests_, userActionTime_, context] = args;
+        this._handlingChannels(account, conn, channels, true);
+        context.accept();
+    }
+
+    _handlingChannels(account, conn, channels, notify) {
+        let len = channels.length;
+        for (let i = 0; i < len; i++) {
+            let channel = channels[i];
+
+            // We can only handle text channel, so close any other channel
+            if (!(channel instanceof Tp.TextChannel)) {
+                channel.close_async(null);
+                continue;
+            }
+
+            if (channel.get_invalidated())
+                continue;
+
+            // 'notify' will be true when coming from an actual HandleChannels
+            // call, and not when from a successful Claim call. The point is
+            // we don't want to notify for a channel we just claimed which
+            // has no new messages (for example, a new channel which only has
+            // a delivery notification). We rely on _displayPendingMessages()
+            // and _messageReceived() to notify for new messages.
+
+            // But we should still notify from HandleChannels because the
+            // Telepathy spec states that handlers must foreground channels
+            // in HandleChannels calls which are already being handled.
+
+            if (notify && this.is_handling_channel(channel)) {
+                // We are already handling the channel, display the source
+                let source = this._chatSources[channel.get_object_path()];
+                if (source)
+                    source.showNotification();
+            }
+        }
+    }
+
+    vfunc_add_dispatch_operation(...args) {
+        let [account, conn, channels, dispatchOp, context] = args;
+        let channel = channels[0];
+        let chanType = channel.get_channel_type();
+
+        if (channel.get_invalidated()) {
+            context.fail(new Tp.Error({ code: Tp.Error.INVALID_ARGUMENT,
+                                        message: 'Channel is invalidated' }));
+            return;
+        }
+
+        if (chanType == Tp.IFACE_CHANNEL_TYPE_TEXT) {
+            this._approveTextChannel(account, conn, channel, dispatchOp, context);
+        } else {
+            context.fail(new Tp.Error({ code: Tp.Error.INVALID_ARGUMENT,
+                                        message: 'Unsupported channel type' }));
+        }
+    }
+
+    _approveTextChannel(account, conn, channel, dispatchOp, context) {
+        let [targetHandle_, targetHandleType] = channel.get_handle();
+
+        if (targetHandleType != Tp.HandleType.CONTACT) {
+            context.fail(new Tp.Error({ code: Tp.Error.INVALID_ARGUMENT,
+                                        message: 'Unsupported handle type' }));
+            return;
+        }
+
+        // Approve private text channels right away as we are going to handle it
+        dispatchOp.claim_with_async(this, (o, result) => {
+            try {
+                dispatchOp.claim_with_finish(result);
+                this._handlingChannels(account, conn, [channel], false);
+            } catch (err) {
+                log('Failed to Claim channel: %s'.format(err.toString()));
+            }
+        });
+
+        context.accept();
+    }
+
+    _delegatedChannelsCb(_client, _channels) {
+        // Nothing to do as we don't make a distinction between observed and
+        // handled channels.
+    }
+}) : null;
+
+var ChatSource = HAVE_TP ? GObject.registerClass(
+class ChatSource extends MessageTray.Source {
+    _init(account, conn, channel, contact, client) {
+        super._init(contact.get_alias());
+
+        this._account = account;
+        this._contact = contact;
+        this._client = client;
+
+        this.isChat = true;
+        this._pendingMessages = [];
+
+        this._conn = conn;
+        this._channel = channel;
+        this._closedId = this._channel.connect('invalidated', this._channelClosed.bind(this));
+
+        this._notifyTimeoutId = 0;
+
+        this._presence = contact.get_presence_type();
+
+        this._sentId = this._channel.connect('message-sent', this._messageSent.bind(this));
+        this._receivedId = this._channel.connect('message-received', this._messageReceived.bind(this));
+        this._pendingId = this._channel.connect('pending-message-removed', this._pendingRemoved.bind(this));
+
+        this._notifyAliasId = this._contact.connect('notify::alias', this._updateAlias.bind(this));
+        this._notifyAvatarId = this._contact.connect('notify::avatar-file', this._updateAvatarIcon.bind(this));
+        this._presenceChangedId = this._contact.connect('presence-changed', this._presenceChanged.bind(this));
+
+        // Add ourselves as a source.
+        Main.messageTray.add(this);
+
+        this._getLogMessages();
+    }
+
+    _ensureNotification() {
+        if (this._notification)
+            return;
+
+        this._notification = new ChatNotification(this);
+        this._notification.connect('activated', this.open.bind(this));
+        this._notification.connect('updated', () => {
+            if (this._banner && this._banner.expanded)
+                this._ackMessages();
+        });
+        this._notification.connect('destroy', () => {
+            this._notification = null;
+        });
+        this.pushNotification(this._notification);
+    }
+
+    _createPolicy() {
+        if (this._account.protocol_name == 'irc')
+            return new MessageTray.NotificationApplicationPolicy('org.gnome.Polari');
+        return new MessageTray.NotificationApplicationPolicy('empathy');
+    }
+
+    createBanner() {
+        this._banner = new ChatNotificationBanner(this._notification);
+
+        // We ack messages when the user expands the new notification
+        let id = this._banner.connect('expanded', this._ackMessages.bind(this));
+        this._banner.connect('destroy', () => {
+            this._banner.disconnect(id);
+            this._banner = null;
+        });
+
+        return this._banner;
+    }
+
+    _updateAlias() {
+        let oldAlias = this.title;
+        let newAlias = this._contact.get_alias();
+
+        if (oldAlias == newAlias)
+            return;
+
+        this.setTitle(newAlias);
+        if (this._notification)
+            this._notification.appendAliasChange(oldAlias, newAlias);
+    }
+
+    getIcon() {
+        let file = this._contact.get_avatar_file();
+        if (file)
+            return new Gio.FileIcon({ file });
+        else
+            return new Gio.ThemedIcon({ name: 'avatar-default' });
+    }
+
+    getSecondaryIcon() {
+        let iconName;
+        let presenceType = this._contact.get_presence_type();
+
+        switch (presenceType) {
+        case Tp.ConnectionPresenceType.AVAILABLE:
+            iconName = 'user-available';
+            break;
+        case Tp.ConnectionPresenceType.BUSY:
+            iconName = 'user-busy';
+            break;
+        case Tp.ConnectionPresenceType.OFFLINE:
+            iconName = 'user-offline';
+            break;
+        case Tp.ConnectionPresenceType.HIDDEN:
+            iconName = 'user-invisible';
+            break;
+        case Tp.ConnectionPresenceType.AWAY:
+            iconName = 'user-away';
+            break;
+        case Tp.ConnectionPresenceType.EXTENDED_AWAY:
+            iconName = 'user-idle';
+            break;
+        default:
+            iconName = 'user-offline';
+        }
+        return new Gio.ThemedIcon({ name: iconName });
+    }
+
+    _updateAvatarIcon() {
+        this.iconUpdated();
+        if (this._notifiction) {
+            this._notification.update(this._notification.title,
+                                      this._notification.bannerBodyText,
+                                      { gicon: this.getIcon() });
+        }
+    }
+
+    open() {
+        Main.overview.hide();
+        Main.panel.closeCalendar();
+
+        if (this._client.is_handling_channel(this._channel)) {
+            // We are handling the channel, try to pass it to Empathy or Polari
+            // (depending on the channel type)
+            // We don't check if either app is available - mission control will
+            // fallback to something else if activation fails
+
+            let target;
+            if (this._channel.connection.protocol_name == 'irc')
+                target = 'org.freedesktop.Telepathy.Client.Polari';
+            else
+                target = 'org.freedesktop.Telepathy.Client.Empathy.Chat';
+            this._client.delegate_channels_async([this._channel], global.get_current_time(), target, null);
+        } else {
+            // We are not the handler, just ask to present the channel
+            let dbus = Tp.DBusDaemon.dup();
+            let cd = Tp.ChannelDispatcher.new(dbus);
+
+            cd.present_channel_async(this._channel, global.get_current_time(), null);
+        }
+    }
+
+    _getLogMessages() {
+        let logManager = Tpl.LogManager.dup_singleton();
+        let entity = Tpl.Entity.new_from_tp_contact(this._contact, Tpl.EntityType.CONTACT);
+
+        logManager.get_filtered_events_async(this._account, entity,
+                                             Tpl.EventTypeMask.TEXT, SCROLLBACK_HISTORY_LINES,
+                                             null, this._displayPendingMessages.bind(this));
+    }
+
+    _displayPendingMessages(logManager, result) {
+        let [success_, events] = logManager.get_filtered_events_finish(result);
+
+        let logMessages = events.map(makeMessageFromTplEvent);
+        this._ensureNotification();
+
+        let pendingTpMessages = this._channel.get_pending_messages();
+        let pendingMessages = [];
+
+        for (let i = 0; i < pendingTpMessages.length; i++) {
+            let message = pendingTpMessages[i];
+
+            if (message.get_message_type() == Tp.ChannelTextMessageType.DELIVERY_REPORT)
+                continue;
+
+            pendingMessages.push(makeMessageFromTpMessage(message, NotificationDirection.RECEIVED));
+
+            this._pendingMessages.push(message);
+        }
+
+        this.countUpdated();
+
+        let showTimestamp = false;
+
+        for (let i = 0; i < logMessages.length; i++) {
+            let logMessage = logMessages[i];
+            let isPending = false;
+
+            // Skip any log messages that are also in pendingMessages
+            for (let j = 0; j < pendingMessages.length; j++) {
+                let pending = pendingMessages[j];
+                if (logMessage.timestamp == pending.timestamp && logMessage.text == pending.text) {
+                    isPending = true;
+                    break;
+                }
+            }
+
+            if (!isPending) {
+                showTimestamp = true;
+                this._notification.appendMessage(logMessage, true, ['chat-log-message']);
+            }
+        }
+
+        if (showTimestamp)
+            this._notification.appendTimestamp();
+
+        for (let i = 0; i < pendingMessages.length; i++)
+            this._notification.appendMessage(pendingMessages[i], true);
+
+        if (pendingMessages.length > 0)
+            this.showNotification();
+    }
+
+    destroy(reason) {
+        if (this._client.is_handling_channel(this._channel)) {
+            this._ackMessages();
+            // The chat box has been destroyed so it can't
+            // handle the channel any more.
+            this._channel.close_async((channel, result) => {
+                channel.close_finish(result);
+            });
+        } else {
+            // Don't indicate any unread messages when the notification
+            // that represents them has been destroyed.
+            this._pendingMessages = [];
+            this.countUpdated();
+        }
+
+        // Keep source alive while the channel is open
+        if (reason != MessageTray.NotificationDestroyedReason.SOURCE_CLOSED)
+            return;
+
+        if (this._destroyed)
+            return;
+
+        this._destroyed = true;
+        this._channel.disconnect(this._closedId);
+        this._channel.disconnect(this._receivedId);
+        this._channel.disconnect(this._pendingId);
+        this._channel.disconnect(this._sentId);
+
+        this._contact.disconnect(this._notifyAliasId);
+        this._contact.disconnect(this._notifyAvatarId);
+        this._contact.disconnect(this._presenceChangedId);
+
+        super.destroy(reason);
+    }
+
+    _channelClosed() {
+        this.destroy(MessageTray.NotificationDestroyedReason.SOURCE_CLOSED);
+    }
+
+    /* All messages are new messages for Telepathy sources */
+    get count() {
+        return this._pendingMessages.length;
+    }
+
+    get unseenCount() {
+        return this.count;
+    }
+
+    get countVisible() {
+        return this.count > 0;
+    }
+
+    _messageReceived(channel, message) {
+        if (message.get_message_type() == Tp.ChannelTextMessageType.DELIVERY_REPORT)
+            return;
+
+        this._ensureNotification();
+        this._pendingMessages.push(message);
+        this.countUpdated();
+
+        message = makeMessageFromTpMessage(message, NotificationDirection.RECEIVED);
+        this._notification.appendMessage(message);
+
+        // Wait a bit before notifying for the received message, a handler
+        // could ack it in the meantime.
+        if (this._notifyTimeoutId != 0)
+            GLib.source_remove(this._notifyTimeoutId);
+        this._notifyTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 500,
+            this._notifyTimeout.bind(this));
+        GLib.Source.set_name_by_id(this._notifyTimeoutId, '[gnome-shell] this._notifyTimeout');
+    }
+
+    _notifyTimeout() {
+        if (this._pendingMessages.length != 0)
+            this.showNotification();
+
+        this._notifyTimeoutId = 0;
+
+        return GLib.SOURCE_REMOVE;
+    }
+
+    // This is called for both messages we send from
+    // our client and other clients as well.
+    _messageSent(channel, message, _flags, _token) {
+        this._ensureNotification();
+        message = makeMessageFromTpMessage(message, NotificationDirection.SENT);
+        this._notification.appendMessage(message);
+    }
+
+    showNotification() {
+        super.showNotification(this._notification);
+    }
+
+    respond(text) {
+        let type;
+        if (text.slice(0, 4) == '/me ') {
+            type = Tp.ChannelTextMessageType.ACTION;
+            text = text.slice(4);
+        } else {
+            type = Tp.ChannelTextMessageType.NORMAL;
+        }
+
+        let msg = Tp.ClientMessage.new_text(type, text);
+        this._channel.send_message_async(msg, 0, (src, result) => {
+            this._channel.send_message_finish(result);
+        });
+    }
+
+    setChatState(state) {
+        // We don't want to send COMPOSING every time a letter is typed into
+        // the entry. We send the state only when it changes. Telepathy/Empathy
+        // might change it behind our back if the user is using both
+        // gnome-shell's entry and the Empathy conversation window. We could
+        // keep track of it with the ChatStateChanged signal but it is good
+        // enough right now.
+        if (state != this._chatState) {
+            this._chatState = state;
+            this._channel.set_chat_state_async(state, null);
+        }
+    }
+
+    _presenceChanged(_contact, _presence, _status, _message) {
+        if (this._notification) {
+            this._notification.update(this._notification.title,
+                                      this._notification.bannerBodyText,
+                                      { secondaryGIcon: this.getSecondaryIcon() });
+        }
+    }
+
+    _pendingRemoved(channel, message) {
+        let idx = this._pendingMessages.indexOf(message);
+
+        if (idx >= 0) {
+            this._pendingMessages.splice(idx, 1);
+            this.countUpdated();
+        }
+
+        if (this._pendingMessages.length == 0 &&
+            this._banner && !this._banner.expanded)
+            this._banner.hide();
+    }
+
+    _ackMessages() {
+        // Don't clear our messages here, tp-glib will send a
+        // 'pending-message-removed' for each one.
+        this._channel.ack_all_pending_messages_async(null);
+    }
+}) : null;
+
+var ChatNotification = HAVE_TP ? GObject.registerClass({
+    Signals: {
+        'message-removed': { param_types: [Tp.Message.$gtype] },
+        'message-added': { param_types: [Tp.Message.$gtype] },
+        'timestamp-changed': { param_types: [Tp.Message.$gtype] },
+    },
+}, class ChatNotification extends MessageTray.Notification {
+    _init(source) {
+        super._init(source, source.title, null,
+            { secondaryGIcon: source.getSecondaryIcon() });
+        this.setUrgency(MessageTray.Urgency.HIGH);
+        this.setResident(true);
+
+        this.messages = [];
+        this._timestampTimeoutId = 0;
+    }
+
+    destroy(reason) {
+        if (this._timestampTimeoutId)
+            GLib.source_remove(this._timestampTimeoutId);
+        this._timestampTimeoutId = 0;
+        super.destroy(reason);
+    }
+
+    /**
+     * appendMessage:
+     * @param {Object} message: An object with the properties
+     *   {string} message.text: the body of the message,
+     *   {Tp.ChannelTextMessageType} message.messageType: the type
+     *   {string} message.sender: the name of the sender,
+     *   {number} message.timestamp: the time the message was sent
+     *   {NotificationDirection} message.direction: a #NotificationDirection
+     *
+     * @param {bool} noTimestamp: Whether to add a timestamp. If %true,
+     *   no timestamp will be added, regardless of the difference since
+     *   the last timestamp
+     */
+    appendMessage(message, noTimestamp) {
+        let messageBody = GLib.markup_escape_text(message.text, -1);
+        let styles = [message.direction];
+
+        if (message.messageType == Tp.ChannelTextMessageType.ACTION) {
+            let senderAlias = GLib.markup_escape_text(message.sender, -1);
+            messageBody = '<i>%s</i> %s'.format(senderAlias, messageBody);
+            styles.push('chat-action');
+        }
+
+        if (message.direction == NotificationDirection.RECEIVED) {
+            this.update(this.source.title, messageBody,
+                        { datetime: GLib.DateTime.new_from_unix_local(message.timestamp),
+                          bannerMarkup: true });
+        }
+
+        let group = message.direction == NotificationDirection.RECEIVED
+            ? 'received' : 'sent';
+
+        this._append({ body: messageBody,
+                       group,
+                       styles,
+                       timestamp: message.timestamp,
+                       noTimestamp });
+    }
+
+    _filterMessages() {
+        if (this.messages.length < 1)
+            return;
+
+        let lastMessageTime = this.messages[0].timestamp;
+        let currentTime = Date.now() / 1000;
+
+        // Keep the scrollback from growing too long. If the most
+        // recent message (before the one we just added) is within
+        // SCROLLBACK_RECENT_TIME, we will keep
+        // SCROLLBACK_RECENT_LENGTH previous messages. Otherwise
+        // we'll keep SCROLLBACK_IDLE_LENGTH messages.
+
+        let maxLength = lastMessageTime < currentTime - SCROLLBACK_RECENT_TIME
+            ? SCROLLBACK_IDLE_LENGTH : SCROLLBACK_RECENT_LENGTH;
+
+        let filteredHistory = this.messages.filter(item => item.realMessage);
+        if (filteredHistory.length > maxLength) {
+            let lastMessageToKeep = filteredHistory[maxLength];
+            let expired = this.messages.splice(this.messages.indexOf(lastMessageToKeep));
+            for (let i = 0; i < expired.length; i++)
+                this.emit('message-removed', expired[i]);
+        }
+    }
+
+    /**
+     * _append:
+     * @param {Object} props: An object with the properties:
+     *  {string} props.body: The text of the message.
+     *  {string} props.group: The group of the message, one of:
+     *         'received', 'sent', 'meta'.
+     *  {string[]} props.styles: Style class names for the message to have.
+     *  {number} props.timestamp: The timestamp of the message.
+     *  {bool} props.noTimestamp: suppress timestamp signal?
+     */
+    _append(props) {
+        let currentTime = Date.now() / 1000;
+        props = Params.parse(props, { body: null,
+                                      group: null,
+                                      styles: [],
+                                      timestamp: currentTime,
+                                      noTimestamp: false });
+
+        // Reset the old message timeout
+        if (this._timestampTimeoutId)
+            GLib.source_remove(this._timestampTimeoutId);
+        this._timestampTimeoutId = 0;
+
+        let message = { realMessage: props.group != 'meta',
+                        showTimestamp: false };
+        Lang.copyProperties(props, message);
+        delete message.noTimestamp;
+
+        this.messages.unshift(message);
+        this.emit('message-added', message);
+
+        if (!props.noTimestamp) {
+            let timestamp = props.timestamp;
+            if (timestamp < currentTime - SCROLLBACK_IMMEDIATE_TIME) {
+                this.appendTimestamp();
+            } else {
+                // Schedule a new timestamp in SCROLLBACK_IMMEDIATE_TIME
+                // from the timestamp of the message.
+                this._timestampTimeoutId = GLib.timeout_add_seconds(
+                    GLib.PRIORITY_DEFAULT,
+                    SCROLLBACK_IMMEDIATE_TIME - (currentTime - timestamp),
+                    this.appendTimestamp.bind(this));
+                GLib.Source.set_name_by_id(this._timestampTimeoutId, '[gnome-shell] this.appendTimestamp');
+            }
+        }
+
+        this._filterMessages();
+    }
+
+    appendTimestamp() {
+        this._timestampTimeoutId = 0;
+
+        this.messages[0].showTimestamp = true;
+        this.emit('timestamp-changed', this.messages[0]);
+
+        this._filterMessages();
+
+        return GLib.SOURCE_REMOVE;
+    }
+
+    appendAliasChange(oldAlias, newAlias) {
+        oldAlias = GLib.markup_escape_text(oldAlias, -1);
+        newAlias = GLib.markup_escape_text(newAlias, -1);
+
+        /* Translators: this is the other person changing their old IM name to their new
+           IM name. */
+        let message = '<i>' + _("%s is now known as %s").format(oldAlias, newAlias) + '</i>';
+
+        this._append({ body: message,
+                       group: 'meta',
+                       styles: ['chat-meta-message'] });
+
+        this._filterMessages();
+    }
+}) : null;
+
+var ChatLineBox = GObject.registerClass(
+class ChatLineBox extends St.BoxLayout {
+    vfunc_get_preferred_height(forWidth) {
+        let [, natHeight] = super.vfunc_get_preferred_height(forWidth);
+        return [natHeight, natHeight];
+    }
+});
+
+var ChatNotificationBanner = GObject.registerClass(
+class ChatNotificationBanner extends MessageTray.NotificationBanner {
+    _init(notification) {
+        super._init(notification);
+
+        this._responseEntry = new St.Entry({ style_class: 'chat-response',
+                                             x_expand: true,
+                                             can_focus: true });
+        this._responseEntry.clutter_text.connect('activate', this._onEntryActivated.bind(this));
+        this._responseEntry.clutter_text.connect('text-changed', this._onEntryChanged.bind(this));
+        this.setActionArea(this._responseEntry);
+
+        this._responseEntry.clutter_text.connect('key-focus-in', () => {
+            this.focused = true;
+        });
+        this._responseEntry.clutter_text.connect('key-focus-out', () => {
+            this.focused = false;
+            this.emit('unfocused');
+        });
+
+        this._scrollArea = new St.ScrollView({ style_class: 'chat-scrollview vfade',
+                                               vscrollbar_policy: St.PolicyType.AUTOMATIC,
+                                               hscrollbar_policy: St.PolicyType.NEVER,
+                                               visible: this.expanded });
+        this._contentArea = new St.BoxLayout({ style_class: 'chat-body',
+                                               vertical: true });
+        this._scrollArea.add_actor(this._contentArea);
+
+        this.setExpandedBody(this._scrollArea);
+        this.setExpandedLines(CHAT_EXPAND_LINES);
+
+        this._lastGroup = null;
+
+        // Keep track of the bottom position for the current adjustment and
+        // force a scroll to the bottom if things change while we were at the
+        // bottom
+        this._oldMaxScrollValue = this._scrollArea.vscroll.adjustment.value;
+        this._scrollArea.vscroll.adjustment.connect('changed', adjustment => {
+            if (adjustment.value == this._oldMaxScrollValue)
+                this.scrollTo(St.Side.BOTTOM);
+            this._oldMaxScrollValue = Math.max(adjustment.lower, adjustment.upper - adjustment.page_size);
+        });
+
+        this._inputHistory = new History.HistoryManager({ entry: this._responseEntry.clutter_text });
+
+        this._composingTimeoutId = 0;
+
+        this._messageActors = new Map();
+
+        this._messageAddedId = this.notification.connect('message-added',
+            (n, message) => {
+                this._addMessage(message);
+            });
+        this._messageRemovedId = this.notification.connect('message-removed',
+            (n, message) => {
+                let actor = this._messageActors.get(message);
+                if (this._messageActors.delete(message))
+                    actor.destroy();
+            });
+        this._timestampChangedId = this.notification.connect('timestamp-changed',
+            (n, message) => {
+                this._updateTimestamp(message);
+            });
+
+        for (let i = this.notification.messages.length - 1; i >= 0; i--)
+            this._addMessage(this.notification.messages[i]);
+    }
+
+    _onDestroy() {
+        super._onDestroy();
+        this.notification.disconnect(this._messageAddedId);
+        this.notification.disconnect(this._messageRemovedId);
+        this.notification.disconnect(this._timestampChangedId);
+    }
+
+    scrollTo(side) {
+        let adjustment = this._scrollArea.vscroll.adjustment;
+        if (side == St.Side.TOP)
+            adjustment.value = adjustment.lower;
+        else if (side == St.Side.BOTTOM)
+            adjustment.value = adjustment.upper;
+    }
+
+    hide() {
+        this.emit('done-displaying');
+    }
+
+    _addMessage(message) {
+        let body = new MessageList.URLHighlighter(message.body, true, true);
+
+        let styles = message.styles;
+        for (let i = 0; i < styles.length; i++)
+            body.add_style_class_name(styles[i]);
+
+        let group = message.group;
+        if (group != this._lastGroup) {
+            this._lastGroup = group;
+            body.add_style_class_name('chat-new-group');
+        }
+
+        let lineBox = new ChatLineBox();
+        lineBox.add(body);
+        this._contentArea.add_actor(lineBox);
+        this._messageActors.set(message, lineBox);
+
+        this._updateTimestamp(message);
+    }
+
+    _updateTimestamp(message) {
+        let actor = this._messageActors.get(message);
+        if (!actor)
+            return;
+
+        while (actor.get_n_children() > 1)
+            actor.get_child_at_index(1).destroy();
+
+        if (message.showTimestamp) {
+            let lastMessageTime = message.timestamp;
+            let lastMessageDate = new Date(lastMessageTime * 1000);
+
+            let timeLabel = Util.createTimeLabel(lastMessageDate);
+            timeLabel.style_class = 'chat-meta-message';
+            timeLabel.x_expand = timeLabel.y_expand = true;
+            timeLabel.x_align = timeLabel.y_align = Clutter.ActorAlign.END;
+
+            actor.add_actor(timeLabel);
+        }
+    }
+
+    _onEntryActivated() {
+        let text = this._responseEntry.get_text();
+        if (text == '')
+            return;
+
+        this._inputHistory.addItem(text);
+
+        // Telepathy sends out the Sent signal for us.
+        // see Source._messageSent
+        this._responseEntry.set_text('');
+        this.notification.source.respond(text);
+    }
+
+    _composingStopTimeout() {
+        this._composingTimeoutId = 0;
+
+        this.notification.source.setChatState(Tp.ChannelChatState.PAUSED);
+
+        return GLib.SOURCE_REMOVE;
+    }
+
+    _onEntryChanged() {
+        let text = this._responseEntry.get_text();
+
+        // If we're typing, we want to send COMPOSING.
+        // If we empty the entry, we want to send ACTIVE.
+        // If we've stopped typing for COMPOSING_STOP_TIMEOUT
+        //    seconds, we want to send PAUSED.
+
+        // Remove composing timeout.
+        if (this._composingTimeoutId > 0) {
+            GLib.source_remove(this._composingTimeoutId);
+            this._composingTimeoutId = 0;
+        }
+
+        if (text != '') {
+            this.notification.source.setChatState(Tp.ChannelChatState.COMPOSING);
+
+            this._composingTimeoutId = GLib.timeout_add_seconds(
+                GLib.PRIORITY_DEFAULT,
+                COMPOSING_STOP_TIMEOUT,
+                this._composingStopTimeout.bind(this));
+            GLib.Source.set_name_by_id(this._composingTimeoutId, '[gnome-shell] this._composingStopTimeout');
+        } else {
+            this.notification.source.setChatState(Tp.ChannelChatState.ACTIVE);
+        }
+    }
+});
+
+var Component = TelepathyComponent;

js/ui/ctrlAltTab.js

@@ -0,0 +1,191 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported CtrlAltTabManager */
+
+const { Clutter, GObject, Meta, Shell, St } = imports.gi;
+
+const Main = imports.ui.main;
+const SwitcherPopup = imports.ui.switcherPopup;
+const Params = imports.misc.params;
+
+var POPUP_APPICON_SIZE = 96;
+
+var SortGroup = {
+    TOP:    0,
+    MIDDLE: 1,
+    BOTTOM: 2,
+};
+
+var CtrlAltTabManager = class CtrlAltTabManager {
+    constructor() {
+        this._items = [];
+        this.addGroup(global.window_group, _("Windows"),
+                      'focus-windows-symbolic', { sortGroup: SortGroup.TOP,
+                                                  focusCallback: this._focusWindows.bind(this) });
+    }
+
+    addGroup(root, name, icon, params) {
+        let item = Params.parse(params, { sortGroup: SortGroup.MIDDLE,
+                                          proxy: root,
+                                          focusCallback: null });
+
+        item.root = root;
+        item.name = name;
+        item.iconName = icon;
+
+        this._items.push(item);
+        root.connect('destroy', () => this.removeGroup(root));
+        if (root instanceof St.Widget)
+            global.focus_manager.add_group(root);
+    }
+
+    removeGroup(root) {
+        if (root instanceof St.Widget)
+            global.focus_manager.remove_group(root);
+        for (let i = 0; i < this._items.length; i++) {
+            if (this._items[i].root == root) {
+                this._items.splice(i, 1);
+                return;
+            }
+        }
+    }
+
+    focusGroup(item, timestamp) {
+        if (item.focusCallback)
+            item.focusCallback(timestamp);
+        else
+            item.root.navigate_focus(null, St.DirectionType.TAB_FORWARD, false);
+    }
+
+    // Sort the items into a consistent order; panel first, tray last,
+    // and everything else in between, sorted by X coordinate, so that
+    // they will have the same left-to-right ordering in the
+    // Ctrl-Alt-Tab dialog as they do onscreen.
+    _sortItems(a, b) {
+        if (a.sortGroup != b.sortGroup)
+            return a.sortGroup - b.sortGroup;
+
+        let [ax] = a.proxy.get_transformed_position();
+        let [bx] = b.proxy.get_transformed_position();
+
+        return ax - bx;
+    }
+
+    popup(backward, binding, mask) {
+        // Start with the set of focus groups that are currently mapped
+        let items = this._items.filter(item => item.proxy.mapped);
+
+        // And add the windows metacity would show in its Ctrl-Alt-Tab list
+        if (Main.sessionMode.hasWindows && !Main.overview.visible) {
+            let display = global.display;
+            let workspaceManager = global.workspace_manager;
+            let activeWorkspace = workspaceManager.get_active_workspace();
+            let windows = display.get_tab_list(Meta.TabList.DOCKS,
+                                               activeWorkspace);
+            let windowTracker = Shell.WindowTracker.get_default();
+            let textureCache = St.TextureCache.get_default();
+            for (let i = 0; i < windows.length; i++) {
+                let icon = null;
+                let iconName = null;
+                if (windows[i].get_window_type() == Meta.WindowType.DESKTOP) {
+                    iconName = 'video-display-symbolic';
+                } else {
+                    let app = windowTracker.get_window_app(windows[i]);
+                    if (app) {
+                        icon = app.create_icon_texture(POPUP_APPICON_SIZE);
+                    } else {
+                        icon = textureCache.bind_cairo_surface_property(windows[i],
+                                                                        'icon',
+                                                                        POPUP_APPICON_SIZE);
+                    }
+                }
+
+                items.push({ name: windows[i].title,
+                             proxy: windows[i].get_compositor_private(),
+                             focusCallback: timestamp => {
+                                 Main.activateWindow(windows[i], timestamp);
+                             },
+                             iconActor: icon,
+                             iconName,
+                             sortGroup: SortGroup.MIDDLE });
+            }
+        }
+
+        if (!items.length)
+            return;
+
+        items.sort(this._sortItems.bind(this));
+
+        if (!this._popup) {
+            this._popup = new CtrlAltTabPopup(items);
+            this._popup.show(backward, binding, mask);
+
+            this._popup.connect('destroy',
+                                () => {
+                                    this._popup = null;
+                                });
+        }
+    }
+
+    _focusWindows(timestamp) {
+        global.display.focus_default_window(timestamp);
+    }
+};
+
+var CtrlAltTabPopup = GObject.registerClass(
+class CtrlAltTabPopup extends SwitcherPopup.SwitcherPopup {
+    _init(items) {
+        super._init(items);
+
+        this._switcherList = new CtrlAltTabSwitcher(this._items);
+    }
+
+    _keyPressHandler(keysym, action) {
+        if (action == Meta.KeyBindingAction.SWITCH_PANELS)
+            this._select(this._next());
+        else if (action == Meta.KeyBindingAction.SWITCH_PANELS_BACKWARD)
+            this._select(this._previous());
+        else if (keysym == Clutter.KEY_Left)
+            this._select(this._previous());
+        else if (keysym == Clutter.KEY_Right)
+            this._select(this._next());
+        else
+            return Clutter.EVENT_PROPAGATE;
+
+        return Clutter.EVENT_STOP;
+    }
+
+    _finish(time) {
+        super._finish(time);
+        Main.ctrlAltTabManager.focusGroup(this._items[this._selectedIndex], time);
+    }
+});
+
+var CtrlAltTabSwitcher = GObject.registerClass(
+class CtrlAltTabSwitcher extends SwitcherPopup.SwitcherList {
+    _init(items) {
+        super._init(true);
+
+        for (let i = 0; i < items.length; i++)
+            this._addIcon(items[i]);
+    }
+
+    _addIcon(item) {
+        let box = new St.BoxLayout({ style_class: 'alt-tab-app',
+                                     vertical: true });
+
+        let icon = item.iconActor;
+        if (!icon) {
+            icon = new St.Icon({ icon_name: item.iconName,
+                                 icon_size: POPUP_APPICON_SIZE });
+        }
+        box.add_child(icon);
+
+        let text = new St.Label({
+            text: item.name,
+            x_align: Clutter.ActorAlign.CENTER,
+        });
+        box.add_child(text);
+
+        this.addItem(box, text);
+    }
+});

js/ui/dash.js

@@ -0,0 +1,909 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Dash */
+
+const { Clutter, GLib, GObject,
+        Graphene, Meta, Shell, St } = imports.gi;
+
+const AppDisplay = imports.ui.appDisplay;
+const AppFavorites = imports.ui.appFavorites;
+const DND = imports.ui.dnd;
+const IconGrid = imports.ui.iconGrid;
+const Main = imports.ui.main;
+
+var DASH_ANIMATION_TIME = 200;
+var DASH_ITEM_LABEL_SHOW_TIME = 150;
+var DASH_ITEM_LABEL_HIDE_TIME = 100;
+var DASH_ITEM_HOVER_TIMEOUT = 300;
+
+function getAppFromSource(source) {
+    if (source instanceof AppDisplay.AppIcon)
+        return source.app;
+    else
+        return null;
+}
+
+var DashIcon = GObject.registerClass(
+class DashIcon extends AppDisplay.AppIcon {
+    _init(app) {
+        super._init(app, {
+            setSizeManually: true,
+            showLabel: false,
+        });
+    }
+
+    // Disable all DnD methods
+    _onDragBegin() {
+    }
+
+    _onDragEnd() {
+    }
+
+    handleDragOver() {
+        return DND.DragMotionResult.CONTINUE;
+    }
+
+    acceptDrop() {
+        return false;
+    }
+});
+
+// A container like StBin, but taking the child's scale into account
+// when requesting a size
+var DashItemContainer = GObject.registerClass(
+class DashItemContainer extends St.Widget {
+    _init() {
+        super._init({ style_class: 'dash-item-container',
+                      pivot_point: new Graphene.Point({ x: .5, y: .5 }),
+                      scale_x: 0,
+                      scale_y: 0,
+                      opacity: 0,
+                      x_expand: true,
+                      x_align: Clutter.ActorAlign.CENTER });
+
+        this._labelText = "";
+        this.label = new St.Label({ style_class: 'dash-label' });
+        this.label.hide();
+        Main.layoutManager.addChrome(this.label);
+        this.label_actor = this.label;
+
+        this.child = null;
+        this.animatingOut = false;
+
+        this.connect('notify::scale-x', () => this.queue_relayout());
+        this.connect('notify::scale-y', () => this.queue_relayout());
+
+        this.connect('destroy', () => {
+            if (this.child != null)
+                this.child.destroy();
+            this.label.destroy();
+        });
+    }
+
+    vfunc_get_preferred_height(forWidth) {
+        let themeNode = this.get_theme_node();
+        forWidth = themeNode.adjust_for_width(forWidth);
+        let [minHeight, natHeight] = super.vfunc_get_preferred_height(forWidth);
+        return themeNode.adjust_preferred_height(minHeight * this.scale_y,
+                                                 natHeight * this.scale_y);
+    }
+
+    vfunc_get_preferred_width(forHeight) {
+        let themeNode = this.get_theme_node();
+        forHeight = themeNode.adjust_for_height(forHeight);
+        let [minWidth, natWidth] = super.vfunc_get_preferred_width(forHeight);
+        return themeNode.adjust_preferred_width(minWidth * this.scale_x,
+                                                natWidth * this.scale_x);
+    }
+
+    showLabel() {
+        if (!this._labelText)
+            return;
+
+        this.label.set_text(this._labelText);
+        this.label.opacity = 0;
+        this.label.show();
+
+        let [stageX, stageY] = this.get_transformed_position();
+
+        let itemHeight = this.allocation.y2 - this.allocation.y1;
+
+        let labelHeight = this.label.get_height();
+        let yOffset = Math.floor((itemHeight - labelHeight) / 2);
+
+        let y = stageY + yOffset;
+
+        let node = this.label.get_theme_node();
+        let xOffset = node.get_length('-x-offset');
+
+        let x;
+        if (Clutter.get_default_text_direction() == Clutter.TextDirection.RTL)
+            x = stageX - this.label.get_width() - xOffset;
+        else
+            x = stageX + this.get_width() + xOffset;
+
+        this.label.set_position(x, y);
+        this.label.ease({
+            opacity: 255,
+            duration: DASH_ITEM_LABEL_SHOW_TIME,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        });
+    }
+
+    setLabelText(text) {
+        this._labelText = text;
+        this.child.accessible_name = text;
+    }
+
+    hideLabel() {
+        this.label.ease({
+            opacity: 0,
+            duration: DASH_ITEM_LABEL_HIDE_TIME,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            onComplete: () => this.label.hide(),
+        });
+    }
+
+    setChild(actor) {
+        if (this.child == actor)
+            return;
+
+        this.destroy_all_children();
+
+        this.child = actor;
+        this.add_actor(this.child);
+    }
+
+    show(animate) {
+        if (this.child == null)
+            return;
+
+        let time = animate ? DASH_ANIMATION_TIME : 0;
+        this.ease({
+            scale_x: 1,
+            scale_y: 1,
+            opacity: 255,
+            duration: time,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        });
+    }
+
+    animateOutAndDestroy() {
+        this.label.hide();
+
+        if (this.child == null) {
+            this.destroy();
+            return;
+        }
+
+        this.animatingOut = true;
+        this.ease({
+            scale_x: 0,
+            scale_y: 0,
+            opacity: 0,
+            duration: DASH_ANIMATION_TIME,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            onComplete: () => this.destroy(),
+        });
+    }
+});
+
+var ShowAppsIcon = GObject.registerClass(
+class ShowAppsIcon extends DashItemContainer {
+    _init() {
+        super._init();
+
+        this.toggleButton = new St.Button({ style_class: 'show-apps',
+                                            track_hover: true,
+                                            can_focus: true,
+                                            toggle_mode: true });
+        this._iconActor = null;
+        this.icon = new IconGrid.BaseIcon(_("Show Applications"),
+                                          { setSizeManually: true,
+                                            showLabel: false,
+                                            createIcon: this._createIcon.bind(this) });
+        this.toggleButton.add_actor(this.icon);
+        this.toggleButton._delegate = this;
+
+        this.setChild(this.toggleButton);
+        this.setDragApp(null);
+    }
+
+    _createIcon(size) {
+        this._iconActor = new St.Icon({ icon_name: 'view-app-grid-symbolic',
+                                        icon_size: size,
+                                        style_class: 'show-apps-icon',
+                                        track_hover: true });
+        return this._iconActor;
+    }
+
+    _canRemoveApp(app) {
+        if (app == null)
+            return false;
+
+        if (!global.settings.is_writable('favorite-apps'))
+            return false;
+
+        let id = app.get_id();
+        let isFavorite = AppFavorites.getAppFavorites().isFavorite(id);
+        return isFavorite;
+    }
+
+    setDragApp(app) {
+        let canRemove = this._canRemoveApp(app);
+
+        this.toggleButton.set_hover(canRemove);
+        if (this._iconActor)
+            this._iconActor.set_hover(canRemove);
+
+        if (canRemove)
+            this.setLabelText(_("Remove from Favorites"));
+        else
+            this.setLabelText(_("Show Applications"));
+    }
+
+    handleDragOver(source, _actor, _x, _y, _time) {
+        if (!this._canRemoveApp(getAppFromSource(source)))
+            return DND.DragMotionResult.NO_DROP;
+
+        return DND.DragMotionResult.MOVE_DROP;
+    }
+
+    acceptDrop(source, _actor, _x, _y, _time) {
+        let app = getAppFromSource(source);
+        if (!this._canRemoveApp(app))
+            return false;
+
+        let id = app.get_id();
+
+        Meta.later_add(Meta.LaterType.BEFORE_REDRAW, () => {
+            AppFavorites.getAppFavorites().removeFavorite(id);
+            return false;
+        });
+
+        return true;
+    }
+});
+
+var DragPlaceholderItem = GObject.registerClass(
+class DragPlaceholderItem extends DashItemContainer {
+    _init() {
+        super._init();
+        this.setChild(new St.Bin({ style_class: 'placeholder' }));
+    }
+});
+
+var EmptyDropTargetItem = GObject.registerClass(
+class EmptyDropTargetItem extends DashItemContainer {
+    _init() {
+        super._init();
+        this.setChild(new St.Bin({ style_class: 'empty-dash-drop-target' }));
+    }
+});
+
+var DashActor = GObject.registerClass(
+class DashActor extends St.Widget {
+    _init() {
+        let layout = new Clutter.BoxLayout({ orientation: Clutter.Orientation.VERTICAL });
+        super._init({
+            name: 'dash',
+            layout_manager: layout,
+            clip_to_allocation: true,
+            y_align: Clutter.ActorAlign.CENTER,
+        });
+    }
+
+    vfunc_allocate(box, flags) {
+        let contentBox = this.get_theme_node().get_content_box(box);
+        let availWidth = contentBox.x2 - contentBox.x1;
+
+        this.set_allocation(box, flags);
+
+        let [appIcons, showAppsButton] = this.get_children();
+        let [, showAppsNatHeight] = showAppsButton.get_preferred_height(availWidth);
+
+        let childBox = new Clutter.ActorBox();
+        childBox.x1 = contentBox.x1;
+        childBox.y1 = contentBox.y1;
+        childBox.x2 = contentBox.x2;
+        childBox.y2 = contentBox.y2 - showAppsNatHeight;
+        appIcons.allocate(childBox, flags);
+
+        childBox.y1 = contentBox.y2 - showAppsNatHeight;
+        childBox.y2 = contentBox.y2;
+        showAppsButton.allocate(childBox, flags);
+    }
+
+    vfunc_get_preferred_height(forWidth) {
+        // We want to request the natural height of all our children
+        // as our natural height, so we chain up to StWidget (which
+        // then calls BoxLayout), but we only request the showApps
+        // button as the minimum size
+
+        let [, natHeight] = super.vfunc_get_preferred_height(forWidth);
+
+        let themeNode = this.get_theme_node();
+        let adjustedForWidth = themeNode.adjust_for_width(forWidth);
+        let [, showAppsButton] = this.get_children();
+        let [minHeight] = showAppsButton.get_preferred_height(adjustedForWidth);
+        [minHeight] = themeNode.adjust_preferred_height(minHeight, natHeight);
+
+        return [minHeight, natHeight];
+    }
+});
+
+const baseIconSizes = [16, 22, 24, 32, 48, 64];
+
+var Dash = GObject.registerClass({
+    Signals: { 'icon-size-changed': {} },
+}, class Dash extends St.Bin {
+    _init() {
+        this._maxHeight = -1;
+        this.iconSize = 64;
+        this._shownInitially = false;
+
+        this._dragPlaceholder = null;
+        this._dragPlaceholderPos = -1;
+        this._animatingPlaceholdersCount = 0;
+        this._showLabelTimeoutId = 0;
+        this._resetHoverTimeoutId = 0;
+        this._labelShowing = false;
+
+        this._container = new DashActor();
+        this._box = new St.BoxLayout({ vertical: true,
+                                       clip_to_allocation: true });
+        this._box._delegate = this;
+        this._container.add_actor(this._box);
+        this._container.set_offscreen_redirect(Clutter.OffscreenRedirect.ALWAYS);
+
+        this._showAppsIcon = new ShowAppsIcon();
+        this._showAppsIcon.show(false);
+        this._showAppsIcon.icon.setIconSize(this.iconSize);
+        this._hookUpLabel(this._showAppsIcon);
+
+        this.showAppsButton = this._showAppsIcon.toggleButton;
+
+        this._container.add_actor(this._showAppsIcon);
+
+        super._init({ child: this._container });
+        this.connect('notify::height', () => {
+            if (this._maxHeight != this.height)
+                this._queueRedisplay();
+            this._maxHeight = this.height;
+        });
+
+        this._workId = Main.initializeDeferredWork(this._box, this._redisplay.bind(this));
+
+        this._appSystem = Shell.AppSystem.get_default();
+
+        this._appSystem.connect('installed-changed', () => {
+            AppFavorites.getAppFavorites().reload();
+            this._queueRedisplay();
+        });
+        AppFavorites.getAppFavorites().connect('changed', this._queueRedisplay.bind(this));
+        this._appSystem.connect('app-state-changed', this._queueRedisplay.bind(this));
+
+        Main.overview.connect('item-drag-begin',
+                              this._onDragBegin.bind(this));
+        Main.overview.connect('item-drag-end',
+                              this._onDragEnd.bind(this));
+        Main.overview.connect('item-drag-cancelled',
+                              this._onDragCancelled.bind(this));
+
+        // Translators: this is the name of the dock/favorites area on
+        // the left of the overview
+        Main.ctrlAltTabManager.addGroup(this, _("Dash"), 'user-bookmarks-symbolic');
+    }
+
+    _onDragBegin() {
+        this._dragCancelled = false;
+        this._dragMonitor = {
+            dragMotion: this._onDragMotion.bind(this),
+        };
+        DND.addDragMonitor(this._dragMonitor);
+
+        if (this._box.get_n_children() == 0) {
+            this._emptyDropTarget = new EmptyDropTargetItem();
+            this._box.insert_child_at_index(this._emptyDropTarget, 0);
+            this._emptyDropTarget.show(true);
+        }
+    }
+
+    _onDragCancelled() {
+        this._dragCancelled = true;
+        this._endDrag();
+    }
+
+    _onDragEnd() {
+        if (this._dragCancelled)
+            return;
+
+        this._endDrag();
+    }
+
+    _endDrag() {
+        this._clearDragPlaceholder();
+        this._clearEmptyDropTarget();
+        this._showAppsIcon.setDragApp(null);
+        DND.removeDragMonitor(this._dragMonitor);
+    }
+
+    _onDragMotion(dragEvent) {
+        let app = getAppFromSource(dragEvent.source);
+        if (app == null)
+            return DND.DragMotionResult.CONTINUE;
+
+        let showAppsHovered =
+                this._showAppsIcon.contains(dragEvent.targetActor);
+
+        if (!this._box.contains(dragEvent.targetActor) || showAppsHovered)
+            this._clearDragPlaceholder();
+
+        if (showAppsHovered)
+            this._showAppsIcon.setDragApp(app);
+        else
+            this._showAppsIcon.setDragApp(null);
+
+        return DND.DragMotionResult.CONTINUE;
+    }
+
+    _appIdListToHash(apps) {
+        let ids = {};
+        for (let i = 0; i < apps.length; i++)
+            ids[apps[i].get_id()] = apps[i];
+        return ids;
+    }
+
+    _queueRedisplay() {
+        Main.queueDeferredWork(this._workId);
+    }
+
+    _hookUpLabel(item, appIcon) {
+        item.child.connect('notify::hover', () => {
+            this._syncLabel(item, appIcon);
+        });
+
+        let id = Main.overview.connect('hiding', () => {
+            this._labelShowing = false;
+            item.hideLabel();
+        });
+        item.child.connect('destroy', () => {
+            Main.overview.disconnect(id);
+        });
+
+        if (appIcon) {
+            appIcon.connect('sync-tooltip', () => {
+                this._syncLabel(item, appIcon);
+            });
+        }
+    }
+
+    _createAppItem(app) {
+        let appIcon = new DashIcon(app);
+
+        appIcon.connect('menu-state-changed',
+                        (o, opened) => {
+                            this._itemMenuStateChanged(item, opened);
+                        });
+
+        let item = new DashItemContainer();
+        item.setChild(appIcon);
+
+        // Override default AppIcon label_actor, now the
+        // accessible_name is set at DashItemContainer.setLabelText
+        appIcon.label_actor = null;
+        item.setLabelText(app.get_name());
+
+        appIcon.icon.setIconSize(this.iconSize);
+        this._hookUpLabel(item, appIcon);
+
+        return item;
+    }
+
+    _itemMenuStateChanged(item, opened) {
+        // When the menu closes, it calls sync_hover, which means
+        // that the notify::hover handler does everything we need to.
+        if (opened) {
+            if (this._showLabelTimeoutId > 0) {
+                GLib.source_remove(this._showLabelTimeoutId);
+                this._showLabelTimeoutId = 0;
+            }
+
+            item.hideLabel();
+        }
+    }
+
+    _syncLabel(item, appIcon) {
+        let shouldShow = appIcon ? appIcon.shouldShowTooltip() : item.child.get_hover();
+
+        if (shouldShow) {
+            if (this._showLabelTimeoutId == 0) {
+                let timeout = this._labelShowing ? 0 : DASH_ITEM_HOVER_TIMEOUT;
+                this._showLabelTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, timeout,
+                    () => {
+                        this._labelShowing = true;
+                        item.showLabel();
+                        this._showLabelTimeoutId = 0;
+                        return GLib.SOURCE_REMOVE;
+                    });
+                GLib.Source.set_name_by_id(this._showLabelTimeoutId, '[gnome-shell] item.showLabel');
+                if (this._resetHoverTimeoutId > 0) {
+                    GLib.source_remove(this._resetHoverTimeoutId);
+                    this._resetHoverTimeoutId = 0;
+                }
+            }
+        } else {
+            if (this._showLabelTimeoutId > 0)
+                GLib.source_remove(this._showLabelTimeoutId);
+            this._showLabelTimeoutId = 0;
+            item.hideLabel();
+            if (this._labelShowing) {
+                this._resetHoverTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, DASH_ITEM_HOVER_TIMEOUT,
+                    () => {
+                        this._labelShowing = false;
+                        this._resetHoverTimeoutId = 0;
+                        return GLib.SOURCE_REMOVE;
+                    });
+                GLib.Source.set_name_by_id(this._resetHoverTimeoutId, '[gnome-shell] this._labelShowing');
+            }
+        }
+    }
+
+    _adjustIconSize() {
+        // For the icon size, we only consider children which are "proper"
+        // icons (i.e. ignoring drag placeholders) and which are not
+        // animating out (which means they will be destroyed at the end of
+        // the animation)
+        let iconChildren = this._box.get_children().filter(actor => {
+            return actor.child &&
+                   actor.child._delegate &&
+                   actor.child._delegate.icon &&
+                   !actor.animatingOut;
+        });
+
+        iconChildren.push(this._showAppsIcon);
+
+        if (this._maxHeight == -1)
+            return;
+
+        let themeNode = this._container.get_theme_node();
+        let maxAllocation = new Clutter.ActorBox({ x1: 0, y1: 0,
+                                                   x2: 42 /* whatever */,
+                                                   y2: this._maxHeight });
+        let maxContent = themeNode.get_content_box(maxAllocation);
+        let availHeight = maxContent.y2 - maxContent.y1;
+        let spacing = themeNode.get_length('spacing');
+
+        let firstButton = iconChildren[0].child;
+        let firstIcon = firstButton._delegate.icon;
+
+        // Enforce valid spacings during the size request
+        firstIcon.icon.ensure_style();
+        let [, iconHeight] = firstIcon.icon.get_preferred_height(-1);
+        let [, buttonHeight] = firstButton.get_preferred_height(-1);
+
+        // Subtract icon padding and box spacing from the available height
+        availHeight -= iconChildren.length * (buttonHeight - iconHeight) +
+                       (iconChildren.length - 1) * spacing;
+
+        let availSize = availHeight / iconChildren.length;
+
+        let scaleFactor = St.ThemeContext.get_for_stage(global.stage).scale_factor;
+        let iconSizes = baseIconSizes.map(s => s * scaleFactor);
+
+        let newIconSize = baseIconSizes[0];
+        for (let i = 0; i < iconSizes.length; i++) {
+            if (iconSizes[i] < availSize)
+                newIconSize = baseIconSizes[i];
+        }
+
+        if (newIconSize == this.iconSize)
+            return;
+
+        let oldIconSize = this.iconSize;
+        this.iconSize = newIconSize;
+        this.emit('icon-size-changed');
+
+        let scale = oldIconSize / newIconSize;
+        for (let i = 0; i < iconChildren.length; i++) {
+            let icon = iconChildren[i].child._delegate.icon;
+
+            // Set the new size immediately, to keep the icons' sizes
+            // in sync with this.iconSize
+            icon.setIconSize(this.iconSize);
+
+            // Don't animate the icon size change when the overview
+            // is transitioning, not visible or when initially filling
+            // the dash
+            if (!Main.overview.visible || Main.overview.animationInProgress ||
+                !this._shownInitially)
+                continue;
+
+            let [targetWidth, targetHeight] = icon.icon.get_size();
+
+            // Scale the icon's texture to the previous size and
+            // tween to the new size
+            icon.icon.set_size(icon.icon.width * scale,
+                               icon.icon.height * scale);
+
+            icon.icon.ease({
+                width: targetWidth,
+                height: targetHeight,
+                duration: DASH_ANIMATION_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            });
+        }
+    }
+
+    _redisplay() {
+        let favorites = AppFavorites.getAppFavorites().getFavoriteMap();
+
+        let running = this._appSystem.get_running();
+
+        let children = this._box.get_children().filter(actor => {
+            return actor.child &&
+                   actor.child._delegate &&
+                   actor.child._delegate.app;
+        });
+        // Apps currently in the dash
+        let oldApps = children.map(actor => actor.child._delegate.app);
+        // Apps supposed to be in the dash
+        let newApps = [];
+
+        for (let id in favorites)
+            newApps.push(favorites[id]);
+
+        for (let i = 0; i < running.length; i++) {
+            let app = running[i];
+            if (app.get_id() in favorites)
+                continue;
+            newApps.push(app);
+        }
+
+        // Figure out the actual changes to the list of items; we iterate
+        // over both the list of items currently in the dash and the list
+        // of items expected there, and collect additions and removals.
+        // Moves are both an addition and a removal, where the order of
+        // the operations depends on whether we encounter the position
+        // where the item has been added first or the one from where it
+        // was removed.
+        // There is an assumption that only one item is moved at a given
+        // time; when moving several items at once, everything will still
+        // end up at the right position, but there might be additional
+        // additions/removals (e.g. it might remove all the launchers
+        // and add them back in the new order even if a smaller set of
+        // additions and removals is possible).
+        // If above assumptions turns out to be a problem, we might need
+        // to use a more sophisticated algorithm, e.g. Longest Common
+        // Subsequence as used by diff.
+        let addedItems = [];
+        let removedActors = [];
+
+        let newIndex = 0;
+        let oldIndex = 0;
+        while (newIndex < newApps.length || oldIndex < oldApps.length) {
+            let oldApp = oldApps.length > oldIndex ? oldApps[oldIndex] : null;
+            let newApp = newApps.length > newIndex ? newApps[newIndex] : null;
+
+            // No change at oldIndex/newIndex
+            if (oldApp == newApp) {
+                oldIndex++;
+                newIndex++;
+                continue;
+            }
+
+            // App removed at oldIndex
+            if (oldApp && !newApps.includes(oldApp)) {
+                removedActors.push(children[oldIndex]);
+                oldIndex++;
+                continue;
+            }
+
+            // App added at newIndex
+            if (newApp && !oldApps.includes(newApp)) {
+                addedItems.push({ app: newApp,
+                                  item: this._createAppItem(newApp),
+                                  pos: newIndex });
+                newIndex++;
+                continue;
+            }
+
+            // App moved
+            let nextApp = newApps.length > newIndex + 1
+                ? newApps[newIndex + 1] : null;
+            let insertHere = nextApp && nextApp == oldApp;
+            let alreadyRemoved = removedActors.reduce((result, actor) => {
+                let removedApp = actor.child._delegate.app;
+                return result || removedApp == newApp;
+            }, false);
+
+            if (insertHere || alreadyRemoved) {
+                let newItem = this._createAppItem(newApp);
+                addedItems.push({ app: newApp,
+                                  item: newItem,
+                                  pos: newIndex + removedActors.length });
+                newIndex++;
+            } else {
+                removedActors.push(children[oldIndex]);
+                oldIndex++;
+            }
+        }
+
+        for (let i = 0; i < addedItems.length; i++) {
+            this._box.insert_child_at_index(addedItems[i].item,
+                                            addedItems[i].pos);
+        }
+
+        for (let i = 0; i < removedActors.length; i++) {
+            let item = removedActors[i];
+
+            // Don't animate item removal when the overview is transitioning
+            // or hidden
+            if (Main.overview.visible && !Main.overview.animationInProgress)
+                item.animateOutAndDestroy();
+            else
+                item.destroy();
+        }
+
+        this._adjustIconSize();
+
+        // Skip animations on first run when adding the initial set
+        // of items, to avoid all items zooming in at once
+
+        let animate = this._shownInitially && Main.overview.visible &&
+            !Main.overview.animationInProgress;
+
+        if (!this._shownInitially)
+            this._shownInitially = true;
+
+        for (let i = 0; i < addedItems.length; i++)
+            addedItems[i].item.show(animate);
+
+        // Workaround for https://bugzilla.gnome.org/show_bug.cgi?id=692744
+        // Without it, StBoxLayout may use a stale size cache
+        this._box.queue_relayout();
+    }
+
+    _clearDragPlaceholder() {
+        if (this._dragPlaceholder) {
+            this._animatingPlaceholdersCount++;
+            this._dragPlaceholder.animateOutAndDestroy();
+            this._dragPlaceholder.connect('destroy', () => {
+                this._animatingPlaceholdersCount--;
+            });
+            this._dragPlaceholder = null;
+        }
+        this._dragPlaceholderPos = -1;
+    }
+
+    _clearEmptyDropTarget() {
+        if (this._emptyDropTarget) {
+            this._emptyDropTarget.animateOutAndDestroy();
+            this._emptyDropTarget = null;
+        }
+    }
+
+    handleDragOver(source, actor, x, y, _time) {
+        let app = getAppFromSource(source);
+
+        // Don't allow favoriting of transient apps
+        if (app == null || app.is_window_backed())
+            return DND.DragMotionResult.NO_DROP;
+
+        if (!global.settings.is_writable('favorite-apps'))
+            return DND.DragMotionResult.NO_DROP;
+
+        let favorites = AppFavorites.getAppFavorites().getFavorites();
+        let numFavorites = favorites.length;
+
+        let favPos = favorites.indexOf(app);
+
+        let children = this._box.get_children();
+        let numChildren = children.length;
+        let boxHeight = this._box.height;
+
+        // Keep the placeholder out of the index calculation; assuming that
+        // the remove target has the same size as "normal" items, we don't
+        // need to do the same adjustment there.
+        if (this._dragPlaceholder) {
+            boxHeight -= this._dragPlaceholder.height;
+            numChildren--;
+        }
+
+        let pos;
+        if (!this._emptyDropTarget)
+            pos = Math.floor(y * numChildren / boxHeight);
+        else
+            pos = 0; // always insert at the top when dash is empty
+
+        if (pos != this._dragPlaceholderPos && pos <= numFavorites && this._animatingPlaceholdersCount == 0) {
+            this._dragPlaceholderPos = pos;
+
+            // Don't allow positioning before or after self
+            if (favPos != -1 && (pos == favPos || pos == favPos + 1)) {
+                this._clearDragPlaceholder();
+                return DND.DragMotionResult.CONTINUE;
+            }
+
+            // If the placeholder already exists, we just move
+            // it, but if we are adding it, expand its size in
+            // an animation
+            let fadeIn;
+            if (this._dragPlaceholder) {
+                this._dragPlaceholder.destroy();
+                fadeIn = false;
+            } else {
+                fadeIn = true;
+            }
+
+            this._dragPlaceholder = new DragPlaceholderItem();
+            this._dragPlaceholder.child.set_width(this.iconSize);
+            this._dragPlaceholder.child.set_height(this.iconSize / 2);
+            this._box.insert_child_at_index(this._dragPlaceholder,
+                                            this._dragPlaceholderPos);
+            this._dragPlaceholder.show(fadeIn);
+        }
+
+        // Remove the drag placeholder if we are not in the
+        // "favorites zone"
+        if (pos > numFavorites)
+            this._clearDragPlaceholder();
+
+        if (!this._dragPlaceholder)
+            return DND.DragMotionResult.NO_DROP;
+
+        let srcIsFavorite = favPos != -1;
+
+        if (srcIsFavorite)
+            return DND.DragMotionResult.MOVE_DROP;
+
+        return DND.DragMotionResult.COPY_DROP;
+    }
+
+    // Draggable target interface
+    acceptDrop(source, _actor, _x, _y, _time) {
+        let app = getAppFromSource(source);
+
+        // Don't allow favoriting of transient apps
+        if (app == null || app.is_window_backed())
+            return false;
+
+        if (!global.settings.is_writable('favorite-apps'))
+            return false;
+
+        let id = app.get_id();
+
+        let favorites = AppFavorites.getAppFavorites().getFavoriteMap();
+
+        let srcIsFavorite = id in favorites;
+
+        let favPos = 0;
+        let children = this._box.get_children();
+        for (let i = 0; i < this._dragPlaceholderPos; i++) {
+            if (this._dragPlaceholder &&
+                children[i] == this._dragPlaceholder)
+                continue;
+
+            let childId = children[i].child._delegate.app.get_id();
+            if (childId == id)
+                continue;
+            if (childId in favorites)
+                favPos++;
+        }
+
+        // No drag placeholder means we don't want to favorite the app
+        // and we are dragging it to its original position
+        if (!this._dragPlaceholder)
+            return true;
+
+        Meta.later_add(Meta.LaterType.BEFORE_REDRAW, () => {
+            let appFavorites = AppFavorites.getAppFavorites();
+            if (srcIsFavorite)
+                appFavorites.moveFavoriteToPos(id, favPos);
+            else
+                appFavorites.addFavoriteAtPos(id, favPos);
+            return false;
+        });
+
+        return true;
+    }
+});

js/ui/dateMenu.js

@@ -0,0 +1,685 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported DateMenuButton */
+
+const { Clutter, Gio, GLib, GnomeDesktop,
+        GObject, GWeather, Pango, Shell, St } = imports.gi;
+
+const Util = imports.misc.util;
+const Main = imports.ui.main;
+const PanelMenu = imports.ui.panelMenu;
+const Calendar = imports.ui.calendar;
+const Weather = imports.misc.weather;
+const System = imports.system;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const MAX_FORECASTS = 5;
+
+const ClocksIntegrationIface = loadInterfaceXML('org.gnome.Shell.ClocksIntegration');
+const ClocksProxy = Gio.DBusProxy.makeProxyWrapper(ClocksIntegrationIface);
+
+function _isToday(date) {
+    let now = new Date();
+    return now.getYear() == date.getYear() &&
+           now.getMonth() == date.getMonth() &&
+           now.getDate() == date.getDate();
+}
+
+function _gDateTimeToDate(datetime) {
+    return new Date(datetime.to_unix() * 1000 + datetime.get_microsecond() / 1000);
+}
+
+var TodayButton = GObject.registerClass(
+class TodayButton extends St.Button {
+    _init(calendar) {
+        // Having the ability to go to the current date if the user is already
+        // on the current date can be confusing. So don't make the button reactive
+        // until the selected date changes.
+        super._init({
+            style_class: 'datemenu-today-button',
+            x_expand: true,
+            can_focus: true,
+            reactive: false,
+        });
+
+        let hbox = new St.BoxLayout({ vertical: true });
+        this.add_actor(hbox);
+
+        this._dayLabel = new St.Label({ style_class: 'day-label',
+                                        x_align: Clutter.ActorAlign.START });
+        hbox.add_actor(this._dayLabel);
+
+        this._dateLabel = new St.Label({ style_class: 'date-label' });
+        hbox.add_actor(this._dateLabel);
+
+        this._calendar = calendar;
+        this._calendar.connect('selected-date-changed', (_calendar, datetime) => {
+            // Make the button reactive only if the selected date is not the
+            // current date.
+            this.reactive = !_isToday(_gDateTimeToDate(datetime));
+        });
+    }
+
+    vfunc_clicked() {
+        this._calendar.setDate(new Date(), false);
+    }
+
+    setDate(date) {
+        this._dayLabel.set_text(date.toLocaleFormat('%A'));
+
+        /* Translators: This is the date format to use when the calendar popup is
+         * shown - it is shown just below the time in the top bar (e.g.,
+         * "Tue 9:29 AM").  The string itself should become a full date, e.g.,
+         * "February 17 2015".
+         */
+        let dateFormat = Shell.util_translate_time_string(N_("%B %-d %Y"));
+        this._dateLabel.set_text(date.toLocaleFormat(dateFormat));
+
+        /* Translators: This is the accessible name of the date button shown
+         * below the time in the shell; it should combine the weekday and the
+         * date, e.g. "Tuesday February 17 2015".
+         */
+        dateFormat = Shell.util_translate_time_string(N_("%A %B %e %Y"));
+        this.accessible_name = date.toLocaleFormat(dateFormat);
+    }
+});
+
+var WorldClocksSection = GObject.registerClass(
+class WorldClocksSection extends St.Button {
+    _init() {
+        super._init({
+            style_class: 'world-clocks-button',
+            can_focus: true,
+            x_expand: true,
+        });
+        this._clock = new GnomeDesktop.WallClock();
+        this._clockNotifyId = 0;
+
+        this._locations = [];
+
+        let layout = new Clutter.GridLayout({ orientation: Clutter.Orientation.VERTICAL });
+        this._grid = new St.Widget({ style_class: 'world-clocks-grid',
+                                     x_expand: true,
+                                     layout_manager: layout });
+        layout.hookup_style(this._grid);
+
+        this.child = this._grid;
+
+        this._clocksApp = null;
+        this._clocksProxy = new ClocksProxy(
+            Gio.DBus.session,
+            'org.gnome.clocks',
+            '/org/gnome/clocks',
+            this._onProxyReady.bind(this),
+            null /* cancellable */,
+            Gio.DBusProxyFlags.DO_NOT_AUTO_START | Gio.DBusProxyFlags.GET_INVALIDATED_PROPERTIES);
+
+        this._settings = new Gio.Settings({
+            schema_id: 'org.gnome.shell.world-clocks',
+        });
+        this._settings.connect('changed', this._clocksChanged.bind(this));
+        this._clocksChanged();
+
+        this._appSystem = Shell.AppSystem.get_default();
+        this._appSystem.connect('installed-changed',
+            this._sync.bind(this));
+        this._sync();
+    }
+
+    vfunc_clicked() {
+        if (this._clocksApp)
+            this._clocksApp.activate();
+
+        Main.overview.hide();
+        Main.panel.closeCalendar();
+    }
+
+    _sync() {
+        this._clocksApp = this._appSystem.lookup_app('org.gnome.clocks.desktop');
+        this.visible = this._clocksApp != null;
+    }
+
+    _clocksChanged() {
+        this._grid.destroy_all_children();
+        this._locations = [];
+
+        let world = GWeather.Location.get_world();
+        let clocks = this._settings.get_value('locations').deep_unpack();
+        for (let i = 0; i < clocks.length; i++) {
+            let l = world.deserialize(clocks[i]);
+            if (l && l.get_timezone() != null)
+                this._locations.push({ location: l });
+        }
+
+        this._locations.sort((a, b) => {
+            return a.location.get_timezone().get_offset() -
+                   b.location.get_timezone().get_offset();
+        });
+
+        let layout = this._grid.layout_manager;
+        let title = this._locations.length == 0
+            ? _("Add world clocks…")
+            : _("World Clocks");
+        let header = new St.Label({ style_class: 'world-clocks-header',
+                                    x_align: Clutter.ActorAlign.START,
+                                    text: title });
+        layout.attach(header, 0, 0, 2, 1);
+        this.label_actor = header;
+
+        let localOffset = GLib.DateTime.new_now_local().get_utc_offset();
+
+        for (let i = 0; i < this._locations.length; i++) {
+            let l = this._locations[i].location;
+
+            let name = l.get_city_name() || l.get_name();
+            let label = new St.Label({ style_class: 'world-clocks-city',
+                                       text: name,
+                                       x_align: Clutter.ActorAlign.START,
+                                       y_align: Clutter.ActorAlign.CENTER,
+                                       x_expand: true });
+
+            let time = new St.Label({ style_class: 'world-clocks-time' });
+
+            let otherOffset = this._getTimeAtLocation(l).get_utc_offset();
+            let offset = (otherOffset - localOffset) / GLib.TIME_SPAN_HOUR;
+            let fmt = Math.trunc(offset) == offset ? '%s%.0f' : '%s%.1f';
+            let prefix = offset >= 0 ? '+' : '-';
+            let tz = new St.Label({ style_class: 'world-clocks-timezone',
+                                    text: fmt.format(prefix, Math.abs(offset)),
+                                    x_align: Clutter.ActorAlign.END,
+                                    y_align: Clutter.ActorAlign.CENTER });
+
+            if (this._grid.text_direction == Clutter.TextDirection.RTL) {
+                layout.attach(tz, 0, i + 1, 1, 1);
+                layout.attach(time, 1, i + 1, 1, 1);
+                layout.attach(label, 2, i + 1, 1, 1);
+            } else {
+                layout.attach(label, 0, i + 1, 1, 1);
+                layout.attach(time, 1, i + 1, 1, 1);
+                layout.attach(tz, 2, i + 1, 1, 1);
+            }
+
+            this._locations[i].actor = time;
+        }
+
+        if (this._grid.get_n_children() > 1) {
+            if (!this._clockNotifyId) {
+                this._clockNotifyId =
+                    this._clock.connect('notify::clock', this._updateLabels.bind(this));
+            }
+            this._updateLabels();
+        } else {
+            if (this._clockNotifyId)
+                this._clock.disconnect(this._clockNotifyId);
+            this._clockNotifyId = 0;
+        }
+    }
+
+    _getTimeAtLocation(location) {
+        let tz = GLib.TimeZone.new(location.get_timezone().get_tzid());
+        return GLib.DateTime.new_now(tz);
+    }
+
+    _updateLabels() {
+        for (let i = 0; i < this._locations.length; i++) {
+            let l = this._locations[i];
+            let now = this._getTimeAtLocation(l.location);
+            l.actor.text = Util.formatTime(now, { timeOnly: true });
+        }
+    }
+
+    _onProxyReady(proxy, error) {
+        if (error) {
+            log('Failed to create GNOME Clocks proxy: %s'.format(error));
+            return;
+        }
+
+        this._clocksProxy.connect('g-properties-changed',
+            this._onClocksPropertiesChanged.bind(this));
+        this._onClocksPropertiesChanged();
+    }
+
+    _onClocksPropertiesChanged() {
+        if (this._clocksProxy.g_name_owner == null)
+            return;
+
+        this._settings.set_value('locations',
+            new GLib.Variant('av', this._clocksProxy.Locations));
+    }
+});
+
+var WeatherSection = GObject.registerClass(
+class WeatherSection extends St.Button {
+    _init() {
+        super._init({
+            style_class: 'weather-button',
+            can_focus: true,
+            x_expand: true,
+        });
+
+        this._weatherClient = new Weather.WeatherClient();
+
+        let box = new St.BoxLayout({
+            style_class: 'weather-box',
+            vertical: true,
+            x_expand: true,
+        });
+
+        this.child = box;
+
+        let titleBox = new St.BoxLayout({ style_class: 'weather-header-box' });
+        titleBox.add_child(new St.Label({
+            style_class: 'weather-header',
+            x_align: Clutter.ActorAlign.START,
+            x_expand: true,
+            y_align: Clutter.ActorAlign.END,
+            text: _('Weather'),
+        }));
+        box.add_child(titleBox);
+
+        this._titleLocation = new St.Label({
+            style_class: 'weather-header location',
+            x_align: Clutter.ActorAlign.END,
+            y_align: Clutter.ActorAlign.END,
+        });
+        titleBox.add_child(this._titleLocation);
+
+        let layout = new Clutter.GridLayout({ orientation: Clutter.Orientation.VERTICAL });
+        this._forecastGrid = new St.Widget({
+            style_class: 'weather-grid',
+            layout_manager: layout,
+        });
+        layout.hookup_style(this._forecastGrid);
+        box.add_child(this._forecastGrid);
+
+        this._weatherClient.connect('changed', this._sync.bind(this));
+        this._sync();
+    }
+
+    vfunc_map() {
+        this._weatherClient.update();
+        super.vfunc_map();
+    }
+
+    vfunc_clicked() {
+        this._weatherClient.activateApp();
+
+        Main.overview.hide();
+        Main.panel.closeCalendar();
+    }
+
+    _getInfos() {
+        let forecasts = this._weatherClient.info.get_forecast_list();
+
+        let now = GLib.DateTime.new_now_local();
+        let current = GLib.DateTime.new_from_unix_local(0);
+        let infos = [];
+        for (let i = 0; i < forecasts.length; i++) {
+            const [valid, timestamp] = forecasts[i].get_value_update();
+            if (!valid || timestamp === 0)
+                continue;  // 0 means 'never updated'
+
+            const datetime = GLib.DateTime.new_from_unix_local(timestamp);
+            if (now.difference(datetime) > 0)
+                continue; // Ignore earlier forecasts
+
+            if (datetime.difference(current) < GLib.TIME_SPAN_HOUR)
+                continue; // Enforce a minimum interval of 1h
+
+            if (infos.push(forecasts[i]) == MAX_FORECASTS)
+                break; // Use a maximum of five forecasts
+
+            current = datetime;
+        }
+        return infos;
+    }
+
+    _addForecasts() {
+        let layout = this._forecastGrid.layout_manager;
+
+        let infos = this._getInfos();
+        if (this._forecastGrid.text_direction == Clutter.TextDirection.RTL)
+            infos.reverse();
+
+        let col = 0;
+        infos.forEach(fc => {
+            const [valid_, timestamp] = fc.get_value_update();
+            let timeStr = Util.formatTime(new Date(timestamp * 1000), {
+                timeOnly: true,
+                ampm: false,
+            });
+            const [, tempValue] = fc.get_value_temp(GWeather.TemperatureUnit.DEFAULT);
+            const tempPrefix = tempValue >= 0 ? ' ' : '';
+
+            let time = new St.Label({
+                style_class: 'weather-forecast-time',
+                text: timeStr,
+                x_align: Clutter.ActorAlign.CENTER,
+            });
+            let icon = new St.Icon({
+                style_class: 'weather-forecast-icon',
+                icon_name: fc.get_symbolic_icon_name(),
+                x_align: Clutter.ActorAlign.CENTER,
+                x_expand: true,
+            });
+            let temp = new St.Label({
+                style_class: 'weather-forecast-temp',
+                text: '%s%.0f°'.format(tempPrefix, tempValue),
+                x_align: Clutter.ActorAlign.CENTER,
+            });
+
+            temp.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+            time.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+
+            layout.attach(time, col, 0, 1, 1);
+            layout.attach(icon, col, 1, 1, 1);
+            layout.attach(temp, col, 2, 1, 1);
+            col++;
+        });
+    }
+
+    _setStatusLabel(text) {
+        let layout = this._forecastGrid.layout_manager;
+        let label = new St.Label({ text });
+        layout.attach(label, 0, 0, 1, 1);
+    }
+
+    _updateForecasts() {
+        this._forecastGrid.destroy_all_children();
+
+        if (!this._weatherClient.hasLocation) {
+            this._setStatusLabel(_("Select a location…"));
+            return;
+        }
+
+        let info = this._weatherClient.info;
+        let loc = info.get_location();
+        if (loc.get_level() !== GWeather.LocationLevel.CITY && loc.has_coords()) {
+            let world = GWeather.Location.get_world();
+            loc = world.find_nearest_city(...loc.get_coords());
+        }
+        this._titleLocation.text = loc.get_name();
+
+        if (this._weatherClient.loading) {
+            this._setStatusLabel(_("Loading…"));
+            return;
+        }
+
+        if (info.is_valid()) {
+            this._addForecasts();
+            return;
+        }
+
+        if (info.network_error())
+            this._setStatusLabel(_("Go online for weather information"));
+        else
+            this._setStatusLabel(_("Weather information is currently unavailable"));
+    }
+
+    _sync() {
+        this.visible = this._weatherClient.available;
+
+        if (!this.visible)
+            return;
+
+        this._titleLocation.visible = this._weatherClient.hasLocation;
+
+        this._updateForecasts();
+    }
+});
+
+var MessagesIndicator = GObject.registerClass(
+class MessagesIndicator extends St.Icon {
+    _init() {
+        super._init({
+            icon_size: 16,
+            visible: false,
+            y_expand: true,
+            y_align: Clutter.ActorAlign.CENTER,
+        });
+
+        this._sources = [];
+        this._count = 0;
+        this._doNotDisturb = false;
+
+        this._settings = new Gio.Settings({
+            schema_id: 'org.gnome.desktop.notifications',
+        });
+        this._settings.connect('changed::show-banners', this._sync.bind(this));
+
+        Main.messageTray.connect('source-added', this._onSourceAdded.bind(this));
+        Main.messageTray.connect('source-removed', this._onSourceRemoved.bind(this));
+        Main.messageTray.connect('queue-changed', this._updateCount.bind(this));
+
+        let sources = Main.messageTray.getSources();
+        sources.forEach(source => this._onSourceAdded(null, source));
+
+        this._sync();
+
+        this.connect('destroy', () => {
+            this._settings.run_dispose();
+            this._settings = null;
+        });
+    }
+
+    _onSourceAdded(tray, source) {
+        source.connect('notify::count', this._updateCount.bind(this));
+        this._sources.push(source);
+        this._updateCount();
+    }
+
+    _onSourceRemoved(tray, source) {
+        this._sources.splice(this._sources.indexOf(source), 1);
+        this._updateCount();
+    }
+
+    _updateCount() {
+        let count = 0;
+        this._sources.forEach(source => (count += source.unseenCount));
+        this._count = count - Main.messageTray.queueCount;
+
+        this._sync();
+    }
+
+    _sync() {
+        let doNotDisturb = !this._settings.get_boolean('show-banners');
+        this.icon_name = doNotDisturb
+            ? 'notifications-disabled-symbolic'
+            : 'message-indicator-symbolic';
+        this.visible = doNotDisturb || this._count > 0;
+    }
+});
+
+var FreezableBinLayout = GObject.registerClass(
+class FreezableBinLayout extends Clutter.BinLayout {
+    _init() {
+        super._init();
+
+        this._frozen = false;
+        this._savedWidth = [NaN, NaN];
+        this._savedHeight = [NaN, NaN];
+    }
+
+    set frozen(v) {
+        if (this._frozen == v)
+            return;
+
+        this._frozen = v;
+        if (!this._frozen)
+            this.layout_changed();
+    }
+
+    vfunc_get_preferred_width(container, forHeight) {
+        if (!this._frozen || this._savedWidth.some(isNaN))
+            return super.vfunc_get_preferred_width(container, forHeight);
+        return this._savedWidth;
+    }
+
+    vfunc_get_preferred_height(container, forWidth) {
+        if (!this._frozen || this._savedHeight.some(isNaN))
+            return super.vfunc_get_preferred_height(container, forWidth);
+        return this._savedHeight;
+    }
+
+    vfunc_allocate(container, allocation, flags) {
+        super.vfunc_allocate(container, allocation, flags);
+
+        let [width, height] = allocation.get_size();
+        this._savedWidth = [width, width];
+        this._savedHeight = [height, height];
+    }
+});
+
+var CalendarColumnLayout = GObject.registerClass(
+class CalendarColumnLayout extends Clutter.BoxLayout {
+    _init(actor) {
+        super._init({ orientation: Clutter.Orientation.VERTICAL });
+        this._calActor = actor;
+    }
+
+    vfunc_get_preferred_width(container, forHeight) {
+        if (!this._calActor || this._calActor.get_parent() != container)
+            return super.vfunc_get_preferred_width(container, forHeight);
+        return this._calActor.get_preferred_width(forHeight);
+    }
+});
+
+var DateMenuButton = GObject.registerClass(
+class DateMenuButton extends PanelMenu.Button {
+    _init() {
+        let hbox;
+        let vbox;
+
+        super._init(0.5);
+
+        this._clockDisplay = new St.Label({ style_class: 'clock' });
+        this._clockDisplay.clutter_text.y_align = Clutter.ActorAlign.CENTER;
+
+        this._indicator = new MessagesIndicator();
+
+        const indicatorPad = new St.Widget();
+        this._indicator.bind_property('visible',
+            indicatorPad, 'visible',
+            GObject.BindingFlags.SYNC_CREATE);
+        indicatorPad.add_constraint(new Clutter.BindConstraint({
+            source: this._indicator,
+            coordinate: Clutter.BindCoordinate.SIZE,
+        }));
+
+        let box = new St.BoxLayout({ style_class: 'clock-display-box' });
+        box.add_actor(indicatorPad);
+        box.add_actor(this._clockDisplay);
+        box.add_actor(this._indicator);
+
+        this.label_actor = this._clockDisplay;
+        this.add_actor(box);
+        this.add_style_class_name('clock-display');
+
+        let layout = new FreezableBinLayout();
+        let bin = new St.Widget({ layout_manager: layout });
+        // For some minimal compatibility with PopupMenuItem
+        bin._delegate = this;
+        this.menu.box.add_child(bin);
+
+        hbox = new St.BoxLayout({ name: 'calendarArea' });
+        bin.add_actor(hbox);
+
+        this._calendar = new Calendar.Calendar();
+        this._calendar.connect('selected-date-changed', (_calendar, datetime) => {
+            let date = _gDateTimeToDate(datetime);
+            layout.frozen = !_isToday(date);
+            this._messageList.setDate(date);
+        });
+
+        this.menu.connect('open-state-changed', (menu, isOpen) => {
+            // Whenever the menu is opened, select today
+            if (isOpen) {
+                let now = new Date();
+                this._calendar.setDate(now);
+                this._date.setDate(now);
+                this._messageList.setDate(now);
+            }
+        });
+
+        // Fill up the first column
+        this._messageList = new Calendar.CalendarMessageList();
+        hbox.add_child(this._messageList);
+
+        // Fill up the second column
+        let boxLayout = new CalendarColumnLayout(this._calendar);
+        vbox = new St.Widget({ style_class: 'datemenu-calendar-column',
+                               layout_manager: boxLayout });
+        boxLayout.hookup_style(vbox);
+        hbox.add(vbox);
+
+        this._date = new TodayButton(this._calendar);
+        vbox.add_actor(this._date);
+
+        vbox.add_actor(this._calendar);
+
+        this._displaysSection = new St.ScrollView({ style_class: 'datemenu-displays-section vfade',
+                                                    x_expand: true,
+                                                    overlay_scrollbars: true });
+        this._displaysSection.set_policy(St.PolicyType.NEVER, St.PolicyType.EXTERNAL);
+        vbox.add_actor(this._displaysSection);
+
+        let displaysBox = new St.BoxLayout({ vertical: true,
+                                             x_expand: true,
+                                             style_class: 'datemenu-displays-box' });
+        this._displaysSection.add_actor(displaysBox);
+
+        this._clocksItem = new WorldClocksSection();
+        displaysBox.add_child(this._clocksItem);
+
+        this._weatherItem = new WeatherSection();
+        displaysBox.add_child(this._weatherItem);
+
+        // Done with hbox for calendar and event list
+
+        this._clock = new GnomeDesktop.WallClock();
+        this._clock.bind_property('clock', this._clockDisplay, 'text', GObject.BindingFlags.SYNC_CREATE);
+        this._clock.connect('notify::timezone', this._updateTimeZone.bind(this));
+
+        Main.sessionMode.connect('updated', this._sessionUpdated.bind(this));
+        this._sessionUpdated();
+    }
+
+    _getEventSource() {
+        return new Calendar.DBusEventSource();
+    }
+
+    _setEventSource(eventSource) {
+        if (this._eventSource)
+            this._eventSource.destroy();
+
+        this._calendar.setEventSource(eventSource);
+        this._messageList.setEventSource(eventSource);
+
+        this._eventSource = eventSource;
+    }
+
+    _updateTimeZone() {
+        // SpiderMonkey caches the time zone so we must explicitly clear it
+        // before we can update the calendar, see
+        // https://bugzilla.gnome.org/show_bug.cgi?id=678507
+        System.clearDateCaches();
+
+        this._calendar.updateTimeZone();
+    }
+
+    _sessionUpdated() {
+        let eventSource;
+        let showEvents = Main.sessionMode.showCalendarEvents;
+        if (showEvents)
+            eventSource = this._getEventSource();
+        else
+            eventSource = new Calendar.EmptyEventSource();
+
+        this._setEventSource(eventSource);
+
+        // Displays are not actually expected to launch Settings when activated
+        // but the corresponding app (clocks, weather); however we can consider
+        // that display-specific settings, so re-use "allowSettings" here ...
+        this._displaysSection.visible = Main.sessionMode.allowSettings;
+    }
+});

js/ui/dialog.js

@@ -0,0 +1,362 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Dialog, MessageDialogContent, ListSection, ListSectionItem */
+
+const { Clutter, GObject, Meta, Pango, St } = imports.gi;
+
+function _setLabel(label, value) {
+    label.set({
+        text: value || '',
+        visible: value !== null,
+    });
+}
+
+var Dialog = GObject.registerClass(
+class Dialog extends St.Widget {
+    _init(parentActor, styleClass) {
+        super._init({ layout_manager: new Clutter.BinLayout() });
+        this.connect('destroy', this._onDestroy.bind(this));
+
+        this._initialKeyFocus = null;
+        this._initialKeyFocusDestroyId = 0;
+        this._pressedKey = null;
+        this._buttonKeys = {};
+        this._createDialog();
+        this.add_child(this._dialog);
+
+        if (styleClass != null)
+            this._dialog.add_style_class_name(styleClass);
+
+        this._parentActor = parentActor;
+        this._eventId = this._parentActor.connect('event', this._modalEventHandler.bind(this));
+        this._parentActor.add_child(this);
+    }
+
+    _createDialog() {
+        this._dialog = new St.BoxLayout({
+            style_class: 'modal-dialog',
+            x_align: Clutter.ActorAlign.CENTER,
+            y_align: Clutter.ActorAlign.CENTER,
+            vertical: true,
+        });
+
+        // modal dialogs are fixed width and grow vertically; set the request
+        // mode accordingly so wrapped labels are handled correctly during
+        // size requests.
+        this._dialog.request_mode = Clutter.RequestMode.HEIGHT_FOR_WIDTH;
+        this._dialog.set_offscreen_redirect(Clutter.OffscreenRedirect.ALWAYS);
+
+        this.contentLayout = new St.BoxLayout({
+            vertical: true,
+            style_class: 'modal-dialog-content-box',
+            y_expand: true,
+        });
+        this._dialog.add_child(this.contentLayout);
+
+        this.buttonLayout = new St.Widget({
+            layout_manager: new Clutter.BoxLayout({ homogeneous: true }),
+        });
+        this._dialog.add_child(this.buttonLayout);
+    }
+
+    makeInactive() {
+        if (this._eventId != 0)
+            this._parentActor.disconnect(this._eventId);
+        this._eventId = 0;
+
+        this.buttonLayout.get_children().forEach(c => c.set_reactive(false));
+    }
+
+    _onDestroy() {
+        this.makeInactive();
+    }
+
+    _modalEventHandler(actor, event) {
+        if (event.type() == Clutter.EventType.KEY_PRESS) {
+            this._pressedKey = event.get_key_symbol();
+        } else if (event.type() == Clutter.EventType.KEY_RELEASE) {
+            let pressedKey = this._pressedKey;
+            this._pressedKey = null;
+
+            let symbol = event.get_key_symbol();
+            if (symbol != pressedKey)
+                return Clutter.EVENT_PROPAGATE;
+
+            let buttonInfo = this._buttonKeys[symbol];
+            if (!buttonInfo)
+                return Clutter.EVENT_PROPAGATE;
+
+            let { button, action } = buttonInfo;
+
+            if (action && button.reactive) {
+                action();
+                return Clutter.EVENT_STOP;
+            }
+        }
+
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    _setInitialKeyFocus(actor) {
+        if (this._initialKeyFocus)
+            this._initialKeyFocus.disconnect(this._initialKeyFocusDestroyId);
+
+        this._initialKeyFocus = actor;
+
+        this._initialKeyFocusDestroyId = actor.connect('destroy', () => {
+            this._initialKeyFocus = null;
+            this._initialKeyFocusDestroyId = 0;
+        });
+    }
+
+    get initialKeyFocus() {
+        return this._initialKeyFocus || this;
+    }
+
+    addButton(buttonInfo) {
+        let { label, action, key } = buttonInfo;
+        let isDefault = buttonInfo['default'];
+        let keys;
+
+        if (key)
+            keys = [key];
+        else if (isDefault)
+            keys = [Clutter.KEY_Return, Clutter.KEY_KP_Enter, Clutter.KEY_ISO_Enter];
+        else
+            keys = [];
+
+        let button = new St.Button({
+            style_class: 'modal-dialog-linked-button',
+            button_mask: St.ButtonMask.ONE | St.ButtonMask.THREE,
+            reactive: true,
+            can_focus: true,
+            x_expand: true,
+            y_expand: true,
+            label,
+        });
+        button.connect('clicked', action);
+
+        buttonInfo['button'] = button;
+
+        if (isDefault)
+            button.add_style_pseudo_class('default');
+
+        if (this._initialKeyFocus == null || isDefault)
+            this._setInitialKeyFocus(button);
+
+        for (let i in keys)
+            this._buttonKeys[keys[i]] = buttonInfo;
+
+        this.buttonLayout.add_actor(button);
+
+        return button;
+    }
+
+    clearButtons() {
+        this.buttonLayout.destroy_all_children();
+        this._buttonKeys = {};
+    }
+});
+
+var MessageDialogContent = GObject.registerClass({
+    Properties: {
+        'title': GObject.ParamSpec.string(
+            'title', 'title', 'title',
+            GObject.ParamFlags.READWRITE |
+            GObject.ParamFlags.CONSTRUCT,
+            null),
+        'description': GObject.ParamSpec.string(
+            'description', 'description', 'description',
+            GObject.ParamFlags.READWRITE |
+            GObject.ParamFlags.CONSTRUCT,
+            null),
+    },
+}, class MessageDialogContent extends St.BoxLayout {
+    _init(params) {
+        this._title = new St.Label({ style_class: 'message-dialog-title' });
+        this._description = new St.Label({ style_class: 'message-dialog-description' });
+
+        this._description.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+        this._description.clutter_text.line_wrap = true;
+
+        let defaultParams = {
+            style_class: 'message-dialog-content',
+            x_expand: true,
+            vertical: true,
+        };
+        super._init(Object.assign(defaultParams, params));
+
+        this.connect('notify::size', this._updateTitleStyle.bind(this));
+        this.connect('destroy', this._onDestroy.bind(this));
+
+        this.add_child(this._title);
+        this.add_child(this._description);
+    }
+
+    _onDestroy() {
+        if (this._updateTitleStyleLater) {
+            Meta.later_remove(this._updateTitleStyleLater);
+            delete this._updateTitleStyleLater;
+        }
+    }
+
+    get title() {
+        return this._title.text;
+    }
+
+    get description() {
+        return this._description.text;
+    }
+
+    _updateTitleStyle() {
+        if (!this._title.mapped)
+            return;
+
+        this._title.ensure_style();
+        const [, titleNatWidth] = this._title.get_preferred_width(-1);
+
+        if (titleNatWidth > this.width) {
+            if (this._updateTitleStyleLater)
+                return;
+
+            this._updateTitleStyleLater = Meta.later_add(Meta.LaterType.BEFORE_REDRAW, () => {
+                this._updateTitleStyleLater = 0;
+                this._title.add_style_class_name('leightweight');
+                return false;
+            });
+        }
+
+    }
+
+    set title(title) {
+        _setLabel(this._title, title);
+
+        this._title.remove_style_class_name('leightweight');
+        this._updateTitleStyle();
+
+        this.notify('title');
+    }
+
+    set description(description) {
+        _setLabel(this._description, description);
+        this.notify('description');
+    }
+});
+
+var ListSection = GObject.registerClass({
+    Properties: {
+        'title': GObject.ParamSpec.string(
+            'title', 'title', 'title',
+            GObject.ParamFlags.READWRITE |
+            GObject.ParamFlags.CONSTRUCT,
+            null),
+    },
+}, class ListSection extends St.BoxLayout {
+    _init(params) {
+        this._title = new St.Label({ style_class: 'dialog-list-title' });
+
+        this._listScrollView = new St.ScrollView({
+            style_class: 'dialog-list-scrollview',
+            hscrollbar_policy: St.PolicyType.NEVER,
+        });
+
+        this.list = new St.BoxLayout({
+            style_class: 'dialog-list-box',
+            vertical: true,
+        });
+        this._listScrollView.add_actor(this.list);
+
+        let defaultParams = {
+            style_class: 'dialog-list',
+            x_expand: true,
+            vertical: true,
+        };
+        super._init(Object.assign(defaultParams, params));
+
+        this.label_actor = this._title;
+        this.add_child(this._title);
+        this.add_child(this._listScrollView);
+    }
+
+    get title() {
+        return this._title.text;
+    }
+
+    set title(title) {
+        _setLabel(this._title, title);
+        this.notify('title');
+    }
+});
+
+var ListSectionItem = GObject.registerClass({
+    Properties: {
+        'icon-actor':  GObject.ParamSpec.object(
+            'icon-actor', 'icon-actor', 'Icon actor',
+            GObject.ParamFlags.READWRITE,
+            Clutter.Actor.$gtype),
+        'title': GObject.ParamSpec.string(
+            'title', 'title', 'title',
+            GObject.ParamFlags.READWRITE |
+            GObject.ParamFlags.CONSTRUCT,
+            null),
+        'description': GObject.ParamSpec.string(
+            'description', 'description', 'description',
+            GObject.ParamFlags.READWRITE |
+            GObject.ParamFlags.CONSTRUCT,
+            null),
+    },
+}, class ListSectionItem extends St.BoxLayout {
+    _init(params) {
+        this._iconActorBin = new St.Bin();
+
+        let textLayout = new St.BoxLayout({
+            vertical: true,
+            y_expand: true,
+            y_align: Clutter.ActorAlign.CENTER,
+        });
+
+        this._title = new St.Label({ style_class: 'dialog-list-item-title' });
+
+        this._description = new St.Label({
+            style_class: 'dialog-list-item-title-description',
+        });
+
+        textLayout.add_child(this._title);
+        textLayout.add_child(this._description);
+
+        let defaultParams = { style_class: 'dialog-list-item' };
+        super._init(Object.assign(defaultParams, params));
+
+        this.label_actor = this._title;
+        this.add_child(this._iconActorBin);
+        this.add_child(textLayout);
+    }
+
+    // eslint-disable-next-line camelcase
+    get icon_actor() {
+        return this._iconActorBin.get_child();
+    }
+
+    // eslint-disable-next-line camelcase
+    set icon_actor(actor) {
+        this._iconActorBin.set_child(actor);
+        this.notify('icon-actor');
+    }
+
+    get title() {
+        return this._title.text;
+    }
+
+    set title(title) {
+        _setLabel(this._title, title);
+        this.notify('title');
+    }
+
+    get description() {
+        return this._description.text;
+    }
+
+    set description(description) {
+        _setLabel(this._description, description);
+        this.notify('description');
+    }
+});

js/ui/dnd.js

@@ -0,0 +1,777 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported addDragMonitor, removeDragMonitor, makeDraggable */
+
+const { Clutter, GLib, Meta, Shell, St } = imports.gi;
+const Signals = imports.signals;
+
+const Main = imports.ui.main;
+const Params = imports.misc.params;
+
+// Time to scale down to maxDragActorSize
+var SCALE_ANIMATION_TIME = 250;
+// Time to animate to original position on cancel
+var SNAP_BACK_ANIMATION_TIME = 250;
+// Time to animate to original position on success
+var REVERT_ANIMATION_TIME = 750;
+
+var DragMotionResult = {
+    NO_DROP:   0,
+    COPY_DROP: 1,
+    MOVE_DROP: 2,
+    CONTINUE:  3,
+};
+
+var DragState = {
+    INIT:      0,
+    DRAGGING:  1,
+    CANCELLED: 2,
+};
+
+var DRAG_CURSOR_MAP = {
+    0: Meta.Cursor.DND_UNSUPPORTED_TARGET,
+    1: Meta.Cursor.DND_COPY,
+    2: Meta.Cursor.DND_MOVE,
+};
+
+var DragDropResult = {
+    FAILURE:  0,
+    SUCCESS:  1,
+    CONTINUE: 2,
+};
+var dragMonitors = [];
+
+let eventHandlerActor = null;
+let currentDraggable = null;
+
+function _getEventHandlerActor() {
+    if (!eventHandlerActor) {
+        eventHandlerActor = new Clutter.Actor({ width: 0, height: 0 });
+        Main.uiGroup.add_actor(eventHandlerActor);
+        // We connect to 'event' rather than 'captured-event' because the capturing phase doesn't happen
+        // when you've grabbed the pointer.
+        eventHandlerActor.connect('event', (actor, event) => {
+            return currentDraggable._onEvent(actor, event);
+        });
+    }
+    return eventHandlerActor;
+}
+
+function addDragMonitor(monitor) {
+    dragMonitors.push(monitor);
+}
+
+function removeDragMonitor(monitor) {
+    for (let i = 0; i < dragMonitors.length; i++) {
+        if (dragMonitors[i] == monitor) {
+            dragMonitors.splice(i, 1);
+            return;
+        }
+    }
+}
+
+var _Draggable = class _Draggable {
+    constructor(actor, params) {
+        params = Params.parse(params, { manualMode: false,
+                                        restoreOnSuccess: false,
+                                        dragActorMaxSize: undefined,
+                                        dragActorOpacity: undefined });
+
+        this.actor = actor;
+        this._dragState = DragState.INIT;
+
+        if (!params.manualMode) {
+            this.actor.connect('button-press-event',
+                               this._onButtonPress.bind(this));
+            this.actor.connect('touch-event',
+                               this._onTouchEvent.bind(this));
+        }
+
+        this.actor.connect('destroy', () => {
+            this._actorDestroyed = true;
+
+            if (this._dragState == DragState.DRAGGING && this._dragCancellable)
+                this._cancelDrag(global.get_current_time());
+            this.disconnectAll();
+        });
+        this._onEventId = null;
+        this._touchSequence = null;
+
+        this._restoreOnSuccess = params.restoreOnSuccess;
+        this._dragActorMaxSize = params.dragActorMaxSize;
+        this._dragActorOpacity = params.dragActorOpacity;
+
+        this._buttonDown = false; // The mouse button has been pressed and has not yet been released.
+        this._animationInProgress = false; // The drag is over and the item is in the process of animating to its original position (snapping back or reverting).
+        this._dragCancellable = true;
+
+        this._eventsGrabbed = false;
+        this._capturedEventId = 0;
+    }
+
+    _onButtonPress(actor, event) {
+        if (event.get_button() != 1)
+            return Clutter.EVENT_PROPAGATE;
+
+        this._buttonDown = true;
+        this._grabActor(event.get_device());
+
+        let [stageX, stageY] = event.get_coords();
+        this._dragStartX = stageX;
+        this._dragStartY = stageY;
+
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    _onTouchEvent(actor, event) {
+        // We only handle touch events here on wayland. On X11
+        // we do get emulated pointer events, which already works
+        // for single-touch cases. Besides, the X11 passive touch grab
+        // set up by Mutter will make us see first the touch events
+        // and later the pointer events, so it will look like two
+        // unrelated series of events, we want to avoid double handling
+        // in these cases.
+        if (!Meta.is_wayland_compositor())
+            return Clutter.EVENT_PROPAGATE;
+
+        if (event.type() != Clutter.EventType.TOUCH_BEGIN ||
+            !global.display.is_pointer_emulating_sequence(event.get_event_sequence()))
+            return Clutter.EVENT_PROPAGATE;
+
+        this._buttonDown = true;
+        this._grabActor(event.get_device(), event.get_event_sequence());
+
+        let [stageX, stageY] = event.get_coords();
+        this._dragStartX = stageX;
+        this._dragStartY = stageY;
+
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    _grabDevice(actor, pointer, touchSequence) {
+        if (touchSequence)
+            pointer.sequence_grab(touchSequence, actor);
+        else if (pointer)
+            pointer.grab(actor);
+
+        this._grabbedDevice = pointer;
+        this._touchSequence = touchSequence;
+
+        this._capturedEventId = global.stage.connect('captured-event', (o, event) => {
+            let device = event.get_device();
+            if (device != this._grabbedDevice &&
+                device.get_device_type() != Clutter.InputDeviceType.KEYBOARD_DEVICE)
+                return Clutter.EVENT_STOP;
+            return Clutter.EVENT_PROPAGATE;
+        });
+    }
+
+    _ungrabDevice() {
+        if (this._capturedEventId != 0) {
+            global.stage.disconnect(this._capturedEventId);
+            this._capturedEventId = 0;
+        }
+
+        if (this._touchSequence)
+            this._grabbedDevice.sequence_ungrab(this._touchSequence);
+        else
+            this._grabbedDevice.ungrab();
+
+        this._touchSequence = null;
+        this._grabbedDevice = null;
+    }
+
+    _grabActor(device, touchSequence) {
+        this._grabDevice(this.actor, device, touchSequence);
+        this._onEventId = this.actor.connect('event',
+                                             this._onEvent.bind(this));
+    }
+
+    _ungrabActor() {
+        if (!this._onEventId)
+            return;
+
+        this._ungrabDevice();
+        this.actor.disconnect(this._onEventId);
+        this._onEventId = null;
+    }
+
+    _grabEvents(device, touchSequence) {
+        if (!this._eventsGrabbed) {
+            this._eventsGrabbed = Main.pushModal(_getEventHandlerActor());
+            if (this._eventsGrabbed)
+                this._grabDevice(_getEventHandlerActor(), device, touchSequence);
+        }
+    }
+
+    _ungrabEvents() {
+        if (this._eventsGrabbed) {
+            this._ungrabDevice();
+            Main.popModal(_getEventHandlerActor());
+            this._eventsGrabbed = false;
+        }
+    }
+
+    _eventIsRelease(event) {
+        if (event.type() == Clutter.EventType.BUTTON_RELEASE) {
+            let buttonMask = Clutter.ModifierType.BUTTON1_MASK |
+                              Clutter.ModifierType.BUTTON2_MASK |
+                              Clutter.ModifierType.BUTTON3_MASK;
+            /* We only obey the last button release from the device,
+             * other buttons may get pressed/released during the DnD op.
+             */
+            return (event.get_state() & buttonMask) == 0;
+        } else if (event.type() == Clutter.EventType.TOUCH_END) {
+            /* For touch, we only obey the pointer emulating sequence */
+            return global.display.is_pointer_emulating_sequence(event.get_event_sequence());
+        }
+
+        return false;
+    }
+
+    _onEvent(actor, event) {
+        let device = event.get_device();
+
+        if (this._grabbedDevice &&
+            device != this._grabbedDevice &&
+            device.get_device_type() != Clutter.InputDeviceType.KEYBOARD_DEVICE)
+            return Clutter.EVENT_PROPAGATE;
+
+        // We intercept BUTTON_RELEASE event to know that the button was released in case we
+        // didn't start the drag, to drop the draggable in case the drag was in progress, and
+        // to complete the drag and ensure that whatever happens to be under the pointer does
+        // not get triggered if the drag was cancelled with Esc.
+        if (this._eventIsRelease(event)) {
+            this._buttonDown = false;
+            if (this._dragState == DragState.DRAGGING) {
+                return this._dragActorDropped(event);
+            } else if ((this._dragActor != null || this._dragState == DragState.CANCELLED) &&
+                       !this._animationInProgress) {
+                // Drag must have been cancelled with Esc.
+                this._dragComplete();
+                return Clutter.EVENT_STOP;
+            } else {
+                // Drag has never started.
+                this._ungrabActor();
+                return Clutter.EVENT_PROPAGATE;
+            }
+        // We intercept MOTION event to figure out if the drag has started and to draw
+        // this._dragActor under the pointer when dragging is in progress
+        } else if (event.type() == Clutter.EventType.MOTION ||
+                   (event.type() == Clutter.EventType.TOUCH_UPDATE &&
+                    global.display.is_pointer_emulating_sequence(event.get_event_sequence()))) {
+            if (this._dragActor && this._dragState == DragState.DRAGGING)
+                return this._updateDragPosition(event);
+            else if (this._dragActor == null && this._dragState != DragState.CANCELLED)
+                return this._maybeStartDrag(event);
+
+        // We intercept KEY_PRESS event so that we can process Esc key press to cancel
+        // dragging and ignore all other key presses.
+        } else if (event.type() == Clutter.EventType.KEY_PRESS && this._dragState == DragState.DRAGGING) {
+            let symbol = event.get_key_symbol();
+            if (symbol == Clutter.KEY_Escape) {
+                this._cancelDrag(event.get_time());
+                return Clutter.EVENT_STOP;
+            }
+        }
+
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    /**
+     * fakeRelease:
+     *
+     * Fake a release event.
+     * Must be called if you want to intercept release events on draggable
+     * actors for other purposes (for example if you're using
+     * PopupMenu.ignoreRelease())
+     */
+    fakeRelease() {
+        this._buttonDown = false;
+        this._ungrabActor();
+    }
+
+    /**
+     * startDrag:
+     * @param {number} stageX: X coordinate of event
+     * @param {number} stageY: Y coordinate of event
+     * @param {number} time: Event timestamp
+     * @param {Clutter.EventSequence=} sequence: Event sequence
+     * @param {Clutter.InputDevice=} device: device that originated the event
+     *
+     * Directly initiate a drag and drop operation from the given actor.
+     * This function is useful to call if you've specified manualMode
+     * for the draggable.
+     */
+    startDrag(stageX, stageY, time, sequence, device) {
+        if (currentDraggable)
+            return;
+
+        if (device == undefined) {
+            let event = Clutter.get_current_event();
+
+            if (event)
+                device = event.get_device();
+
+            if (device == undefined) {
+                let seat = Clutter.get_default_backend().get_default_seat();
+                device = seat.get_pointer();
+            }
+        }
+
+        currentDraggable = this;
+        this._dragState = DragState.DRAGGING;
+
+        // Special-case St.Button: the pointer grab messes with the internal
+        // state, so force a reset to a reasonable state here
+        if (this.actor instanceof St.Button) {
+            this.actor.fake_release();
+            this.actor.hover = false;
+        }
+
+        this.emit('drag-begin', time);
+        if (this._onEventId)
+            this._ungrabActor();
+
+        this._grabEvents(device, sequence);
+        global.display.set_cursor(Meta.Cursor.DND_IN_DRAG);
+
+        this._dragX = this._dragStartX = stageX;
+        this._dragY = this._dragStartY = stageY;
+
+        if (this.actor._delegate && this.actor._delegate.getDragActor) {
+            this._dragActor = this.actor._delegate.getDragActor();
+            Main.uiGroup.add_child(this._dragActor);
+            Main.uiGroup.set_child_above_sibling(this._dragActor, null);
+            Shell.util_set_hidden_from_pick(this._dragActor, true);
+
+            // Drag actor does not always have to be the same as actor. For example drag actor
+            // can be an image that's part of the actor. So to perform "snap back" correctly we need
+            // to know what was the drag actor source.
+            if (this.actor._delegate.getDragActorSource) {
+                this._dragActorSource = this.actor._delegate.getDragActorSource();
+                // If the user dragged from the source, then position
+                // the dragActor over it. Otherwise, center it
+                // around the pointer
+                let [sourceX, sourceY] = this._dragActorSource.get_transformed_position();
+                let x, y;
+                if (stageX > sourceX && stageX <= sourceX + this._dragActor.width &&
+                    stageY > sourceY && stageY <= sourceY + this._dragActor.height) {
+                    x = sourceX;
+                    y = sourceY;
+                } else {
+                    x = stageX - this._dragActor.width / 2;
+                    y = stageY - this._dragActor.height / 2;
+                }
+                this._dragActor.set_position(x, y);
+            } else {
+                this._dragActorSource = this.actor;
+            }
+            this._dragOrigParent = undefined;
+
+            this._dragOffsetX = this._dragActor.x - this._dragStartX;
+            this._dragOffsetY = this._dragActor.y - this._dragStartY;
+        } else {
+            this._dragActor = this.actor;
+
+            this._dragActorSource = undefined;
+            this._dragOrigParent = this.actor.get_parent();
+            this._dragOrigX = this._dragActor.x;
+            this._dragOrigY = this._dragActor.y;
+            this._dragOrigScale = this._dragActor.scale_x;
+
+            // Set the actor's scale such that it will keep the same
+            // transformed size when it's reparented to the uiGroup
+            let [scaledWidth, scaledHeight] = this.actor.get_transformed_size();
+            this._dragActor.set_scale(scaledWidth / this.actor.width,
+                                      scaledHeight / this.actor.height);
+
+            let [actorStageX, actorStageY] = this.actor.get_transformed_position();
+            this._dragOffsetX = actorStageX - this._dragStartX;
+            this._dragOffsetY = actorStageY - this._dragStartY;
+
+            this._dragOrigParent.remove_actor(this._dragActor);
+            Main.uiGroup.add_child(this._dragActor);
+            Main.uiGroup.set_child_above_sibling(this._dragActor, null);
+            Shell.util_set_hidden_from_pick(this._dragActor, true);
+        }
+
+        this._dragActorDestroyId = this._dragActor.connect('destroy', () => {
+            // Cancel ongoing animation (if any)
+            this._finishAnimation();
+
+            this._dragActor = null;
+            if (this._dragState == DragState.DRAGGING)
+                this._dragState = DragState.CANCELLED;
+        });
+        this._dragOrigOpacity = this._dragActor.opacity;
+        if (this._dragActorOpacity != undefined)
+            this._dragActor.opacity = this._dragActorOpacity;
+
+        this._snapBackX = this._dragStartX + this._dragOffsetX;
+        this._snapBackY = this._dragStartY + this._dragOffsetY;
+        this._snapBackScale = this._dragActor.scale_x;
+
+        let origDragOffsetX = this._dragOffsetX;
+        let origDragOffsetY = this._dragOffsetY;
+        let [transX, transY] = this._dragActor.get_translation();
+        this._dragOffsetX -= transX;
+        this._dragOffsetY -= transY;
+
+        if (this._dragActorMaxSize != undefined) {
+            let [scaledWidth, scaledHeight] = this._dragActor.get_transformed_size();
+            let currentSize = Math.max(scaledWidth, scaledHeight);
+            if (currentSize > this._dragActorMaxSize) {
+                let scale = this._dragActorMaxSize / currentSize;
+                let origScale =  this._dragActor.scale_x;
+
+                // The position of the actor changes as we scale
+                // around the drag position, but we can't just tween
+                // to the final position because that tween would
+                // fight with updates as the user continues dragging
+                // the mouse; instead we do the position computations in
+                // a ::new-frame handler.
+                this._dragActor.ease({
+                    scale_x: scale * origScale,
+                    scale_y: scale * origScale,
+                    duration: SCALE_ANIMATION_TIME,
+                    mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+                });
+
+                this._dragActor.get_transition('scale-x').connect('new-frame', () => {
+                    let currentScale = this._dragActor.scale_x / origScale;
+                    this._dragOffsetX = currentScale * origDragOffsetX - transX;
+                    this._dragOffsetY = currentScale * origDragOffsetY - transY;
+                    this._dragActor.set_position(
+                        this._dragX + this._dragOffsetX,
+                        this._dragY + this._dragOffsetY);
+                });
+            }
+        }
+    }
+
+    _maybeStartDrag(event) {
+        let [stageX, stageY] = event.get_coords();
+
+        // See if the user has moved the mouse enough to trigger a drag
+        let scaleFactor = St.ThemeContext.get_for_stage(global.stage).scale_factor;
+        let threshold = St.Settings.get().drag_threshold * scaleFactor;
+        if (!currentDraggable &&
+            (Math.abs(stageX - this._dragStartX) > threshold ||
+             Math.abs(stageY - this._dragStartY) > threshold)) {
+            this.startDrag(stageX, stageY, event.get_time(), this._touchSequence, event.get_device());
+            this._updateDragPosition(event);
+        }
+
+        return true;
+    }
+
+    _pickTargetActor() {
+        return this._dragActor.get_stage().get_actor_at_pos(Clutter.PickMode.ALL,
+                                                            this._dragX, this._dragY);
+    }
+
+    _updateDragHover() {
+        this._updateHoverId = 0;
+        let target = this._pickTargetActor();
+
+        let dragEvent = {
+            x: this._dragX,
+            y: this._dragY,
+            dragActor: this._dragActor,
+            source: this.actor._delegate,
+            targetActor: target,
+        };
+
+        let targetActorDestroyHandlerId;
+        let handleTargetActorDestroyClosure;
+        handleTargetActorDestroyClosure = () => {
+            target = this._pickTargetActor();
+            dragEvent.targetActor = target;
+            targetActorDestroyHandlerId =
+                target.connect('destroy', handleTargetActorDestroyClosure);
+        };
+        targetActorDestroyHandlerId =
+            target.connect('destroy', handleTargetActorDestroyClosure);
+
+        for (let i = 0; i < dragMonitors.length; i++) {
+            let motionFunc = dragMonitors[i].dragMotion;
+            if (motionFunc) {
+                let result = motionFunc(dragEvent);
+                if (result != DragMotionResult.CONTINUE) {
+                    global.display.set_cursor(DRAG_CURSOR_MAP[result]);
+                    return GLib.SOURCE_REMOVE;
+                }
+            }
+        }
+        dragEvent.targetActor.disconnect(targetActorDestroyHandlerId);
+
+        while (target) {
+            if (target._delegate && target._delegate.handleDragOver) {
+                let [r_, targX, targY] = target.transform_stage_point(this._dragX, this._dragY);
+                // We currently loop through all parents on drag-over even if one of the children has handled it.
+                // We can check the return value of the function and break the loop if it's true if we don't want
+                // to continue checking the parents.
+                let result = target._delegate.handleDragOver(this.actor._delegate,
+                                                             this._dragActor,
+                                                             targX,
+                                                             targY,
+                                                             0);
+                if (result != DragMotionResult.CONTINUE) {
+                    global.display.set_cursor(DRAG_CURSOR_MAP[result]);
+                    return GLib.SOURCE_REMOVE;
+                }
+            }
+            target = target.get_parent();
+        }
+        global.display.set_cursor(Meta.Cursor.DND_IN_DRAG);
+        return GLib.SOURCE_REMOVE;
+    }
+
+    _queueUpdateDragHover() {
+        if (this._updateHoverId)
+            return;
+
+        this._updateHoverId = GLib.idle_add(GLib.PRIORITY_DEFAULT,
+                                            this._updateDragHover.bind(this));
+        GLib.Source.set_name_by_id(this._updateHoverId, '[gnome-shell] this._updateDragHover');
+    }
+
+    _updateDragPosition(event) {
+        let [stageX, stageY] = event.get_coords();
+        this._dragX = stageX;
+        this._dragY = stageY;
+        this._dragActor.set_position(stageX + this._dragOffsetX,
+                                     stageY + this._dragOffsetY);
+
+        this._queueUpdateDragHover();
+        return true;
+    }
+
+    _dragActorDropped(event) {
+        let [dropX, dropY] = event.get_coords();
+        let target = this._dragActor.get_stage().get_actor_at_pos(Clutter.PickMode.ALL,
+                                                                  dropX, dropY);
+
+        // We call observers only once per motion with the innermost
+        // target actor. If necessary, the observer can walk the
+        // parent itself.
+        let dropEvent = {
+            dropActor: this._dragActor,
+            targetActor: target,
+            clutterEvent: event,
+        };
+        for (let i = 0; i < dragMonitors.length; i++) {
+            let dropFunc = dragMonitors[i].dragDrop;
+            if (dropFunc) {
+                switch (dropFunc(dropEvent)) {
+                case DragDropResult.FAILURE:
+                case DragDropResult.SUCCESS:
+                    return true;
+                case DragDropResult.CONTINUE:
+                    continue;
+                }
+            }
+        }
+
+        // At this point it is too late to cancel a drag by destroying
+        // the actor, the fate of which is decided by acceptDrop and its
+        // side-effects
+        this._dragCancellable = false;
+
+        while (target) {
+            if (target._delegate && target._delegate.acceptDrop) {
+                let [r_, targX, targY] = target.transform_stage_point(dropX, dropY);
+                let accepted = false;
+                try {
+                    accepted = target._delegate.acceptDrop(this.actor._delegate,
+                        this._dragActor, targX, targY, event.get_time());
+                } catch (e) {
+                    // On error, skip this target
+                    logError(e, "Skipping drag target");
+                }
+                if (accepted) {
+                    // If it accepted the drop without taking the actor,
+                    // handle it ourselves.
+                    if (this._dragActor && this._dragActor.get_parent() == Main.uiGroup) {
+                        if (this._restoreOnSuccess) {
+                            this._restoreDragActor(event.get_time());
+                            return true;
+                        } else {
+                            this._dragActor.destroy();
+                        }
+                    }
+
+                    this._dragState = DragState.INIT;
+                    global.display.set_cursor(Meta.Cursor.DEFAULT);
+                    this.emit('drag-end', event.get_time(), true);
+                    this._dragComplete();
+                    return true;
+                }
+            }
+            target = target.get_parent();
+        }
+
+        this._cancelDrag(event.get_time());
+
+        return true;
+    }
+
+    _getRestoreLocation() {
+        let x, y, scale;
+
+        if (this._dragActorSource && this._dragActorSource.visible) {
+            // Snap the clone back to its source
+            [x, y] = this._dragActorSource.get_transformed_position();
+            let [sourceScaledWidth] = this._dragActorSource.get_transformed_size();
+            scale = sourceScaledWidth ? sourceScaledWidth / this._dragActor.width : 0;
+        } else if (this._dragOrigParent) {
+            // Snap the actor back to its original position within
+            // its parent, adjusting for the fact that the parent
+            // may have been moved or scaled
+            let [parentX, parentY] = this._dragOrigParent.get_transformed_position();
+            let [parentWidth] = this._dragOrigParent.get_size();
+            let [parentScaledWidth] = this._dragOrigParent.get_transformed_size();
+            let parentScale = 1.0;
+            if (parentWidth != 0)
+                parentScale = parentScaledWidth / parentWidth;
+
+            x = parentX + parentScale * this._dragOrigX;
+            y = parentY + parentScale * this._dragOrigY;
+            scale = this._dragOrigScale * parentScale;
+        } else {
+            // Snap back actor to its original stage position
+            x = this._snapBackX;
+            y = this._snapBackY;
+            scale = this._snapBackScale;
+        }
+
+        return [x, y, scale];
+    }
+
+    _cancelDrag(eventTime) {
+        this.emit('drag-cancelled', eventTime);
+        let wasCancelled = this._dragState == DragState.CANCELLED;
+        this._dragState = DragState.CANCELLED;
+
+        if (this._actorDestroyed || wasCancelled) {
+            global.display.set_cursor(Meta.Cursor.DEFAULT);
+            if (!this._buttonDown)
+                this._dragComplete();
+            this.emit('drag-end', eventTime, false);
+            if (!this._dragOrigParent && this._dragActor)
+                this._dragActor.destroy();
+
+            return;
+        }
+
+        let [snapBackX, snapBackY, snapBackScale] = this._getRestoreLocation();
+
+        this._animateDragEnd(eventTime, {
+            x: snapBackX,
+            y: snapBackY,
+            scale_x: snapBackScale,
+            scale_y: snapBackScale,
+            duration: SNAP_BACK_ANIMATION_TIME,
+        });
+    }
+
+    _restoreDragActor(eventTime) {
+        this._dragState = DragState.INIT;
+        let [restoreX, restoreY, restoreScale] = this._getRestoreLocation();
+
+        // fade the actor back in at its original location
+        this._dragActor.set_position(restoreX, restoreY);
+        this._dragActor.set_scale(restoreScale, restoreScale);
+        this._dragActor.opacity = 0;
+
+        this._animateDragEnd(eventTime, {
+            duration: REVERT_ANIMATION_TIME,
+        });
+    }
+
+    _animateDragEnd(eventTime, params) {
+        this._animationInProgress = true;
+
+        // start the animation
+        this._dragActor.ease(Object.assign(params, {
+            opacity: this._dragOrigOpacity,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            onComplete: () => {
+                this._onAnimationComplete(this._dragActor, eventTime);
+            },
+        }));
+    }
+
+    _finishAnimation() {
+        if (!this._animationInProgress)
+            return;
+
+        this._animationInProgress = false;
+        if (!this._buttonDown)
+            this._dragComplete();
+
+        global.display.set_cursor(Meta.Cursor.DEFAULT);
+    }
+
+    _onAnimationComplete(dragActor, eventTime) {
+        if (this._dragOrigParent) {
+            Main.uiGroup.remove_child(this._dragActor);
+            this._dragOrigParent.add_actor(this._dragActor);
+            dragActor.set_scale(this._dragOrigScale, this._dragOrigScale);
+            dragActor.set_position(this._dragOrigX, this._dragOrigY);
+        } else {
+            dragActor.destroy();
+        }
+
+        this.emit('drag-end', eventTime, false);
+        this._finishAnimation();
+    }
+
+    _dragComplete() {
+        if (!this._actorDestroyed && this._dragActor)
+            Shell.util_set_hidden_from_pick(this._dragActor, false);
+
+        this._ungrabEvents();
+        global.sync_pointer();
+
+        if (this._updateHoverId) {
+            GLib.source_remove(this._updateHoverId);
+            this._updateHoverId = 0;
+        }
+
+        if (this._dragActor) {
+            this._dragActor.disconnect(this._dragActorDestroyId);
+            this._dragActor = null;
+        }
+
+        this._dragState = DragState.INIT;
+        currentDraggable = null;
+    }
+};
+Signals.addSignalMethods(_Draggable.prototype);
+
+/**
+ * makeDraggable:
+ * @param {Clutter.Actor} actor: Source actor
+ * @param {Object=} params: Additional parameters
+ * @returns {Object} a new Draggable
+ *
+ * Create an object which controls drag and drop for the given actor.
+ *
+ * If %manualMode is %true in @params, do not automatically start
+ * drag and drop on click
+ *
+ * If %dragActorMaxSize is present in @params, the drag actor will
+ * be scaled down to be no larger than that size in pixels.
+ *
+ * If %dragActorOpacity is present in @params, the drag actor will
+ * will be set to have that opacity during the drag.
+ *
+ * Note that when the drag actor is the source actor and the drop
+ * succeeds, the actor scale and opacity aren't reset; if the drop
+ * target wants to reuse the actor, it's up to the drop target to
+ * reset these values.
+ */
+function makeDraggable(actor, params) {
+    return new _Draggable(actor, params);
+}

js/ui/edgeDragAction.js

@@ -0,0 +1,77 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported EdgeDragAction */
+
+const { Clutter, GObject, Meta, St } = imports.gi;
+
+const Main = imports.ui.main;
+
+var EDGE_THRESHOLD = 20;
+var DRAG_DISTANCE = 80;
+
+var EdgeDragAction = GObject.registerClass({
+    Signals: { 'activated': {} },
+}, class EdgeDragAction extends Clutter.GestureAction {
+    _init(side, allowedModes) {
+        super._init();
+        this._side = side;
+        this._allowedModes = allowedModes;
+        this.set_n_touch_points(1);
+
+        global.display.connect('grab-op-begin', () => this.cancel());
+    }
+
+    _getMonitorRect(x, y) {
+        let rect = new Meta.Rectangle({ x: x - 1, y: y - 1, width: 1, height: 1 });
+        let monitorIndex = global.display.get_monitor_index_for_rect(rect);
+
+        return global.display.get_monitor_geometry(monitorIndex);
+    }
+
+    vfunc_gesture_prepare(_actor) {
+        if (this.get_n_current_points() == 0)
+            return false;
+
+        if (!(this._allowedModes & Main.actionMode))
+            return false;
+
+        let [x, y] = this.get_press_coords(0);
+        let monitorRect = this._getMonitorRect(x, y);
+
+        return (this._side == St.Side.LEFT && x < monitorRect.x + EDGE_THRESHOLD) ||
+                (this._side == St.Side.RIGHT && x > monitorRect.x + monitorRect.width - EDGE_THRESHOLD) ||
+                (this._side == St.Side.TOP && y < monitorRect.y + EDGE_THRESHOLD) ||
+                (this._side == St.Side.BOTTOM && y > monitorRect.y + monitorRect.height - EDGE_THRESHOLD);
+    }
+
+    vfunc_gesture_progress(_actor) {
+        let [startX, startY] = this.get_press_coords(0);
+        let [x, y] = this.get_motion_coords(0);
+        let offsetX = Math.abs(x - startX);
+        let offsetY = Math.abs(y - startY);
+
+        if (offsetX < EDGE_THRESHOLD && offsetY < EDGE_THRESHOLD)
+            return true;
+
+        if ((offsetX > offsetY &&
+             (this._side == St.Side.TOP || this._side == St.Side.BOTTOM)) ||
+            (offsetY > offsetX &&
+             (this._side == St.Side.LEFT || this._side == St.Side.RIGHT))) {
+            this.cancel();
+            return false;
+        }
+
+        return true;
+    }
+
+    vfunc_gesture_end(_actor) {
+        let [startX, startY] = this.get_press_coords(0);
+        let [x, y] = this.get_motion_coords(0);
+        let monitorRect = this._getMonitorRect(startX, startY);
+
+        if ((this._side == St.Side.TOP && y > monitorRect.y + DRAG_DISTANCE) ||
+            (this._side == St.Side.BOTTOM && y < monitorRect.y + monitorRect.height - DRAG_DISTANCE) ||
+            (this._side == St.Side.LEFT && x > monitorRect.x + DRAG_DISTANCE) ||
+            (this._side == St.Side.RIGHT && x < monitorRect.x + monitorRect.width - DRAG_DISTANCE))
+            this.emit('activated');
+    }
+});

js/ui/endSessionDialog.js

@@ -0,0 +1,686 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported init, EndSessionDialog */
+/*
+ * Copyright 2010-2016 Red Hat, Inc
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+const { AccountsService, Clutter, Gio,
+        GLib, GObject, Pango, Polkit, Shell, St }  = imports.gi;
+
+const CheckBox = imports.ui.checkBox;
+const Dialog = imports.ui.dialog;
+const GnomeSession = imports.misc.gnomeSession;
+const LoginManager = imports.misc.loginManager;
+const ModalDialog = imports.ui.modalDialog;
+const UserWidget = imports.ui.userWidget;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const _ITEM_ICON_SIZE = 64;
+
+const EndSessionDialogIface = loadInterfaceXML('org.gnome.SessionManager.EndSessionDialog');
+
+const logoutDialogContent = {
+    subjectWithUser: C_("title", "Log Out %s"),
+    subject: C_("title", "Log Out"),
+    descriptionWithUser(user, seconds) {
+        return ngettext("%s will be logged out automatically in %d second.",
+                        "%s will be logged out automatically in %d seconds.",
+                        seconds).format(user, seconds);
+    },
+    description(seconds) {
+        return ngettext("You will be logged out automatically in %d second.",
+                        "You will be logged out automatically in %d seconds.",
+                        seconds).format(seconds);
+    },
+    showBatteryWarning: false,
+    confirmButtons: [{ signal: 'ConfirmedLogout',
+                       label: C_("button", "Log Out") }],
+    showOtherSessions: false,
+};
+
+const shutdownDialogContent = {
+    subject: C_("title", "Power Off"),
+    subjectWithUpdates: C_("title", "Install Updates & Power Off"),
+    description(seconds) {
+        return ngettext("The system will power off automatically in %d second.",
+                        "The system will power off automatically in %d seconds.",
+                        seconds).format(seconds);
+    },
+    checkBoxText: C_("checkbox", "Install pending software updates"),
+    showBatteryWarning: true,
+    confirmButtons: [{ signal: 'ConfirmedReboot',
+                       label: C_("button", "Restart") },
+                     { signal: 'ConfirmedShutdown',
+                       label: C_("button", "Power Off") }],
+    iconName: 'system-shutdown-symbolic',
+    showOtherSessions: true,
+};
+
+const restartDialogContent = {
+    subject: C_("title", "Restart"),
+    description(seconds) {
+        return ngettext("The system will restart automatically in %d second.",
+                        "The system will restart automatically in %d seconds.",
+                        seconds).format(seconds);
+    },
+    showBatteryWarning: false,
+    confirmButtons: [{ signal: 'ConfirmedReboot',
+                       label: C_("button", "Restart") }],
+    iconName: 'view-refresh-symbolic',
+    showOtherSessions: true,
+};
+
+const restartUpdateDialogContent = {
+
+    subject: C_("title", "Restart & Install Updates"),
+    description(seconds) {
+        return ngettext("The system will automatically restart and install updates in %d second.",
+                        "The system will automatically restart and install updates in %d seconds.",
+                        seconds).format(seconds);
+    },
+    showBatteryWarning: true,
+    confirmButtons: [{ signal: 'ConfirmedReboot',
+                       label: C_("button", "Restart &amp; Install") }],
+    unusedFutureButtonForTranslation: C_("button", "Install &amp; Power Off"),
+    unusedFutureCheckBoxForTranslation: C_("checkbox", "Power off after updates are installed"),
+    iconName: 'view-refresh-symbolic',
+    showOtherSessions: true,
+};
+
+const restartUpgradeDialogContent = {
+
+    subject: C_("title", "Restart & Install Upgrade"),
+    upgradeDescription(distroName, distroVersion) {
+        /* Translators: This is the text displayed for system upgrades in the
+           shut down dialog. First %s gets replaced with the distro name and
+           second %s with the distro version to upgrade to */
+        return _("%s %s will be installed after restart. Upgrade installation can take a long time: ensure that you have backed up and that the computer is plugged in.").format(distroName, distroVersion);
+    },
+    disableTimer: true,
+    showBatteryWarning: false,
+    confirmButtons: [{ signal: 'ConfirmedReboot',
+                       label: C_("button", "Restart &amp; Install") }],
+    iconName: 'view-refresh-symbolic',
+    showOtherSessions: true,
+};
+
+const DialogType = {
+    LOGOUT: 0 /* GSM_SHELL_END_SESSION_DIALOG_TYPE_LOGOUT */,
+    SHUTDOWN: 1 /* GSM_SHELL_END_SESSION_DIALOG_TYPE_SHUTDOWN */,
+    RESTART: 2 /* GSM_SHELL_END_SESSION_DIALOG_TYPE_RESTART */,
+    UPDATE_RESTART: 3,
+    UPGRADE_RESTART: 4,
+};
+
+const DialogContent = {
+    0 /* DialogType.LOGOUT */: logoutDialogContent,
+    1 /* DialogType.SHUTDOWN */: shutdownDialogContent,
+    2 /* DialogType.RESTART */: restartDialogContent,
+    3 /* DialogType.UPDATE_RESTART */: restartUpdateDialogContent,
+    4 /* DialogType.UPGRADE_RESTART */: restartUpgradeDialogContent,
+};
+
+var MAX_USERS_IN_SESSION_DIALOG = 5;
+
+const LogindSessionIface = loadInterfaceXML('org.freedesktop.login1.Session');
+const LogindSession = Gio.DBusProxy.makeProxyWrapper(LogindSessionIface);
+
+const PkOfflineIface = loadInterfaceXML('org.freedesktop.PackageKit.Offline');
+const PkOfflineProxy = Gio.DBusProxy.makeProxyWrapper(PkOfflineIface);
+
+const UPowerIface = loadInterfaceXML('org.freedesktop.UPower');
+const UPowerProxy = Gio.DBusProxy.makeProxyWrapper(UPowerIface);
+
+function findAppFromInhibitor(inhibitor) {
+    let desktopFile;
+    try {
+        [desktopFile] = inhibitor.GetAppIdSync();
+    } catch (e) {
+        // XXX -- sometimes JIT inhibitors generated by gnome-session
+        // get removed too soon. Don't fail in this case.
+        log('gnome-session gave us a dead inhibitor: %s'.format(inhibitor.get_object_path()));
+        return null;
+    }
+
+    if (!GLib.str_has_suffix(desktopFile, '.desktop'))
+        desktopFile += '.desktop';
+
+    return Shell.AppSystem.get_default().lookup_heuristic_basename(desktopFile);
+}
+
+// The logout timer only shows updates every 10 seconds
+// until the last 10 seconds, then it shows updates every
+// second.  This function takes a given time and returns
+// what we should show to the user for that time.
+function _roundSecondsToInterval(totalSeconds, secondsLeft, interval) {
+    let time;
+
+    time = Math.ceil(secondsLeft);
+
+    // Final count down is in decrements of 1
+    if (time <= interval)
+        return time;
+
+    // Round up higher than last displayable time interval
+    time += interval - 1;
+
+    // Then round down to that time interval
+    if (time > totalSeconds)
+        time = Math.ceil(totalSeconds);
+    else
+        time -= time % interval;
+
+    return time;
+}
+
+function _setCheckBoxLabel(checkBox, text) {
+    let label = checkBox.getLabelActor();
+
+    if (text) {
+        label.set_text(text);
+        checkBox.show();
+    } else {
+        label.set_text('');
+        checkBox.hide();
+    }
+}
+
+function init() {
+    // This always returns the same singleton object
+    // By instantiating it initially, we register the
+    // bus object, etc.
+    new EndSessionDialog();
+}
+
+var EndSessionDialog = GObject.registerClass(
+class EndSessionDialog extends ModalDialog.ModalDialog {
+    _init() {
+        super._init({ styleClass: 'end-session-dialog',
+                      destroyOnClose: false });
+
+        this._loginManager = LoginManager.getLoginManager();
+        this._userManager = AccountsService.UserManager.get_default();
+        this._user = this._userManager.get_user(GLib.get_user_name());
+        this._updatesPermission = null;
+
+        this._pkOfflineProxy = new PkOfflineProxy(Gio.DBus.system,
+                                                  'org.freedesktop.PackageKit',
+                                                  '/org/freedesktop/PackageKit',
+                                                  this._onPkOfflineProxyCreated.bind(this));
+
+        this._powerProxy = new UPowerProxy(Gio.DBus.system,
+                                           'org.freedesktop.UPower',
+                                           '/org/freedesktop/UPower',
+                                           (proxy, error) => {
+                                               if (error) {
+                                                   log(error.message);
+                                                   return;
+                                               }
+                                               this._powerProxy.connect('g-properties-changed',
+                                                                        this._sync.bind(this));
+                                               this._sync();
+                                           });
+
+        this._secondsLeft = 0;
+        this._totalSecondsToStayOpen = 0;
+        this._applications = [];
+        this._sessions = [];
+
+        this.connect('destroy',
+                     this._onDestroy.bind(this));
+        this.connect('opened',
+                     this._onOpened.bind(this));
+
+        this._userLoadedId = this._user.connect('notify::is-loaded', this._sync.bind(this));
+        this._userChangedId = this._user.connect('changed', this._sync.bind(this));
+
+        this._messageDialogContent = new Dialog.MessageDialogContent();
+
+        this._checkBox = new CheckBox.CheckBox();
+        this._checkBox.connect('clicked', this._sync.bind(this));
+        this._messageDialogContent.add_child(this._checkBox);
+
+        this._batteryWarning = new St.Label({
+            style_class: 'end-session-dialog-battery-warning',
+            text: _('Running on battery power: Please plug in before installing updates.'),
+        });
+        this._batteryWarning.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+        this._batteryWarning.clutter_text.line_wrap = true;
+        this._messageDialogContent.add_child(this._batteryWarning);
+
+        this.contentLayout.add_child(this._messageDialogContent);
+
+        this._applicationSection = new Dialog.ListSection({
+            title: _('Some applications are busy or have unsaved work'),
+        });
+        this.contentLayout.add_child(this._applicationSection);
+
+        this._sessionSection = new Dialog.ListSection({
+            title: _('Other users are logged in'),
+        });
+        this.contentLayout.add_child(this._sessionSection);
+
+        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(EndSessionDialogIface, this);
+        this._dbusImpl.export(Gio.DBus.session, '/org/gnome/SessionManager/EndSessionDialog');
+    }
+
+    _onPkOfflineProxyCreated(proxy, error) {
+        if (error) {
+            log(error.message);
+            return;
+        }
+
+        // Creating a D-Bus proxy won't propagate SERVICE_UNKNOWN or NAME_HAS_NO_OWNER
+        // errors if PackageKit is not available, but the GIO implementation will make
+        // sure in that case that the proxy's g-name-owner is set to null, so check that.
+        if (this._pkOfflineProxy.g_name_owner === null) {
+            this._pkOfflineProxy = null;
+            return;
+        }
+
+        // It only makes sense to check for this permission if PackageKit is available.
+        Polkit.Permission.new(
+            'org.freedesktop.packagekit.trigger-offline-update', null, null,
+            (source, res) => {
+                try {
+                    this._updatesPermission = Polkit.Permission.new_finish(res);
+                } catch (e) {
+                    log('No permission to trigger offline updates: %s'.format(e.toString()));
+                }
+            });
+    }
+
+    _onDestroy() {
+        this._user.disconnect(this._userLoadedId);
+        this._user.disconnect(this._userChangedId);
+    }
+
+    _sync() {
+        let open = this.state == ModalDialog.State.OPENING || this.state == ModalDialog.State.OPENED;
+        if (!open)
+            return;
+
+        let dialogContent = DialogContent[this._type];
+
+        let subject = dialogContent.subject;
+
+        // Use different title when we are installing updates
+        if (dialogContent.subjectWithUpdates && this._checkBox.checked)
+            subject = dialogContent.subjectWithUpdates;
+
+        if (dialogContent.showBatteryWarning) {
+            this._batteryWarning.visible =
+                this._powerProxy.OnBattery && this._checkBox.checked;
+        }
+
+        let description;
+        let displayTime = _roundSecondsToInterval(this._totalSecondsToStayOpen,
+                                                  this._secondsLeft,
+                                                  10);
+
+        if (this._user.is_loaded) {
+            let realName = this._user.get_real_name();
+
+            if (realName != null) {
+                if (dialogContent.subjectWithUser)
+                    subject = dialogContent.subjectWithUser.format(realName);
+
+                if (dialogContent.descriptionWithUser)
+                    description = dialogContent.descriptionWithUser(realName, displayTime);
+            }
+        }
+
+        // Use a different description when we are installing a system upgrade
+        // if the PackageKit proxy is available (i.e. PackageKit is available).
+        if (this._pkOfflineProxy && dialogContent.upgradeDescription) {
+            let name = this._pkOfflineProxy.PreparedUpgrade['name'].deep_unpack();
+            let version = this._pkOfflineProxy.PreparedUpgrade['version'].deep_unpack();
+
+            if (name != null && version != null)
+                description = dialogContent.upgradeDescription(name, version);
+        }
+
+        // Fall back to regular description
+        if (!description)
+            description = dialogContent.description(displayTime);
+
+        this._messageDialogContent.title = subject;
+        this._messageDialogContent.description = description;
+
+        let hasApplications = this._applications.length > 0;
+        let hasSessions = this._sessions.length > 0;
+
+        this._applicationSection.visible = hasApplications;
+        this._sessionSection.visible = hasSessions;
+    }
+
+    _updateButtons() {
+        let dialogContent = DialogContent[this._type];
+        let buttons = [{ action: this.cancel.bind(this),
+                         label: _("Cancel"),
+                         key: Clutter.KEY_Escape }];
+
+        for (let i = 0; i < dialogContent.confirmButtons.length; i++) {
+            let signal = dialogContent.confirmButtons[i].signal;
+            let label = dialogContent.confirmButtons[i].label;
+            buttons.push({
+                action: () => {
+                    this.close(true);
+                    let signalId = this.connect('closed', () => {
+                        this.disconnect(signalId);
+                        this._confirm(signal);
+                    });
+                },
+                label,
+            });
+        }
+
+        this.setButtons(buttons);
+    }
+
+    close(skipSignal) {
+        super.close();
+
+        if (!skipSignal)
+            this._dbusImpl.emit_signal('Closed', null);
+    }
+
+    cancel() {
+        this._stopTimer();
+        this._dbusImpl.emit_signal('Canceled', null);
+        this.close();
+    }
+
+    _confirm(signal) {
+        let callback = () => {
+            this._fadeOutDialog();
+            this._stopTimer();
+            this._dbusImpl.emit_signal(signal, null);
+        };
+
+        // Offline update not available; just emit the signal
+        if (!this._checkBox.visible) {
+            callback();
+            return;
+        }
+
+        // Trigger the offline update as requested
+        if (this._checkBox.checked) {
+            switch (signal) {
+            case "ConfirmedReboot":
+                this._triggerOfflineUpdateReboot(callback);
+                break;
+            case "ConfirmedShutdown":
+                // To actually trigger the offline update, we need to
+                // reboot to do the upgrade. When the upgrade is complete,
+                // the computer will shut down automatically.
+                signal = "ConfirmedReboot";
+                this._triggerOfflineUpdateShutdown(callback);
+                break;
+            default:
+                callback();
+                break;
+            }
+        } else {
+            this._triggerOfflineUpdateCancel(callback);
+        }
+    }
+
+    _onOpened() {
+        this._sync();
+    }
+
+    _triggerOfflineUpdateReboot(callback) {
+        // Handle this gracefully if PackageKit is not available.
+        if (!this._pkOfflineProxy) {
+            callback();
+            return;
+        }
+
+        this._pkOfflineProxy.TriggerRemote('reboot', (result, error) => {
+            if (error)
+                log(error.message);
+
+            callback();
+        });
+    }
+
+    _triggerOfflineUpdateShutdown(callback) {
+        // Handle this gracefully if PackageKit is not available.
+        if (!this._pkOfflineProxy) {
+            callback();
+            return;
+        }
+
+        this._pkOfflineProxy.TriggerRemote('power-off', (result, error) => {
+            if (error)
+                log(error.message);
+
+            callback();
+        });
+    }
+
+    _triggerOfflineUpdateCancel(callback) {
+        // Handle this gracefully if PackageKit is not available.
+        if (!this._pkOfflineProxy) {
+            callback();
+            return;
+        }
+
+        this._pkOfflineProxy.CancelRemote((result, error) => {
+            if (error)
+                log(error.message);
+
+            callback();
+        });
+    }
+
+    _startTimer() {
+        let startTime = GLib.get_monotonic_time();
+        this._secondsLeft = this._totalSecondsToStayOpen;
+
+        this._timerId = GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, 1, () => {
+            let currentTime = GLib.get_monotonic_time();
+            let secondsElapsed = (currentTime - startTime) / 1000000;
+
+            this._secondsLeft = this._totalSecondsToStayOpen - secondsElapsed;
+            if (this._secondsLeft > 0) {
+                this._sync();
+                return GLib.SOURCE_CONTINUE;
+            }
+
+            let dialogContent = DialogContent[this._type];
+            let button = dialogContent.confirmButtons[dialogContent.confirmButtons.length - 1];
+            this._confirm(button.signal);
+            this._timerId = 0;
+
+            return GLib.SOURCE_REMOVE;
+        });
+        GLib.Source.set_name_by_id(this._timerId, '[gnome-shell] this._confirm');
+    }
+
+    _stopTimer() {
+        if (this._timerId > 0) {
+            GLib.source_remove(this._timerId);
+            this._timerId = 0;
+        }
+
+        this._secondsLeft = 0;
+    }
+
+    _onInhibitorLoaded(inhibitor) {
+        if (!this._applications.includes(inhibitor)) {
+            // Stale inhibitor
+            return;
+        }
+
+        let app = findAppFromInhibitor(inhibitor);
+
+        if (app) {
+            let [description] = inhibitor.GetReasonSync();
+            let listItem = new Dialog.ListSectionItem({
+                icon_actor: app.create_icon_texture(_ITEM_ICON_SIZE),
+                title: app.get_name(),
+                description,
+            });
+            this._applicationSection.list.add_child(listItem);
+        } else {
+            // inhibiting app is a service, not an application
+            this._applications.splice(this._applications.indexOf(inhibitor), 1);
+        }
+
+        this._sync();
+    }
+
+    _loadSessions() {
+        this._loginManager.listSessions(result => {
+            let n = 0;
+            for (let i = 0; i < result.length; i++) {
+                let [id_, uid_, userName, seat_, sessionPath] = result[i];
+                let proxy = new LogindSession(Gio.DBus.system, 'org.freedesktop.login1', sessionPath);
+
+                if (proxy.Class != 'user')
+                    continue;
+
+                if (proxy.State == 'closing')
+                    continue;
+
+                let sessionId = GLib.getenv('XDG_SESSION_ID');
+                if (!sessionId) {
+                    this._loginManager.getCurrentSessionProxy(currentSessionProxy => {
+                        sessionId = currentSessionProxy.Id;
+                        log('endSessionDialog: No XDG_SESSION_ID, fetched from logind: %d'.format(sessionId));
+                    });
+                }
+
+                if (proxy.Id == sessionId)
+                    continue;
+
+                let session = { user: this._userManager.get_user(userName),
+                                username: userName,
+                                type: proxy.Type,
+                                remote: proxy.Remote };
+                this._sessions.push(session);
+
+                let userAvatar = new UserWidget.Avatar(session.user, { iconSize: _ITEM_ICON_SIZE });
+                userAvatar.update();
+
+                userName = session.user.get_real_name()
+                    ? session.user.get_real_name() : session.username;
+
+                let userLabelText;
+                if (session.remote)
+                    /* Translators: Remote here refers to a remote session, like a ssh login */
+                    userLabelText = _('%s (remote)').format(userName);
+                else if (session.type === 'tty')
+                    /* Translators: Console here refers to a tty like a VT console */
+                    userLabelText = _('%s (console)').format(userName);
+                else
+                    userLabelText = userName;
+
+                let listItem = new Dialog.ListSectionItem({
+                    icon_actor: userAvatar,
+                    title: userLabelText,
+                });
+                this._sessionSection.list.add_child(listItem);
+
+                // limit the number of entries
+                n++;
+                if (n == MAX_USERS_IN_SESSION_DIALOG)
+                    break;
+            }
+
+            this._sync();
+        });
+    }
+
+    OpenAsync(parameters, invocation) {
+        let [type, timestamp, totalSecondsToStayOpen, inhibitorObjectPaths] = parameters;
+        this._totalSecondsToStayOpen = totalSecondsToStayOpen;
+        this._type = type;
+
+        // Only consider updates and upgrades if PackageKit is available.
+        if (this._pkOfflineProxy && this._type == DialogType.RESTART) {
+            if (this._pkOfflineProxy.UpdateTriggered)
+                this._type = DialogType.UPDATE_RESTART;
+            else if (this._pkOfflineProxy.UpgradeTriggered)
+                this._type = DialogType.UPGRADE_RESTART;
+        }
+
+        this._applications = [];
+        this._applicationSection.list.destroy_all_children();
+
+        this._sessions = [];
+        this._sessionSection.list.destroy_all_children();
+
+        if (!(this._type in DialogContent)) {
+            invocation.return_dbus_error('org.gnome.Shell.ModalDialog.TypeError',
+                                         "Unknown dialog type requested");
+            return;
+        }
+
+        let dialogContent = DialogContent[this._type];
+
+        for (let i = 0; i < inhibitorObjectPaths.length; i++) {
+            let inhibitor = new GnomeSession.Inhibitor(inhibitorObjectPaths[i], proxy => {
+                this._onInhibitorLoaded(proxy);
+            });
+
+            this._applications.push(inhibitor);
+        }
+
+        if (dialogContent.showOtherSessions)
+            this._loadSessions();
+
+        // Only consider updates and upgrades if PackageKit is available.
+        let updateTriggered = this._pkOfflineProxy ? this._pkOfflineProxy.UpdateTriggered : false;
+        let updatePrepared = this._pkOfflineProxy ? this._pkOfflineProxy.UpdatePrepared : false;
+        let updatesAllowed = this._updatesPermission && this._updatesPermission.allowed;
+
+        _setCheckBoxLabel(this._checkBox, dialogContent.checkBoxText || '');
+        this._checkBox.visible = dialogContent.checkBoxText && updatePrepared && updatesAllowed;
+        this._checkBox.checked = updatePrepared && updateTriggered;
+
+        // We show the warning either together with the checkbox, or when
+        // updates have already been triggered, but the user doesn't have
+        // enough permissions to cancel them.
+        this._batteryWarning.visible = dialogContent.showBatteryWarning &&
+                                        (this._checkBox.visible || updatePrepared && updateTriggered && !updatesAllowed);
+
+        this._updateButtons();
+
+        if (!this.open(timestamp)) {
+            invocation.return_dbus_error('org.gnome.Shell.ModalDialog.GrabError',
+                                         "Cannot grab pointer and keyboard");
+            return;
+        }
+
+        if (!dialogContent.disableTimer)
+            this._startTimer();
+
+        this._sync();
+
+        let signalId = this.connect('opened', () => {
+            invocation.return_value(null);
+            this.disconnect(signalId);
+        });
+    }
+
+    Close(_parameters, _invocation) {
+        this.close();
+    }
+});

js/ui/environment.js

@@ -0,0 +1,359 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported init */
+
+const Config = imports.misc.config;
+
+imports.gi.versions.Clutter = Config.LIBMUTTER_API_VERSION;
+imports.gi.versions.Gio = '2.0';
+imports.gi.versions.GdkPixbuf = '2.0';
+imports.gi.versions.Gtk = '3.0';
+imports.gi.versions.TelepathyGLib = '0.12';
+imports.gi.versions.TelepathyLogger = '0.2';
+
+const { Clutter, GLib, GObject, Meta, Shell, St } = imports.gi;
+const Gettext = imports.gettext;
+const System = imports.system;
+
+let _localTimeZone = null;
+
+// We can't import shell JS modules yet, because they may have
+// variable initializations, etc, that depend on init() already having
+// been run.
+
+
+// "monkey patch" in some varargs ClutterContainer methods; we need
+// to do this per-container class since there is no representation
+// of interfaces in Javascript
+function _patchContainerClass(containerClass) {
+    // This one is a straightforward mapping of the C method
+    containerClass.prototype.child_set = function (actor, props) {
+        let meta = this.get_child_meta(actor);
+        for (let prop in props)
+            meta[prop] = props[prop];
+    };
+
+    // clutter_container_add() actually is a an add-many-actors
+    // method. We conveniently, but somewhat dubiously, take the
+    // this opportunity to make it do something more useful.
+    containerClass.prototype.add = function (actor, props) {
+        this.add_actor(actor);
+        if (props)
+            this.child_set(actor, props);
+    };
+}
+
+function _patchLayoutClass(layoutClass, styleProps) {
+    if (styleProps) {
+        layoutClass.prototype.hookup_style = function (container) {
+            container.connect('style-changed', () => {
+                let node = container.get_theme_node();
+                for (let prop in styleProps) {
+                    let [found, length] = node.lookup_length(styleProps[prop], false);
+                    if (found)
+                        this[prop] = length;
+                }
+            });
+        };
+    }
+}
+
+function _makeEaseCallback(params, cleanup) {
+    let onComplete = params.onComplete;
+    delete params.onComplete;
+
+    let onStopped = params.onStopped;
+    delete params.onStopped;
+
+    return isFinished => {
+        cleanup();
+
+        if (onStopped)
+            onStopped(isFinished);
+        if (onComplete && isFinished)
+            onComplete();
+    };
+}
+
+function _getPropertyTarget(actor, propName) {
+    if (!propName.startsWith('@'))
+        return [actor, propName];
+
+    let [type, name, prop] = propName.split('.');
+    switch (type) {
+    case '@layout':
+        return [actor.layout_manager, name];
+    case '@actions':
+        return [actor.get_action(name), prop];
+    case '@constraints':
+        return [actor.get_constraint(name), prop];
+    case '@effects':
+        return [actor.get_effect(name), prop];
+    }
+
+    throw new Error(`Invalid property name ${propName}`);
+}
+
+function _easeActor(actor, params) {
+    actor.save_easing_state();
+
+    if (params.duration != undefined)
+        actor.set_easing_duration(params.duration);
+    delete params.duration;
+
+    if (params.delay != undefined)
+        actor.set_easing_delay(params.delay);
+    delete params.delay;
+
+    let repeatCount = 0;
+    if (params.repeatCount != undefined)
+        repeatCount = params.repeatCount;
+    delete params.repeatCount;
+
+    let autoReverse = false;
+    if (params.autoReverse != undefined)
+        autoReverse = params.autoReverse;
+    delete params.autoReverse;
+
+    // repeatCount doesn't include the initial iteration
+    const numIterations = repeatCount + 1;
+    // whether the transition should finish where it started
+    const isReversed = autoReverse && numIterations % 2 === 0;
+
+    if (params.mode != undefined)
+        actor.set_easing_mode(params.mode);
+    delete params.mode;
+
+    let cleanup = () => Meta.enable_unredirect_for_display(global.display);
+    let callback = _makeEaseCallback(params, cleanup);
+
+    // cancel overwritten transitions
+    let animatedProps = Object.keys(params).map(p => p.replace('_', '-', 'g'));
+    animatedProps.forEach(p => actor.remove_transition(p));
+
+    if (actor.get_easing_duration() > 0 || !isReversed)
+        actor.set(params);
+    actor.restore_easing_state();
+
+    let transition = animatedProps.map(p => actor.get_transition(p))
+        .find(t => t !== null);
+
+    if (transition && transition.delay)
+        transition.connect('started', () => Meta.disable_unredirect_for_display(global.display));
+    else
+        Meta.disable_unredirect_for_display(global.display);
+
+    if (transition) {
+        transition.set({ repeatCount, autoReverse });
+        transition.connect('stopped', (t, finished) => callback(finished));
+    } else {
+        callback(true);
+    }
+}
+
+function _easeActorProperty(actor, propName, target, params) {
+    // Avoid pointless difference with ease()
+    if (params.mode)
+        params.progress_mode = params.mode;
+    delete params.mode;
+
+    if (params.duration)
+        params.duration = adjustAnimationTime(params.duration);
+    let duration = Math.floor(params.duration || 0);
+
+    let repeatCount = 0;
+    if (params.repeatCount != undefined)
+        repeatCount = params.repeatCount;
+    delete params.repeatCount;
+
+    let autoReverse = false;
+    if (params.autoReverse != undefined)
+        autoReverse = params.autoReverse;
+    delete params.autoReverse;
+
+    // repeatCount doesn't include the initial iteration
+    const numIterations = repeatCount + 1;
+    // whether the transition should finish where it started
+    const isReversed = autoReverse && numIterations % 2 === 0;
+
+    // Copy Clutter's behavior for implicit animations, see
+    // should_skip_implicit_transition()
+    if (actor instanceof Clutter.Actor && !actor.mapped)
+        duration = 0;
+
+    let cleanup = () => Meta.enable_unredirect_for_display(global.display);
+    let callback = _makeEaseCallback(params, cleanup);
+
+    // cancel overwritten transition
+    actor.remove_transition(propName);
+
+    if (duration == 0) {
+        let [obj, prop] = _getPropertyTarget(actor, propName);
+
+        if (!isReversed)
+            obj[prop] = target;
+
+        Meta.disable_unredirect_for_display(global.display);
+        callback(true);
+
+        return;
+    }
+
+    let pspec = actor.find_property(propName);
+    let transition = new Clutter.PropertyTransition(Object.assign({
+        property_name: propName,
+        interval: new Clutter.Interval({ value_type: pspec.value_type }),
+        remove_on_complete: true,
+        repeat_count: repeatCount,
+        auto_reverse: autoReverse,
+    }, params));
+    actor.add_transition(propName, transition);
+
+    transition.set_to(target);
+
+    if (transition.delay)
+        transition.connect('started', () => Meta.disable_unredirect_for_display(global.display));
+    else
+        Meta.disable_unredirect_for_display(global.display);
+
+    transition.connect('stopped', (t, finished) => callback(finished));
+}
+
+function _loggingFunc(...args) {
+    let fields = { 'MESSAGE': args.join(', ') };
+    let domain = "GNOME Shell";
+
+    // If the caller is an extension, add it as metadata
+    let extension = imports.misc.extensionUtils.getCurrentExtension();
+    if (extension != null) {
+        domain = extension.metadata.name;
+        fields['GNOME_SHELL_EXTENSION_UUID'] = extension.uuid;
+        fields['GNOME_SHELL_EXTENSION_NAME'] = extension.metadata.name;
+    }
+
+    GLib.log_structured(domain, GLib.LogLevelFlags.LEVEL_MESSAGE, fields);
+}
+
+function init() {
+    // Add some bindings to the global JS namespace; (gjs keeps the web
+    // browser convention of having that namespace be called 'window'.)
+    window.global = Shell.Global.get();
+
+    window.log = _loggingFunc;
+
+    window._ = Gettext.gettext;
+    window.C_ = Gettext.pgettext;
+    window.ngettext = Gettext.ngettext;
+    window.N_ = s => s;
+
+    GObject.gtypeNameBasedOnJSPath = true;
+
+    // Miscellaneous monkeypatching
+    _patchContainerClass(St.BoxLayout);
+
+    _patchLayoutClass(Clutter.GridLayout, { row_spacing: 'spacing-rows',
+                                            column_spacing: 'spacing-columns' });
+    _patchLayoutClass(Clutter.BoxLayout, { spacing: 'spacing' });
+
+    let origSetEasingDuration = Clutter.Actor.prototype.set_easing_duration;
+    Clutter.Actor.prototype.set_easing_duration = function (msecs) {
+        origSetEasingDuration.call(this, adjustAnimationTime(msecs));
+    };
+    let origSetEasingDelay = Clutter.Actor.prototype.set_easing_delay;
+    Clutter.Actor.prototype.set_easing_delay = function (msecs) {
+        origSetEasingDelay.call(this, adjustAnimationTime(msecs));
+    };
+
+    Clutter.Actor.prototype.ease = function (props) {
+        _easeActor(this, props);
+    };
+    Clutter.Actor.prototype.ease_property = function (propName, target, params) {
+        _easeActorProperty(this, propName, target, params);
+    };
+    St.Adjustment.prototype.ease = function (target, params) {
+        // we're not an actor of course, but we implement the same
+        // transition API as Clutter.Actor, so this works anyway
+        _easeActorProperty(this, 'value', target, params);
+    };
+
+    Clutter.Actor.prototype.toString = function () {
+        return St.describe_actor(this);
+    };
+    // Deprecation warning for former JS classes turned into an actor subclass
+    Object.defineProperty(Clutter.Actor.prototype, 'actor', {
+        get() {
+            let klass = this.constructor.name;
+            let { stack } = new Error();
+            log(`Usage of object.actor is deprecated for ${klass}\n${stack}`);
+            return this;
+        },
+    });
+
+    St.set_slow_down_factor = function (factor) {
+        let { stack } = new Error();
+        log(`St.set_slow_down_factor() is deprecated, use St.Settings.slow_down_factor\n${stack}`);
+        St.Settings.get().slow_down_factor = factor;
+    };
+
+    let origToString = Object.prototype.toString;
+    Object.prototype.toString = function () {
+        let base = origToString.call(this);
+        try {
+            if ('actor' in this && this.actor instanceof Clutter.Actor)
+                return base.replace(/\]$/, ` delegate for ${this.actor.toString().substring(1)}`);
+            else
+                return base;
+        } catch (e) {
+            return base;
+        }
+    };
+
+    // Override to clear our own timezone cache as well
+    const origClearDateCaches = System.clearDateCaches;
+    System.clearDateCaches = function () {
+        _localTimeZone = null;
+        origClearDateCaches();
+    };
+
+    // Work around https://bugzilla.mozilla.org/show_bug.cgi?id=508783
+    Date.prototype.toLocaleFormat = function (format) {
+        if (_localTimeZone === null)
+            _localTimeZone = GLib.TimeZone.new_local();
+
+        let dt = GLib.DateTime.new(_localTimeZone,
+            this.getYear(),
+            this.getMonth() + 1,
+            this.getDate(),
+            this.getHours(),
+            this.getMinutes(),
+            this.getSeconds());
+        return dt ? dt.format(format) : '';
+    };
+
+    let slowdownEnv = GLib.getenv('GNOME_SHELL_SLOWDOWN_FACTOR');
+    if (slowdownEnv) {
+        let factor = parseFloat(slowdownEnv);
+        if (!isNaN(factor) && factor > 0.0)
+            St.Settings.get().slow_down_factor = factor;
+    }
+
+    // OK, now things are initialized enough that we can import shell JS
+    const Format = imports.format;
+    const Tweener = imports.ui.tweener;
+
+    Tweener.init();
+    String.prototype.format = Format.format;
+}
+
+// adjustAnimationTime:
+// @msecs: time in milliseconds
+//
+// Adjust @msecs to account for St's enable-animations
+// and slow-down-factor settings
+function adjustAnimationTime(msecs) {
+    let settings = St.Settings.get();
+
+    if (!settings.enable_animations)
+        return 1;
+    return settings.slow_down_factor * msecs;
+}
+

js/ui/extensionDownloader.js

@@ -0,0 +1,230 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported init, installExtension, uninstallExtension, checkForUpdates */
+
+const { Clutter, Gio, GLib, GObject, Soup } = imports.gi;
+
+const Config = imports.misc.config;
+const Dialog = imports.ui.dialog;
+const ExtensionUtils = imports.misc.extensionUtils;
+const FileUtils = imports.misc.fileUtils;
+const Main = imports.ui.main;
+const ModalDialog = imports.ui.modalDialog;
+
+var REPOSITORY_URL_DOWNLOAD = 'https://extensions.gnome.org/download-extension/%s.shell-extension.zip';
+var REPOSITORY_URL_INFO     = 'https://extensions.gnome.org/extension-info/';
+var REPOSITORY_URL_UPDATE   = 'https://extensions.gnome.org/update-info/';
+
+let _httpSession;
+
+function installExtension(uuid, invocation) {
+    let params = { uuid,
+                   shell_version: Config.PACKAGE_VERSION };
+
+    let message = Soup.form_request_new_from_hash('GET', REPOSITORY_URL_INFO, params);
+
+    _httpSession.queue_message(message, () => {
+        if (message.status_code != Soup.KnownStatusCode.OK) {
+            Main.extensionManager.logExtensionError(uuid, 'downloading info: %d'.format(message.status_code));
+            invocation.return_dbus_error('org.gnome.Shell.DownloadInfoError', message.status_code.toString());
+            return;
+        }
+
+        let info;
+        try {
+            info = JSON.parse(message.response_body.data);
+        } catch (e) {
+            Main.extensionManager.logExtensionError(uuid, 'parsing info: %s'.format(e.toString()));
+            invocation.return_dbus_error('org.gnome.Shell.ParseInfoError', e.toString());
+            return;
+        }
+
+        let dialog = new InstallExtensionDialog(uuid, info, invocation);
+        dialog.open(global.get_current_time());
+    });
+}
+
+function uninstallExtension(uuid) {
+    let extension = Main.extensionManager.lookup(uuid);
+    if (!extension)
+        return false;
+
+    // Don't try to uninstall system extensions
+    if (extension.type != ExtensionUtils.ExtensionType.PER_USER)
+        return false;
+
+    if (!Main.extensionManager.unloadExtension(extension))
+        return false;
+
+    FileUtils.recursivelyDeleteDir(extension.dir, true);
+    return true;
+}
+
+function gotExtensionZipFile(session, message, uuid, dir, callback, errback) {
+    if (message.status_code != Soup.KnownStatusCode.OK) {
+        errback('DownloadExtensionError', message.status_code);
+        return;
+    }
+
+    try {
+        if (!dir.query_exists(null))
+            dir.make_directory_with_parents(null);
+    } catch (e) {
+        errback('CreateExtensionDirectoryError', e);
+        return;
+    }
+
+    let [file, stream] = Gio.File.new_tmp('XXXXXX.shell-extension.zip');
+    let contents = message.response_body.flatten().get_as_bytes();
+    stream.output_stream.write_bytes(contents, null);
+    stream.close(null);
+    let [success, pid] = GLib.spawn_async(null,
+                                          ['unzip', '-uod', dir.get_path(), '--', file.get_path()],
+                                          null,
+                                          GLib.SpawnFlags.SEARCH_PATH | GLib.SpawnFlags.DO_NOT_REAP_CHILD,
+                                          null);
+
+    if (!success) {
+        errback('ExtractExtensionError');
+        return;
+    }
+
+    GLib.child_watch_add(GLib.PRIORITY_DEFAULT, pid, (o, status) => {
+        GLib.spawn_close_pid(pid);
+
+        if (status != 0)
+            errback('ExtractExtensionError');
+        else
+            callback();
+    });
+}
+
+function downloadExtensionUpdate(uuid) {
+    let dir = Gio.File.new_for_path(
+        GLib.build_filenamev([global.userdatadir, 'extension-updates', uuid]));
+
+    let params = { shell_version: Config.PACKAGE_VERSION };
+
+    let url = REPOSITORY_URL_DOWNLOAD.format(uuid);
+    let message = Soup.form_request_new_from_hash('GET', url, params);
+
+    _httpSession.queue_message(message, session => {
+        gotExtensionZipFile(session, message, uuid, dir, () => {
+            Main.extensionManager.notifyExtensionUpdate(uuid);
+        }, (code, msg) => {
+            log('Error while downloading update for extension %s: %s (%s)'.format(uuid, code, msg));
+        });
+    });
+}
+
+function checkForUpdates() {
+    let metadatas = {};
+    Main.extensionManager.getUuids().forEach(uuid => {
+        let extension = Main.extensionManager.lookup(uuid);
+        if (extension.type !== ExtensionUtils.ExtensionType.PER_USER)
+            return;
+        if (extension.hasUpdate)
+            return;
+        metadatas[uuid] = extension.metadata;
+    });
+
+    let versionCheck = global.settings.get_boolean(
+        'disable-extension-version-validation');
+    let params = {
+        shell_version: Config.PACKAGE_VERSION,
+        installed: JSON.stringify(metadatas),
+        disable_version_validation: versionCheck.toString(),
+    };
+
+    let url = REPOSITORY_URL_UPDATE;
+    let message = Soup.form_request_new_from_hash('GET', url, params);
+    _httpSession.queue_message(message, () => {
+        if (message.status_code != Soup.KnownStatusCode.OK)
+            return;
+
+        let operations = JSON.parse(message.response_body.data);
+        for (let uuid in operations) {
+            let operation = operations[uuid];
+            if (operation == 'blacklist')
+                uninstallExtension(uuid);
+            else if (operation == 'upgrade' || operation == 'downgrade')
+                downloadExtensionUpdate(uuid);
+        }
+    });
+}
+
+var InstallExtensionDialog = GObject.registerClass(
+class InstallExtensionDialog extends ModalDialog.ModalDialog {
+    _init(uuid, info, invocation) {
+        super._init({ styleClass: 'extension-dialog' });
+
+        this._uuid = uuid;
+        this._info = info;
+        this._invocation = invocation;
+
+        this.setButtons([{
+            label: _("Cancel"),
+            action: this._onCancelButtonPressed.bind(this),
+            key: Clutter.KEY_Escape,
+        }, {
+            label: _("Install"),
+            action: this._onInstallButtonPressed.bind(this),
+            default: true,
+        }]);
+
+        let content = new Dialog.MessageDialogContent({
+            title: _('Install Extension'),
+            description: _('Download and install “%s” from extensions.gnome.org?').format(info.name),
+        });
+
+        this.contentLayout.add(content);
+    }
+
+    _onCancelButtonPressed() {
+        this.close();
+        this._invocation.return_value(GLib.Variant.new('(s)', ['cancelled']));
+    }
+
+    _onInstallButtonPressed() {
+        let params = { shell_version: Config.PACKAGE_VERSION };
+
+        let url = REPOSITORY_URL_DOWNLOAD.format(this._uuid);
+        let message = Soup.form_request_new_from_hash('GET', url, params);
+
+        let uuid = this._uuid;
+        let dir = Gio.File.new_for_path(GLib.build_filenamev([global.userdatadir, 'extensions', uuid]));
+        let invocation = this._invocation;
+        function errback(code, msg) {
+            log('Error while installing %s: %s (%s)'.format(uuid, code, msg));
+            invocation.return_dbus_error('org.gnome.Shell.%s'.format(code), msg || '');
+        }
+
+        function callback() {
+            try {
+                let extension = Main.extensionManager.createExtensionObject(uuid, dir, ExtensionUtils.ExtensionType.PER_USER);
+                Main.extensionManager.loadExtension(extension);
+                if (!Main.extensionManager.enableExtension(uuid))
+                    throw new Error('Cannot add %s to enabled extensions gsettings key'.format(uuid));
+            } catch (e) {
+                uninstallExtension(uuid);
+                errback('LoadExtensionError', e);
+                return;
+            }
+
+            invocation.return_value(GLib.Variant.new('(s)', ['successful']));
+        }
+
+        _httpSession.queue_message(message, session => {
+            gotExtensionZipFile(session, message, uuid, dir, callback, errback);
+        });
+
+        this.close();
+    }
+});
+
+function init() {
+    _httpSession = new Soup.SessionAsync({ ssl_use_system_ca_file: true });
+
+    // See: https://bugzilla.gnome.org/show_bug.cgi?id=655189 for context.
+    // _httpSession.add_feature(new Soup.ProxyResolverDefault());
+    Soup.Session.prototype.add_feature.call(_httpSession, new Soup.ProxyResolverDefault());
+}

js/ui/extensionSystem.js

@@ -0,0 +1,606 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported init connect disconnect */
+
+const { GLib, Gio, GObject, Shell, St } = imports.gi;
+const Signals = imports.signals;
+
+const ExtensionDownloader = imports.ui.extensionDownloader;
+const ExtensionUtils = imports.misc.extensionUtils;
+const FileUtils = imports.misc.fileUtils;
+const Main = imports.ui.main;
+const MessageTray = imports.ui.messageTray;
+
+const { ExtensionState, ExtensionType } = ExtensionUtils;
+
+const ENABLED_EXTENSIONS_KEY = 'enabled-extensions';
+const DISABLED_EXTENSIONS_KEY = 'disabled-extensions';
+const DISABLE_USER_EXTENSIONS_KEY = 'disable-user-extensions';
+const EXTENSION_DISABLE_VERSION_CHECK_KEY = 'disable-extension-version-validation';
+
+const UPDATE_CHECK_TIMEOUT = 24 * 60 * 60; // 1 day in seconds
+
+var ExtensionManager = class {
+    constructor() {
+        this._initialized = false;
+        this._enabled = false;
+        this._updateNotified = false;
+
+        this._extensions = new Map();
+        this._enabledExtensions = [];
+        this._extensionOrder = [];
+
+        Main.sessionMode.connect('updated', this._sessionUpdated.bind(this));
+    }
+
+    init() {
+        // The following file should exist for a period of time when extensions
+        // are enabled after start. If it exists, then the systemd unit will
+        // disable extensions should gnome-shell crash.
+        // Should the file already exist from a previous login, then this is OK.
+        let disableFilename = GLib.build_filenamev([GLib.get_user_runtime_dir(), 'gnome-shell-disable-extensions']);
+        let disableFile = Gio.File.new_for_path(disableFilename);
+        try {
+            disableFile.create(Gio.FileCreateFlags.REPLACE_DESTINATION, null);
+        } catch (e) {
+            log('Failed to create file %s: %s'.format(disableFilename, e.message));
+        }
+
+        GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, 60, () => {
+            disableFile.delete(null);
+            return GLib.SOURCE_REMOVE;
+        });
+
+        this._installExtensionUpdates();
+        this._sessionUpdated();
+
+        GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, UPDATE_CHECK_TIMEOUT, () => {
+            ExtensionDownloader.checkForUpdates();
+            return GLib.SOURCE_CONTINUE;
+        });
+        ExtensionDownloader.checkForUpdates();
+    }
+
+    lookup(uuid) {
+        return this._extensions.get(uuid);
+    }
+
+    getUuids() {
+        return [...this._extensions.keys()];
+    }
+
+    _callExtensionDisable(uuid) {
+        let extension = this.lookup(uuid);
+        if (!extension)
+            return;
+
+        if (extension.state != ExtensionState.ENABLED)
+            return;
+
+        // "Rebase" the extension order by disabling and then enabling extensions
+        // in order to help prevent conflicts.
+
+        // Example:
+        //   order = [A, B, C, D, E]
+        //   user disables C
+        //   this should: disable E, disable D, disable C, enable D, enable E
+
+        let orderIdx = this._extensionOrder.indexOf(uuid);
+        let order = this._extensionOrder.slice(orderIdx + 1);
+        let orderReversed = order.slice().reverse();
+
+        for (let i = 0; i < orderReversed.length; i++) {
+            let otherUuid = orderReversed[i];
+            try {
+                this.lookup(otherUuid).stateObj.disable();
+            } catch (e) {
+                this.logExtensionError(otherUuid, e);
+            }
+        }
+
+        if (extension.stylesheet) {
+            let theme = St.ThemeContext.get_for_stage(global.stage).get_theme();
+            theme.unload_stylesheet(extension.stylesheet);
+            delete extension.stylesheet;
+        }
+
+        try {
+            extension.stateObj.disable();
+        } catch (e) {
+            this.logExtensionError(uuid, e);
+        }
+
+        for (let i = 0; i < order.length; i++) {
+            let otherUuid = order[i];
+            try {
+                this.lookup(otherUuid).stateObj.enable();
+            } catch (e) {
+                this.logExtensionError(otherUuid, e);
+            }
+        }
+
+        this._extensionOrder.splice(orderIdx, 1);
+
+        if (extension.state != ExtensionState.ERROR) {
+            extension.state = ExtensionState.DISABLED;
+            this.emit('extension-state-changed', extension);
+        }
+    }
+
+    _callExtensionEnable(uuid) {
+        if (!Main.sessionMode.allowExtensions)
+            return;
+
+        let extension = this.lookup(uuid);
+        if (!extension)
+            return;
+
+        if (extension.state == ExtensionState.INITIALIZED)
+            this._callExtensionInit(uuid);
+
+        if (extension.state != ExtensionState.DISABLED)
+            return;
+
+        let stylesheetNames = ['%s.css'.format(global.session_mode), 'stylesheet.css'];
+        let theme = St.ThemeContext.get_for_stage(global.stage).get_theme();
+        for (let i = 0; i < stylesheetNames.length; i++) {
+            try {
+                let stylesheetFile = extension.dir.get_child(stylesheetNames[i]);
+                theme.load_stylesheet(stylesheetFile);
+                extension.stylesheet = stylesheetFile;
+                break;
+            } catch (e) {
+                if (e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.NOT_FOUND))
+                    continue; // not an error
+                this.logExtensionError(uuid, e);
+                return;
+            }
+        }
+
+        try {
+            extension.stateObj.enable();
+            extension.state = ExtensionState.ENABLED;
+            this._extensionOrder.push(uuid);
+            this.emit('extension-state-changed', extension);
+        } catch (e) {
+            if (extension.stylesheet) {
+                theme.unload_stylesheet(extension.stylesheet);
+                delete extension.stylesheet;
+            }
+            this.logExtensionError(uuid, e);
+        }
+    }
+
+    enableExtension(uuid) {
+        if (!this._extensions.has(uuid))
+            return false;
+
+        let enabledExtensions = global.settings.get_strv(ENABLED_EXTENSIONS_KEY);
+        let disabledExtensions = global.settings.get_strv(DISABLED_EXTENSIONS_KEY);
+
+        if (disabledExtensions.includes(uuid)) {
+            disabledExtensions = disabledExtensions.filter(item => item !== uuid);
+            global.settings.set_strv(DISABLED_EXTENSIONS_KEY, disabledExtensions);
+        }
+
+        if (!enabledExtensions.includes(uuid)) {
+            enabledExtensions.push(uuid);
+            global.settings.set_strv(ENABLED_EXTENSIONS_KEY, enabledExtensions);
+        }
+
+        return true;
+    }
+
+    disableExtension(uuid) {
+        if (!this._extensions.has(uuid))
+            return false;
+
+        let enabledExtensions = global.settings.get_strv(ENABLED_EXTENSIONS_KEY);
+        let disabledExtensions = global.settings.get_strv(DISABLED_EXTENSIONS_KEY);
+
+        if (enabledExtensions.includes(uuid)) {
+            enabledExtensions = enabledExtensions.filter(item => item !== uuid);
+            global.settings.set_strv(ENABLED_EXTENSIONS_KEY, enabledExtensions);
+        }
+
+        if (!disabledExtensions.includes(uuid)) {
+            disabledExtensions.push(uuid);
+            global.settings.set_strv(DISABLED_EXTENSIONS_KEY, disabledExtensions);
+        }
+
+        return true;
+    }
+
+    notifyExtensionUpdate(uuid) {
+        let extension = this.lookup(uuid);
+        if (!extension)
+            return;
+
+        extension.hasUpdate = true;
+        this.emit('extension-state-changed', extension);
+
+        if (!this._updateNotified) {
+            this._updateNotified = true;
+
+            let source = new ExtensionUpdateSource();
+            Main.messageTray.add(source);
+
+            let notification = new MessageTray.Notification(source,
+                _('Extension Updates Available'),
+                _('Extension updates are ready to be installed.'));
+            source.showNotification(notification);
+        }
+    }
+
+    logExtensionError(uuid, error) {
+        let extension = this.lookup(uuid);
+        if (!extension)
+            return;
+
+        let message = error.toString();
+
+        extension.error = message;
+        extension.state = ExtensionState.ERROR;
+        if (!extension.errors)
+            extension.errors = [];
+        extension.errors.push(message);
+
+        logError(error, 'Extension %s'.format(uuid));
+        this.emit('extension-state-changed', extension);
+    }
+
+    createExtensionObject(uuid, dir, type) {
+        let metadataFile = dir.get_child('metadata.json');
+        if (!metadataFile.query_exists(null))
+            throw new Error('Missing metadata.json');
+
+        let metadataContents, success_;
+        try {
+            [success_, metadataContents] = metadataFile.load_contents(null);
+            if (metadataContents instanceof Uint8Array)
+                metadataContents = imports.byteArray.toString(metadataContents);
+        } catch (e) {
+            throw new Error('Failed to load metadata.json: %s'.format(e.toString()));
+        }
+        let meta;
+        try {
+            meta = JSON.parse(metadataContents);
+        } catch (e) {
+            throw new Error('Failed to parse metadata.json: %s'.format(e.toString()));
+        }
+
+        let requiredProperties = ['uuid', 'name', 'description', 'shell-version'];
+        for (let i = 0; i < requiredProperties.length; i++) {
+            let prop = requiredProperties[i];
+            if (!meta[prop])
+                throw new Error('missing "%s" property in metadata.json'.format(prop));
+        }
+
+        if (uuid != meta.uuid)
+            throw new Error('uuid "%s" from metadata.json does not match directory name "%s"'.format(meta.uuid, uuid));
+
+        let extension = {
+            metadata: meta,
+            uuid: meta.uuid,
+            type,
+            dir,
+            path: dir.get_path(),
+            error: '',
+            hasPrefs: dir.get_child('prefs.js').query_exists(null),
+            hasUpdate: false,
+            canChange: false,
+        };
+        this._extensions.set(uuid, extension);
+
+        return extension;
+    }
+
+    loadExtension(extension) {
+        // Default to error, we set success as the last step
+        extension.state = ExtensionState.ERROR;
+
+        let checkVersion = !global.settings.get_boolean(EXTENSION_DISABLE_VERSION_CHECK_KEY);
+
+        if (checkVersion && ExtensionUtils.isOutOfDate(extension)) {
+            extension.state = ExtensionState.OUT_OF_DATE;
+        } else {
+            let enabled = this._enabledExtensions.includes(extension.uuid);
+            if (enabled) {
+                if (!this._callExtensionInit(extension.uuid))
+                    return;
+                if (extension.state == ExtensionState.DISABLED)
+                    this._callExtensionEnable(extension.uuid);
+            } else {
+                extension.state = ExtensionState.INITIALIZED;
+            }
+        }
+
+        this._updateCanChange(extension);
+        this.emit('extension-state-changed', extension);
+    }
+
+    unloadExtension(extension) {
+        // Try to disable it -- if it's ERROR'd, we can't guarantee that,
+        // but it will be removed on next reboot, and hopefully nothing
+        // broke too much.
+        this._callExtensionDisable(extension.uuid);
+
+        extension.state = ExtensionState.UNINSTALLED;
+        this.emit('extension-state-changed', extension);
+
+        this._extensions.delete(extension.uuid);
+        return true;
+    }
+
+    reloadExtension(oldExtension) {
+        // Grab the things we'll need to pass to createExtensionObject
+        // to reload it.
+        let { uuid, dir, type } = oldExtension;
+
+        // Then unload the old extension.
+        this.unloadExtension(oldExtension);
+
+        // Now, recreate the extension and load it.
+        let newExtension;
+        try {
+            newExtension = this.createExtensionObject(uuid, dir, type);
+        } catch (e) {
+            this.logExtensionError(uuid, e);
+            return;
+        }
+
+        this.loadExtension(newExtension);
+    }
+
+    _callExtensionInit(uuid) {
+        if (!Main.sessionMode.allowExtensions)
+            return false;
+
+        let extension = this.lookup(uuid);
+        if (!extension)
+            throw new Error("Extension was not properly created. Call createExtensionObject first");
+
+        let dir = extension.dir;
+        let extensionJs = dir.get_child('extension.js');
+        if (!extensionJs.query_exists(null)) {
+            this.logExtensionError(uuid, new Error('Missing extension.js'));
+            return false;
+        }
+
+        let extensionModule;
+        let extensionState = null;
+
+        ExtensionUtils.installImporter(extension);
+        try {
+            extensionModule = extension.imports.extension;
+        } catch (e) {
+            this.logExtensionError(uuid, e);
+            return false;
+        }
+
+        if (extensionModule.init) {
+            try {
+                extensionState = extensionModule.init(extension);
+            } catch (e) {
+                this.logExtensionError(uuid, e);
+                return false;
+            }
+        }
+
+        if (!extensionState)
+            extensionState = extensionModule;
+        extension.stateObj = extensionState;
+
+        extension.state = ExtensionState.DISABLED;
+        this.emit('extension-loaded', uuid);
+        return true;
+    }
+
+    _getModeExtensions() {
+        if (Array.isArray(Main.sessionMode.enabledExtensions))
+            return Main.sessionMode.enabledExtensions;
+        return [];
+    }
+
+    _updateCanChange(extension) {
+        let hasError =
+            extension.state == ExtensionState.ERROR ||
+            extension.state == ExtensionState.OUT_OF_DATE;
+
+        let isMode = this._getModeExtensions().includes(extension.uuid);
+        let modeOnly = global.settings.get_boolean(DISABLE_USER_EXTENSIONS_KEY);
+
+        let changeKey = isMode
+            ? DISABLE_USER_EXTENSIONS_KEY
+            : ENABLED_EXTENSIONS_KEY;
+
+        extension.canChange =
+            !hasError &&
+            global.settings.is_writable(changeKey) &&
+            (isMode || !modeOnly);
+    }
+
+    _getEnabledExtensions() {
+        let extensions = this._getModeExtensions();
+
+        if (!global.settings.get_boolean(DISABLE_USER_EXTENSIONS_KEY))
+            extensions = extensions.concat(global.settings.get_strv(ENABLED_EXTENSIONS_KEY));
+
+        // filter out 'disabled-extensions' which takes precedence
+        let disabledExtensions = global.settings.get_strv(DISABLED_EXTENSIONS_KEY);
+        return extensions.filter(item => !disabledExtensions.includes(item));
+    }
+
+    _onUserExtensionsEnabledChanged() {
+        this._onEnabledExtensionsChanged();
+        this._onSettingsWritableChanged();
+    }
+
+    _onEnabledExtensionsChanged() {
+        let newEnabledExtensions = this._getEnabledExtensions();
+
+        // Find and enable all the newly enabled extensions: UUIDs found in the
+        // new setting, but not in the old one.
+        newEnabledExtensions.filter(
+            uuid => !this._enabledExtensions.includes(uuid)
+        ).forEach(uuid => {
+            this._callExtensionEnable(uuid);
+        });
+
+        // Find and disable all the newly disabled extensions: UUIDs found in the
+        // old setting, but not in the new one.
+        this._extensionOrder.filter(
+            uuid => !newEnabledExtensions.includes(uuid)
+        ).reverse().forEach(uuid => {
+            this._callExtensionDisable(uuid);
+        });
+
+        this._enabledExtensions = newEnabledExtensions;
+    }
+
+    _onSettingsWritableChanged() {
+        for (let extension of this._extensions.values()) {
+            this._updateCanChange(extension);
+            this.emit('extension-state-changed', extension);
+        }
+    }
+
+    _onVersionValidationChanged() {
+        // Disabling extensions modifies the order array, so use a copy
+        let extensionOrder = this._extensionOrder.slice();
+
+        // Disable enabled extensions in the reverse order first to avoid
+        // the "rebasing" done in _callExtensionDisable...
+        extensionOrder.slice().reverse().forEach(uuid => {
+            this._callExtensionDisable(uuid);
+        });
+
+        // ...and then reload and enable extensions in the correct order again.
+        [...this._extensions.values()].sort((a, b) => {
+            return extensionOrder.indexOf(a.uuid) - extensionOrder.indexOf(b.uuid);
+        }).forEach(extension => this.reloadExtension(extension));
+    }
+
+    _installExtensionUpdates() {
+        FileUtils.collectFromDatadirs('extension-updates', true, (dir, info) => {
+            let fileType = info.get_file_type();
+            if (fileType !== Gio.FileType.DIRECTORY)
+                return;
+            let uuid = info.get_name();
+            let extensionDir = Gio.File.new_for_path(
+                GLib.build_filenamev([global.userdatadir, 'extensions', uuid]));
+
+            FileUtils.recursivelyDeleteDir(extensionDir, false);
+            FileUtils.recursivelyMoveDir(dir, extensionDir);
+            FileUtils.recursivelyDeleteDir(dir, true);
+        });
+    }
+
+    _loadExtensions() {
+        global.settings.connect('changed::%s'.format(ENABLED_EXTENSIONS_KEY),
+            this._onEnabledExtensionsChanged.bind(this));
+        global.settings.connect('changed::%s'.format(DISABLED_EXTENSIONS_KEY),
+            this._onEnabledExtensionsChanged.bind(this));
+        global.settings.connect('changed::%s'.format(DISABLE_USER_EXTENSIONS_KEY),
+            this._onUserExtensionsEnabledChanged.bind(this));
+        global.settings.connect('changed::%s'.format(EXTENSION_DISABLE_VERSION_CHECK_KEY),
+            this._onVersionValidationChanged.bind(this));
+        global.settings.connect('writable-changed::%s'.format(ENABLED_EXTENSIONS_KEY),
+            this._onSettingsWritableChanged.bind(this));
+        global.settings.connect('writable-changed::%s'.format(DISABLED_EXTENSIONS_KEY),
+            this._onSettingsWritableChanged.bind(this));
+
+        this._enabledExtensions = this._getEnabledExtensions();
+
+        let perUserDir = Gio.File.new_for_path(global.userdatadir);
+        FileUtils.collectFromDatadirs('extensions', true, (dir, info) => {
+            let fileType = info.get_file_type();
+            if (fileType != Gio.FileType.DIRECTORY)
+                return;
+            let uuid = info.get_name();
+            let existing = this.lookup(uuid);
+            if (existing) {
+                log('Extension %s already installed in %s. %s will not be loaded'.format(uuid, existing.path, dir.get_path()));
+                return;
+            }
+
+            let extension;
+            let type = dir.has_prefix(perUserDir)
+                ? ExtensionType.PER_USER
+                : ExtensionType.SYSTEM;
+            try {
+                extension = this.createExtensionObject(uuid, dir, type);
+            } catch (e) {
+                logError(e, 'Could not load extension %s'.format(uuid));
+                return;
+            }
+            this.loadExtension(extension);
+        });
+    }
+
+    _enableAllExtensions() {
+        if (this._enabled)
+            return;
+
+        if (!this._initialized) {
+            this._loadExtensions();
+            this._initialized = true;
+        } else {
+            this._enabledExtensions.forEach(uuid => {
+                this._callExtensionEnable(uuid);
+            });
+        }
+        this._enabled = true;
+    }
+
+    _disableAllExtensions() {
+        if (!this._enabled)
+            return;
+
+        if (this._initialized) {
+            this._extensionOrder.slice().reverse().forEach(uuid => {
+                this._callExtensionDisable(uuid);
+            });
+        }
+
+        this._enabled = false;
+    }
+
+    _sessionUpdated() {
+        // For now sessionMode.allowExtensions controls extensions from both the
+        // 'enabled-extensions' preference and the sessionMode.enabledExtensions
+        // property; it might make sense to make enabledExtensions independent
+        // from allowExtensions in the future
+        if (Main.sessionMode.allowExtensions) {
+            // Take care of added or removed sessionMode extensions
+            this._onEnabledExtensionsChanged();
+            this._enableAllExtensions();
+        } else {
+            this._disableAllExtensions();
+        }
+    }
+};
+Signals.addSignalMethods(ExtensionManager.prototype);
+
+const ExtensionUpdateSource = GObject.registerClass(
+class ExtensionUpdateSource extends MessageTray.Source {
+    _init() {
+        let appSys = Shell.AppSystem.get_default();
+        this._app = appSys.lookup_app('org.gnome.Extensions.desktop');
+
+        super._init(this._app.get_name());
+    }
+
+    getIcon() {
+        return this._app.app_info.get_icon();
+    }
+
+    _createPolicy() {
+        return new MessageTray.NotificationApplicationPolicy(this._app.id);
+    }
+
+    open() {
+        this._app.activate();
+        Main.overview.hide();
+        Main.panel.closeCalendar();
+    }
+});

js/ui/focusCaretTracker.js

@@ -0,0 +1,89 @@
+/** -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2012 Inclusive Design Research Centre, OCAD University.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author:
+ *   Joseph Scheuhammer <clown@alum.mit.edu>
+ * Contributor:
+ *   Magdalen Berns <m.berns@sms.ed.ac.uk>
+ */
+
+const Atspi = imports.gi.Atspi;
+const Signals = imports.signals;
+
+const CARETMOVED        = 'object:text-caret-moved';
+const STATECHANGED      = 'object:state-changed';
+
+var FocusCaretTracker = class FocusCaretTracker {
+    constructor() {
+        this._atspiListener = Atspi.EventListener.new(this._onChanged.bind(this));
+
+        this._atspiInited = false;
+        this._focusListenerRegistered = false;
+        this._caretListenerRegistered = false;
+    }
+
+    _onChanged(event) {
+        if (event.type.indexOf(STATECHANGED) == 0)
+            this.emit('focus-changed', event);
+        else if (event.type == CARETMOVED)
+            this.emit('caret-moved', event);
+    }
+
+    _initAtspi() {
+        if (!this._atspiInited && Atspi.init() == 0) {
+            Atspi.set_timeout(250, 250);
+            this._atspiInited = true;
+        }
+
+        return this._atspiInited;
+    }
+
+    registerFocusListener() {
+        if (!this._initAtspi() || this._focusListenerRegistered)
+            return;
+
+        this._atspiListener.register(`${STATECHANGED}:focused`);
+        this._atspiListener.register(`${STATECHANGED}:selected`);
+        this._focusListenerRegistered = true;
+    }
+
+    registerCaretListener() {
+        if (!this._initAtspi() || this._caretListenerRegistered)
+            return;
+
+        this._atspiListener.register(CARETMOVED);
+        this._caretListenerRegistered = true;
+    }
+
+    deregisterFocusListener() {
+        if (!this._focusListenerRegistered)
+            return;
+
+        this._atspiListener.deregister(`${STATECHANGED}:focused`);
+        this._atspiListener.deregister(`${STATECHANGED}:selected`);
+        this._focusListenerRegistered = false;
+    }
+
+    deregisterCaretListener() {
+        if (!this._caretListenerRegistered)
+            return;
+
+        this._atspiListener.deregister(CARETMOVED);
+        this._caretListenerRegistered = false;
+    }
+};
+Signals.addSignalMethods(FocusCaretTracker.prototype);

js/ui/grabHelper.js

@@ -0,0 +1,332 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported GrabHelper */
+
+const { Clutter, St } = imports.gi;
+
+const Main = imports.ui.main;
+const Params = imports.misc.params;
+
+let _capturedEventId = 0;
+let _grabHelperStack = [];
+function _onCapturedEvent(actor, event) {
+    let grabHelper = _grabHelperStack[_grabHelperStack.length - 1];
+    return grabHelper.onCapturedEvent(event);
+}
+
+function _pushGrabHelper(grabHelper) {
+    _grabHelperStack.push(grabHelper);
+
+    if (_capturedEventId == 0)
+        _capturedEventId = global.stage.connect('captured-event', _onCapturedEvent);
+}
+
+function _popGrabHelper(grabHelper) {
+    let poppedHelper = _grabHelperStack.pop();
+    if (poppedHelper != grabHelper)
+        throw new Error("incorrect grab helper pop");
+
+    if (_grabHelperStack.length == 0) {
+        global.stage.disconnect(_capturedEventId);
+        _capturedEventId = 0;
+    }
+}
+
+// GrabHelper:
+// @owner: the actor that owns the GrabHelper
+// @params: optional parameters to pass to Main.pushModal()
+//
+// Creates a new GrabHelper object, for dealing with keyboard and pointer grabs
+// associated with a set of actors.
+//
+// Note that the grab can be automatically dropped at any time by the user, and
+// your code just needs to deal with it; you shouldn't adjust behavior directly
+// after you call ungrab(), but instead pass an 'onUngrab' callback when you
+// call grab().
+var GrabHelper = class GrabHelper {
+    constructor(owner, params) {
+        if (!(owner instanceof Clutter.Actor))
+            throw new Error('GrabHelper owner must be a Clutter.Actor');
+
+        this._owner = owner;
+        this._modalParams = params;
+
+        this._grabStack = [];
+
+        this._actors = [];
+        this._ignoreUntilRelease = false;
+
+        this._modalCount = 0;
+    }
+
+    // addActor:
+    // @actor: an actor
+    //
+    // Adds @actor to the set of actors that are allowed to process events
+    // during a grab.
+    addActor(actor) {
+        actor.__grabHelperDestroyId = actor.connect('destroy', () => {
+            this.removeActor(actor);
+        });
+        this._actors.push(actor);
+    }
+
+    // removeActor:
+    // @actor: an actor
+    //
+    // Removes @actor from the set of actors that are allowed to
+    // process events during a grab.
+    removeActor(actor) {
+        let index = this._actors.indexOf(actor);
+        if (index != -1)
+            this._actors.splice(index, 1);
+        if (actor.__grabHelperDestroyId) {
+            actor.disconnect(actor.__grabHelperDestroyId);
+            delete actor.__grabHelperDestroyId;
+        }
+    }
+
+    _isWithinGrabbedActor(actor) {
+        let currentActor = this.currentGrab.actor;
+        while (actor) {
+            if (this._actors.includes(actor))
+                return true;
+            if (actor == currentActor)
+                return true;
+            actor = actor.get_parent();
+        }
+        return false;
+    }
+
+    get currentGrab() {
+        return this._grabStack[this._grabStack.length - 1] || {};
+    }
+
+    get grabbed() {
+        return this._grabStack.length > 0;
+    }
+
+    get grabStack() {
+        return this._grabStack;
+    }
+
+    _findStackIndex(actor) {
+        if (!actor)
+            return -1;
+
+        for (let i = 0; i < this._grabStack.length; i++) {
+            if (this._grabStack[i].actor === actor)
+                return i;
+        }
+        return -1;
+    }
+
+    _actorInGrabStack(actor) {
+        while (actor) {
+            let idx = this._findStackIndex(actor);
+            if (idx >= 0)
+                return idx;
+            actor = actor.get_parent();
+        }
+        return -1;
+    }
+
+    isActorGrabbed(actor) {
+        return this._findStackIndex(actor) >= 0;
+    }
+
+    // grab:
+    // @params: A bunch of parameters, see below
+    //
+    // The general effect of a "grab" is to ensure that the passed in actor
+    // and all actors inside the grab get exclusive control of the mouse and
+    // keyboard, with the grab automatically being dropped if the user tries
+    // to dismiss it. The actor is passed in through @params.actor.
+    //
+    // grab() can be called multiple times, with the scope of the grab being
+    // changed to a different actor every time. A nested grab does not have
+    // to have its grabbed actor inside the parent grab actors.
+    //
+    // Grabs can be automatically dropped if the user tries to dismiss it
+    // in one of two ways: the user clicking outside the currently grabbed
+    // actor, or the user typing the Escape key.
+    //
+    // If the user clicks outside the grabbed actors, and the clicked on
+    // actor is part of a previous grab in the stack, grabs will be popped
+    // until that grab is active. However, the click event will not be
+    // replayed to the actor.
+    //
+    // If the user types the Escape key, one grab from the grab stack will
+    // be popped.
+    //
+    // When a grab is popped by user interacting as described above, if you
+    // pass a callback as @params.onUngrab, it will be called with %true.
+    //
+    // If @params.focus is not null, we'll set the key focus directly
+    // to that actor instead of navigating in @params.actor. This is for
+    // use cases like menus, where we want to grab the menu actor, but keep
+    // focus on the clicked on menu item.
+    grab(params) {
+        params = Params.parse(params, { actor: null,
+                                        focus: null,
+                                        onUngrab: null });
+
+        let focus = global.stage.key_focus;
+        let hadFocus = focus && this._isWithinGrabbedActor(focus);
+        let newFocus = params.actor;
+
+        if (this.isActorGrabbed(params.actor))
+            return true;
+
+        params.savedFocus = focus;
+
+        if (!this._takeModalGrab())
+            return false;
+
+        this._grabStack.push(params);
+
+        if (params.focus) {
+            params.focus.grab_key_focus();
+        } else if (newFocus && hadFocus) {
+            if (!newFocus.navigate_focus(null, St.DirectionType.TAB_FORWARD, false))
+                newFocus.grab_key_focus();
+        }
+
+        return true;
+    }
+
+    grabAsync(params) {
+        return new Promise((resolve, reject) => {
+            params.onUngrab = resolve;
+
+            if (!this.grab(params))
+                reject(new Error('Grab failed'));
+        });
+    }
+
+    _takeModalGrab() {
+        let firstGrab = this._modalCount == 0;
+        if (firstGrab) {
+            if (!Main.pushModal(this._owner, this._modalParams))
+                return false;
+
+            _pushGrabHelper(this);
+        }
+
+        this._modalCount++;
+        return true;
+    }
+
+    _releaseModalGrab() {
+        this._modalCount--;
+        if (this._modalCount > 0)
+            return;
+
+        _popGrabHelper(this);
+
+        this._ignoreUntilRelease = false;
+
+        Main.popModal(this._owner);
+        global.sync_pointer();
+    }
+
+    // ignoreRelease:
+    //
+    // Make sure that the next button release event evaluated by the
+    // capture event handler returns false. This is designed for things
+    // like the ComboBoxMenu that go away on press, but need to eat
+    // the next release event.
+    ignoreRelease() {
+        this._ignoreUntilRelease = true;
+    }
+
+    // ungrab:
+    // @params: The parameters for the grab; see below.
+    //
+    // Pops @params.actor from the grab stack, potentially dropping
+    // the grab. If the actor is not on the grab stack, this call is
+    // ignored with no ill effects.
+    //
+    // If the actor is not at the top of the grab stack, grabs are
+    // popped until the grabbed actor is at the top of the grab stack.
+    // The onUngrab callback for every grab is called for every popped
+    // grab with the parameter %false.
+    ungrab(params) {
+        params = Params.parse(params, { actor: this.currentGrab.actor,
+                                        isUser: false });
+
+        let grabStackIndex = this._findStackIndex(params.actor);
+        if (grabStackIndex < 0)
+            return;
+
+        let focus = global.stage.key_focus;
+        let hadFocus = focus && this._isWithinGrabbedActor(focus);
+
+        let poppedGrabs = this._grabStack.slice(grabStackIndex);
+        // "Pop" all newly ungrabbed actors off the grab stack
+        // by truncating the array.
+        this._grabStack.length = grabStackIndex;
+
+        for (let i = poppedGrabs.length - 1; i >= 0; i--) {
+            let poppedGrab = poppedGrabs[i];
+
+            if (poppedGrab.onUngrab)
+                poppedGrab.onUngrab(params.isUser);
+
+            this._releaseModalGrab();
+        }
+
+        if (hadFocus) {
+            let poppedGrab = poppedGrabs[0];
+            if (poppedGrab.savedFocus)
+                poppedGrab.savedFocus.grab_key_focus();
+        }
+    }
+
+    onCapturedEvent(event) {
+        let type = event.type();
+
+        if (type == Clutter.EventType.KEY_PRESS &&
+            event.get_key_symbol() == Clutter.KEY_Escape) {
+            this.ungrab({ isUser: true });
+            return Clutter.EVENT_STOP;
+        }
+
+        let motion = type == Clutter.EventType.MOTION;
+        let press = type == Clutter.EventType.BUTTON_PRESS;
+        let release = type == Clutter.EventType.BUTTON_RELEASE;
+        let button = press || release;
+
+        let touchUpdate = type == Clutter.EventType.TOUCH_UPDATE;
+        let touchBegin = type == Clutter.EventType.TOUCH_BEGIN;
+        let touchEnd = type == Clutter.EventType.TOUCH_END;
+        let touch = touchUpdate || touchBegin || touchEnd;
+
+        if (touch && !global.display.is_pointer_emulating_sequence(event.get_event_sequence()))
+            return Clutter.EVENT_PROPAGATE;
+
+        if (this._ignoreUntilRelease && (motion || release || touch)) {
+            if (release || touchEnd)
+                this._ignoreUntilRelease = false;
+            return Clutter.EVENT_STOP;
+        }
+
+        if (this._isWithinGrabbedActor(event.get_source()))
+            return Clutter.EVENT_PROPAGATE;
+
+        if (Main.keyboard.shouldTakeEvent(event))
+            return Clutter.EVENT_PROPAGATE;
+
+        if (button || touchBegin) {
+            // If we have a press event, ignore the next
+            // motion/release events.
+            if (press || touchBegin)
+                this._ignoreUntilRelease = true;
+
+            let i = this._actorInGrabStack(event.get_source()) + 1;
+            this.ungrab({ actor: this._grabStack[i].actor, isUser: true });
+            return Clutter.EVENT_STOP;
+        }
+
+        return Clutter.EVENT_STOP;
+    }
+};

js/ui/ibusCandidatePopup.js

@@ -0,0 +1,325 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported CandidatePopup */
+
+const { Clutter, GObject, IBus, St } = imports.gi;
+
+const BoxPointer = imports.ui.boxpointer;
+const Main = imports.ui.main;
+
+var MAX_CANDIDATES_PER_PAGE = 16;
+
+var DEFAULT_INDEX_LABELS = ['1', '2', '3', '4', '5', '6', '7', '8',
+                            '9', '0', 'a', 'b', 'c', 'd', 'e', 'f'];
+
+var CandidateArea = GObject.registerClass({
+    Signals: {
+        'candidate-clicked': { param_types: [GObject.TYPE_UINT,
+                                             GObject.TYPE_UINT,
+                                             Clutter.ModifierType.$gtype] },
+        'cursor-down': {},
+        'cursor-up': {},
+        'next-page': {},
+        'previous-page': {},
+    },
+}, class CandidateArea extends St.BoxLayout {
+    _init() {
+        super._init({
+            vertical: true,
+            reactive: true,
+            visible: false,
+        });
+        this._candidateBoxes = [];
+        for (let i = 0; i < MAX_CANDIDATES_PER_PAGE; ++i) {
+            let box = new St.BoxLayout({ style_class: 'candidate-box',
+                                         reactive: true,
+                                         track_hover: true });
+            box._indexLabel = new St.Label({ style_class: 'candidate-index' });
+            box._candidateLabel = new St.Label({ style_class: 'candidate-label' });
+            box.add_child(box._indexLabel);
+            box.add_child(box._candidateLabel);
+            this._candidateBoxes.push(box);
+            this.add(box);
+
+            let j = i;
+            box.connect('button-release-event', (actor, event) => {
+                this.emit('candidate-clicked', j, event.get_button(), event.get_state());
+                return Clutter.EVENT_PROPAGATE;
+            });
+        }
+
+        this._buttonBox = new St.BoxLayout({ style_class: 'candidate-page-button-box' });
+
+        this._previousButton = new St.Button({
+            style_class: 'candidate-page-button candidate-page-button-previous button',
+            x_expand: true,
+        });
+        this._previousButton.child = new St.Icon({ style_class: 'candidate-page-button-icon' });
+        this._buttonBox.add_child(this._previousButton);
+
+        this._nextButton = new St.Button({
+            style_class: 'candidate-page-button candidate-page-button-next button',
+            x_expand: true,
+        });
+        this._nextButton.child = new St.Icon({ style_class: 'candidate-page-button-icon' });
+        this._buttonBox.add_child(this._nextButton);
+
+        this.add(this._buttonBox);
+
+        this._previousButton.connect('clicked', () => {
+            this.emit('previous-page');
+        });
+        this._nextButton.connect('clicked', () => {
+            this.emit('next-page');
+        });
+
+        this._orientation = -1;
+        this._cursorPosition = 0;
+    }
+
+    vfunc_scroll_event(scrollEvent) {
+        switch (scrollEvent.direction) {
+        case Clutter.ScrollDirection.UP:
+            this.emit('cursor-up');
+            break;
+        case Clutter.ScrollDirection.DOWN:
+            this.emit('cursor-down');
+            break;
+        }
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    setOrientation(orientation) {
+        if (this._orientation == orientation)
+            return;
+
+        this._orientation = orientation;
+
+        if (this._orientation == IBus.Orientation.HORIZONTAL) {
+            this.vertical = false;
+            this.remove_style_class_name('vertical');
+            this.add_style_class_name('horizontal');
+            this._previousButton.child.icon_name = 'go-previous-symbolic';
+            this._nextButton.child.icon_name = 'go-next-symbolic';
+        } else {                // VERTICAL || SYSTEM
+            this.vertical = true;
+            this.add_style_class_name('vertical');
+            this.remove_style_class_name('horizontal');
+            this._previousButton.child.icon_name = 'go-up-symbolic';
+            this._nextButton.child.icon_name = 'go-down-symbolic';
+        }
+    }
+
+    setCandidates(indexes, candidates, cursorPosition, cursorVisible) {
+        for (let i = 0; i < MAX_CANDIDATES_PER_PAGE; ++i) {
+            let visible = i < candidates.length;
+            let box = this._candidateBoxes[i];
+            box.visible = visible;
+
+            if (!visible)
+                continue;
+
+            box._indexLabel.text = indexes && indexes[i] ? indexes[i] : DEFAULT_INDEX_LABELS[i];
+            box._candidateLabel.text = candidates[i];
+        }
+
+        this._candidateBoxes[this._cursorPosition].remove_style_pseudo_class('selected');
+        this._cursorPosition = cursorPosition;
+        if (cursorVisible)
+            this._candidateBoxes[cursorPosition].add_style_pseudo_class('selected');
+    }
+
+    updateButtons(wrapsAround, page, nPages) {
+        if (nPages < 2) {
+            this._buttonBox.hide();
+            return;
+        }
+        this._buttonBox.show();
+        this._previousButton.reactive = wrapsAround || page > 0;
+        this._nextButton.reactive = wrapsAround || page < nPages - 1;
+    }
+});
+
+var CandidatePopup = GObject.registerClass(
+class IbusCandidatePopup extends BoxPointer.BoxPointer {
+    _init() {
+        super._init(St.Side.TOP);
+        this.visible = false;
+        this.style_class = 'candidate-popup-boxpointer';
+
+        this._dummyCursor = new St.Widget({ opacity: 0 });
+        Main.layoutManager.uiGroup.add_actor(this._dummyCursor);
+
+        Main.layoutManager.addChrome(this);
+
+        let box = new St.BoxLayout({ style_class: 'candidate-popup-content',
+                                     vertical: true });
+        this.bin.set_child(box);
+
+        this._preeditText = new St.Label({ style_class: 'candidate-popup-text',
+                                           visible: false });
+        box.add(this._preeditText);
+
+        this._auxText = new St.Label({ style_class: 'candidate-popup-text',
+                                       visible: false });
+        box.add(this._auxText);
+
+        this._candidateArea = new CandidateArea();
+        box.add(this._candidateArea);
+
+        this._candidateArea.connect('previous-page', () => {
+            this._panelService.page_up();
+        });
+        this._candidateArea.connect('next-page', () => {
+            this._panelService.page_down();
+        });
+
+        this._candidateArea.connect('cursor-up', () => {
+            this._panelService.cursor_up();
+        });
+        this._candidateArea.connect('cursor-down', () => {
+            this._panelService.cursor_down();
+        });
+
+        this._candidateArea.connect('candidate-clicked', (area, index, button, state) => {
+            this._panelService.candidate_clicked(index, button, state);
+        });
+
+        this._panelService = null;
+    }
+
+    setPanelService(panelService) {
+        this._panelService = panelService;
+        if (!panelService)
+            return;
+
+        panelService.connect('set-cursor-location', (ps, x, y, w, h) => {
+            this._setDummyCursorGeometry(x, y, w, h);
+        });
+        try {
+            panelService.connect('set-cursor-location-relative', (ps, x, y, w, h) => {
+                if (!global.display.focus_window)
+                    return;
+                let window = global.display.focus_window.get_compositor_private();
+                this._setDummyCursorGeometry(window.x + x, window.y + y, w, h);
+            });
+        } catch (e) {
+            // Only recent IBus versions have support for this signal
+            // which is used for wayland clients. In order to work
+            // with older IBus versions we can silently ignore the
+            // signal's absence.
+        }
+        panelService.connect('update-preedit-text', (ps, text, cursorPosition, visible) => {
+            this._preeditText.visible = visible;
+            this._updateVisibility();
+
+            this._preeditText.text = text.get_text();
+
+            let attrs = text.get_attributes();
+            if (attrs) {
+                this._setTextAttributes(this._preeditText.clutter_text,
+                                        attrs);
+            }
+        });
+        panelService.connect('show-preedit-text', () => {
+            this._preeditText.show();
+            this._updateVisibility();
+        });
+        panelService.connect('hide-preedit-text', () => {
+            this._preeditText.hide();
+            this._updateVisibility();
+        });
+        panelService.connect('update-auxiliary-text', (_ps, text, visible) => {
+            this._auxText.visible = visible;
+            this._updateVisibility();
+
+            this._auxText.text = text.get_text();
+        });
+        panelService.connect('show-auxiliary-text', () => {
+            this._auxText.show();
+            this._updateVisibility();
+        });
+        panelService.connect('hide-auxiliary-text', () => {
+            this._auxText.hide();
+            this._updateVisibility();
+        });
+        panelService.connect('update-lookup-table', (_ps, lookupTable, visible) => {
+            this._candidateArea.visible = visible;
+            this._updateVisibility();
+
+            let nCandidates = lookupTable.get_number_of_candidates();
+            let cursorPos = lookupTable.get_cursor_pos();
+            let pageSize = lookupTable.get_page_size();
+            let nPages = Math.ceil(nCandidates / pageSize);
+            let page = cursorPos == 0 ? 0 : Math.floor(cursorPos / pageSize);
+            let startIndex = page * pageSize;
+            let endIndex = Math.min((page + 1) * pageSize, nCandidates);
+
+            let indexes = [];
+            let indexLabel;
+            for (let i = 0; (indexLabel = lookupTable.get_label(i)); ++i)
+                indexes.push(indexLabel.get_text());
+
+            Main.keyboard.resetSuggestions();
+
+            let candidates = [];
+            for (let i = startIndex; i < endIndex; ++i) {
+                candidates.push(lookupTable.get_candidate(i).get_text());
+
+                Main.keyboard.addSuggestion(lookupTable.get_candidate(i).get_text(), () => {
+                    let index = i;
+                    this._panelService.candidate_clicked(index, 1, 0);
+                });
+            }
+
+            this._candidateArea.setCandidates(indexes,
+                                              candidates,
+                                              cursorPos % pageSize,
+                                              lookupTable.is_cursor_visible());
+            this._candidateArea.setOrientation(lookupTable.get_orientation());
+            this._candidateArea.updateButtons(lookupTable.is_round(), page, nPages);
+        });
+        panelService.connect('show-lookup-table', () => {
+            this._candidateArea.show();
+            this._updateVisibility();
+        });
+        panelService.connect('hide-lookup-table', () => {
+            this._candidateArea.hide();
+            this._updateVisibility();
+        });
+        panelService.connect('focus-out', () => {
+            this.close(BoxPointer.PopupAnimation.NONE);
+            Main.keyboard.resetSuggestions();
+        });
+    }
+
+    _setDummyCursorGeometry(x, y, w, h) {
+        this._dummyCursor.set_position(Math.round(x), Math.round(y));
+        this._dummyCursor.set_size(Math.round(w), Math.round(h));
+
+        if (this.visible)
+            this.setPosition(this._dummyCursor, 0);
+    }
+
+    _updateVisibility() {
+        let isVisible = !Main.keyboard.visible &&
+                         (this._preeditText.visible ||
+                          this._auxText.visible ||
+                          this._candidateArea.visible);
+
+        if (isVisible) {
+            this.setPosition(this._dummyCursor, 0);
+            this.open(BoxPointer.PopupAnimation.NONE);
+            this.get_parent().set_child_above_sibling(this, null);
+        } else {
+            this.close(BoxPointer.PopupAnimation.NONE);
+        }
+    }
+
+    _setTextAttributes(clutterText, ibusAttrList) {
+        let attr;
+        for (let i = 0; (attr = ibusAttrList.get(i)); ++i) {
+            if (attr.get_attr_type() == IBus.AttrType.BACKGROUND)
+                clutterText.set_selection(attr.get_start_index(), attr.get_end_index());
+        }
+    }
+});

js/ui/iconGrid.js

@@ -0,0 +1,990 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported BaseIcon, IconGrid, PaginatedIconGrid */
+
+const { Clutter, GLib, GObject, Graphene, Meta, St } = imports.gi;
+
+const Params = imports.misc.params;
+const Main = imports.ui.main;
+
+var ICON_SIZE = 96;
+var MIN_ICON_SIZE = 16;
+
+var ANIMATION_TIME_IN = 350;
+var ANIMATION_TIME_OUT = 1 / 2 * ANIMATION_TIME_IN;
+var ANIMATION_MAX_DELAY_FOR_ITEM = 2 / 3 * ANIMATION_TIME_IN;
+var ANIMATION_BASE_DELAY_FOR_ITEM = 1 / 4 * ANIMATION_MAX_DELAY_FOR_ITEM;
+var ANIMATION_MAX_DELAY_OUT_FOR_ITEM = 2 / 3 * ANIMATION_TIME_OUT;
+var ANIMATION_FADE_IN_TIME_FOR_ITEM = 1 / 4 * ANIMATION_TIME_IN;
+
+var ANIMATION_BOUNCE_ICON_SCALE = 1.1;
+
+var AnimationDirection = {
+    IN: 0,
+    OUT: 1,
+};
+
+var APPICON_ANIMATION_OUT_SCALE = 3;
+var APPICON_ANIMATION_OUT_TIME = 250;
+
+const ICON_POSITION_DELAY = 25;
+
+var BaseIcon = GObject.registerClass(
+class BaseIcon extends St.Bin {
+    _init(label, params) {
+        params = Params.parse(params, { createIcon: null,
+                                        setSizeManually: false,
+                                        showLabel: true });
+
+        let styleClass = 'overview-icon';
+        if (params.showLabel)
+            styleClass += ' overview-icon-with-label';
+
+        super._init({ style_class: styleClass });
+
+        this.connect('destroy', this._onDestroy.bind(this));
+
+        this._box = new St.BoxLayout({
+            vertical: true,
+            x_expand: true,
+            y_expand: true,
+        });
+        this.set_child(this._box);
+
+        this.iconSize = ICON_SIZE;
+        this._iconBin = new St.Bin({ x_align: Clutter.ActorAlign.CENTER });
+
+        this._box.add_actor(this._iconBin);
+
+        if (params.showLabel) {
+            this.label = new St.Label({ text: label });
+            this.label.clutter_text.set({
+                x_align: Clutter.ActorAlign.CENTER,
+                y_align: Clutter.ActorAlign.CENTER,
+            });
+            this._box.add_actor(this.label);
+        } else {
+            this.label = null;
+        }
+
+        if (params.createIcon)
+            this.createIcon = params.createIcon;
+        this._setSizeManually = params.setSizeManually;
+
+        this.icon = null;
+
+        let cache = St.TextureCache.get_default();
+        this._iconThemeChangedId = cache.connect('icon-theme-changed', this._onIconThemeChanged.bind(this));
+    }
+
+    vfunc_get_preferred_width(_forHeight) {
+        // Return the actual height to keep the squared aspect
+        return this.get_preferred_height(-1);
+    }
+
+    // This can be overridden by a subclass, or by the createIcon
+    // parameter to _init()
+    createIcon(_size) {
+        throw new GObject.NotImplementedError(`createIcon in ${this.constructor.name}`);
+    }
+
+    setIconSize(size) {
+        if (!this._setSizeManually)
+            throw new Error('setSizeManually has to be set to use setIconsize');
+
+        if (size == this.iconSize)
+            return;
+
+        this._createIconTexture(size);
+    }
+
+    _createIconTexture(size) {
+        if (this.icon)
+            this.icon.destroy();
+        this.iconSize = size;
+        this.icon = this.createIcon(this.iconSize);
+
+        this._iconBin.child = this.icon;
+    }
+
+    vfunc_style_changed() {
+        super.vfunc_style_changed();
+        let node = this.get_theme_node();
+
+        let size;
+        if (this._setSizeManually) {
+            size = this.iconSize;
+        } else {
+            let [found, len] = node.lookup_length('icon-size', false);
+            size = found ? len : ICON_SIZE;
+        }
+
+        if (this.iconSize == size && this._iconBin.child)
+            return;
+
+        this._createIconTexture(size);
+    }
+
+    _onDestroy() {
+        if (this._iconThemeChangedId > 0) {
+            let cache = St.TextureCache.get_default();
+            cache.disconnect(this._iconThemeChangedId);
+            this._iconThemeChangedId = 0;
+        }
+    }
+
+    _onIconThemeChanged() {
+        this._createIconTexture(this.iconSize);
+    }
+
+    animateZoomOut() {
+        // Animate only the child instead of the entire actor, so the
+        // styles like hover and running are not applied while
+        // animating.
+        zoomOutActor(this.child);
+    }
+
+    animateZoomOutAtPos(x, y) {
+        zoomOutActorAtPos(this.child, x, y);
+    }
+
+    update() {
+        this._createIconTexture(this.iconSize);
+    }
+});
+
+function clamp(value, min, max) {
+    return Math.max(Math.min(value, max), min);
+}
+
+function zoomOutActor(actor) {
+    let [x, y] = actor.get_transformed_position();
+    zoomOutActorAtPos(actor, x, y);
+}
+
+function zoomOutActorAtPos(actor, x, y) {
+    let actorClone = new Clutter.Clone({ source: actor,
+                                         reactive: false });
+    let [width, height] = actor.get_transformed_size();
+
+    actorClone.set_size(width, height);
+    actorClone.set_position(x, y);
+    actorClone.opacity = 255;
+    actorClone.set_pivot_point(0.5, 0.5);
+
+    Main.uiGroup.add_actor(actorClone);
+
+    // Avoid monitor edges to not zoom outside the current monitor
+    let monitor = Main.layoutManager.findMonitorForActor(actor);
+    let scaledWidth = width * APPICON_ANIMATION_OUT_SCALE;
+    let scaledHeight = height * APPICON_ANIMATION_OUT_SCALE;
+    let scaledX = x - (scaledWidth - width) / 2;
+    let scaledY = y - (scaledHeight - height) / 2;
+    let containedX = clamp(scaledX, monitor.x, monitor.x + monitor.width - scaledWidth);
+    let containedY = clamp(scaledY, monitor.y, monitor.y + monitor.height - scaledHeight);
+
+    actorClone.ease({
+        scale_x: APPICON_ANIMATION_OUT_SCALE,
+        scale_y: APPICON_ANIMATION_OUT_SCALE,
+        translation_x: containedX - scaledX,
+        translation_y: containedY - scaledY,
+        opacity: 0,
+        duration: APPICON_ANIMATION_OUT_TIME,
+        mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        onComplete: () => actorClone.destroy(),
+    });
+}
+
+function animateIconPosition(icon, box, flags, nChangedIcons) {
+    if (!icon.has_allocation() || icon.allocation.equal(box) || icon.opacity === 0) {
+        icon.allocate(box, flags);
+        return false;
+    }
+
+    icon.save_easing_state();
+    icon.set_easing_mode(Clutter.AnimationMode.EASE_OUT_QUAD);
+    icon.set_easing_delay(nChangedIcons * ICON_POSITION_DELAY);
+
+    icon.allocate(box, flags);
+
+    icon.restore_easing_state();
+
+    return true;
+}
+
+var IconGrid = GObject.registerClass({
+    Signals: { 'animation-done': {},
+               'child-focused': { param_types: [Clutter.Actor.$gtype] } },
+}, class IconGrid extends St.Widget {
+    _init(params) {
+        super._init({ style_class: 'icon-grid',
+                      y_align: Clutter.ActorAlign.START });
+
+        params = Params.parse(params, { rowLimit: null,
+                                        columnLimit: null,
+                                        minRows: 1,
+                                        minColumns: 1,
+                                        fillParent: false,
+                                        xAlign: St.Align.MIDDLE,
+                                        padWithSpacing: false });
+        this._rowLimit = params.rowLimit;
+        this._colLimit = params.columnLimit;
+        this._minRows = params.minRows;
+        this._minColumns = params.minColumns;
+        this._xAlign = params.xAlign;
+        this._fillParent = params.fillParent;
+        this._padWithSpacing = params.padWithSpacing;
+
+        this.topPadding = 0;
+        this.bottomPadding = 0;
+        this.rightPadding = 0;
+        this.leftPadding = 0;
+
+        this._updateIconSizesLaterId = 0;
+
+        this._items = [];
+        this._clonesAnimating = [];
+        // Pulled from CSS, but hardcode some defaults here
+        this._spacing = 0;
+        this._hItemSize = this._vItemSize = ICON_SIZE;
+        this._fixedHItemSize = this._fixedVItemSize = undefined;
+        this.connect('style-changed', this._onStyleChanged.bind(this));
+
+        this.connect('actor-added', this._childAdded.bind(this));
+        this.connect('actor-removed', this._childRemoved.bind(this));
+        this.connect('destroy', this._onDestroy.bind(this));
+    }
+
+    vfunc_unmap() {
+        // Cancel animations when hiding the overview, to avoid icons
+        // swarming into the void ...
+        this._resetAnimationActors();
+        super.vfunc_unmap();
+    }
+
+    _onDestroy() {
+        if (this._updateIconSizesLaterId) {
+            Meta.later_remove(this._updateIconSizesLaterId);
+            this._updateIconSizesLaterId = 0;
+        }
+    }
+
+    _keyFocusIn(actor) {
+        this.emit('child-focused', actor);
+    }
+
+    _childAdded(grid, child) {
+        child._iconGridKeyFocusInId = child.connect('key-focus-in', this._keyFocusIn.bind(this));
+
+        child._paintVisible = child.opacity > 0;
+        child._opacityChangedId = child.connect('notify::opacity', () => {
+            let paintVisible = child._paintVisible;
+            child._paintVisible = child.opacity > 0;
+            if (paintVisible !== child._paintVisible)
+                this.queue_relayout();
+        });
+    }
+
+    _childRemoved(grid, child) {
+        child.disconnect(child._iconGridKeyFocusInId);
+        delete child._iconGridKeyFocusInId;
+
+        child.disconnect(child._opacityChangedId);
+        delete child._opacityChangedId;
+        delete child._paintVisible;
+    }
+
+    vfunc_get_preferred_width(_forHeight) {
+        if (this._fillParent)
+            // Ignore all size requests of children and request a size of 0;
+            // later we'll allocate as many children as fit the parent
+            return [0, 0];
+
+        let nChildren = this.get_n_children();
+        let nColumns = this._colLimit
+            ? Math.min(this._colLimit, nChildren)
+            : nChildren;
+        let totalSpacing = Math.max(0, nColumns - 1) * this._getSpacing();
+        // Kind of a lie, but not really an issue right now.  If
+        // we wanted to support some sort of hidden/overflow that would
+        // need higher level design
+        let minSize = this._getHItemSize() + this.leftPadding + this.rightPadding;
+        let natSize = nColumns * this._getHItemSize() + totalSpacing + this.leftPadding + this.rightPadding;
+
+        return this.get_theme_node().adjust_preferred_width(minSize, natSize);
+    }
+
+    _getVisibleChildren() {
+        return this.get_children().filter(actor => actor.visible);
+    }
+
+    vfunc_get_preferred_height(forWidth) {
+        if (this._fillParent)
+            // Ignore all size requests of children and request a size of 0;
+            // later we'll allocate as many children as fit the parent
+            return [0, 0];
+
+        let themeNode = this.get_theme_node();
+        let children = this._getVisibleChildren();
+        let nColumns;
+
+        forWidth = themeNode.adjust_for_width(forWidth);
+
+        if (forWidth < 0)
+            nColumns = children.length;
+        else
+            [nColumns] = this._computeLayout(forWidth);
+
+        let nRows;
+        if (nColumns > 0)
+            nRows = Math.ceil(children.length / nColumns);
+        else
+            nRows = 0;
+        if (this._rowLimit)
+            nRows = Math.min(nRows, this._rowLimit);
+        let totalSpacing = Math.max(0, nRows - 1) * this._getSpacing();
+        let height = nRows * this._getVItemSize() + totalSpacing + this.topPadding + this.bottomPadding;
+
+        return themeNode.adjust_preferred_height(height, height);
+    }
+
+    vfunc_allocate(box, flags) {
+        this.set_allocation(box, flags);
+
+        let themeNode = this.get_theme_node();
+        box = themeNode.get_content_box(box);
+
+        if (this._fillParent) {
+            // Reset the passed in box to fill the parent
+            let parentBox = this.get_parent().allocation;
+            let gridBox = themeNode.get_content_box(parentBox);
+            box = themeNode.get_content_box(gridBox);
+        }
+
+        let children = this._getVisibleChildren();
+        let availWidth = box.x2 - box.x1;
+        let availHeight = box.y2 - box.y1;
+        let spacing = this._getSpacing();
+        let [nColumns, usedWidth] = this._computeLayout(availWidth);
+
+        let leftEmptySpace;
+        switch (this._xAlign) {
+        case St.Align.START:
+            leftEmptySpace = 0;
+            break;
+        case St.Align.MIDDLE:
+            leftEmptySpace = Math.floor((availWidth - usedWidth) / 2);
+            break;
+        case St.Align.END:
+            leftEmptySpace = availWidth - usedWidth;
+        }
+
+        let animating = this._clonesAnimating.length > 0;
+        let x = box.x1 + leftEmptySpace + this.leftPadding;
+        let y = box.y1 + this.topPadding;
+        let columnIndex = 0;
+        let rowIndex = 0;
+        let nChangedIcons = 0;
+        for (let i = 0; i < children.length; i++) {
+            let childBox = this._calculateChildBox(children[i], x, y, box);
+
+            if (this._rowLimit && rowIndex >= this._rowLimit ||
+                this._fillParent && childBox.y2 > availHeight - this.bottomPadding) {
+                children[i].opacity = 0;
+            } else {
+                if (!animating)
+                    children[i].opacity = 255;
+
+                if (animateIconPosition(children[i], childBox, flags, nChangedIcons))
+                    nChangedIcons++;
+            }
+
+            columnIndex++;
+            if (columnIndex == nColumns) {
+                columnIndex = 0;
+                rowIndex++;
+            }
+
+            if (columnIndex == 0) {
+                y += this._getVItemSize() + spacing;
+                x = box.x1 + leftEmptySpace + this.leftPadding;
+            } else {
+                x += this._getHItemSize() + spacing;
+            }
+        }
+    }
+
+    vfunc_get_paint_volume(paintVolume) {
+        // Setting the paint volume does not make sense when we don't have
+        // any allocation
+        if (!this.has_allocation())
+            return false;
+
+        let themeNode = this.get_theme_node();
+        let allocationBox = this.get_allocation_box();
+        let paintBox = themeNode.get_paint_box(allocationBox);
+
+        let origin = new Graphene.Point3D();
+        origin.x = paintBox.x1 - allocationBox.x1;
+        origin.y = paintBox.y1 - allocationBox.y1;
+        origin.z = 0.0;
+
+        paintVolume.set_origin(origin);
+        paintVolume.set_width(paintBox.x2 - paintBox.x1);
+        paintVolume.set_height(paintBox.y2 - paintBox.y1);
+
+        if (this.get_clip_to_allocation())
+            return true;
+
+        for (let child = this.get_first_child();
+            child != null;
+            child = child.get_next_sibling()) {
+
+            if (!child.visible || !child.opacity)
+                continue;
+
+            let childVolume = child.get_transformed_paint_volume(this);
+            if (!childVolume)
+                return false;
+
+            paintVolume.union(childVolume);
+        }
+
+        return true;
+    }
+
+    /*
+     * Intended to be override by subclasses if they need a different
+     * set of items to be animated.
+     */
+    _getChildrenToAnimate() {
+        return this._getVisibleChildren().filter(child => child.opacity > 0);
+    }
+
+    _resetAnimationActors() {
+        this._clonesAnimating.forEach(clone => {
+            clone.source.reactive = true;
+            clone.source.opacity = 255;
+            clone.destroy();
+        });
+        this._clonesAnimating = [];
+    }
+
+    _animationDone() {
+        this._resetAnimationActors();
+        this.emit('animation-done');
+    }
+
+    animatePulse(animationDirection) {
+        if (animationDirection != AnimationDirection.IN) {
+            throw new GObject.NotImplementedError("Pulse animation only implements " +
+                                                  "'in' animation direction");
+        }
+
+        this._resetAnimationActors();
+
+        let actors = this._getChildrenToAnimate();
+        if (actors.length == 0) {
+            this._animationDone();
+            return;
+        }
+
+        // For few items the animation can be slow, so use a smaller
+        // delay when there are less than 4 items
+        // (ANIMATION_BASE_DELAY_FOR_ITEM = 1/4 *
+        // ANIMATION_MAX_DELAY_FOR_ITEM)
+        let maxDelay = Math.min(ANIMATION_BASE_DELAY_FOR_ITEM * actors.length,
+                                ANIMATION_MAX_DELAY_FOR_ITEM);
+
+        for (let index = 0; index < actors.length; index++) {
+            let actor = actors[index];
+            actor.set_scale(0, 0);
+            actor.set_pivot_point(0.5, 0.5);
+
+            let delay = index / actors.length * maxDelay;
+            let bounceUpTime = ANIMATION_TIME_IN / 4;
+            let isLastItem = index == actors.length - 1;
+            actor.ease({
+                scale_x: ANIMATION_BOUNCE_ICON_SCALE,
+                scale_y: ANIMATION_BOUNCE_ICON_SCALE,
+                duration: bounceUpTime,
+                mode: Clutter.AnimationMode.EASE_IN_OUT_QUAD,
+                delay,
+                onComplete: () => {
+                    let duration = ANIMATION_TIME_IN - bounceUpTime;
+                    actor.ease({
+                        scale_x: 1,
+                        scale_y: 1,
+                        duration,
+                        mode: Clutter.AnimationMode.EASE_IN_OUT_QUAD,
+                        onComplete: () => {
+                            if (isLastItem)
+                                this._animationDone();
+                            actor.reactive = true;
+                        },
+                    });
+                },
+            });
+        }
+    }
+
+    animateSpring(animationDirection, sourceActor) {
+        this._resetAnimationActors();
+
+        let actors = this._getChildrenToAnimate();
+        if (actors.length == 0) {
+            this._animationDone();
+            return;
+        }
+
+        let [sourceX, sourceY] = sourceActor.get_transformed_position();
+        let [sourceWidth, sourceHeight] = sourceActor.get_size();
+        // Get the center
+        let [sourceCenterX, sourceCenterY] = [sourceX + sourceWidth / 2, sourceY + sourceHeight / 2];
+        // Design decision, 1/2 of the source actor size.
+        let [sourceScaledWidth, sourceScaledHeight] = [sourceWidth / 2, sourceHeight / 2];
+
+        actors.forEach(actor => {
+            let [actorX, actorY] = actor._transformedPosition = actor.get_transformed_position();
+            let [x, y] = [actorX - sourceX, actorY - sourceY];
+            actor._distance = Math.sqrt(x * x + y * y);
+        });
+        let maxDist = actors.reduce((prev, cur) => {
+            return Math.max(prev, cur._distance);
+        }, 0);
+        let minDist = actors.reduce((prev, cur) => {
+            return Math.min(prev, cur._distance);
+        }, Infinity);
+        let normalization = maxDist - minDist;
+
+        actors.forEach(actor => {
+            let clone = new Clutter.Clone({ source: actor });
+            this._clonesAnimating.push(clone);
+            Main.uiGroup.add_actor(clone);
+        });
+
+        /*
+         * ^
+         * | These need to be separate loops because Main.uiGroup.add_actor
+         * | is excessively slow if done inside the below loop and we want the
+         * | below loop to complete within one frame interval (#2065, !1002).
+         * v
+         */
+
+        this._clonesAnimating.forEach(actorClone => {
+            let actor = actorClone.source;
+            actor.opacity = 0;
+            actor.reactive = false;
+
+            let [width, height] = this._getAllocatedChildSizeAndSpacing(actor);
+            actorClone.set_size(width, height);
+            let scaleX = sourceScaledWidth / width;
+            let scaleY = sourceScaledHeight / height;
+            let [adjustedSourcePositionX, adjustedSourcePositionY] = [sourceCenterX - sourceScaledWidth / 2, sourceCenterY - sourceScaledHeight / 2];
+
+            let movementParams, fadeParams;
+            if (animationDirection == AnimationDirection.IN) {
+                let isLastItem = actor._distance == minDist;
+
+                actorClone.opacity = 0;
+                actorClone.set_scale(scaleX, scaleY);
+                actorClone.set_translation(
+                    adjustedSourcePositionX, adjustedSourcePositionY, 0);
+
+                let delay = (1 - (actor._distance - minDist) / normalization) * ANIMATION_MAX_DELAY_FOR_ITEM;
+                let [finalX, finalY]  = actor._transformedPosition;
+                movementParams = {
+                    translation_x: finalX,
+                    translation_y: finalY,
+                    scale_x: 1,
+                    scale_y: 1,
+                    duration: ANIMATION_TIME_IN,
+                    mode: Clutter.AnimationMode.EASE_IN_OUT_QUAD,
+                    delay,
+                };
+
+                if (isLastItem)
+                    movementParams.onComplete = this._animationDone.bind(this);
+
+                fadeParams = {
+                    opacity: 255,
+                    duration: ANIMATION_FADE_IN_TIME_FOR_ITEM,
+                    mode: Clutter.AnimationMode.EASE_IN_OUT_QUAD,
+                    delay,
+                };
+            } else {
+                let isLastItem = actor._distance == maxDist;
+
+                let [startX, startY]  = actor._transformedPosition;
+                actorClone.set_translation(startX, startY, 0);
+
+                let delay = (actor._distance - minDist) / normalization * ANIMATION_MAX_DELAY_OUT_FOR_ITEM;
+                movementParams = {
+                    translation_x: adjustedSourcePositionX,
+                    translation_y: adjustedSourcePositionY,
+                    scale_x: scaleX,
+                    scale_y: scaleY,
+                    duration: ANIMATION_TIME_OUT,
+                    mode: Clutter.AnimationMode.EASE_IN_OUT_QUAD,
+                    delay,
+                };
+
+                if (isLastItem)
+                    movementParams.onComplete = this._animationDone.bind(this);
+
+                fadeParams = {
+                    opacity: 0,
+                    duration: ANIMATION_FADE_IN_TIME_FOR_ITEM,
+                    mode: Clutter.AnimationMode.EASE_IN_OUT_QUAD,
+                    delay: ANIMATION_TIME_OUT + delay - ANIMATION_FADE_IN_TIME_FOR_ITEM,
+                };
+            }
+
+            actorClone.ease(movementParams);
+            actorClone.ease(fadeParams);
+        });
+    }
+
+    _getAllocatedChildSizeAndSpacing(child) {
+        let [,, natWidth, natHeight] = child.get_preferred_size();
+        let width = Math.min(this._getHItemSize(), natWidth);
+        let xSpacing = Math.max(0, width - natWidth) / 2;
+        let height = Math.min(this._getVItemSize(), natHeight);
+        let ySpacing = Math.max(0, height - natHeight) / 2;
+        return [width, height, xSpacing, ySpacing];
+    }
+
+    _calculateChildBox(child, x, y, box) {
+        /* Center the item in its allocation horizontally */
+        let [width, height, childXSpacing, childYSpacing] =
+            this._getAllocatedChildSizeAndSpacing(child);
+
+        let childBox = new Clutter.ActorBox();
+        if (Clutter.get_default_text_direction() == Clutter.TextDirection.RTL) {
+            let _x = box.x2 - (x + width);
+            childBox.x1 = Math.floor(_x - childXSpacing);
+        } else {
+            childBox.x1 = Math.floor(x + childXSpacing);
+        }
+        childBox.y1 = Math.floor(y + childYSpacing);
+        childBox.x2 = childBox.x1 + width;
+        childBox.y2 = childBox.y1 + height;
+        return childBox;
+    }
+
+    columnsForWidth(rowWidth) {
+        return this._computeLayout(rowWidth)[0];
+    }
+
+    getRowLimit() {
+        return this._rowLimit;
+    }
+
+    _computeLayout(forWidth) {
+        this.ensure_style();
+
+        let nColumns = 0;
+        let usedWidth = this.leftPadding + this.rightPadding;
+        let spacing = this._getSpacing();
+
+        while ((this._colLimit == null || nColumns < this._colLimit) &&
+               (usedWidth + this._getHItemSize() <= forWidth)) {
+            usedWidth += this._getHItemSize() + spacing;
+            nColumns += 1;
+        }
+
+        if (nColumns > 0)
+            usedWidth -= spacing;
+
+        return [nColumns, usedWidth];
+    }
+
+    _onStyleChanged() {
+        let themeNode = this.get_theme_node();
+        this._spacing = themeNode.get_length('spacing');
+        this._hItemSize = themeNode.get_length('-shell-grid-horizontal-item-size') || ICON_SIZE;
+        this._vItemSize = themeNode.get_length('-shell-grid-vertical-item-size') || ICON_SIZE;
+        this.queue_relayout();
+    }
+
+    nRows(forWidth) {
+        let children = this._getVisibleChildren();
+        let nColumns = forWidth < 0 ? children.length : this._computeLayout(forWidth)[0];
+        let nRows = nColumns > 0 ? Math.ceil(children.length / nColumns) : 0;
+        if (this._rowLimit)
+            nRows = Math.min(nRows, this._rowLimit);
+        return nRows;
+    }
+
+    rowsForHeight(forHeight) {
+        return Math.floor((forHeight - (this.topPadding + this.bottomPadding) + this._getSpacing()) / (this._getVItemSize() + this._getSpacing()));
+    }
+
+    usedHeightForNRows(nRows) {
+        return (this._getVItemSize() + this._getSpacing()) * nRows - this._getSpacing() + this.topPadding + this.bottomPadding;
+    }
+
+    usedWidth(forWidth) {
+        return this.usedWidthForNColumns(this.columnsForWidth(forWidth));
+    }
+
+    usedWidthForNColumns(columns) {
+        let usedWidth = columns  * (this._getHItemSize() + this._getSpacing());
+        usedWidth -= this._getSpacing();
+        return usedWidth + this.leftPadding + this.rightPadding;
+    }
+
+    removeAll() {
+        this._items = [];
+        this.remove_all_children();
+    }
+
+    destroyAll() {
+        this._items = [];
+        this.destroy_all_children();
+    }
+
+    addItem(item, index) {
+        if (!(item.icon instanceof BaseIcon))
+            throw new Error('Only items with a BaseIcon icon property can be added to IconGrid');
+
+        this._items.push(item);
+        if (index !== undefined)
+            this.insert_child_at_index(item, index);
+        else
+            this.add_actor(item);
+    }
+
+    removeItem(item) {
+        this.remove_child(item);
+    }
+
+    getItemAtIndex(index) {
+        return this.get_child_at_index(index);
+    }
+
+    visibleItemsCount() {
+        return this.get_children().filter(c => c.is_visible()).length;
+    }
+
+    setSpacing(spacing) {
+        this._fixedSpacing = spacing;
+    }
+
+    _getSpacing() {
+        return this._fixedSpacing ? this._fixedSpacing : this._spacing;
+    }
+
+    _getHItemSize() {
+        return this._fixedHItemSize ? this._fixedHItemSize : this._hItemSize;
+    }
+
+    _getVItemSize() {
+        return this._fixedVItemSize ? this._fixedVItemSize : this._vItemSize;
+    }
+
+    _updateSpacingForSize(availWidth, availHeight) {
+        let maxEmptyVArea = availHeight - this._minRows * this._getVItemSize();
+        let maxEmptyHArea = availWidth - this._minColumns * this._getHItemSize();
+        let maxHSpacing, maxVSpacing;
+
+        if (this._padWithSpacing) {
+            // minRows + 1 because we want to put spacing before the first row, so it is like we have one more row
+            // to divide the empty space
+            maxVSpacing = Math.floor(maxEmptyVArea / (this._minRows + 1));
+            maxHSpacing = Math.floor(maxEmptyHArea / (this._minColumns + 1));
+        } else {
+            if (this._minRows <=  1)
+                maxVSpacing = maxEmptyVArea;
+            else
+                maxVSpacing = Math.floor(maxEmptyVArea / (this._minRows - 1));
+
+            if (this._minColumns <=  1)
+                maxHSpacing = maxEmptyHArea;
+            else
+                maxHSpacing = Math.floor(maxEmptyHArea / (this._minColumns - 1));
+        }
+
+        let maxSpacing = Math.min(maxHSpacing, maxVSpacing);
+        // Limit spacing to the item size
+        maxSpacing = Math.min(maxSpacing, Math.min(this._getVItemSize(), this._getHItemSize()));
+        // The minimum spacing, regardless of whether it satisfies the row/columng minima,
+        // is the spacing we get from CSS.
+        let spacing = Math.max(this._spacing, maxSpacing);
+        this.setSpacing(spacing);
+        if (this._padWithSpacing)
+            this.topPadding = this.rightPadding = this.bottomPadding = this.leftPadding = spacing;
+    }
+
+    /*
+     * This function must to be called before iconGrid allocation,
+     * to know how much spacing can the grid has
+     */
+    adaptToSize(availWidth, availHeight) {
+        this._fixedHItemSize = this._hItemSize;
+        this._fixedVItemSize = this._vItemSize;
+        this._updateSpacingForSize(availWidth, availHeight);
+
+        if (this.columnsForWidth(availWidth) < this._minColumns || this.rowsForHeight(availHeight) < this._minRows) {
+            let neededWidth = this.usedWidthForNColumns(this._minColumns) - availWidth;
+            let neededHeight = this.usedHeightForNRows(this._minRows) - availHeight;
+
+            let neededSpacePerItem = neededWidth > neededHeight
+                ? Math.ceil(neededWidth / this._minColumns)
+                : Math.ceil(neededHeight / this._minRows);
+            this._fixedHItemSize = Math.max(this._hItemSize - neededSpacePerItem, MIN_ICON_SIZE);
+            this._fixedVItemSize = Math.max(this._vItemSize - neededSpacePerItem, MIN_ICON_SIZE);
+
+            this._updateSpacingForSize(availWidth, availHeight);
+        }
+        if (!this._updateIconSizesLaterId) {
+            this._updateIconSizesLaterId = Meta.later_add(Meta.LaterType.BEFORE_REDRAW,
+                                                          this._updateIconSizes.bind(this));
+        }
+    }
+
+    // Note that this is ICON_SIZE as used by BaseIcon, not elsewhere in IconGrid; it's a bit messed up
+    _updateIconSizes() {
+        this._updateIconSizesLaterId = 0;
+        let scale = Math.min(this._fixedHItemSize, this._fixedVItemSize) / Math.max(this._hItemSize, this._vItemSize);
+        let newIconSize = Math.floor(ICON_SIZE * scale);
+        for (let i in this._items)
+            this._items[i].icon.setIconSize(newIconSize);
+
+        return GLib.SOURCE_REMOVE;
+    }
+});
+
+var PaginatedIconGrid = GObject.registerClass(
+class PaginatedIconGrid extends IconGrid {
+    _init(params) {
+        super._init(params);
+        this._nPages = 0;
+        this.currentPage = 0;
+        this._rowsPerPage = 0;
+        this._spaceBetweenPages = 0;
+        this._childrenPerPage = 0;
+    }
+
+    vfunc_get_preferred_height(_forWidth) {
+        let height = (this._availableHeightPerPageForItems() + this.bottomPadding + this.topPadding) * this._nPages + this._spaceBetweenPages * this._nPages;
+        return [height, height];
+    }
+
+    vfunc_allocate(box, flags) {
+        if (this._childrenPerPage == 0)
+            log('computePages() must be called before allocate(); pagination will not work.');
+
+        this.set_allocation(box, flags);
+
+        if (this._fillParent) {
+            // Reset the passed in box to fill the parent
+            let parentBox = this.get_parent().allocation;
+            let gridBox = this.get_theme_node().get_content_box(parentBox);
+            box = this.get_theme_node().get_content_box(gridBox);
+        }
+        let children = this._getVisibleChildren();
+        let availWidth = box.x2 - box.x1;
+        let spacing = this._getSpacing();
+        let [nColumns, usedWidth] = this._computeLayout(availWidth);
+
+        let leftEmptySpace;
+        switch (this._xAlign) {
+        case St.Align.START:
+            leftEmptySpace = 0;
+            break;
+        case St.Align.MIDDLE:
+            leftEmptySpace = Math.floor((availWidth - usedWidth) / 2);
+            break;
+        case St.Align.END:
+            leftEmptySpace = availWidth - usedWidth;
+        }
+
+        let x = box.x1 + leftEmptySpace + this.leftPadding;
+        let y = box.y1 + this.topPadding;
+        let columnIndex = 0;
+
+        let nChangedIcons = 0;
+        for (let i = 0; i < children.length; i++) {
+            let childBox = this._calculateChildBox(children[i], x, y, box);
+
+            if (animateIconPosition(children[i], childBox, flags, nChangedIcons))
+                nChangedIcons++;
+
+            children[i].show();
+
+            columnIndex++;
+            if (columnIndex == nColumns)
+                columnIndex = 0;
+
+            if (columnIndex == 0) {
+                y += this._getVItemSize() + spacing;
+                if ((i + 1) % this._childrenPerPage == 0)
+                    y +=  this._spaceBetweenPages - spacing + this.bottomPadding + this.topPadding;
+                x = box.x1 + leftEmptySpace + this.leftPadding;
+            } else {
+                x += this._getHItemSize() + spacing;
+            }
+        }
+    }
+
+    // Overridden from IconGrid
+    _getChildrenToAnimate() {
+        let children = super._getChildrenToAnimate();
+        let firstIndex = this._childrenPerPage * this.currentPage;
+        let lastIndex = firstIndex + this._childrenPerPage;
+
+        return children.slice(firstIndex, lastIndex);
+    }
+
+    _computePages(availWidthPerPage, availHeightPerPage) {
+        let [nColumns, usedWidth_] = this._computeLayout(availWidthPerPage);
+        let nRows;
+        let children = this._getVisibleChildren();
+        if (nColumns > 0)
+            nRows = Math.ceil(children.length / nColumns);
+        else
+            nRows = 0;
+        if (this._rowLimit)
+            nRows = Math.min(nRows, this._rowLimit);
+
+        // We want to contain the grid inside the parent box with padding
+        this._rowsPerPage = this.rowsForHeight(availHeightPerPage);
+        this._nPages = Math.ceil(nRows / this._rowsPerPage);
+        this._spaceBetweenPages = availHeightPerPage - (this.topPadding + this.bottomPadding) - this._availableHeightPerPageForItems();
+        this._childrenPerPage = nColumns * this._rowsPerPage;
+    }
+
+    adaptToSize(availWidth, availHeight) {
+        super.adaptToSize(availWidth, availHeight);
+        this._computePages(availWidth, availHeight);
+    }
+
+    _availableHeightPerPageForItems() {
+        return this.usedHeightForNRows(this._rowsPerPage) - (this.topPadding + this.bottomPadding);
+    }
+
+    nPages() {
+        return this._nPages;
+    }
+
+    getPageHeight() {
+        return this._availableHeightPerPageForItems();
+    }
+
+    getPageY(pageNumber) {
+        if (!this._nPages)
+            return 0;
+
+        let firstPageItem = pageNumber * this._childrenPerPage;
+        let childBox = this._getVisibleChildren()[firstPageItem].get_allocation_box();
+        return childBox.y1 - this.topPadding;
+    }
+
+    getItemPage(item) {
+        let children = this._getVisibleChildren();
+        let index = children.indexOf(item);
+        if (index == -1)
+            throw new Error('Item not found.');
+        return Math.floor(index / this._childrenPerPage);
+    }
+});

js/ui/inhibitShortcutsDialog.js

@@ -0,0 +1,161 @@
+/* exported InhibitShortcutsDialog */
+const { Clutter, Gio, GLib, GObject, Gtk, Meta, Shell, St } = imports.gi;
+
+const Dialog = imports.ui.dialog;
+const ModalDialog = imports.ui.modalDialog;
+const PermissionStore = imports.misc.permissionStore;
+
+const WAYLAND_KEYBINDINGS_SCHEMA = 'org.gnome.mutter.wayland.keybindings';
+
+const APP_WHITELIST = ['gnome-control-center.desktop'];
+const APP_PERMISSIONS_TABLE = 'gnome';
+const APP_PERMISSIONS_ID = 'shortcuts-inhibitor';
+const GRANTED = 'GRANTED';
+const DENIED = 'DENIED';
+
+var DialogResponse = Meta.InhibitShortcutsDialogResponse;
+
+var InhibitShortcutsDialog = GObject.registerClass({
+    Implements: [Meta.InhibitShortcutsDialog],
+    Properties: {
+        'window': GObject.ParamSpec.override('window', Meta.InhibitShortcutsDialog),
+    },
+}, class InhibitShortcutsDialog extends GObject.Object {
+    _init(window) {
+        super._init();
+        this._window = window;
+
+        this._dialog = new ModalDialog.ModalDialog();
+        this._buildLayout();
+    }
+
+    get window() {
+        return this._window;
+    }
+
+    set window(window) {
+        this._window = window;
+    }
+
+    get _app() {
+        let windowTracker = Shell.WindowTracker.get_default();
+        return windowTracker.get_window_app(this._window);
+    }
+
+    _getRestoreAccel() {
+        let settings = new Gio.Settings({ schema_id: WAYLAND_KEYBINDINGS_SCHEMA });
+        let accel = settings.get_strv('restore-shortcuts')[0] || '';
+        return Gtk.accelerator_get_label.apply(null,
+                                               Gtk.accelerator_parse(accel));
+    }
+
+    _shouldUsePermStore() {
+        return this._app && !this._app.is_window_backed();
+    }
+
+    _saveToPermissionStore(grant) {
+        if (!this._shouldUsePermStore() || this._permStore == null)
+            return;
+
+        let permissions = {};
+        permissions[this._app.get_id()] = [grant];
+        let data = GLib.Variant.new('av', {});
+
+        this._permStore.SetRemote(APP_PERMISSIONS_TABLE,
+                                  true,
+                                  APP_PERMISSIONS_ID,
+                                  permissions,
+                                  data,
+            (result, error) => {
+                if (error != null)
+                    log(error.message);
+            });
+    }
+
+    _buildLayout() {
+        let name = this._app ? this._app.get_name() : this._window.title;
+
+        let content = new Dialog.MessageDialogContent({
+            title: _('Allow inhibiting shortcuts'),
+            description: name
+                /* Translators: %s is an application name like "Settings" */
+                ? _('The application %s wants to inhibit shortcuts').format(name)
+                : _('An application wants to inhibit shortcuts'),
+        });
+
+        let restoreAccel = this._getRestoreAccel();
+        if (restoreAccel) {
+            let restoreLabel = new St.Label({
+                /* Translators: %s is a keyboard shortcut like "Super+x" */
+                text: _('You can restore shortcuts by pressing %s.').format(restoreAccel),
+                style_class: 'message-dialog-description',
+            });
+            content.add_child(restoreLabel);
+        }
+
+        this._dialog.contentLayout.add_child(content);
+
+        this._dialog.addButton({ label: _("Deny"),
+                                 action: () => {
+                                     this._saveToPermissionStore(DENIED);
+                                     this._emitResponse(DialogResponse.DENY);
+                                 },
+                                 key: Clutter.KEY_Escape });
+
+        this._dialog.addButton({ label: _("Allow"),
+                                 action: () => {
+                                     this._saveToPermissionStore(GRANTED);
+                                     this._emitResponse(DialogResponse.ALLOW);
+                                 },
+                                 default: true });
+    }
+
+    _emitResponse(response) {
+        this.emit('response', response);
+        this._dialog.close();
+    }
+
+    vfunc_show() {
+        if (this._app && APP_WHITELIST.includes(this._app.get_id())) {
+            this._emitResponse(DialogResponse.ALLOW);
+            return;
+        }
+
+        if (!this._shouldUsePermStore()) {
+            this._dialog.open();
+            return;
+        }
+
+        /* Check with the permission store */
+        let appId = this._app.get_id();
+        this._permStore = new PermissionStore.PermissionStore((proxy, error) => {
+            if (error) {
+                log(error.message);
+                this._dialog.open();
+                return;
+            }
+
+            this._permStore.LookupRemote(APP_PERMISSIONS_TABLE,
+                                         APP_PERMISSIONS_ID,
+                (res, err) => {
+                    if (err) {
+                        this._dialog.open();
+                        log(err.message);
+                        return;
+                    }
+
+                    let [permissions] = res;
+                    if (permissions[appId] === undefined) // Not found
+                        this._dialog.open();
+                    else if (permissions[appId] == GRANTED)
+                        this._emitResponse(DialogResponse.ALLOW);
+                    else
+                        this._emitResponse(DialogResponse.DENY);
+                });
+        });
+    }
+
+    vfunc_hide() {
+        this._dialog.close();
+    }
+});

js/ui/kbdA11yDialog.js

@@ -0,0 +1,73 @@
+/* exported KbdA11yDialog */
+const { Clutter, Gio, GObject } = imports.gi;
+
+const Dialog = imports.ui.dialog;
+const ModalDialog = imports.ui.modalDialog;
+
+const KEYBOARD_A11Y_SCHEMA    = 'org.gnome.desktop.a11y.keyboard';
+const KEY_STICKY_KEYS_ENABLED = 'stickykeys-enable';
+const KEY_SLOW_KEYS_ENABLED   = 'slowkeys-enable';
+
+var KbdA11yDialog = GObject.registerClass(
+class KbdA11yDialog extends GObject.Object {
+    _init() {
+        super._init();
+
+        this._a11ySettings = new Gio.Settings({ schema_id: KEYBOARD_A11Y_SCHEMA });
+
+        let seat = Clutter.get_default_backend().get_default_seat();
+        seat.connect('kbd-a11y-flags-changed',
+                     this._showKbdA11yDialog.bind(this));
+    }
+
+    _showKbdA11yDialog(seat, newFlags, whatChanged) {
+        let dialog = new ModalDialog.ModalDialog();
+        let title, description;
+        let key, enabled;
+
+        if (whatChanged & Clutter.KeyboardA11yFlags.SLOW_KEYS_ENABLED) {
+            key = KEY_SLOW_KEYS_ENABLED;
+            enabled = (newFlags & Clutter.KeyboardA11yFlags.SLOW_KEYS_ENABLED) > 0;
+            title = enabled
+                ? _("Slow Keys Turned On")
+                : _("Slow Keys Turned Off");
+            description = _('You just held down the Shift key for 8 seconds. This is the shortcut ' +
+                            'for the Slow Keys feature, which affects the way your keyboard works.');
+
+        } else  if (whatChanged & Clutter.KeyboardA11yFlags.STICKY_KEYS_ENABLED) {
+            key = KEY_STICKY_KEYS_ENABLED;
+            enabled = (newFlags & Clutter.KeyboardA11yFlags.STICKY_KEYS_ENABLED) > 0;
+            title = enabled
+                ? _("Sticky Keys Turned On")
+                : _("Sticky Keys Turned Off");
+            description = enabled
+                ? _("You just pressed the Shift key 5 times in a row. This is the shortcut " +
+                  "for the Sticky Keys feature, which affects the way your keyboard works.")
+                : _("You just pressed two keys at once, or pressed the Shift key 5 times in a row. " +
+                  "This turns off the Sticky Keys feature, which affects the way your keyboard works.");
+        } else {
+            return;
+        }
+
+        let content = new Dialog.MessageDialogContent({ title, description });
+        dialog.contentLayout.add_child(content);
+
+        dialog.addButton({ label: enabled ? _("Leave On") : _("Turn On"),
+                           action: () => {
+                               this._a11ySettings.set_boolean(key, true);
+                               dialog.close();
+                           },
+                           default: enabled,
+                           key: !enabled ? Clutter.KEY_Escape : null });
+
+        dialog.addButton({ label: enabled ? _("Turn Off") : _("Leave Off"),
+                           action: () => {
+                               this._a11ySettings.set_boolean(key, false);
+                               dialog.close();
+                           },
+                           default: !enabled,
+                           key: enabled ? Clutter.KEY_Escape : null });
+
+        dialog.open();
+    }
+});

js/ui/lightbox.js

@@ -0,0 +1,295 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Lightbox */
+
+const { Clutter, GObject, Shell, St } = imports.gi;
+
+const Params = imports.misc.params;
+
+var DEFAULT_FADE_FACTOR = 0.4;
+var VIGNETTE_BRIGHTNESS = 0.5;
+var VIGNETTE_SHARPNESS = 0.7;
+
+const VIGNETTE_DECLARATIONS = '\
+uniform float brightness;\n\
+uniform float vignette_sharpness;\n';
+
+const VIGNETTE_CODE = '\
+cogl_color_out.a = cogl_color_in.a;\n\
+cogl_color_out.rgb = vec3(0.0, 0.0, 0.0);\n\
+vec2 position = cogl_tex_coord_in[0].xy - 0.5;\n\
+float t = length(2.0 * position);\n\
+t = clamp(t, 0.0, 1.0);\n\
+float pixel_brightness = mix(1.0, 1.0 - vignette_sharpness, t);\n\
+cogl_color_out.a = cogl_color_out.a * (1 - pixel_brightness * brightness);';
+
+var RadialShaderEffect = GObject.registerClass({
+    Properties: {
+        'brightness': GObject.ParamSpec.float(
+            'brightness', 'brightness', 'brightness',
+            GObject.ParamFlags.READWRITE,
+            0, 1, 1
+        ),
+        'sharpness': GObject.ParamSpec.float(
+            'sharpness', 'sharpness', 'sharpness',
+            GObject.ParamFlags.READWRITE,
+            0, 1, 0
+        ),
+    },
+}, class RadialShaderEffect extends Shell.GLSLEffect {
+    _init(params) {
+        this._brightness = undefined;
+        this._sharpness = undefined;
+
+        super._init(params);
+
+        this._brightnessLocation = this.get_uniform_location('brightness');
+        this._sharpnessLocation = this.get_uniform_location('vignette_sharpness');
+
+        this.brightness = 1.0;
+        this.sharpness = 0.0;
+    }
+
+    vfunc_build_pipeline() {
+        this.add_glsl_snippet(Shell.SnippetHook.FRAGMENT,
+                              VIGNETTE_DECLARATIONS, VIGNETTE_CODE, true);
+    }
+
+    get brightness() {
+        return this._brightness;
+    }
+
+    set brightness(v) {
+        if (this._brightness == v)
+            return;
+        this._brightness = v;
+        this.set_uniform_float(this._brightnessLocation,
+                               1, [this._brightness]);
+        this.notify('brightness');
+    }
+
+    get sharpness() {
+        return this._sharpness;
+    }
+
+    set sharpness(v) {
+        if (this._sharpness == v)
+            return;
+        this._sharpness = v;
+        this.set_uniform_float(this._sharpnessLocation,
+                               1, [this._sharpness]);
+        this.notify('sharpness');
+    }
+});
+
+/**
+ * Lightbox:
+ * @container: parent Clutter.Container
+ * @params: (optional) additional parameters:
+ *           - inhibitEvents: whether to inhibit events for @container
+ *           - width: shade actor width
+ *           - height: shade actor height
+ *           - fadeFactor: fading opacity factor
+ *           - radialEffect: whether to enable the GLSL radial effect
+ *
+ * Lightbox creates a dark translucent "shade" actor to hide the
+ * contents of @container, and allows you to specify particular actors
+ * in @container to highlight by bringing them above the shade. It
+ * tracks added and removed actors in @container while the lightboxing
+ * is active, and ensures that all actors are returned to their
+ * original stacking order when the lightboxing is removed. (However,
+ * if actors are restacked by outside code while the lightboxing is
+ * active, the lightbox may later revert them back to their original
+ * order.)
+ *
+ * By default, the shade window will have the height and width of
+ * @container and will track any changes in its size. You can override
+ * this by passing an explicit width and height in @params.
+ */
+var Lightbox = GObject.registerClass({
+    Properties: {
+        'active': GObject.ParamSpec.boolean(
+            'active', 'active', 'active', GObject.ParamFlags.READABLE, false),
+    },
+}, class Lightbox extends St.Bin {
+    _init(container, params) {
+        params = Params.parse(params, {
+            inhibitEvents: false,
+            width: null,
+            height: null,
+            fadeFactor: DEFAULT_FADE_FACTOR,
+            radialEffect: false,
+        });
+
+        super._init({
+            reactive: params.inhibitEvents,
+            width: params.width,
+            height: params.height,
+            visible: false,
+        });
+
+        this._active = false;
+        this._container = container;
+        this._children = container.get_children();
+        this._fadeFactor = params.fadeFactor;
+        this._radialEffect = Clutter.feature_available(Clutter.FeatureFlags.SHADERS_GLSL) && params.radialEffect;
+
+        if (this._radialEffect)
+            this.add_effect(new RadialShaderEffect({ name: 'radial' }));
+        else
+            this.set({ opacity: 0, style_class: 'lightbox' });
+
+        container.add_actor(this);
+        container.set_child_above_sibling(this, null);
+
+        this.connect('destroy', this._onDestroy.bind(this));
+
+        if (!params.width || !params.height) {
+            this.add_constraint(new Clutter.BindConstraint({
+                source: container,
+                coordinate: Clutter.BindCoordinate.ALL,
+            }));
+        }
+
+        this._actorAddedSignalId = container.connect('actor-added', this._actorAdded.bind(this));
+        this._actorRemovedSignalId = container.connect('actor-removed', this._actorRemoved.bind(this));
+
+        this._highlighted = null;
+    }
+
+    get active() {
+        return this._active;
+    }
+
+    _actorAdded(container, newChild) {
+        let children = this._container.get_children();
+        let myIndex = children.indexOf(this);
+        let newChildIndex = children.indexOf(newChild);
+
+        if (newChildIndex > myIndex) {
+            // The child was added above the shade (presumably it was
+            // made the new top-most child). Move it below the shade,
+            // and add it to this._children as the new topmost actor.
+            this._container.set_child_above_sibling(this, newChild);
+            this._children.push(newChild);
+        } else if (newChildIndex == 0) {
+            // Bottom of stack
+            this._children.unshift(newChild);
+        } else {
+            // Somewhere else; insert it into the correct spot
+            let prevChild = this._children.indexOf(children[newChildIndex - 1]);
+            if (prevChild != -1) // paranoia
+                this._children.splice(prevChild + 1, 0, newChild);
+        }
+    }
+
+    lightOn(fadeInTime) {
+        this.remove_all_transitions();
+
+        let easeProps = {
+            duration: fadeInTime || 0,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        };
+
+        let onComplete = () => {
+            this._active = true;
+            this.notify('active');
+        };
+
+        this.show();
+
+        if (this._radialEffect) {
+            this.ease_property(
+                '@effects.radial.brightness', VIGNETTE_BRIGHTNESS, easeProps);
+            this.ease_property(
+                '@effects.radial.sharpness', VIGNETTE_SHARPNESS,
+                Object.assign({ onComplete }, easeProps));
+        } else {
+            this.ease(Object.assign(easeProps, {
+                opacity: 255 * this._fadeFactor,
+                onComplete,
+            }));
+        }
+    }
+
+    lightOff(fadeOutTime) {
+        this.remove_all_transitions();
+
+        this._active = false;
+        this.notify('active');
+
+        let easeProps = {
+            duration: fadeOutTime || 0,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        };
+
+        let onComplete = () => this.hide();
+
+        if (this._radialEffect) {
+            this.ease_property(
+                '@effects.radial.brightness', 1.0, easeProps);
+            this.ease_property(
+                '@effects.radial.sharpness', 0.0, Object.assign({ onComplete }, easeProps));
+        } else {
+            this.ease(Object.assign(easeProps, { opacity: 0, onComplete }));
+        }
+    }
+
+    _actorRemoved(container, child) {
+        let index = this._children.indexOf(child);
+        if (index != -1) // paranoia
+            this._children.splice(index, 1);
+
+        if (child == this._highlighted)
+            this._highlighted = null;
+    }
+
+    /**
+     * highlight:
+     * @param {Clutter.Actor=} window: actor to highlight
+     *
+     * Highlights the indicated actor and unhighlights any other
+     * currently-highlighted actor. With no arguments or a false/null
+     * argument, all actors will be unhighlighted.
+     */
+    highlight(window) {
+        if (this._highlighted == window)
+            return;
+
+        // Walk this._children raising and lowering actors as needed.
+        // Things get a little tricky if the to-be-raised and
+        // to-be-lowered actors were originally adjacent, in which
+        // case we may need to indicate some *other* actor as the new
+        // sibling of the to-be-lowered one.
+
+        let below = this;
+        for (let i = this._children.length - 1; i >= 0; i--) {
+            if (this._children[i] == window)
+                this._container.set_child_above_sibling(this._children[i], null);
+            else if (this._children[i] == this._highlighted)
+                this._container.set_child_below_sibling(this._children[i], below);
+            else
+                below = this._children[i];
+        }
+
+        this._highlighted = window;
+    }
+
+    /**
+     * _onDestroy:
+     *
+     * This is called when the lightbox' actor is destroyed, either
+     * by destroying its container or by explicitly calling this.destroy().
+     */
+    _onDestroy() {
+        if (this._actorAddedSignalId) {
+            this._container.disconnect(this._actorAddedSignalId);
+            this._actorAddedSignalId = 0;
+        }
+        if (this._actorRemovedSignalId) {
+            this._container.disconnect(this._actorRemovedSignalId);
+            this._actorRemovedSignalId = 0;
+        }
+
+        this.highlight(null);
+    }
+});

js/ui/locatePointer.js

@@ -0,0 +1,39 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported LocatePointer */
+
+const { Gio } = imports.gi;
+const Ripples = imports.ui.ripples;
+const Main = imports.ui.main;
+
+const LOCATE_POINTER_KEY = "locate-pointer";
+const LOCATE_POINTER_SCHEMA = "org.gnome.desktop.interface";
+
+var LocatePointer = class {
+    constructor() {
+        this._settings = new Gio.Settings({ schema_id: LOCATE_POINTER_SCHEMA });
+        this._settings.connect(`changed::${LOCATE_POINTER_KEY}`, () => this._syncEnabled());
+        this._syncEnabled();
+    }
+
+    _syncEnabled() {
+        let enabled = this._settings.get_boolean(LOCATE_POINTER_KEY);
+        if (enabled == !!this._ripples)
+            return;
+
+        if (enabled) {
+            this._ripples = new Ripples.Ripples(0.5, 0.5, 'ripple-pointer-location');
+            this._ripples.addTo(Main.uiGroup);
+        } else {
+            this._ripples.destroy();
+            this._ripples = null;
+        }
+    }
+
+    show() {
+        if (!this._ripples)
+            return;
+
+        let [x, y] = global.get_pointer();
+        this._ripples.playAnimation(x, y);
+    }
+};

js/ui/magnifierDBus.js

@@ -0,0 +1,351 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported ShellMagnifier */
+
+const Gio = imports.gi.Gio;
+const Main = imports.ui.main;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const MAG_SERVICE_PATH = '/org/gnome/Magnifier';
+const ZOOM_SERVICE_PATH = '/org/gnome/Magnifier/ZoomRegion';
+
+// Subset of gnome-mag's Magnifier dbus interface -- to be expanded.  See:
+// http://git.gnome.org/browse/gnome-mag/tree/xml/...Magnifier.xml
+const MagnifierIface = loadInterfaceXML('org.gnome.Magnifier');
+
+// Subset of gnome-mag's ZoomRegion dbus interface -- to be expanded.  See:
+// http://git.gnome.org/browse/gnome-mag/tree/xml/...ZoomRegion.xml
+const ZoomRegionIface = loadInterfaceXML('org.gnome.Magnifier.ZoomRegion');
+
+// For making unique ZoomRegion DBus proxy object paths of the form:
+// '/org/gnome/Magnifier/ZoomRegion/zoomer0',
+// '/org/gnome/Magnifier/ZoomRegion/zoomer1', etc.
+let _zoomRegionInstanceCount = 0;
+
+var ShellMagnifier = class ShellMagnifier {
+    constructor() {
+        this._zoomers = {};
+
+        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(MagnifierIface, this);
+        this._dbusImpl.export(Gio.DBus.session, MAG_SERVICE_PATH);
+    }
+
+    /**
+     * setActive:
+     * @param {bool} activate: activate or de-activate the magnifier.
+     */
+    setActive(activate) {
+        Main.magnifier.setActive(activate);
+    }
+
+    /**
+     * isActive:
+     * @returns {bool} Whether the magnifier is active.
+     */
+    isActive() {
+        return Main.magnifier.isActive();
+    }
+
+    /**
+     * showCursor:
+     * Show the system mouse pointer.
+     */
+    showCursor() {
+        Main.magnifier.showSystemCursor();
+    }
+
+    /**
+     * hideCursor:
+     * Hide the system mouse pointer.
+     */
+    hideCursor() {
+        Main.magnifier.hideSystemCursor();
+    }
+
+    /**
+     * createZoomRegion:
+     * Create a new ZoomRegion and return its object path.
+     * @param {number} xMagFactor:
+     *     The power to set horizontal magnification of the ZoomRegion.
+     *     A value of 1.0 means no magnification. A value of 2.0 doubles
+     *     the size.
+     * @param {number} yMagFactor:
+     *     The power to set the vertical magnification of the
+     *     ZoomRegion.
+     * @param {number[]} roi
+     *     Array of integers defining the region of the screen/desktop
+     *     to magnify.  The array has the form [left, top, right, bottom].
+     * @param {number[]} viewPort
+     *     Array of integers, [left, top, right, bottom] that defines
+     *     the position of the ZoomRegion on screen.
+     *
+     * FIXME: The arguments here are redundant, since the width and height of
+     *   the ROI are determined by the viewport and magnification factors.
+     *   We ignore the passed in width and height.
+     *
+     * @returns {ZoomRegion} The newly created ZoomRegion.
+     */
+    createZoomRegion(xMagFactor, yMagFactor, roi, viewPort) {
+        let ROI = { x: roi[0], y: roi[1], width: roi[2] - roi[0], height: roi[3] - roi[1] };
+        let viewBox = { x: viewPort[0], y: viewPort[1], width: viewPort[2] - viewPort[0], height: viewPort[3] - viewPort[1] };
+        let realZoomRegion = Main.magnifier.createZoomRegion(xMagFactor, yMagFactor, ROI, viewBox);
+        let objectPath = `${ZOOM_SERVICE_PATH}/zoomer${_zoomRegionInstanceCount}`;
+        _zoomRegionInstanceCount++;
+
+        let zoomRegionProxy = new ShellMagnifierZoomRegion(objectPath, realZoomRegion);
+        let proxyAndZoomRegion = {};
+        proxyAndZoomRegion.proxy = zoomRegionProxy;
+        proxyAndZoomRegion.zoomRegion = realZoomRegion;
+        this._zoomers[objectPath] = proxyAndZoomRegion;
+        return objectPath;
+    }
+
+    /**
+     * addZoomRegion:
+     * Append the given ZoomRegion to the magnifier's list of ZoomRegions.
+     * @param {string} zoomerObjectPath: The object path for the zoom
+     *     region proxy.
+     * @returns {bool} whether the region was added successfully
+     */
+    addZoomRegion(zoomerObjectPath) {
+        let proxyAndZoomRegion = this._zoomers[zoomerObjectPath];
+        if (proxyAndZoomRegion && proxyAndZoomRegion.zoomRegion) {
+            Main.magnifier.addZoomRegion(proxyAndZoomRegion.zoomRegion);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * getZoomRegions:
+     * Return a list of ZoomRegion object paths for this Magnifier.
+     * @returns {string[]}: The Magnifier's zoom region list as an array
+     *     of DBus object paths.
+     */
+    getZoomRegions() {
+        // There may be more ZoomRegions in the magnifier itself than have
+        // been added through dbus.  Make sure all of them are associated with
+        // an object path and proxy.
+        let zoomRegions = Main.magnifier.getZoomRegions();
+        let objectPaths = [];
+        let thoseZoomers = this._zoomers;
+        zoomRegions.forEach(aZoomRegion => {
+            let found = false;
+            for (let objectPath in thoseZoomers) {
+                let proxyAndZoomRegion = thoseZoomers[objectPath];
+                if (proxyAndZoomRegion.zoomRegion === aZoomRegion) {
+                    objectPaths.push(objectPath);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                // Got a ZoomRegion with no DBus proxy, make one.
+                let newPath = `${ZOOM_SERVICE_PATH}/zoomer${_zoomRegionInstanceCount}`;
+                _zoomRegionInstanceCount++;
+                let zoomRegionProxy = new ShellMagnifierZoomRegion(newPath, aZoomRegion);
+                let proxyAndZoomer = {};
+                proxyAndZoomer.proxy = zoomRegionProxy;
+                proxyAndZoomer.zoomRegion = aZoomRegion;
+                thoseZoomers[newPath] = proxyAndZoomer;
+                objectPaths.push(newPath);
+            }
+        });
+        return objectPaths;
+    }
+
+    /**
+     * clearAllZoomRegions:
+     * Remove all the zoom regions from this Magnfier's ZoomRegion list.
+     */
+    clearAllZoomRegions() {
+        Main.magnifier.clearAllZoomRegions();
+        for (let objectPath in this._zoomers) {
+            let proxyAndZoomer = this._zoomers[objectPath];
+            proxyAndZoomer.proxy.destroy();
+            proxyAndZoomer.proxy = null;
+            proxyAndZoomer.zoomRegion = null;
+            delete this._zoomers[objectPath];
+        }
+        this._zoomers = {};
+    }
+
+    /**
+     * fullScreenCapable:
+     * Consult if the Magnifier can magnify in full-screen mode.
+     * @returns {bool} Always return true.
+     */
+    fullScreenCapable() {
+        return true;
+    }
+
+    /**
+     * setCrosswireSize:
+     * Set the crosswire size of all ZoomRegions.
+     * @param {number} size: The thickness of each line in the cross wire.
+     */
+    setCrosswireSize(size) {
+        Main.magnifier.setCrosshairsThickness(size);
+    }
+
+    /**
+     * getCrosswireSize:
+     * Get the crosswire size of all ZoomRegions.
+     * @returns {number}: The thickness of each line in the cross wire.
+     */
+    getCrosswireSize() {
+        return Main.magnifier.getCrosshairsThickness();
+    }
+
+    /**
+     * setCrosswireLength:
+     * Set the crosswire length of all zoom-regions..
+     * @param {number} length: The length of each line in the cross wire.
+     */
+    setCrosswireLength(length) {
+        Main.magnifier.setCrosshairsLength(length);
+    }
+
+    /**
+     * getCrosswireSize:
+     * Get the crosswire length of all zoom-regions.
+     * @returns {number} size: The length of each line in the cross wire.
+     */
+    getCrosswireLength() {
+        return Main.magnifier.getCrosshairsLength();
+    }
+
+    /**
+     * setCrosswireClip:
+     * Set if the crosswire will be clipped by the cursor image..
+     * @param {bool} clip: Flag to indicate whether to clip the crosswire.
+     */
+    setCrosswireClip(clip) {
+        Main.magnifier.setCrosshairsClip(clip);
+    }
+
+    /**
+     * getCrosswireClip:
+     * Get the crosswire clip value.
+     * @returns {bool}: Whether the crosswire is clipped by the cursor image.
+     */
+    getCrosswireClip() {
+        return Main.magnifier.getCrosshairsClip();
+    }
+
+    /**
+     * setCrosswireColor:
+     * Set the crosswire color of all ZoomRegions.
+     * @param {number} color: Unsigned int of the form rrggbbaa.
+     */
+    setCrosswireColor(color) {
+        Main.magnifier.setCrosshairsColor('#%08x'.format(color));
+    }
+
+    /**
+     * getCrosswireClip:
+     * Get the crosswire color of all ZoomRegions.
+     * @returns {number}: The crosswire color as an unsigned int in
+     *     the form rrggbbaa.
+     */
+    getCrosswireColor() {
+        let colorString = Main.magnifier.getCrosshairsColor();
+        // Drop the leading '#'.
+        return parseInt(colorString.slice(1), 16);
+    }
+};
+
+/**
+ * ShellMagnifierZoomRegion:
+ * Object that implements the DBus ZoomRegion interface.
+ * @zoomerObjectPath:   String that is the path to a DBus ZoomRegion.
+ * @zoomRegion:         The actual zoom region associated with the object path.
+ */
+var ShellMagnifierZoomRegion = class ShellMagnifierZoomRegion {
+    constructor(zoomerObjectPath, zoomRegion) {
+        this._zoomRegion = zoomRegion;
+
+        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(ZoomRegionIface, this);
+        this._dbusImpl.export(Gio.DBus.session, zoomerObjectPath);
+    }
+
+    /**
+     * setMagFactor:
+     * @param {number} xMagFactor: The power to set the horizontal
+     *     magnification factor to of the magnified view. A value of
+     *     1.0 means no magnification. A value of 2.0 doubles the size.
+     * @param {number} yMagFactor: The power to set the vertical
+     *     magnification factor to of the magnified view.
+     */
+    setMagFactor(xMagFactor, yMagFactor) {
+        this._zoomRegion.setMagFactor(xMagFactor, yMagFactor);
+    }
+
+    /**
+     * getMagFactor:
+     * @returns {number[]}: [xMagFactor, yMagFactor], containing the horizontal
+     *          and vertical magnification powers.  A value of 1.0 means no
+     *          magnification.  A value of 2.0 means the contents are doubled
+     *          in size, and so on.
+     */
+    getMagFactor() {
+        return this._zoomRegion.getMagFactor();
+    }
+
+    /**
+     * setRoi:
+     * Sets the "region of interest" that the ZoomRegion is magnifying.
+     * @param {number[]} roi: [left, top, right, bottom], defining the
+     *     region of the screen to magnify.
+     *     The values are in screen (unmagnified) coordinate space.
+     */
+    setRoi(roi) {
+        let roiObject = { x: roi[0], y: roi[1], width: roi[2] - roi[0], height: roi[3] - roi[1] };
+        this._zoomRegion.setROI(roiObject);
+    }
+
+    /**
+     * getRoi:
+     * Retrieves the "region of interest" -- the rectangular bounds of that part
+     * of the desktop that the magnified view is showing (x, y, width, height).
+     * The bounds are given in non-magnified coordinates.
+     * @returns {Array}: [left, top, right, bottom], representing the bounding
+     *          rectangle of what is shown in the magnified view.
+     */
+    getRoi() {
+        let roi = this._zoomRegion.getROI();
+        roi[2] += roi[0];
+        roi[3] += roi[1];
+        return roi;
+    }
+
+    /**
+     * Set the "region of interest" by centering the given screen coordinate
+     * within the zoom region.
+     * @param {number} x: The x-coord of the point to place at the
+     *     center of the zoom region.
+     * @param {number} y: The y-coord.
+     * @returns {bool} Whether the shift was successful (for GS-mag, this
+     *     is always true).
+     */
+    shiftContentsTo(x, y) {
+        this._zoomRegion.scrollContentsTo(x, y);
+        return true;
+    }
+
+    /**
+     * moveResize
+     * Sets the position and size of the ZoomRegion on screen.
+     * @param {number[]} viewPort: [left, top, right, bottom], defining
+     *     the position and size on screen to place the zoom region.
+     */
+    moveResize(viewPort) {
+        let viewRect = { x: viewPort[0], y: viewPort[1], width: viewPort[2] - viewPort[0], height: viewPort[3] - viewPort[1] };
+        this._zoomRegion.setViewPort(viewRect);
+    }
+
+    destroy() {
+        this._dbusImpl.unexport();
+    }
+};

js/ui/main.js

@@ -0,0 +1,805 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported componentManager, notificationDaemon, windowAttentionHandler,
+            ctrlAltTabManager, padOsdService, osdWindowManager,
+            osdMonitorLabeler, shellMountOpDBusService, shellDBusService,
+            shellAccessDialogDBusService, shellAudioSelectionDBusService,
+            screenSaverDBus, screencastService, uiGroup, magnifier,
+            xdndHandler, keyboard, kbdA11yDialog, introspectService,
+            start, pushModal, popModal, activateWindow, createLookingGlass,
+            initializeDeferredWork, getThemeStylesheet, setThemeStylesheet */
+
+const { Clutter, Gio, GLib, GObject, Meta, Shell, St } = imports.gi;
+
+const AccessDialog = imports.ui.accessDialog;
+const AudioDeviceSelection = imports.ui.audioDeviceSelection;
+const Components = imports.ui.components;
+const CtrlAltTab = imports.ui.ctrlAltTab;
+const EndSessionDialog = imports.ui.endSessionDialog;
+const ExtensionSystem = imports.ui.extensionSystem;
+const ExtensionDownloader = imports.ui.extensionDownloader;
+const InputMethod = imports.misc.inputMethod;
+const Introspect = imports.misc.introspect;
+const Keyboard = imports.ui.keyboard;
+const MessageTray = imports.ui.messageTray;
+const ModalDialog = imports.ui.modalDialog;
+const OsdWindow = imports.ui.osdWindow;
+const OsdMonitorLabeler = imports.ui.osdMonitorLabeler;
+const Overview = imports.ui.overview;
+const PadOsd = imports.ui.padOsd;
+const Panel = imports.ui.panel;
+const Params = imports.misc.params;
+const RunDialog = imports.ui.runDialog;
+const Layout = imports.ui.layout;
+const LoginManager = imports.misc.loginManager;
+const LookingGlass = imports.ui.lookingGlass;
+const NotificationDaemon = imports.ui.notificationDaemon;
+const WindowAttentionHandler = imports.ui.windowAttentionHandler;
+const Screencast = imports.ui.screencast;
+const ScreenShield = imports.ui.screenShield;
+const Scripting = imports.ui.scripting;
+const SessionMode = imports.ui.sessionMode;
+const ShellDBus = imports.ui.shellDBus;
+const ShellMountOperation = imports.ui.shellMountOperation;
+const WindowManager = imports.ui.windowManager;
+const Magnifier = imports.ui.magnifier;
+const XdndHandler = imports.ui.xdndHandler;
+const KbdA11yDialog = imports.ui.kbdA11yDialog;
+const LocatePointer = imports.ui.locatePointer;
+const PointerA11yTimeout = imports.ui.pointerA11yTimeout;
+
+const A11Y_SCHEMA = 'org.gnome.desktop.a11y.keyboard';
+const STICKY_KEYS_ENABLE = 'stickykeys-enable';
+const LOG_DOMAIN = 'GNOME Shell';
+const GNOMESHELL_STARTED_MESSAGE_ID = 'f3ea493c22934e26811cd62abe8e203a';
+
+var componentManager = null;
+var extensionManager = null;
+var panel = null;
+var overview = null;
+var runDialog = null;
+var lookingGlass = null;
+var wm = null;
+var messageTray = null;
+var screenShield = null;
+var notificationDaemon = null;
+var windowAttentionHandler = null;
+var ctrlAltTabManager = null;
+var padOsdService = null;
+var osdWindowManager = null;
+var osdMonitorLabeler = null;
+var sessionMode = null;
+var shellAccessDialogDBusService = null;
+var shellAudioSelectionDBusService = null;
+var shellDBusService = null;
+var shellMountOpDBusService = null;
+var screenSaverDBus = null;
+var screencastService = null;
+var modalCount = 0;
+var actionMode = Shell.ActionMode.NONE;
+var modalActorFocusStack = [];
+var uiGroup = null;
+var magnifier = null;
+var xdndHandler = null;
+var keyboard = null;
+var layoutManager = null;
+var kbdA11yDialog = null;
+var inputMethod = null;
+var introspectService = null;
+var locatePointer = null;
+let _startDate;
+let _defaultCssStylesheet = null;
+let _cssStylesheet = null;
+let _a11ySettings = null;
+let _themeResource = null;
+let _oskResource = null;
+
+function _sessionUpdated() {
+    if (sessionMode.isPrimary)
+        _loadDefaultStylesheet();
+
+    wm.setCustomKeybindingHandler('panel-main-menu',
+                                  Shell.ActionMode.NORMAL |
+                                  Shell.ActionMode.OVERVIEW,
+                                  sessionMode.hasOverview ? overview.toggle.bind(overview) : null);
+    wm.allowKeybinding('overlay-key', Shell.ActionMode.NORMAL |
+                                      Shell.ActionMode.OVERVIEW);
+
+    wm.allowKeybinding('locate-pointer-key', Shell.ActionMode.ALL);
+
+    wm.setCustomKeybindingHandler('panel-run-dialog',
+                                  Shell.ActionMode.NORMAL |
+                                  Shell.ActionMode.OVERVIEW,
+                                  sessionMode.hasRunDialog ? openRunDialog : null);
+
+    if (!sessionMode.hasRunDialog) {
+        if (runDialog)
+            runDialog.close();
+        if (lookingGlass)
+            lookingGlass.close();
+    }
+}
+
+function start() {
+    // These are here so we don't break compatibility.
+    global.logError = window.log;
+    global.log = window.log;
+
+    // Chain up async errors reported from C
+    global.connect('notify-error', (global, msg, detail) => {
+        notifyError(msg, detail);
+    });
+
+    Gio.DesktopAppInfo.set_desktop_env('GNOME');
+
+    sessionMode = new SessionMode.SessionMode();
+    sessionMode.connect('updated', _sessionUpdated);
+
+    St.Settings.get().connect('notify::gtk-theme', _loadDefaultStylesheet);
+    _initializeUI();
+
+    shellAccessDialogDBusService = new AccessDialog.AccessDialogDBus();
+    shellAudioSelectionDBusService = new AudioDeviceSelection.AudioDeviceSelectionDBus();
+    shellDBusService = new ShellDBus.GnomeShell();
+    shellMountOpDBusService = new ShellMountOperation.GnomeShellMountOpHandler();
+
+    _sessionUpdated();
+}
+
+function _initializeUI() {
+    // Ensure ShellWindowTracker and ShellAppUsage are initialized; this will
+    // also initialize ShellAppSystem first. ShellAppSystem
+    // needs to load all the .desktop files, and ShellWindowTracker
+    // will use those to associate with windows. Right now
+    // the Monitor doesn't listen for installed app changes
+    // and recalculate application associations, so to avoid
+    // races for now we initialize it here. It's better to
+    // be predictable anyways.
+    Shell.WindowTracker.get_default();
+    Shell.AppUsage.get_default();
+
+    reloadThemeResource();
+    _loadOskLayouts();
+    _loadDefaultStylesheet();
+
+    new AnimationsSettings();
+
+    // Setup the stage hierarchy early
+    layoutManager = new Layout.LayoutManager();
+
+    // Various parts of the codebase still refer to Main.uiGroup
+    // instead of using the layoutManager. This keeps that code
+    // working until it's updated.
+    uiGroup = layoutManager.uiGroup;
+
+    padOsdService = new PadOsd.PadOsdService();
+    screencastService = new Screencast.ScreencastService();
+    xdndHandler = new XdndHandler.XdndHandler();
+    ctrlAltTabManager = new CtrlAltTab.CtrlAltTabManager();
+    osdWindowManager = new OsdWindow.OsdWindowManager();
+    osdMonitorLabeler = new OsdMonitorLabeler.OsdMonitorLabeler();
+    overview = new Overview.Overview();
+    kbdA11yDialog = new KbdA11yDialog.KbdA11yDialog();
+    wm = new WindowManager.WindowManager();
+    magnifier = new Magnifier.Magnifier();
+    locatePointer = new LocatePointer.LocatePointer();
+
+    if (LoginManager.canLock())
+        screenShield = new ScreenShield.ScreenShield();
+
+    inputMethod = new InputMethod.InputMethod();
+    Clutter.get_default_backend().set_input_method(inputMethod);
+
+    messageTray = new MessageTray.MessageTray();
+    panel = new Panel.Panel();
+    keyboard = new Keyboard.KeyboardManager();
+    notificationDaemon = new NotificationDaemon.NotificationDaemon();
+    windowAttentionHandler = new WindowAttentionHandler.WindowAttentionHandler();
+    componentManager = new Components.ComponentManager();
+
+    introspectService = new Introspect.IntrospectService();
+
+    layoutManager.init();
+    overview.init();
+
+    new PointerA11yTimeout.PointerA11yTimeout();
+
+    _a11ySettings = new Gio.Settings({ schema_id: A11Y_SCHEMA });
+
+    global.display.connect('overlay-key', () => {
+        if (!_a11ySettings.get_boolean(STICKY_KEYS_ENABLE))
+            overview.toggle();
+    });
+
+    global.connect('locate-pointer', () => {
+        locatePointer.show();
+    });
+
+    global.display.connect('show-restart-message', (display, message) => {
+        showRestartMessage(message);
+        return true;
+    });
+
+    global.display.connect('restart', () => {
+        global.reexec_self();
+        return true;
+    });
+
+    global.display.connect('gl-video-memory-purged', loadTheme);
+
+    // Provide the bus object for gnome-session to
+    // initiate logouts.
+    EndSessionDialog.init();
+
+    // We're ready for the session manager to move to the next phase
+    GLib.idle_add(GLib.PRIORITY_DEFAULT, () => {
+        Shell.util_sd_notify();
+        Meta.register_with_session();
+        return GLib.SOURCE_REMOVE;
+    });
+
+    _startDate = new Date();
+
+    ExtensionDownloader.init();
+    extensionManager = new ExtensionSystem.ExtensionManager();
+    extensionManager.init();
+
+    if (sessionMode.isGreeter && screenShield) {
+        layoutManager.connect('startup-prepared', () => {
+            screenShield.showDialog();
+        });
+    }
+
+    layoutManager.connect('startup-complete', () => {
+        if (actionMode == Shell.ActionMode.NONE)
+            actionMode = Shell.ActionMode.NORMAL;
+
+        if (screenShield)
+            screenShield.lockIfWasLocked();
+
+        if (sessionMode.currentMode != 'gdm' &&
+            sessionMode.currentMode != 'initial-setup') {
+            GLib.log_structured(LOG_DOMAIN, GLib.LogLevelFlags.LEVEL_MESSAGE, {
+                'MESSAGE': 'GNOME Shell started at %s'.format(_startDate),
+                'MESSAGE_ID': GNOMESHELL_STARTED_MESSAGE_ID,
+            });
+        }
+
+        let credentials = new Gio.Credentials();
+        if (credentials.get_unix_user() === 0) {
+            notify(_('Logged in as a privileged user'),
+                   _('Running a session as a privileged user should be avoided for security reasons. If possible, you should log in as a normal user.'));
+        }
+
+        if (sessionMode.currentMode !== 'gdm' &&
+            sessionMode.currentMode !== 'initial-setup' &&
+            screenShield === null) {
+            notify(_('Screen Lock disabled'),
+                   _('Screen Locking requires the GNOME display manager.'));
+        }
+
+        LoginManager.registerSessionWithGDM();
+
+        let perfModuleName = GLib.getenv("SHELL_PERF_MODULE");
+        if (perfModuleName) {
+            let perfOutput = GLib.getenv("SHELL_PERF_OUTPUT");
+            let module = eval('imports.perf.%s;'.format(perfModuleName));
+            Scripting.runPerfScript(module, perfOutput);
+        }
+    });
+}
+
+function _getStylesheet(name) {
+    let stylesheet;
+
+    stylesheet = Gio.File.new_for_uri('resource:///org/gnome/shell/theme/%s'.format(name));
+    if (stylesheet.query_exists(null))
+        return stylesheet;
+
+    let dataDirs = GLib.get_system_data_dirs();
+    for (let i = 0; i < dataDirs.length; i++) {
+        let path = GLib.build_filenamev([dataDirs[i], 'gnome-shell', 'theme', name]);
+        stylesheet = Gio.file_new_for_path(path);
+        if (stylesheet.query_exists(null))
+            return stylesheet;
+    }
+
+    stylesheet = Gio.File.new_for_path('%s/theme/%s'.format(global.datadir, name));
+    if (stylesheet.query_exists(null))
+        return stylesheet;
+
+    return null;
+}
+
+function _getDefaultStylesheet() {
+    let stylesheet = null;
+    let name = sessionMode.stylesheetName;
+
+    // Look for a high-contrast variant first when using GTK+'s HighContrast
+    // theme
+    if (St.Settings.get().gtk_theme == 'HighContrast')
+        stylesheet = _getStylesheet(name.replace('.css', '-high-contrast.css'));
+
+    if (stylesheet == null)
+        stylesheet = _getStylesheet(sessionMode.stylesheetName);
+
+    return stylesheet;
+}
+
+function _loadDefaultStylesheet() {
+    let stylesheet = _getDefaultStylesheet();
+    if (_defaultCssStylesheet && _defaultCssStylesheet.equal(stylesheet))
+        return;
+
+    _defaultCssStylesheet = stylesheet;
+    loadTheme();
+}
+
+/**
+ * getThemeStylesheet:
+ *
+ * Get the theme CSS file that the shell will load
+ *
+ * @returns {?Gio.File}: A #GFile that contains the theme CSS,
+ *          null if using the default
+ */
+function getThemeStylesheet() {
+    return _cssStylesheet;
+}
+
+/**
+ * setThemeStylesheet:
+ * @param {string=} cssStylesheet: A file path that contains the theme CSS,
+ *     set it to null to use the default
+ *
+ * Set the theme CSS file that the shell will load
+ */
+function setThemeStylesheet(cssStylesheet) {
+    _cssStylesheet = cssStylesheet ? Gio.File.new_for_path(cssStylesheet) : null;
+}
+
+function reloadThemeResource() {
+    if (_themeResource)
+        _themeResource._unregister();
+
+    _themeResource = Gio.Resource.load('%s/gnome-shell-theme.gresource'.format(global.datadir));
+    _themeResource._register();
+}
+
+function _loadOskLayouts() {
+    _oskResource = Gio.Resource.load('%s/gnome-shell-osk-layouts.gresource'.format(global.datadir));
+    _oskResource._register();
+}
+
+/**
+ * loadTheme:
+ *
+ * Reloads the theme CSS file
+ */
+function loadTheme() {
+    let themeContext = St.ThemeContext.get_for_stage(global.stage);
+    let previousTheme = themeContext.get_theme();
+
+    let theme = new St.Theme({
+        application_stylesheet: _cssStylesheet,
+        default_stylesheet: _defaultCssStylesheet,
+    });
+
+    if (theme.default_stylesheet == null)
+        throw new Error("No valid stylesheet found for '%s'".format(sessionMode.stylesheetName));
+
+    if (previousTheme) {
+        let customStylesheets = previousTheme.get_custom_stylesheets();
+
+        for (let i = 0; i < customStylesheets.length; i++)
+            theme.load_stylesheet(customStylesheets[i]);
+    }
+
+    themeContext.set_theme(theme);
+}
+
+/**
+ * notify:
+ * @param {string} msg: A message
+ * @param {string} details: Additional information
+ */
+function notify(msg, details) {
+    let source = new MessageTray.SystemNotificationSource();
+    messageTray.add(source);
+    let notification = new MessageTray.Notification(source, msg, details);
+    notification.setTransient(true);
+    source.showNotification(notification);
+}
+
+/**
+ * notifyError:
+ * @param {string} msg: An error message
+ * @param {string} details: Additional information
+ *
+ * See shell_global_notify_problem().
+ */
+function notifyError(msg, details) {
+    // Also print to stderr so it's logged somewhere
+    if (details)
+        log('error: %s: %s'.format(msg, details));
+    else
+        log('error: %s'.format(msg));
+
+    notify(msg, details);
+}
+
+function _findModal(actor) {
+    for (let i = 0; i < modalActorFocusStack.length; i++) {
+        if (modalActorFocusStack[i].actor == actor)
+            return i;
+    }
+    return -1;
+}
+
+/**
+ * pushModal:
+ * @param {Clutter.Actor} actor: actor which will be given keyboard focus
+ * @param {Object=} params: optional parameters
+ *
+ * Ensure we are in a mode where all keyboard and mouse input goes to
+ * the stage, and focus @actor. Multiple calls to this function act in
+ * a stacking fashion; the effect will be undone when an equal number
+ * of popModal() invocations have been made.
+ *
+ * Next, record the current Clutter keyboard focus on a stack. If the
+ * modal stack returns to this actor, reset the focus to the actor
+ * which was focused at the time pushModal() was invoked.
+ *
+ * @params may be used to provide the following parameters:
+ *  - timestamp: used to associate the call with a specific user initiated
+ *               event. If not provided then the value of
+ *               global.get_current_time() is assumed.
+ *
+ *  - options: Meta.ModalOptions flags to indicate that the pointer is
+ *             already grabbed
+ *
+ *  - actionMode: used to set the current Shell.ActionMode to filter
+ *                global keybindings; the default of NONE will filter
+ *                out all keybindings
+ *
+ * @returns {bool}: true iff we successfully acquired a grab or already had one
+ */
+function pushModal(actor, params) {
+    params = Params.parse(params, { timestamp: global.get_current_time(),
+                                    options: 0,
+                                    actionMode: Shell.ActionMode.NONE });
+
+    if (modalCount == 0) {
+        if (!global.begin_modal(params.timestamp, params.options)) {
+            log('pushModal: invocation of begin_modal failed');
+            return false;
+        }
+        Meta.disable_unredirect_for_display(global.display);
+    }
+
+    modalCount += 1;
+    let actorDestroyId = actor.connect('destroy', () => {
+        let index = _findModal(actor);
+        if (index >= 0)
+            popModal(actor);
+    });
+
+    let prevFocus = global.stage.get_key_focus();
+    let prevFocusDestroyId;
+    if (prevFocus != null) {
+        prevFocusDestroyId = prevFocus.connect('destroy', () => {
+            let index = _findModal(actor);
+            if (index >= 0)
+                modalActorFocusStack[index].prevFocus = null;
+        });
+    }
+    modalActorFocusStack.push({ actor,
+                                destroyId: actorDestroyId,
+                                prevFocus,
+                                prevFocusDestroyId,
+                                actionMode });
+
+    actionMode = params.actionMode;
+    global.stage.set_key_focus(actor);
+    return true;
+}
+
+/**
+ * popModal:
+ * @param {Clutter.Actor} actor: the actor passed to original invocation
+ *     of pushModal()
+ * @param {number=} timestamp: optional timestamp
+ *
+ * Reverse the effect of pushModal(). If this invocation is undoing
+ * the topmost invocation, then the focus will be restored to the
+ * previous focus at the time when pushModal() was invoked.
+ *
+ * @timestamp is optionally used to associate the call with a specific user
+ * initiated event. If not provided then the value of
+ * global.get_current_time() is assumed.
+ */
+function popModal(actor, timestamp) {
+    if (timestamp == undefined)
+        timestamp = global.get_current_time();
+
+    let focusIndex = _findModal(actor);
+    if (focusIndex < 0) {
+        global.stage.set_key_focus(null);
+        global.end_modal(timestamp);
+        actionMode = Shell.ActionMode.NORMAL;
+
+        throw new Error('incorrect pop');
+    }
+
+    modalCount -= 1;
+
+    let record = modalActorFocusStack[focusIndex];
+    record.actor.disconnect(record.destroyId);
+
+    if (focusIndex == modalActorFocusStack.length - 1) {
+        if (record.prevFocus)
+            record.prevFocus.disconnect(record.prevFocusDestroyId);
+        actionMode = record.actionMode;
+        global.stage.set_key_focus(record.prevFocus);
+    } else {
+        // If we have:
+        //     global.stage.set_focus(a);
+        //     Main.pushModal(b);
+        //     Main.pushModal(c);
+        //     Main.pushModal(d);
+        //
+        // then we have the stack:
+        //     [{ prevFocus: a, actor: b },
+        //      { prevFocus: b, actor: c },
+        //      { prevFocus: c, actor: d }]
+        //
+        // When actor c is destroyed/popped, if we only simply remove the
+        // record, then the focus stack will be [a, c], rather than the correct
+        // [a, b]. Shift the focus stack up before removing the record to ensure
+        // that we get the correct result.
+        let t = modalActorFocusStack[modalActorFocusStack.length - 1];
+        if (t.prevFocus)
+            t.prevFocus.disconnect(t.prevFocusDestroyId);
+        // Remove from the middle, shift the focus chain up
+        for (let i = modalActorFocusStack.length - 1; i > focusIndex; i--) {
+            modalActorFocusStack[i].prevFocus = modalActorFocusStack[i - 1].prevFocus;
+            modalActorFocusStack[i].prevFocusDestroyId = modalActorFocusStack[i - 1].prevFocusDestroyId;
+            modalActorFocusStack[i].actionMode = modalActorFocusStack[i - 1].actionMode;
+        }
+    }
+    modalActorFocusStack.splice(focusIndex, 1);
+
+    if (modalCount > 0)
+        return;
+
+    layoutManager.modalEnded();
+    global.end_modal(timestamp);
+    Meta.enable_unredirect_for_display(global.display);
+    actionMode = Shell.ActionMode.NORMAL;
+}
+
+function createLookingGlass() {
+    if (lookingGlass == null)
+        lookingGlass = new LookingGlass.LookingGlass();
+
+    return lookingGlass;
+}
+
+function openRunDialog() {
+    if (runDialog == null)
+        runDialog = new RunDialog.RunDialog();
+
+    runDialog.open();
+}
+
+/**
+ * activateWindow:
+ * @param {Meta.Window} window: the window to activate
+ * @param {number=} time: current event time
+ * @param {number=} workspaceNum:  window's workspace number
+ *
+ * Activates @window, switching to its workspace first if necessary,
+ * and switching out of the overview if it's currently active
+ */
+function activateWindow(window, time, workspaceNum) {
+    let workspaceManager = global.workspace_manager;
+    let activeWorkspaceNum = workspaceManager.get_active_workspace_index();
+    let windowWorkspaceNum = workspaceNum !== undefined ? workspaceNum : window.get_workspace().index();
+
+    if (!time)
+        time = global.get_current_time();
+
+    if (windowWorkspaceNum != activeWorkspaceNum) {
+        let workspace = workspaceManager.get_workspace_by_index(windowWorkspaceNum);
+        workspace.activate_with_focus(window, time);
+    } else {
+        window.activate(time);
+    }
+
+    overview.hide();
+    panel.closeCalendar();
+}
+
+// TODO - replace this timeout with some system to guess when the user might
+// be e.g. just reading the screen and not likely to interact.
+var DEFERRED_TIMEOUT_SECONDS = 20;
+var _deferredWorkData = {};
+// Work scheduled for some point in the future
+var _deferredWorkQueue = [];
+// Work we need to process before the next redraw
+var _beforeRedrawQueue = [];
+// Counter to assign work ids
+var _deferredWorkSequence = 0;
+var _deferredTimeoutId = 0;
+
+function _runDeferredWork(workId) {
+    if (!_deferredWorkData[workId])
+        return;
+    let index = _deferredWorkQueue.indexOf(workId);
+    if (index < 0)
+        return;
+
+    _deferredWorkQueue.splice(index, 1);
+    _deferredWorkData[workId].callback();
+    if (_deferredWorkQueue.length == 0 && _deferredTimeoutId > 0) {
+        GLib.source_remove(_deferredTimeoutId);
+        _deferredTimeoutId = 0;
+    }
+}
+
+function _runAllDeferredWork() {
+    while (_deferredWorkQueue.length > 0)
+        _runDeferredWork(_deferredWorkQueue[0]);
+}
+
+function _runBeforeRedrawQueue() {
+    for (let i = 0; i < _beforeRedrawQueue.length; i++) {
+        let workId = _beforeRedrawQueue[i];
+        _runDeferredWork(workId);
+    }
+    _beforeRedrawQueue = [];
+}
+
+function _queueBeforeRedraw(workId) {
+    _beforeRedrawQueue.push(workId);
+    if (_beforeRedrawQueue.length == 1) {
+        Meta.later_add(Meta.LaterType.BEFORE_REDRAW, () => {
+            _runBeforeRedrawQueue();
+            return false;
+        });
+    }
+}
+
+/**
+ * initializeDeferredWork:
+ * @param {Clutter.Actor} actor: an actor
+ * @param {callback} callback: Function to invoke to perform work
+ *
+ * This function sets up a callback to be invoked when either the
+ * given actor is mapped, or after some period of time when the machine
+ * is idle. This is useful if your actor isn't always visible on the
+ * screen (for example, all actors in the overview), and you don't want
+ * to consume resources updating if the actor isn't actually going to be
+ * displaying to the user.
+ *
+ * Note that queueDeferredWork is called by default immediately on
+ * initialization as well, under the assumption that new actors
+ * will need it.
+ *
+ * @returns {string}: A string work identifier
+ */
+function initializeDeferredWork(actor, callback) {
+    // Turn into a string so we can use as an object property
+    let workId = (++_deferredWorkSequence).toString();
+    _deferredWorkData[workId] = { actor,
+                                  callback };
+    actor.connect('notify::mapped', () => {
+        if (!(actor.mapped && _deferredWorkQueue.includes(workId)))
+            return;
+        _queueBeforeRedraw(workId);
+    });
+    actor.connect('destroy', () => {
+        let index = _deferredWorkQueue.indexOf(workId);
+        if (index >= 0)
+            _deferredWorkQueue.splice(index, 1);
+        delete _deferredWorkData[workId];
+    });
+    queueDeferredWork(workId);
+    return workId;
+}
+
+/**
+ * queueDeferredWork:
+ * @param {string} workId: work identifier
+ *
+ * Ensure that the work identified by @workId will be
+ * run on map or timeout. You should call this function
+ * for example when data being displayed by the actor has
+ * changed.
+ */
+function queueDeferredWork(workId) {
+    let data = _deferredWorkData[workId];
+    if (!data) {
+        let message = 'Invalid work id %d'.format(workId);
+        logError(new Error(message), message);
+        return;
+    }
+    if (!_deferredWorkQueue.includes(workId))
+        _deferredWorkQueue.push(workId);
+    if (data.actor.mapped) {
+        _queueBeforeRedraw(workId);
+    } else if (_deferredTimeoutId == 0) {
+        _deferredTimeoutId = GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, DEFERRED_TIMEOUT_SECONDS, () => {
+            _runAllDeferredWork();
+            _deferredTimeoutId = 0;
+            return GLib.SOURCE_REMOVE;
+        });
+        GLib.Source.set_name_by_id(_deferredTimeoutId, '[gnome-shell] _runAllDeferredWork');
+    }
+}
+
+var RestartMessage = GObject.registerClass(
+class RestartMessage extends ModalDialog.ModalDialog {
+    _init(message) {
+        super._init({ shellReactive: true,
+                      styleClass: 'restart-message headline',
+                      shouldFadeIn: false,
+                      destroyOnClose: true });
+
+        let label = new St.Label({
+            text: message,
+            x_align: Clutter.ActorAlign.CENTER,
+            y_align: Clutter.ActorAlign.CENTER,
+        });
+
+        this.contentLayout.add_child(label);
+        this.buttonLayout.hide();
+    }
+});
+
+function showRestartMessage(message) {
+    let restartMessage = new RestartMessage(message);
+    restartMessage.open();
+}
+
+var AnimationsSettings = class {
+    constructor() {
+        let backend = Meta.get_backend();
+        if (!backend.is_rendering_hardware_accelerated()) {
+            St.Settings.get().inhibit_animations();
+            return;
+        }
+
+        let isXvnc = Shell.util_has_x11_display_extension(
+            global.display, 'VNC-EXTENSION');
+        if (isXvnc) {
+            St.Settings.get().inhibit_animations();
+            return;
+        }
+
+        let remoteAccessController = backend.get_remote_access_controller();
+        if (!remoteAccessController)
+            return;
+
+        this._handles = new Set();
+        remoteAccessController.connect('new-handle',
+            (_, handle) => this._onNewRemoteAccessHandle(handle));
+    }
+
+    _onRemoteAccessHandleStopped(handle) {
+        let settings = St.Settings.get();
+
+        settings.uninhibit_animations();
+        this._handles.delete(handle);
+    }
+
+    _onNewRemoteAccessHandle(handle) {
+        if (!handle.get_disable_animations())
+            return;
+
+        let settings = St.Settings.get();
+
+        settings.inhibit_animations();
+        this._handles.add(handle);
+        handle.connect('stopped', this._onRemoteAccessHandleStopped.bind(this));
+    }
+};

js/ui/messageList.js

@@ -0,0 +1,746 @@
+/* exported MessageListSection */
+const { Atk, Clutter, Gio, GLib,
+        GObject, Graphene, Meta, Pango, St } = imports.gi;
+const Main = imports.ui.main;
+const MessageTray = imports.ui.messageTray;
+
+const Calendar = imports.ui.calendar;
+const Util = imports.misc.util;
+
+var MESSAGE_ANIMATION_TIME = 100;
+
+var DEFAULT_EXPAND_LINES = 6;
+
+function _fixMarkup(text, allowMarkup) {
+    if (allowMarkup) {
+        // Support &, ", ', < and >, escape all other
+        // occurrences of '&'.
+        let _text = text.replace(/&(?!amp;|quot;|apos;|lt;|gt;)/g, '&');
+
+        // Support <b>, <i>, and <u>, escape anything else
+        // so it displays as raw markup.
+        // Ref: https://developer.gnome.org/notification-spec/#markup
+        _text = _text.replace(/<(?!\/?[biu]>)/g, '&lt;');
+
+        try {
+            Pango.parse_markup(_text, -1, '');
+            return _text;
+        } catch (e) {}
+    }
+
+    // !allowMarkup, or invalid markup
+    return GLib.markup_escape_text(text, -1);
+}
+
+var URLHighlighter = GObject.registerClass(
+class URLHighlighter extends St.Label {
+    _init(text = '', lineWrap, allowMarkup) {
+        super._init({
+            reactive: true,
+            style_class: 'url-highlighter',
+            x_expand: true,
+            x_align: Clutter.ActorAlign.START,
+        });
+        this._linkColor = '#ccccff';
+        this.connect('style-changed', () => {
+            let [hasColor, color] = this.get_theme_node().lookup_color('link-color', false);
+            if (hasColor) {
+                let linkColor = color.to_string().substr(0, 7);
+                if (linkColor != this._linkColor) {
+                    this._linkColor = linkColor;
+                    this._highlightUrls();
+                }
+            }
+        });
+        this.clutter_text.line_wrap = lineWrap;
+        this.clutter_text.line_wrap_mode = Pango.WrapMode.WORD_CHAR;
+
+        this.setMarkup(text, allowMarkup);
+    }
+
+    vfunc_button_press_event(buttonEvent) {
+        // Don't try to URL highlight when invisible.
+        // The MessageTray doesn't actually hide us, so
+        // we need to check for paint opacities as well.
+        if (!this.visible || this.get_paint_opacity() == 0)
+            return Clutter.EVENT_PROPAGATE;
+
+        // Keep Notification from seeing this and taking
+        // a pointer grab, which would block our button-release-event
+        // handler, if an URL is clicked
+        return this._findUrlAtPos(buttonEvent) != -1;
+    }
+
+    vfunc_button_release_event(buttonEvent) {
+        if (!this.visible || this.get_paint_opacity() == 0)
+            return Clutter.EVENT_PROPAGATE;
+
+        let urlId = this._findUrlAtPos(buttonEvent);
+        if (urlId != -1) {
+            let url = this._urls[urlId].url;
+            if (!url.includes(':'))
+                url = 'http://%s'.format(url);
+
+            Gio.app_info_launch_default_for_uri(
+                url, global.create_app_launch_context(0, -1));
+            return Clutter.EVENT_STOP;
+        }
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    vfunc_motion_event(motionEvent) {
+        if (!this.visible || this.get_paint_opacity() == 0)
+            return Clutter.EVENT_PROPAGATE;
+
+        let urlId = this._findUrlAtPos(motionEvent);
+        if (urlId != -1 && !this._cursorChanged) {
+            global.display.set_cursor(Meta.Cursor.POINTING_HAND);
+            this._cursorChanged = true;
+        } else if (urlId == -1) {
+            global.display.set_cursor(Meta.Cursor.DEFAULT);
+            this._cursorChanged = false;
+        }
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    vfunc_leave_event(crossingEvent) {
+        if (!this.visible || this.get_paint_opacity() == 0)
+            return Clutter.EVENT_PROPAGATE;
+
+        if (this._cursorChanged) {
+            this._cursorChanged = false;
+            global.display.set_cursor(Meta.Cursor.DEFAULT);
+        }
+        return super.vfunc_leave_event(crossingEvent);
+    }
+
+    setMarkup(text, allowMarkup) {
+        text = text ? _fixMarkup(text, allowMarkup) : '';
+        this._text = text;
+
+        this.clutter_text.set_markup(text);
+        /* clutter_text.text contain text without markup */
+        this._urls = Util.findUrls(this.clutter_text.text);
+        this._highlightUrls();
+    }
+
+    _highlightUrls() {
+        // text here contain markup
+        let urls = Util.findUrls(this._text);
+        let markup = '';
+        let pos = 0;
+        for (let i = 0; i < urls.length; i++) {
+            let url = urls[i];
+            let str = this._text.substr(pos, url.pos - pos);
+            markup += '%s<span foreground="%s"><u>%s</u></span>'.format(str, this._linkColor, url.url);
+            pos = url.pos + url.url.length;
+        }
+        markup += this._text.substr(pos);
+        this.clutter_text.set_markup(markup);
+    }
+
+    _findUrlAtPos(event) {
+        let { x, y } = event;
+        [, x, y] = this.transform_stage_point(x, y);
+        let findPos = -1;
+        for (let i = 0; i < this.clutter_text.text.length; i++) {
+            let [, px, py, lineHeight] = this.clutter_text.position_to_coords(i);
+            if (py > y || py + lineHeight < y || x < px)
+                continue;
+            findPos = i;
+        }
+        if (findPos != -1) {
+            for (let i = 0; i < this._urls.length; i++) {
+                if (findPos >= this._urls[i].pos &&
+                    this._urls[i].pos + this._urls[i].url.length > findPos)
+                    return i;
+            }
+        }
+        return -1;
+    }
+});
+
+var ScaleLayout = GObject.registerClass(
+class ScaleLayout extends Clutter.BinLayout {
+    _init(params) {
+        this._container = null;
+        super._init(params);
+    }
+
+    _connectContainer(container) {
+        if (this._container == container)
+            return;
+
+        if (this._container) {
+            for (let id of this._signals)
+                this._container.disconnect(id);
+        }
+
+        this._container = container;
+        this._signals = [];
+
+        if (this._container) {
+            for (let signal of ['notify::scale-x', 'notify::scale-y']) {
+                let id = this._container.connect(signal, () => {
+                    this.layout_changed();
+                });
+                this._signals.push(id);
+            }
+        }
+    }
+
+    vfunc_get_preferred_width(container, forHeight) {
+        this._connectContainer(container);
+
+        let [min, nat] = super.vfunc_get_preferred_width(container, forHeight);
+        return [Math.floor(min * container.scale_x),
+                Math.floor(nat * container.scale_x)];
+    }
+
+    vfunc_get_preferred_height(container, forWidth) {
+        this._connectContainer(container);
+
+        let [min, nat] = super.vfunc_get_preferred_height(container, forWidth);
+        return [Math.floor(min * container.scale_y),
+                Math.floor(nat * container.scale_y)];
+    }
+});
+
+var LabelExpanderLayout = GObject.registerClass({
+    Properties: {
+        'expansion': GObject.ParamSpec.double('expansion',
+                                              'Expansion',
+                                              'Expansion of the layout, between 0 (collapsed) ' +
+                                              'and 1 (fully expanded',
+                                              GObject.ParamFlags.READABLE | GObject.ParamFlags.WRITABLE,
+                                              0, 1, 0),
+    },
+}, class LabelExpanderLayout extends Clutter.LayoutManager {
+    _init(params) {
+        this._expansion = 0;
+        this._expandLines = DEFAULT_EXPAND_LINES;
+
+        super._init(params);
+    }
+
+    get expansion() {
+        return this._expansion;
+    }
+
+    set expansion(v) {
+        if (v == this._expansion)
+            return;
+        this._expansion = v;
+        this.notify('expansion');
+
+        let visibleIndex = this._expansion > 0 ? 1 : 0;
+        for (let i = 0; this._container && i < this._container.get_n_children(); i++)
+            this._container.get_child_at_index(i).visible = i == visibleIndex;
+
+        this.layout_changed();
+    }
+
+    set expandLines(v) {
+        if (v == this._expandLines)
+            return;
+        this._expandLines = v;
+        if (this._expansion > 0)
+            this.layout_changed();
+    }
+
+    vfunc_set_container(container) {
+        this._container = container;
+    }
+
+    vfunc_get_preferred_width(container, forHeight) {
+        let [min, nat] = [0, 0];
+
+        for (let i = 0; i < container.get_n_children(); i++) {
+            if (i > 1)
+                break; // we support one unexpanded + one expanded child
+
+            let child = container.get_child_at_index(i);
+            let [childMin, childNat] = child.get_preferred_width(forHeight);
+            [min, nat] = [Math.max(min, childMin), Math.max(nat, childNat)];
+        }
+
+        return [min, nat];
+    }
+
+    vfunc_get_preferred_height(container, forWidth) {
+        let [min, nat] = [0, 0];
+
+        let children = container.get_children();
+        if (children[0])
+            [min, nat] = children[0].get_preferred_height(forWidth);
+
+        if (children[1]) {
+            let [min2, nat2] = children[1].get_preferred_height(forWidth);
+            let [expMin, expNat] = [Math.min(min2, min * this._expandLines),
+                                    Math.min(nat2, nat * this._expandLines)];
+            [min, nat] = [min + this._expansion * (expMin - min),
+                          nat + this._expansion * (expNat - nat)];
+        }
+
+        return [min, nat];
+    }
+
+    vfunc_allocate(container, box, flags) {
+        for (let i = 0; i < container.get_n_children(); i++) {
+            let child = container.get_child_at_index(i);
+
+            if (child.visible)
+                child.allocate(box, flags);
+        }
+
+    }
+});
+
+
+var Message = GObject.registerClass({
+    Signals: {
+        'close': {},
+        'expanded': {},
+        'unexpanded': {},
+    },
+}, class Message extends St.Button {
+    _init(title, body) {
+        super._init({
+            style_class: 'message',
+            accessible_role: Atk.Role.NOTIFICATION,
+            can_focus: true,
+            x_expand: true,
+            y_expand: true,
+        });
+
+        this.expanded = false;
+        this._useBodyMarkup = false;
+
+        let vbox = new St.BoxLayout({
+            vertical: true,
+            x_expand: true,
+        });
+        this.set_child(vbox);
+
+        let hbox = new St.BoxLayout();
+        vbox.add_actor(hbox);
+
+        this._actionBin = new St.Widget({ layout_manager: new ScaleLayout(),
+                                          visible: false });
+        vbox.add_actor(this._actionBin);
+
+        this._iconBin = new St.Bin({ style_class: 'message-icon-bin',
+                                     y_expand: true,
+                                     y_align: Clutter.ActorAlign.START,
+                                     visible: false });
+        hbox.add_actor(this._iconBin);
+
+        let contentBox = new St.BoxLayout({ style_class: 'message-content',
+                                            vertical: true, x_expand: true });
+        hbox.add_actor(contentBox);
+
+        this._mediaControls = new St.BoxLayout();
+        hbox.add_actor(this._mediaControls);
+
+        let titleBox = new St.BoxLayout();
+        contentBox.add_actor(titleBox);
+
+        this.titleLabel = new St.Label({ style_class: 'message-title' });
+        this.setTitle(title);
+        titleBox.add_actor(this.titleLabel);
+
+        this._secondaryBin = new St.Bin({
+            style_class: 'message-secondary-bin',
+            x_expand: true, y_expand: true,
+        });
+        titleBox.add_actor(this._secondaryBin);
+
+        let closeIcon = new St.Icon({ icon_name: 'window-close-symbolic',
+                                      icon_size: 16 });
+        this._closeButton = new St.Button({
+            style_class: 'message-close-button',
+            child: closeIcon, opacity: 0,
+        });
+        titleBox.add_actor(this._closeButton);
+
+        this._bodyStack = new St.Widget({ x_expand: true });
+        this._bodyStack.layout_manager = new LabelExpanderLayout();
+        contentBox.add_actor(this._bodyStack);
+
+        this.bodyLabel = new URLHighlighter('', false, this._useBodyMarkup);
+        this.bodyLabel.add_style_class_name('message-body');
+        this._bodyStack.add_actor(this.bodyLabel);
+        this.setBody(body);
+
+        this._closeButton.connect('clicked', this.close.bind(this));
+        let actorHoverId = this.connect('notify::hover', this._sync.bind(this));
+        this._closeButton.connect('destroy', this.disconnect.bind(this, actorHoverId));
+        this.connect('destroy', this._onDestroy.bind(this));
+        this._sync();
+    }
+
+    close() {
+        this.emit('close');
+    }
+
+    setIcon(actor) {
+        this._iconBin.child = actor;
+        this._iconBin.visible = actor != null;
+    }
+
+    setSecondaryActor(actor) {
+        this._secondaryBin.child = actor;
+    }
+
+    setTitle(text) {
+        let title = text ? _fixMarkup(text.replace(/\n/g, ' '), false) : '';
+        this.titleLabel.clutter_text.set_markup(title);
+    }
+
+    setBody(text) {
+        this._bodyText = text;
+        this.bodyLabel.setMarkup(text ? text.replace(/\n/g, ' ') : '',
+                                 this._useBodyMarkup);
+        if (this._expandedLabel)
+            this._expandedLabel.setMarkup(text, this._useBodyMarkup);
+    }
+
+    setUseBodyMarkup(enable) {
+        if (this._useBodyMarkup === enable)
+            return;
+        this._useBodyMarkup = enable;
+        if (this.bodyLabel)
+            this.setBody(this._bodyText);
+    }
+
+    setActionArea(actor) {
+        if (actor == null) {
+            if (this._actionBin.get_n_children() > 0)
+                this._actionBin.get_child_at_index(0).destroy();
+            return;
+        }
+
+        if (this._actionBin.get_n_children() > 0)
+            throw new Error('Message already has an action area');
+
+        this._actionBin.add_actor(actor);
+        this._actionBin.visible = this.expanded;
+    }
+
+    addMediaControl(iconName, callback) {
+        let icon = new St.Icon({ icon_name: iconName, icon_size: 16 });
+        let button = new St.Button({ style_class: 'message-media-control',
+                                     child: icon });
+        button.connect('clicked', callback);
+        this._mediaControls.add_actor(button);
+        return button;
+    }
+
+    setExpandedBody(actor) {
+        if (actor == null) {
+            if (this._bodyStack.get_n_children() > 1)
+                this._bodyStack.get_child_at_index(1).destroy();
+            return;
+        }
+
+        if (this._bodyStack.get_n_children() > 1)
+            throw new Error('Message already has an expanded body actor');
+
+        this._bodyStack.insert_child_at_index(actor, 1);
+    }
+
+    setExpandedLines(nLines) {
+        this._bodyStack.layout_manager.expandLines = nLines;
+    }
+
+    expand(animate) {
+        this.expanded = true;
+
+        this._actionBin.visible = this._actionBin.get_n_children() > 0;
+
+        if (this._bodyStack.get_n_children() < 2) {
+            this._expandedLabel = new URLHighlighter(this._bodyText,
+                                                     true, this._useBodyMarkup);
+            this.setExpandedBody(this._expandedLabel);
+        }
+
+        if (animate) {
+            this._bodyStack.ease_property('@layout.expansion', 1, {
+                progress_mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+                duration: MessageTray.ANIMATION_TIME,
+            });
+
+            this._actionBin.scale_y = 0;
+            this._actionBin.ease({
+                scale_y: 1,
+                duration: MessageTray.ANIMATION_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            });
+        } else {
+            this._bodyStack.layout_manager.expansion = 1;
+            this._actionBin.scale_y = 1;
+        }
+
+        this.emit('expanded');
+    }
+
+    unexpand(animate) {
+        if (animate) {
+            this._bodyStack.ease_property('@layout.expansion', 0, {
+                progress_mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+                duration: MessageTray.ANIMATION_TIME,
+            });
+
+            this._actionBin.ease({
+                scale_y: 0,
+                duration: MessageTray.ANIMATION_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+                onComplete: () => {
+                    this._actionBin.hide();
+                    this.expanded = false;
+                },
+            });
+        } else {
+            this._bodyStack.layout_manager.expansion = 0;
+            this._actionBin.scale_y = 0;
+            this.expanded = false;
+        }
+
+        this.emit('unexpanded');
+    }
+
+    canClose() {
+        return false;
+    }
+
+    _sync() {
+        let visible = this.hover && this.canClose();
+        this._closeButton.opacity = visible ? 255 : 0;
+        this._closeButton.reactive = visible;
+    }
+
+    _onDestroy() {
+    }
+
+    vfunc_key_press_event(keyEvent) {
+        let keysym = keyEvent.keyval;
+
+        if (keysym == Clutter.KEY_Delete ||
+            keysym == Clutter.KEY_KP_Delete) {
+            this.close();
+            return Clutter.EVENT_STOP;
+        }
+        return Clutter.EVENT_PROPAGATE;
+    }
+});
+
+var MessageListSection = GObject.registerClass({
+    Properties: {
+        'can-clear': GObject.ParamSpec.boolean(
+            'can-clear', 'can-clear', 'can-clear',
+            GObject.ParamFlags.READABLE,
+            false),
+        'empty': GObject.ParamSpec.boolean(
+            'empty', 'empty', 'empty',
+            GObject.ParamFlags.READABLE,
+            true),
+    },
+    Signals: {
+        'can-clear-changed': {},
+        'empty-changed': {},
+        'message-focused': { param_types: [Message.$gtype] },
+    },
+}, class MessageListSection extends St.BoxLayout {
+    _init() {
+        super._init({
+            style_class: 'message-list-section',
+            clip_to_allocation: true,
+            vertical: true,
+            x_expand: true,
+        });
+
+        this._list = new St.BoxLayout({ style_class: 'message-list-section-list',
+                                        vertical: true });
+        this.add_actor(this._list);
+
+        this._list.connect('actor-added', this._sync.bind(this));
+        this._list.connect('actor-removed', this._sync.bind(this));
+
+        let id = Main.sessionMode.connect('updated',
+                                          this._sync.bind(this));
+        this.connect('destroy', () => {
+            Main.sessionMode.disconnect(id);
+        });
+
+        this._date = new Date();
+        this._empty = true;
+        this._canClear = false;
+        this._sync();
+    }
+
+    get empty() {
+        return this._empty;
+    }
+
+    get canClear() {
+        return this._canClear;
+    }
+
+    get _messages() {
+        return this._list.get_children().map(i => i.child);
+    }
+
+    _onKeyFocusIn(messageActor) {
+        this.emit('message-focused', messageActor);
+    }
+
+    get allowed() {
+        return true;
+    }
+
+    setDate(date) {
+        if (Calendar.sameDay(date, this._date))
+            return;
+        this._date = date;
+        this._sync();
+    }
+
+    addMessage(message, animate) {
+        this.addMessageAtIndex(message, -1, animate);
+    }
+
+    addMessageAtIndex(message, index, animate) {
+        if (this._messages.includes(message))
+            throw new Error('Message was already added previously');
+
+        let listItem = new St.Bin({
+            child: message,
+            layout_manager: new ScaleLayout(),
+            pivot_point: new Graphene.Point({ x: .5, y: .5 }),
+        });
+        listItem._connectionsIds = [];
+
+        listItem._connectionsIds.push(message.connect('key-focus-in',
+            this._onKeyFocusIn.bind(this)));
+        listItem._connectionsIds.push(message.connect('close', () => {
+            this.removeMessage(message, true);
+        }));
+        listItem._connectionsIds.push(message.connect('destroy', () => {
+            listItem._connectionsIds.forEach(id => message.disconnect(id));
+            listItem.destroy();
+        }));
+
+        this._list.insert_child_at_index(listItem, index);
+
+        if (animate) {
+            listItem.set({ scale_x: 0, scale_y: 0 });
+            listItem.ease({
+                scale_x: 1,
+                scale_y: 1,
+                duration: MESSAGE_ANIMATION_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            });
+        }
+    }
+
+    moveMessage(message, index, animate) {
+        if (!this._messages.includes(message))
+            throw new Error(`Impossible to move untracked message`);
+
+        let listItem = message.get_parent();
+
+        if (!animate) {
+            this._list.set_child_at_index(listItem, index);
+            return;
+        }
+
+        let onComplete = () => {
+            this._list.set_child_at_index(listItem, index);
+            listItem.ease({
+                scale_x: 1,
+                scale_y: 1,
+                duration: MESSAGE_ANIMATION_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            });
+        };
+        listItem.ease({
+            scale_x: 0,
+            scale_y: 0,
+            duration: MESSAGE_ANIMATION_TIME,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            onComplete,
+        });
+    }
+
+    removeMessage(message, animate) {
+        if (!this._messages.includes(message))
+            throw new Error(`Impossible to remove untracked message`);
+
+        let listItem = message.get_parent();
+        listItem._connectionsIds.forEach(id => message.disconnect(id));
+
+        if (animate) {
+            listItem.ease({
+                scale_x: 0,
+                scale_y: 0,
+                duration: MESSAGE_ANIMATION_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+                onComplete: () => {
+                    listItem.destroy();
+                    global.sync_pointer();
+                },
+            });
+        } else {
+            listItem.destroy();
+            global.sync_pointer();
+        }
+    }
+
+    clear() {
+        let messages = this._messages.filter(msg => msg.canClose());
+
+        // If there are few messages, letting them all zoom out looks OK
+        if (messages.length < 2) {
+            messages.forEach(message => {
+                message.close();
+            });
+        } else {
+            // Otherwise we slide them out one by one, and then zoom them
+            // out "off-screen" in the end to smoothly shrink the parent
+            let delay = MESSAGE_ANIMATION_TIME / Math.max(messages.length, 5);
+            for (let i = 0; i < messages.length; i++) {
+                let message = messages[i];
+                message.get_parent().ease({
+                    translation_x: this._list.width,
+                    opacity: 0,
+                    duration: MESSAGE_ANIMATION_TIME,
+                    delay: i * delay,
+                    mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+                    onComplete: () => message.close(),
+                });
+            }
+        }
+    }
+
+    _shouldShow() {
+        return !this.empty;
+    }
+
+    _sync() {
+        let messages = this._messages;
+        let empty = messages.length == 0;
+
+        if (this._empty != empty) {
+            this._empty = empty;
+            this.notify('empty');
+        }
+
+        let canClear = messages.some(m => m.canClose());
+        if (this._canClear != canClear) {
+            this._canClear = canClear;
+            this.notify('can-clear');
+        }
+
+        this.visible = this.allowed && this._shouldShow();
+    }
+});

js/ui/modalDialog.js

@@ -0,0 +1,264 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported ModalDialog */
+
+const { Atk, Clutter, GObject, Shell, St } = imports.gi;
+
+const Dialog = imports.ui.dialog;
+const Layout = imports.ui.layout;
+const Lightbox = imports.ui.lightbox;
+const Main = imports.ui.main;
+const Params = imports.misc.params;
+
+var OPEN_AND_CLOSE_TIME = 100;
+var FADE_OUT_DIALOG_TIME = 1000;
+
+var State = {
+    OPENED: 0,
+    CLOSED: 1,
+    OPENING: 2,
+    CLOSING: 3,
+    FADED_OUT: 4,
+};
+
+var ModalDialog = GObject.registerClass({
+    Properties: {
+        'state': GObject.ParamSpec.int('state', 'Dialog state', 'state',
+                                       GObject.ParamFlags.READABLE,
+                                       Math.min(...Object.values(State)),
+                                       Math.max(...Object.values(State)),
+                                       State.CLOSED),
+    },
+    Signals: { 'opened': {}, 'closed': {} },
+}, class ModalDialog extends St.Widget {
+    _init(params) {
+        super._init({ visible: false,
+                      x: 0,
+                      y: 0,
+                      accessible_role: Atk.Role.DIALOG });
+
+        params = Params.parse(params, { shellReactive: false,
+                                        styleClass: null,
+                                        actionMode: Shell.ActionMode.SYSTEM_MODAL,
+                                        shouldFadeIn: true,
+                                        shouldFadeOut: true,
+                                        destroyOnClose: true });
+
+        this._state = State.CLOSED;
+        this._hasModal = false;
+        this._actionMode = params.actionMode;
+        this._shellReactive = params.shellReactive;
+        this._shouldFadeIn = params.shouldFadeIn;
+        this._shouldFadeOut = params.shouldFadeOut;
+        this._destroyOnClose = params.destroyOnClose;
+
+        Main.layoutManager.modalDialogGroup.add_actor(this);
+
+        let constraint = new Clutter.BindConstraint({ source: global.stage,
+                                                      coordinate: Clutter.BindCoordinate.ALL });
+        this.add_constraint(constraint);
+
+        this.backgroundStack = new St.Widget({
+            layout_manager: new Clutter.BinLayout(),
+            x_expand: true,
+            y_expand: true,
+        });
+        this._backgroundBin = new St.Bin({ child: this.backgroundStack });
+        this._monitorConstraint = new Layout.MonitorConstraint();
+        this._backgroundBin.add_constraint(this._monitorConstraint);
+        this.add_actor(this._backgroundBin);
+
+        this.dialogLayout = new Dialog.Dialog(this.backgroundStack, params.styleClass);
+        this.contentLayout = this.dialogLayout.contentLayout;
+        this.buttonLayout = this.dialogLayout.buttonLayout;
+
+        if (!this._shellReactive) {
+            this._lightbox = new Lightbox.Lightbox(this,
+                                                   { inhibitEvents: true,
+                                                     radialEffect: true });
+            this._lightbox.highlight(this._backgroundBin);
+
+            this._eventBlocker = new Clutter.Actor({ reactive: true });
+            this.backgroundStack.add_actor(this._eventBlocker);
+        }
+
+        global.focus_manager.add_group(this.dialogLayout);
+        this._initialKeyFocus = null;
+        this._initialKeyFocusDestroyId = 0;
+        this._savedKeyFocus = null;
+    }
+
+    get state() {
+        return this._state;
+    }
+
+    _setState(state) {
+        if (this._state == state)
+            return;
+
+        this._state = state;
+        this.notify('state');
+    }
+
+    clearButtons() {
+        this.dialogLayout.clearButtons();
+    }
+
+    setButtons(buttons) {
+        this.clearButtons();
+
+        for (let buttonInfo of buttons)
+            this.addButton(buttonInfo);
+    }
+
+    addButton(buttonInfo) {
+        return this.dialogLayout.addButton(buttonInfo);
+    }
+
+    _fadeOpen(onPrimary) {
+        if (onPrimary)
+            this._monitorConstraint.primary = true;
+        else
+            this._monitorConstraint.index = global.display.get_current_monitor();
+
+        this._setState(State.OPENING);
+
+        this.dialogLayout.opacity = 255;
+        if (this._lightbox)
+            this._lightbox.lightOn();
+        this.opacity = 0;
+        this.show();
+        this.ease({
+            opacity: 255,
+            duration: this._shouldFadeIn ? OPEN_AND_CLOSE_TIME : 0,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            onComplete: () => {
+                this._setState(State.OPENED);
+                this.emit('opened');
+            },
+        });
+    }
+
+    setInitialKeyFocus(actor) {
+        if (this._initialKeyFocusDestroyId)
+            this._initialKeyFocus.disconnect(this._initialKeyFocusDestroyId);
+
+        this._initialKeyFocus = actor;
+
+        this._initialKeyFocusDestroyId = actor.connect('destroy', () => {
+            this._initialKeyFocus = null;
+            this._initialKeyFocusDestroyId = 0;
+        });
+    }
+
+    open(timestamp, onPrimary) {
+        if (this.state == State.OPENED || this.state == State.OPENING)
+            return true;
+
+        if (!this.pushModal(timestamp))
+            return false;
+
+        this._fadeOpen(onPrimary);
+        return true;
+    }
+
+    _closeComplete() {
+        this._setState(State.CLOSED);
+        this.hide();
+        this.emit('closed');
+
+        if (this._destroyOnClose)
+            this.destroy();
+    }
+
+    close(timestamp) {
+        if (this.state == State.CLOSED || this.state == State.CLOSING)
+            return;
+
+        this._setState(State.CLOSING);
+        this.popModal(timestamp);
+        this._savedKeyFocus = null;
+
+        if (this._shouldFadeOut) {
+            this.ease({
+                opacity: 0,
+                duration: OPEN_AND_CLOSE_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+                onComplete: () => this._closeComplete(),
+            });
+        } else {
+            this._closeComplete();
+        }
+    }
+
+    // Drop modal status without closing the dialog; this makes the
+    // dialog insensitive as well, so it needs to be followed shortly
+    // by either a close() or a pushModal()
+    popModal(timestamp) {
+        if (!this._hasModal)
+            return;
+
+        let focus = global.stage.key_focus;
+        if (focus && this.contains(focus))
+            this._savedKeyFocus = focus;
+        else
+            this._savedKeyFocus = null;
+        Main.popModal(this, timestamp);
+        this._hasModal = false;
+
+        if (!this._shellReactive)
+            this.backgroundStack.set_child_above_sibling(this._eventBlocker, null);
+    }
+
+    pushModal(timestamp) {
+        if (this._hasModal)
+            return true;
+
+        let params = { actionMode: this._actionMode };
+        if (timestamp)
+            params['timestamp'] = timestamp;
+        if (!Main.pushModal(this, params))
+            return false;
+
+        Main.layoutManager.emit('system-modal-opened');
+
+        this._hasModal = true;
+        if (this._savedKeyFocus) {
+            this._savedKeyFocus.grab_key_focus();
+            this._savedKeyFocus = null;
+        } else {
+            let focus = this._initialKeyFocus || this.dialogLayout.initialKeyFocus;
+            focus.grab_key_focus();
+        }
+
+        if (!this._shellReactive)
+            this.backgroundStack.set_child_below_sibling(this._eventBlocker, null);
+        return true;
+    }
+
+    // This method is like close, but fades the dialog out much slower,
+    // and leaves the lightbox in place. Once in the faded out state,
+    // the dialog can be brought back by an open call, or the lightbox
+    // can be dismissed by a close call.
+    //
+    // The main point of this method is to give some indication to the user
+    // that the dialog response has been acknowledged but will take a few
+    // moments before being processed.
+    // e.g., if a user clicked "Log Out" then the dialog should go away
+    // immediately, but the lightbox should remain until the logout is
+    // complete.
+    _fadeOutDialog(timestamp) {
+        if (this.state == State.CLOSED || this.state == State.CLOSING)
+            return;
+
+        if (this.state == State.FADED_OUT)
+            return;
+
+        this.popModal(timestamp);
+        this.dialogLayout.ease({
+            opacity: 0,
+            duration: FADE_OUT_DIALOG_TIME,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            onComplete: () => (this.state = State.FADED_OUT),
+        });
+    }
+});

js/ui/mpris.js

@@ -0,0 +1,300 @@
+/* exported MediaSection */
+const { Gio, GObject, Shell, St } = imports.gi;
+const Signals = imports.signals;
+
+const Calendar = imports.ui.calendar;
+const Main = imports.ui.main;
+const MessageList = imports.ui.messageList;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const DBusIface = loadInterfaceXML('org.freedesktop.DBus');
+const DBusProxy = Gio.DBusProxy.makeProxyWrapper(DBusIface);
+
+const MprisIface = loadInterfaceXML('org.mpris.MediaPlayer2');
+const MprisProxy = Gio.DBusProxy.makeProxyWrapper(MprisIface);
+
+const MprisPlayerIface = loadInterfaceXML('org.mpris.MediaPlayer2.Player');
+const MprisPlayerProxy = Gio.DBusProxy.makeProxyWrapper(MprisPlayerIface);
+
+const MPRIS_PLAYER_PREFIX = 'org.mpris.MediaPlayer2.';
+
+var MediaMessage = GObject.registerClass(
+class MediaMessage extends MessageList.Message {
+    _init(player) {
+        super._init('', '');
+
+        this._player = player;
+
+        this._icon = new St.Icon({ style_class: 'media-message-cover-icon' });
+        this.setIcon(this._icon);
+
+        this._prevButton = this.addMediaControl('media-skip-backward-symbolic',
+            () => {
+                this._player.previous();
+            });
+
+        this._playPauseButton = this.addMediaControl(null,
+            () => {
+                this._player.playPause();
+            });
+
+        this._nextButton = this.addMediaControl('media-skip-forward-symbolic',
+            () => {
+                this._player.next();
+            });
+
+        this._updateHandlerId =
+            this._player.connect('changed', this._update.bind(this));
+        this._closedHandlerId =
+            this._player.connect('closed', this.close.bind(this));
+        this._update();
+    }
+
+    _onDestroy() {
+        super._onDestroy();
+        this._player.disconnect(this._updateHandlerId);
+        this._player.disconnect(this._closedHandlerId);
+    }
+
+    vfunc_clicked() {
+        this._player.raise();
+        Main.panel.closeCalendar();
+    }
+
+    _updateNavButton(button, sensitive) {
+        button.reactive = sensitive;
+    }
+
+    _update() {
+        this.setTitle(this._player.trackArtists.join(', '));
+        this.setBody(this._player.trackTitle);
+
+        if (this._player.trackCoverUrl) {
+            let file = Gio.File.new_for_uri(this._player.trackCoverUrl);
+            this._icon.gicon = new Gio.FileIcon({ file });
+            this._icon.remove_style_class_name('fallback');
+        } else {
+            this._icon.icon_name = 'audio-x-generic-symbolic';
+            this._icon.add_style_class_name('fallback');
+        }
+
+        let isPlaying = this._player.status == 'Playing';
+        let iconName = isPlaying
+            ? 'media-playback-pause-symbolic'
+            : 'media-playback-start-symbolic';
+        this._playPauseButton.child.icon_name = iconName;
+
+        this._updateNavButton(this._prevButton, this._player.canGoPrevious);
+        this._updateNavButton(this._nextButton, this._player.canGoNext);
+    }
+});
+
+var MprisPlayer = class MprisPlayer {
+    constructor(busName) {
+        this._mprisProxy = new MprisProxy(Gio.DBus.session, busName,
+                                          '/org/mpris/MediaPlayer2',
+                                          this._onMprisProxyReady.bind(this));
+        this._playerProxy = new MprisPlayerProxy(Gio.DBus.session, busName,
+                                                 '/org/mpris/MediaPlayer2',
+                                                 this._onPlayerProxyReady.bind(this));
+
+        this._visible = false;
+        this._trackArtists = [];
+        this._trackTitle = '';
+        this._trackCoverUrl = '';
+        this._busName = busName;
+    }
+
+    get status() {
+        return this._playerProxy.PlaybackStatus;
+    }
+
+    get trackArtists() {
+        return this._trackArtists;
+    }
+
+    get trackTitle() {
+        return this._trackTitle;
+    }
+
+    get trackCoverUrl() {
+        return this._trackCoverUrl;
+    }
+
+    playPause() {
+        this._playerProxy.PlayPauseRemote();
+    }
+
+    get canGoNext() {
+        return this._playerProxy.CanGoNext;
+    }
+
+    next() {
+        this._playerProxy.NextRemote();
+    }
+
+    get canGoPrevious() {
+        return this._playerProxy.CanGoPrevious;
+    }
+
+    previous() {
+        this._playerProxy.PreviousRemote();
+    }
+
+    raise() {
+        // The remote Raise() method may run into focus stealing prevention,
+        // so prefer activating the app via .desktop file if possible
+        let app = null;
+        if (this._mprisProxy.DesktopEntry) {
+            let desktopId = '%s.desktop'.format(this._mprisProxy.DesktopEntry);
+            app = Shell.AppSystem.get_default().lookup_app(desktopId);
+        }
+
+        if (app)
+            app.activate();
+        else if (this._mprisProxy.CanRaise)
+            this._mprisProxy.RaiseRemote();
+    }
+
+    _close() {
+        this._mprisProxy.disconnect(this._ownerNotifyId);
+        this._mprisProxy = null;
+
+        this._playerProxy.disconnect(this._propsChangedId);
+        this._playerProxy = null;
+
+        this.emit('closed');
+    }
+
+    _onMprisProxyReady() {
+        this._ownerNotifyId = this._mprisProxy.connect('notify::g-name-owner',
+            () => {
+                if (!this._mprisProxy.g_name_owner)
+                    this._close();
+            });
+    }
+
+    _onPlayerProxyReady() {
+        this._propsChangedId = this._playerProxy.connect('g-properties-changed',
+                                                         this._updateState.bind(this));
+        this._updateState();
+    }
+
+    _updateState() {
+        let metadata = {};
+        for (let prop in this._playerProxy.Metadata)
+            metadata[prop] = this._playerProxy.Metadata[prop].deep_unpack();
+
+        // Validate according to the spec; some clients send buggy metadata:
+        // https://www.freedesktop.org/wiki/Specifications/mpris-spec/metadata
+        this._trackArtists = metadata['xesam:artist'];
+        if (!Array.isArray(this._trackArtists) ||
+            !this._trackArtists.every(artist => typeof artist === 'string')) {
+            if (typeof this._trackArtists !== 'undefined') {
+                log(('Received faulty track artist metadata from %s; ' +
+                    'expected an array of strings, got %s (%s)').format(
+                    this._busName, this._trackArtists, typeof this._trackArtists));
+            }
+            this._trackArtists =  [_("Unknown artist")];
+        }
+
+        this._trackTitle = metadata['xesam:title'];
+        if (typeof this._trackTitle !== 'string') {
+            if (typeof this._trackTitle !== 'undefined') {
+                log(('Received faulty track title metadata from %s; ' +
+                    'expected a string, got %s (%s)').format(
+                    this._busName, this._trackTitle, typeof this._trackTitle));
+            }
+            this._trackTitle = _("Unknown title");
+        }
+
+        this._trackCoverUrl = metadata['mpris:artUrl'];
+        if (typeof this._trackCoverUrl !== 'string') {
+            if (typeof this._trackCoverUrl !== 'undefined') {
+                log(('Received faulty track cover art metadata from %s; ' +
+                    'expected a string, got %s (%s)').format(
+                    this._busName, this._trackCoverUrl, typeof this._trackCoverUrl));
+            }
+            this._trackCoverUrl = '';
+        }
+
+        this.emit('changed');
+
+        let visible = this._playerProxy.CanPlay;
+
+        if (this._visible != visible) {
+            this._visible = visible;
+            if (visible)
+                this.emit('show');
+            else
+                this.emit('hide');
+        }
+    }
+};
+Signals.addSignalMethods(MprisPlayer.prototype);
+
+var MediaSection = GObject.registerClass(
+class MediaSection extends MessageList.MessageListSection {
+    _init() {
+        super._init();
+
+        this._players = new Map();
+
+        this._proxy = new DBusProxy(Gio.DBus.session,
+                                    'org.freedesktop.DBus',
+                                    '/org/freedesktop/DBus',
+                                    this._onProxyReady.bind(this));
+    }
+
+    _shouldShow() {
+        return !this.empty && Calendar.isToday(this._date);
+    }
+
+    get allowed() {
+        return !Main.sessionMode.isGreeter;
+    }
+
+    _addPlayer(busName) {
+        if (this._players.get(busName))
+            return;
+
+        let player = new MprisPlayer(busName);
+        let message = null;
+        player.connect('closed',
+            () => {
+                this._players.delete(busName);
+            });
+        player.connect('show', () => {
+            message = new MediaMessage(player);
+            this.addMessage(message, true);
+        });
+        player.connect('hide', () => {
+            this.removeMessage(message, true);
+            message = null;
+        });
+
+        this._players.set(busName, player);
+    }
+
+    _onProxyReady() {
+        this._proxy.ListNamesRemote(([names]) => {
+            names.forEach(name => {
+                if (!name.startsWith(MPRIS_PLAYER_PREFIX))
+                    return;
+
+                this._addPlayer(name);
+            });
+        });
+        this._proxy.connectSignal('NameOwnerChanged',
+                                  this._onNameOwnerChanged.bind(this));
+    }
+
+    _onNameOwnerChanged(proxy, sender, [name, oldOwner, newOwner]) {
+        if (!name.startsWith(MPRIS_PLAYER_PREFIX))
+            return;
+
+        if (newOwner && !oldOwner)
+            this._addPlayer(name);
+    }
+});

js/ui/notificationDaemon.js

@@ -0,0 +1,835 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported NotificationDaemon */
+
+const { GdkPixbuf, Gio, GLib, GObject, Shell, St } = imports.gi;
+
+const Config = imports.misc.config;
+const Main = imports.ui.main;
+const MessageTray = imports.ui.messageTray;
+const Params = imports.misc.params;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+// Should really be defined in Gio.js
+const BusIface = loadInterfaceXML('org.freedesktop.DBus');
+var BusProxy = Gio.DBusProxy.makeProxyWrapper(BusIface);
+function Bus() {
+    return new BusProxy(Gio.DBus.session, 'org.freedesktop.DBus', '/org/freedesktop/DBus');
+}
+
+const FdoNotificationsIface = loadInterfaceXML('org.freedesktop.Notifications');
+
+var NotificationClosedReason = {
+    EXPIRED: 1,
+    DISMISSED: 2,
+    APP_CLOSED: 3,
+    UNDEFINED: 4,
+};
+
+var Urgency = {
+    LOW: 0,
+    NORMAL: 1,
+    CRITICAL: 2,
+};
+
+const rewriteRules = {
+    'XChat': [
+        { pattern:     /^XChat: Private message from: (\S*) \(.*\)$/,
+          replacement: '<$1>' },
+        { pattern:     /^XChat: New public message from: (\S*) \((.*)\)$/,
+          replacement: '$2 <$1>' },
+        { pattern:     /^XChat: Highlighted message from: (\S*) \((.*)\)$/,
+          replacement: '$2 <$1>' },
+    ],
+};
+
+var FdoNotificationDaemon = class FdoNotificationDaemon {
+    constructor() {
+        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(FdoNotificationsIface, this);
+        this._dbusImpl.export(Gio.DBus.session, '/org/freedesktop/Notifications');
+
+        this._sources = [];
+        this._senderToPid = {};
+        this._notifications = {};
+        this._busProxy = new Bus();
+
+        this._nextNotificationId = 1;
+
+        Shell.WindowTracker.get_default().connect('notify::focus-app',
+            this._onFocusAppChanged.bind(this));
+        Main.overview.connect('hidden',
+            this._onFocusAppChanged.bind(this));
+    }
+
+    _imageForNotificationData(hints) {
+        if (hints['image-data']) {
+            let [width, height, rowStride, hasAlpha,
+                 bitsPerSample, nChannels_, data] = hints['image-data'];
+            return Shell.util_create_pixbuf_from_data(data, GdkPixbuf.Colorspace.RGB, hasAlpha,
+                                                      bitsPerSample, width, height, rowStride);
+        } else if (hints['image-path']) {
+            return this._iconForNotificationData(hints['image-path']);
+        }
+        return null;
+    }
+
+    _fallbackIconForNotificationData(hints) {
+        let stockIcon;
+        switch (hints.urgency) {
+        case Urgency.LOW:
+        case Urgency.NORMAL:
+            stockIcon = 'dialog-information';
+            break;
+        case Urgency.CRITICAL:
+            stockIcon = 'dialog-error';
+            break;
+        }
+        return new Gio.ThemedIcon({ name: stockIcon });
+    }
+
+    _iconForNotificationData(icon) {
+        if (icon) {
+            if (icon.substr(0, 7) == 'file://')
+                return new Gio.FileIcon({ file: Gio.File.new_for_uri(icon) });
+            else if (icon[0] == '/')
+                return new Gio.FileIcon({ file: Gio.File.new_for_path(icon) });
+            else
+                return new Gio.ThemedIcon({ name: icon });
+        }
+        return null;
+    }
+
+    _lookupSource(title, pid) {
+        for (let i = 0; i < this._sources.length; i++) {
+            let source = this._sources[i];
+            if (source.pid == pid && source.initialTitle == title)
+                return source;
+        }
+        return null;
+    }
+
+    // Returns the source associated with ndata.notification if it is set.
+    // If the existing or requested source is associated with a tray icon
+    // and passed in pid matches a pid of an existing source, the title
+    // match is ignored to enable representing a tray icon and notifications
+    // from the same application with a single source.
+    //
+    // If no existing source is found, a new source is created as long as
+    // pid is provided.
+    //
+    // Either a pid or ndata.notification is needed to retrieve or
+    // create a source.
+    _getSource(title, pid, ndata, sender) {
+        if (!pid && !(ndata && ndata.notification))
+            return null;
+
+        // We use notification's source for the notifications we still have
+        // around that are getting replaced because we don't keep sources
+        // for transient notifications in this._sources, but we still want
+        // the notification associated with them to get replaced correctly.
+        if (ndata && ndata.notification)
+            return ndata.notification.source;
+
+        let source = this._lookupSource(title, pid);
+        if (source) {
+            source.setTitle(title);
+            return source;
+        }
+
+        let appId = ndata ? ndata.hints['desktop-entry'] || null : null;
+        source = new FdoNotificationDaemonSource(title, pid, sender, appId);
+
+        this._sources.push(source);
+        source.connect('destroy', () => {
+            let index = this._sources.indexOf(source);
+            if (index >= 0)
+                this._sources.splice(index, 1);
+        });
+
+        Main.messageTray.add(source);
+        return source;
+    }
+
+    NotifyAsync(params, invocation) {
+        let [appName, replacesId, icon, summary, body, actions, hints, timeout] = params;
+        let id;
+
+        for (let hint in hints) {
+            // unpack the variants
+            hints[hint] = hints[hint].deep_unpack();
+        }
+
+        hints = Params.parse(hints, { urgency: Urgency.NORMAL }, true);
+
+        // Filter out chat, presence, calls and invitation notifications from
+        // Empathy, since we handle that information from telepathyClient.js
+        //
+        // Note that empathy uses im.received for one to one chats and
+        // x-empathy.im.mentioned for multi-user, so we're good here
+        if (appName == 'Empathy' && hints['category'] == 'im.received') {
+            // Ignore replacesId since we already sent back a
+            // NotificationClosed for that id.
+            id = this._nextNotificationId++;
+            let idleId = GLib.idle_add(GLib.PRIORITY_DEFAULT, () => {
+                this._emitNotificationClosed(id, NotificationClosedReason.DISMISSED);
+                return GLib.SOURCE_REMOVE;
+            });
+            GLib.Source.set_name_by_id(idleId, '[gnome-shell] this._emitNotificationClosed');
+            return invocation.return_value(GLib.Variant.new('(u)', [id]));
+        }
+
+        let rewrites = rewriteRules[appName];
+        if (rewrites) {
+            for (let i = 0; i < rewrites.length; i++) {
+                let rule = rewrites[i];
+                if (summary.search(rule.pattern) != -1)
+                    summary = summary.replace(rule.pattern, rule.replacement);
+            }
+        }
+
+        // Be compatible with the various hints for image data and image path
+        // 'image-data' and 'image-path' are the latest name of these hints, introduced in 1.2
+
+        if (!hints['image-path'] && hints['image_path'])
+            hints['image-path'] = hints['image_path']; // version 1.1 of the spec
+
+        if (!hints['image-data']) {
+            if (hints['image_data'])
+                hints['image-data'] = hints['image_data']; // version 1.1 of the spec
+            else if (hints['icon_data'] && !hints['image-path'])
+                // early versions of the spec; 'icon_data' should only be used if 'image-path' is not available
+                hints['image-data'] = hints['icon_data'];
+        }
+
+        let ndata = { appName,
+                      icon,
+                      summary,
+                      body,
+                      actions,
+                      hints,
+                      timeout };
+        if (replacesId != 0 && this._notifications[replacesId]) {
+            ndata.id = id = replacesId;
+            ndata.notification = this._notifications[replacesId].notification;
+        } else {
+            replacesId = 0;
+            ndata.id = id = this._nextNotificationId++;
+        }
+        this._notifications[id] = ndata;
+
+        let sender = invocation.get_sender();
+        let pid = this._senderToPid[sender];
+
+        let source = this._getSource(appName, pid, ndata, sender, null);
+
+        if (source) {
+            this._notifyForSource(source, ndata);
+            return invocation.return_value(GLib.Variant.new('(u)', [id]));
+        }
+
+        if (replacesId) {
+            // There's already a pending call to GetConnectionUnixProcessID,
+            // which will see the new notification data when it finishes,
+            // so we don't have to do anything.
+            return invocation.return_value(GLib.Variant.new('(u)', [id]));
+        }
+
+        this._busProxy.GetConnectionUnixProcessIDRemote(sender, (result, excp) => {
+            // The app may have updated or removed the notification
+            ndata = this._notifications[id];
+            if (!ndata)
+                return;
+
+            if (excp) {
+                logError(excp, 'Call to GetConnectionUnixProcessID failed');
+                return;
+            }
+
+            [pid] = result;
+            source = this._getSource(appName, pid, ndata, sender, null);
+
+            this._senderToPid[sender] = pid;
+            source.connect('destroy', () => {
+                delete this._senderToPid[sender];
+            });
+            this._notifyForSource(source, ndata);
+        });
+
+        return invocation.return_value(GLib.Variant.new('(u)', [id]));
+    }
+
+    _notifyForSource(source, ndata) {
+        let [id_, icon, summary, body, actions, hints, notification] =
+            [ndata.id, ndata.icon, ndata.summary, ndata.body,
+             ndata.actions, ndata.hints, ndata.notification];
+
+        if (notification == null) {
+            notification = new MessageTray.Notification(source);
+            ndata.notification = notification;
+            notification.connect('destroy', (n, reason) => {
+                delete this._notifications[ndata.id];
+                let notificationClosedReason;
+                switch (reason) {
+                case MessageTray.NotificationDestroyedReason.EXPIRED:
+                    notificationClosedReason = NotificationClosedReason.EXPIRED;
+                    break;
+                case MessageTray.NotificationDestroyedReason.DISMISSED:
+                    notificationClosedReason = NotificationClosedReason.DISMISSED;
+                    break;
+                case MessageTray.NotificationDestroyedReason.SOURCE_CLOSED:
+                    notificationClosedReason = NotificationClosedReason.APP_CLOSED;
+                    break;
+                }
+                this._emitNotificationClosed(ndata.id, notificationClosedReason);
+            });
+        }
+
+        let gicon = this._iconForNotificationData(icon);
+        let gimage = this._imageForNotificationData(hints);
+
+        // If an icon is not specified, we use 'image-data' or 'image-path' hint for an icon
+        // and don't show a large image. There are currently many applications that use
+        // notify_notification_set_icon_from_pixbuf() from libnotify, which in turn sets
+        // the 'image-data' hint. These applications don't typically pass in 'app_icon'
+        // argument to Notify() and actually expect the pixbuf to be shown as an icon.
+        // So the logic here does the right thing for this case. If both an icon and either
+        // one of 'image-data' or 'image-path' are specified, the icon and takes precedence.
+        if (!gicon && gimage)
+            gicon = gimage;
+        else if (!gicon)
+            gicon = this._fallbackIconForNotificationData(hints);
+
+        notification.update(summary, body, { gicon,
+                                             bannerMarkup: true,
+                                             clear: true,
+                                             soundFile: hints['sound-file'],
+                                             soundName: hints['sound-name'] });
+
+        let hasDefaultAction = false;
+
+        if (actions.length) {
+            for (let i = 0; i < actions.length - 1; i += 2) {
+                let [actionId, label] = [actions[i], actions[i + 1]];
+                if (actionId == 'default') {
+                    hasDefaultAction = true;
+                } else {
+                    notification.addAction(label, () => {
+                        this._emitActionInvoked(ndata.id, actionId);
+                    });
+                }
+            }
+        }
+
+        if (hasDefaultAction) {
+            notification.connect('activated', () => {
+                this._emitActionInvoked(ndata.id, 'default');
+            });
+        } else {
+            notification.connect('activated', () => {
+                source.open();
+            });
+        }
+
+        switch (hints.urgency) {
+        case Urgency.LOW:
+            notification.setUrgency(MessageTray.Urgency.LOW);
+            break;
+        case Urgency.NORMAL:
+            notification.setUrgency(MessageTray.Urgency.NORMAL);
+            break;
+        case Urgency.CRITICAL:
+            notification.setUrgency(MessageTray.Urgency.CRITICAL);
+            break;
+        }
+        notification.setResident(!!hints.resident);
+        // 'transient' is a reserved keyword in JS, so we have to retrieve the value
+        // of the 'transient' hint with hints['transient'] rather than hints.transient
+        notification.setTransient(!!hints['transient']);
+
+        let privacyScope = hints['x-gnome-privacy-scope'] || 'user';
+        notification.setPrivacyScope(privacyScope == 'system'
+            ? MessageTray.PrivacyScope.SYSTEM
+            : MessageTray.PrivacyScope.USER);
+
+        let sourceGIcon = source.useNotificationIcon ? gicon : null;
+        source.processNotification(notification, sourceGIcon);
+    }
+
+    CloseNotification(id) {
+        let ndata = this._notifications[id];
+        if (ndata) {
+            if (ndata.notification)
+                ndata.notification.destroy(MessageTray.NotificationDestroyedReason.SOURCE_CLOSED);
+            delete this._notifications[id];
+        }
+    }
+
+    GetCapabilities() {
+        return [
+            'actions',
+            // 'action-icons',
+            'body',
+            // 'body-hyperlinks',
+            // 'body-images',
+            'body-markup',
+            // 'icon-multi',
+            'icon-static',
+            'persistence',
+            'sound',
+        ];
+    }
+
+    GetServerInformation() {
+        return [
+            Config.PACKAGE_NAME,
+            'GNOME',
+            Config.PACKAGE_VERSION,
+            '1.2',
+        ];
+    }
+
+    _onFocusAppChanged() {
+        let tracker = Shell.WindowTracker.get_default();
+        if (!tracker.focus_app)
+            return;
+
+        for (let i = 0; i < this._sources.length; i++) {
+            let source = this._sources[i];
+            if (source.app == tracker.focus_app) {
+                source.destroyNonResidentNotifications();
+                return;
+            }
+        }
+    }
+
+    _emitNotificationClosed(id, reason) {
+        this._dbusImpl.emit_signal('NotificationClosed',
+                                   GLib.Variant.new('(uu)', [id, reason]));
+    }
+
+    _emitActionInvoked(id, action) {
+        this._dbusImpl.emit_signal('ActionInvoked',
+                                   GLib.Variant.new('(us)', [id, action]));
+    }
+};
+
+var FdoNotificationDaemonSource = GObject.registerClass(
+class FdoNotificationDaemonSource extends MessageTray.Source {
+    _init(title, pid, sender, appId) {
+        super._init(title);
+
+        this.pid = pid;
+        this.app = this._getApp(appId);
+
+        this.initialTitle = title;
+
+        if (this.app)
+            this.title = this.app.get_name();
+        else
+            this.useNotificationIcon = true;
+
+        if (sender) {
+            this._nameWatcherId = Gio.DBus.session.watch_name(sender,
+                                                              Gio.BusNameWatcherFlags.NONE,
+                                                              null,
+                                                              this._onNameVanished.bind(this));
+        } else {
+            this._nameWatcherId = 0;
+        }
+    }
+
+    _createPolicy() {
+        if (this.app && this.app.get_app_info()) {
+            let id = this.app.get_id().replace(/\.desktop$/, '');
+            return new MessageTray.NotificationApplicationPolicy(id);
+        } else {
+            return new MessageTray.NotificationGenericPolicy();
+        }
+    }
+
+    _onNameVanished() {
+        // Destroy the notification source when its sender is removed from DBus.
+        // Only do so if this.app is set to avoid removing "notify-send" sources, senders
+        // of which аre removed from DBus immediately.
+        // Sender being removed from DBus would normally result in a tray icon being removed,
+        // so allow the code path that handles the tray icon being removed to handle that case.
+        if (this.app)
+            this.destroy();
+    }
+
+    processNotification(notification, gicon) {
+        if (gicon)
+            this._gicon = gicon;
+        this.iconUpdated();
+
+        let tracker = Shell.WindowTracker.get_default();
+        if (notification.resident && this.app && tracker.focus_app == this.app)
+            this.pushNotification(notification);
+        else
+            this.showNotification(notification);
+    }
+
+    _getApp(appId) {
+        let app;
+
+        app = Shell.WindowTracker.get_default().get_app_from_pid(this.pid);
+        if (app != null)
+            return app;
+
+        if (appId) {
+            app = Shell.AppSystem.get_default().lookup_app('%s.desktop'.format(appId));
+            if (app != null)
+                return app;
+        }
+
+        return null;
+    }
+
+    setTitle(title) {
+        // Do nothing if .app is set, we don't want to override the
+        // app name with whatever is provided through libnotify (usually
+        // garbage)
+        if (this.app)
+            return;
+
+        super.setTitle(title);
+    }
+
+    open() {
+        this.openApp();
+        this.destroyNonResidentNotifications();
+    }
+
+    openApp() {
+        if (this.app == null)
+            return;
+
+        this.app.activate();
+        Main.overview.hide();
+        Main.panel.closeCalendar();
+    }
+
+    destroy() {
+        if (this._nameWatcherId) {
+            Gio.DBus.session.unwatch_name(this._nameWatcherId);
+            this._nameWatcherId = 0;
+        }
+
+        super.destroy();
+    }
+
+    createIcon(size) {
+        if (this.app) {
+            return this.app.create_icon_texture(size);
+        } else if (this._gicon) {
+            return new St.Icon({ gicon: this._gicon,
+                                 icon_size: size });
+        } else {
+            return null;
+        }
+    }
+});
+
+const PRIORITY_URGENCY_MAP = {
+    low: MessageTray.Urgency.LOW,
+    normal: MessageTray.Urgency.NORMAL,
+    high: MessageTray.Urgency.HIGH,
+    urgent: MessageTray.Urgency.CRITICAL,
+};
+
+var GtkNotificationDaemonNotification = GObject.registerClass(
+class GtkNotificationDaemonNotification extends MessageTray.Notification {
+    _init(source, notification) {
+        super._init(source);
+        this._serialized = GLib.Variant.new('a{sv}', notification);
+
+        let { title,
+              body,
+              icon: gicon,
+              urgent,
+              priority,
+              buttons,
+              "default-action": defaultAction,
+              "default-action-target": defaultActionTarget,
+              timestamp: time } = notification;
+
+        if (priority) {
+            let urgency = PRIORITY_URGENCY_MAP[priority.unpack()];
+            this.setUrgency(urgency != undefined ? urgency : MessageTray.Urgency.NORMAL);
+        } else if (urgent) {
+            this.setUrgency(urgent.unpack()
+                ? MessageTray.Urgency.CRITICAL
+                : MessageTray.Urgency.NORMAL);
+        } else {
+            this.setUrgency(MessageTray.Urgency.NORMAL);
+        }
+
+        if (buttons) {
+            buttons.deep_unpack().forEach(button => {
+                this.addAction(button.label.unpack(), () => {
+                    this._onButtonClicked(button);
+                });
+            });
+        }
+
+        this._defaultAction = defaultAction ? defaultAction.unpack() : null;
+        this._defaultActionTarget = defaultActionTarget;
+
+        this.update(title.unpack(), body ? body.unpack() : null,
+                    { gicon: gicon ? Gio.icon_deserialize(gicon) : null,
+                      datetime: time ? GLib.DateTime.new_from_unix_local(time.unpack()) : null });
+    }
+
+    _activateAction(namespacedActionId, target) {
+        if (namespacedActionId) {
+            if (namespacedActionId.startsWith('app.')) {
+                let actionId = namespacedActionId.slice('app.'.length);
+                this.source.activateAction(actionId, target);
+            }
+        } else {
+            this.source.open();
+        }
+    }
+
+    _onButtonClicked(button) {
+        let { action, target } = button;
+        this._activateAction(action.unpack(), target);
+    }
+
+    activate() {
+        this._activateAction(this._defaultAction, this._defaultActionTarget);
+        super.activate();
+    }
+
+    serialize() {
+        return this._serialized;
+    }
+});
+
+const FdoApplicationIface = loadInterfaceXML('org.freedesktop.Application');
+const FdoApplicationProxy = Gio.DBusProxy.makeProxyWrapper(FdoApplicationIface);
+
+function objectPathFromAppId(appId) {
+    return '/' + appId.replace(/\./g, '/').replace(/-/g, '_');
+}
+
+function getPlatformData() {
+    let startupId = GLib.Variant.new('s', '_TIME%s'.format(global.get_current_time()));
+    return { "desktop-startup-id": startupId };
+}
+
+function InvalidAppError() {}
+
+var GtkNotificationDaemonAppSource = GObject.registerClass(
+class GtkNotificationDaemonAppSource extends MessageTray.Source {
+    _init(appId) {
+        let objectPath = objectPathFromAppId(appId);
+        if (!GLib.Variant.is_object_path(objectPath))
+            throw new InvalidAppError();
+
+        let app = Shell.AppSystem.get_default().lookup_app('%s.desktop'.format(appId));
+        if (!app)
+            throw new InvalidAppError();
+
+        super._init(app.get_name());
+
+        this._appId = appId;
+        this._app = app;
+        this._objectPath = objectPath;
+
+        this._notifications = {};
+        this._notificationPending = false;
+    }
+
+    createIcon(size) {
+        return this._app.create_icon_texture(size);
+    }
+
+    _createPolicy() {
+        return new MessageTray.NotificationApplicationPolicy(this._appId);
+    }
+
+    _createApp(callback) {
+        return new FdoApplicationProxy(Gio.DBus.session, this._appId, this._objectPath, callback);
+    }
+
+    _createNotification(params) {
+        return new GtkNotificationDaemonNotification(this, params);
+    }
+
+    activateAction(actionId, target) {
+        this._createApp((app, error) => {
+            if (error == null)
+                app.ActivateActionRemote(actionId, target ? [target] : [], getPlatformData());
+            else
+                logError(error, 'Failed to activate application proxy');
+        });
+        Main.overview.hide();
+        Main.panel.closeCalendar();
+    }
+
+    open() {
+        this._createApp((app, error) => {
+            if (error == null)
+                app.ActivateRemote(getPlatformData());
+            else
+                logError(error, 'Failed to open application proxy');
+        });
+        Main.overview.hide();
+        Main.panel.closeCalendar();
+    }
+
+    addNotification(notificationId, notificationParams, showBanner) {
+        this._notificationPending = true;
+
+        if (this._notifications[notificationId])
+            this._notifications[notificationId].destroy(MessageTray.NotificationDestroyedReason.REPLACED);
+
+        let notification = this._createNotification(notificationParams);
+        notification.connect('destroy', () => {
+            delete this._notifications[notificationId];
+        });
+        this._notifications[notificationId] = notification;
+
+        if (showBanner)
+            this.showNotification(notification);
+        else
+            this.pushNotification(notification);
+
+        this._notificationPending = false;
+    }
+
+    destroy(reason) {
+        if (this._notificationPending)
+            return;
+        super.destroy(reason);
+    }
+
+    removeNotification(notificationId) {
+        if (this._notifications[notificationId])
+            this._notifications[notificationId].destroy(MessageTray.NotificationDestroyedReason.SOURCE_CLOSED);
+    }
+
+    serialize() {
+        let notifications = [];
+        for (let notificationId in this._notifications) {
+            let notification = this._notifications[notificationId];
+            notifications.push([notificationId, notification.serialize()]);
+        }
+        return [this._appId, notifications];
+    }
+});
+
+const GtkNotificationsIface = loadInterfaceXML('org.gtk.Notifications');
+
+var GtkNotificationDaemon = class GtkNotificationDaemon {
+    constructor() {
+        this._sources = {};
+
+        this._loadNotifications();
+
+        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(GtkNotificationsIface, this);
+        this._dbusImpl.export(Gio.DBus.session, '/org/gtk/Notifications');
+
+        Gio.DBus.session.own_name('org.gtk.Notifications', Gio.BusNameOwnerFlags.REPLACE, null, null);
+    }
+
+    _ensureAppSource(appId) {
+        if (this._sources[appId])
+            return this._sources[appId];
+
+        let source = new GtkNotificationDaemonAppSource(appId);
+
+        source.connect('destroy', () => {
+            delete this._sources[appId];
+            this._saveNotifications();
+        });
+        source.connect('notify::count', this._saveNotifications.bind(this));
+        Main.messageTray.add(source);
+        this._sources[appId] = source;
+        return source;
+    }
+
+    _loadNotifications() {
+        this._isLoading = true;
+
+        try {
+            let value = global.get_persistent_state('a(sa(sv))', 'notifications');
+            if (value) {
+                let sources = value.deep_unpack();
+                sources.forEach(([appId, notifications]) => {
+                    if (notifications.length == 0)
+                        return;
+
+                    let source;
+                    try {
+                        source = this._ensureAppSource(appId);
+                    } catch (e) {
+                        if (e instanceof InvalidAppError)
+                            return;
+                        throw e;
+                    }
+
+                    notifications.forEach(([notificationId, notification]) => {
+                        source.addNotification(notificationId, notification.deep_unpack(), false);
+                    });
+                });
+            }
+        } catch (e) {
+            logError(e, 'Failed to load saved notifications');
+        } finally {
+            this._isLoading = false;
+        }
+    }
+
+    _saveNotifications() {
+        if (this._isLoading)
+            return;
+
+        let sources = [];
+        for (let appId in this._sources) {
+            let source = this._sources[appId];
+            sources.push(source.serialize());
+        }
+
+        global.set_persistent_state('notifications', new GLib.Variant('a(sa(sv))', sources));
+    }
+
+    AddNotificationAsync(params, invocation) {
+        let [appId, notificationId, notification] = params;
+
+        let source;
+        try {
+            source = this._ensureAppSource(appId);
+        } catch (e) {
+            if (e instanceof InvalidAppError) {
+                invocation.return_dbus_error('org.gtk.Notifications.InvalidApp', 'The app by ID "%s" could not be found'.format(appId));
+                return;
+            }
+            throw e;
+        }
+
+        let timestamp = GLib.DateTime.new_now_local().to_unix();
+        notification['timestamp'] = new GLib.Variant('x', timestamp);
+
+        source.addNotification(notificationId, notification, true);
+
+        invocation.return_value(null);
+    }
+
+    RemoveNotificationAsync(params, invocation) {
+        let [appId, notificationId] = params;
+        let source = this._sources[appId];
+        if (source)
+            source.removeNotification(notificationId);
+
+        invocation.return_value(null);
+    }
+};
+
+var NotificationDaemon = class NotificationDaemon {
+    constructor() {
+        this._fdoNotificationDaemon = new FdoNotificationDaemon();
+        this._gtkNotificationDaemon = new GtkNotificationDaemon();
+    }
+};

js/ui/osdMonitorLabeler.js

@@ -0,0 +1,114 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported OsdMonitorLabeler */
+
+const { Clutter, Gio, GObject, Meta, St } = imports.gi;
+
+const Main = imports.ui.main;
+
+var OsdMonitorLabel = GObject.registerClass(
+class OsdMonitorLabel extends St.Widget {
+    _init(monitor, label) {
+        super._init({ x_expand: true, y_expand: true });
+
+        this._monitor = monitor;
+
+        this._box = new St.BoxLayout({ style_class: 'osd-window',
+                                       vertical: true });
+        this.add_actor(this._box);
+
+        this._label = new St.Label({ style_class: 'osd-monitor-label',
+                                     text: label });
+        this._box.add(this._label);
+
+        Main.uiGroup.add_child(this);
+        Main.uiGroup.set_child_above_sibling(this, null);
+        this._position();
+
+        Meta.disable_unredirect_for_display(global.display);
+        this.connect('destroy', () => {
+            Meta.enable_unredirect_for_display(global.display);
+        });
+    }
+
+    _position() {
+        let workArea = Main.layoutManager.getWorkAreaForMonitor(this._monitor);
+
+        if (Clutter.get_default_text_direction() == Clutter.TextDirection.RTL)
+            this._box.x = workArea.x + (workArea.width - this._box.width);
+        else
+            this._box.x = workArea.x;
+
+        this._box.y = workArea.y;
+    }
+});
+
+var OsdMonitorLabeler = class {
+    constructor() {
+        this._monitorManager = Meta.MonitorManager.get();
+        this._client = null;
+        this._clientWatchId = 0;
+        this._osdLabels = [];
+        this._monitorLabels = null;
+        Main.layoutManager.connect('monitors-changed',
+                                   this._reset.bind(this));
+        this._reset();
+    }
+
+    _reset() {
+        for (let i in this._osdLabels)
+            this._osdLabels[i].destroy();
+        this._osdLabels = [];
+        this._monitorLabels = new Map();
+        let monitors = Main.layoutManager.monitors;
+        for (let i in monitors)
+            this._monitorLabels.set(monitors[i].index, []);
+    }
+
+    _trackClient(client) {
+        if (this._client)
+            return this._client == client;
+
+        this._client = client;
+        this._clientWatchId = Gio.bus_watch_name(Gio.BusType.SESSION, client, 0, null,
+                                                 (c, name) => {
+                                                     this.hide(name);
+                                                 });
+        return true;
+    }
+
+    _untrackClient(client) {
+        if (!this._client || this._client != client)
+            return false;
+
+        Gio.bus_unwatch_name(this._clientWatchId);
+        this._clientWatchId = 0;
+        this._client = null;
+        return true;
+    }
+
+    show(client, params) {
+        if (!this._trackClient(client))
+            return;
+
+        this._reset();
+
+        for (let connector in params) {
+            let monitor = this._monitorManager.get_monitor_for_connector(connector);
+            if (monitor == -1)
+                continue;
+            this._monitorLabels.get(monitor).push(params[connector].deep_unpack());
+        }
+
+        for (let [monitor, labels] of this._monitorLabels.entries()) {
+            labels.sort();
+            this._osdLabels.push(new OsdMonitorLabel(monitor, labels.join(' ')));
+        }
+    }
+
+    hide(client) {
+        if (!this._untrackClient(client))
+            return;
+
+        this._reset();
+    }
+};

js/ui/osdWindow.js

@@ -0,0 +1,250 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported OsdWindowManager */
+
+const { Clutter, GLib, GObject, Meta, St } = imports.gi;
+
+const BarLevel = imports.ui.barLevel;
+const Layout = imports.ui.layout;
+const Main = imports.ui.main;
+
+var HIDE_TIMEOUT = 1500;
+var FADE_TIME = 100;
+var LEVEL_ANIMATION_TIME = 100;
+
+var OsdWindowConstraint = GObject.registerClass(
+class OsdWindowConstraint extends Clutter.Constraint {
+    _init(props) {
+        this._minSize = 0;
+        super._init(props);
+    }
+
+    set minSize(v) {
+        this._minSize = v;
+        if (this.actor)
+            this.actor.queue_relayout();
+    }
+
+    vfunc_update_allocation(actor, actorBox) {
+        // Clutter will adjust the allocation for margins,
+        // so add it to our minimum size
+        let minSize = this._minSize + actor.margin_top + actor.margin_bottom;
+        let [width, height] = actorBox.get_size();
+
+        // Enforce a ratio of 1
+        let size = Math.ceil(Math.max(minSize, height));
+        actorBox.set_size(size, size);
+
+        // Recenter
+        let [x, y] = actorBox.get_origin();
+        actorBox.set_origin(Math.ceil(x + width / 2 - size / 2),
+                            Math.ceil(y + height / 2 - size / 2));
+    }
+});
+
+var OsdWindow = GObject.registerClass(
+class OsdWindow extends St.Widget {
+    _init(monitorIndex) {
+        super._init({
+            x_expand: true,
+            y_expand: true,
+            x_align: Clutter.ActorAlign.CENTER,
+            y_align: Clutter.ActorAlign.CENTER,
+        });
+
+        this._monitorIndex = monitorIndex;
+        let constraint = new Layout.MonitorConstraint({ index: monitorIndex });
+        this.add_constraint(constraint);
+
+        this._boxConstraint = new OsdWindowConstraint();
+        this._box = new St.BoxLayout({ style_class: 'osd-window',
+                                       vertical: true });
+        this._box.add_constraint(this._boxConstraint);
+        this.add_actor(this._box);
+
+        this._icon = new St.Icon({ y_expand: true });
+        this._box.add_child(this._icon);
+
+        this._label = new St.Label();
+        this._box.add(this._label);
+
+        this._level = new BarLevel.BarLevel({
+            style_class: 'level',
+            value: 0,
+        });
+        this._box.add(this._level);
+
+        this._hideTimeoutId = 0;
+        this._reset();
+
+        this.connect('destroy', this._onDestroy.bind(this));
+
+        this._monitorsChangedId =
+            Main.layoutManager.connect('monitors-changed',
+                                       this._relayout.bind(this));
+        let themeContext = St.ThemeContext.get_for_stage(global.stage);
+        this._scaleChangedId =
+            themeContext.connect('notify::scale-factor',
+                                 this._relayout.bind(this));
+        this._relayout();
+        Main.uiGroup.add_child(this);
+    }
+
+    _onDestroy() {
+        if (this._monitorsChangedId)
+            Main.layoutManager.disconnect(this._monitorsChangedId);
+        this._monitorsChangedId = 0;
+
+        let themeContext = St.ThemeContext.get_for_stage(global.stage);
+        if (this._scaleChangedId)
+            themeContext.disconnect(this._scaleChangedId);
+        this._scaleChangedId = 0;
+    }
+
+    setIcon(icon) {
+        this._icon.gicon = icon;
+    }
+
+    setLabel(label) {
+        this._label.visible = label != undefined;
+        if (label)
+            this._label.text = label;
+    }
+
+    setLevel(value) {
+        this._level.visible = value != undefined;
+        if (value != undefined) {
+            if (this.visible) {
+                this._level.ease_property('value', value, {
+                    mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+                    duration: LEVEL_ANIMATION_TIME,
+                });
+            } else {
+                this._level.value = value;
+            }
+        }
+    }
+
+    setMaxLevel(maxLevel = 1) {
+        this._level.maximum_value = maxLevel;
+    }
+
+    show() {
+        if (!this._icon.gicon)
+            return;
+
+        if (!this.visible) {
+            Meta.disable_unredirect_for_display(global.display);
+            super.show();
+            this.opacity = 0;
+            this.get_parent().set_child_above_sibling(this, null);
+
+            this.ease({
+                opacity: 255,
+                duration: FADE_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            });
+        }
+
+        if (this._hideTimeoutId)
+            GLib.source_remove(this._hideTimeoutId);
+        this._hideTimeoutId = GLib.timeout_add(
+            GLib.PRIORITY_DEFAULT, HIDE_TIMEOUT, this._hide.bind(this));
+        GLib.Source.set_name_by_id(this._hideTimeoutId, '[gnome-shell] this._hide');
+    }
+
+    cancel() {
+        if (!this._hideTimeoutId)
+            return;
+
+        GLib.source_remove(this._hideTimeoutId);
+        this._hide();
+    }
+
+    _hide() {
+        this._hideTimeoutId = 0;
+        this.ease({
+            opacity: 0,
+            duration: FADE_TIME,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            onComplete: () => {
+                this._reset();
+                Meta.enable_unredirect_for_display(global.display);
+            },
+        });
+        return GLib.SOURCE_REMOVE;
+    }
+
+    _reset() {
+        super.hide();
+        this.setLabel(null);
+        this.setMaxLevel(null);
+        this.setLevel(null);
+    }
+
+    _relayout() {
+        /* assume 110x110 on a 640x480 display and scale from there */
+        let monitor = Main.layoutManager.monitors[this._monitorIndex];
+        if (!monitor)
+            return; // we are about to be removed
+
+        let scalew = monitor.width / 640.0;
+        let scaleh = monitor.height / 480.0;
+        let scale = Math.min(scalew, scaleh);
+        let popupSize = 110 * Math.max(1, scale);
+
+        let scaleFactor = St.ThemeContext.get_for_stage(global.stage).scale_factor;
+        this._icon.icon_size = popupSize / (2 * scaleFactor);
+        this._box.translation_y = Math.round(monitor.height / 4);
+        this._boxConstraint.minSize = popupSize;
+    }
+});
+
+var OsdWindowManager = class {
+    constructor() {
+        this._osdWindows = [];
+        Main.layoutManager.connect('monitors-changed',
+                                   this._monitorsChanged.bind(this));
+        this._monitorsChanged();
+    }
+
+    _monitorsChanged() {
+        for (let i = 0; i < Main.layoutManager.monitors.length; i++) {
+            if (this._osdWindows[i] == undefined)
+                this._osdWindows[i] = new OsdWindow(i);
+        }
+
+        for (let i = Main.layoutManager.monitors.length; i < this._osdWindows.length; i++) {
+            this._osdWindows[i].destroy();
+            this._osdWindows[i] = null;
+        }
+
+        this._osdWindows.length = Main.layoutManager.monitors.length;
+    }
+
+    _showOsdWindow(monitorIndex, icon, label, level, maxLevel) {
+        this._osdWindows[monitorIndex].setIcon(icon);
+        this._osdWindows[monitorIndex].setLabel(label);
+        this._osdWindows[monitorIndex].setMaxLevel(maxLevel);
+        this._osdWindows[monitorIndex].setLevel(level);
+        this._osdWindows[monitorIndex].show();
+    }
+
+    show(monitorIndex, icon, label, level, maxLevel) {
+        if (monitorIndex != -1) {
+            for (let i = 0; i < this._osdWindows.length; i++) {
+                if (i == monitorIndex)
+                    this._showOsdWindow(i, icon, label, level, maxLevel);
+                else
+                    this._osdWindows[i].cancel();
+            }
+        } else {
+            for (let i = 0; i < this._osdWindows.length; i++)
+                this._showOsdWindow(i, icon, label, level, maxLevel);
+        }
+    }
+
+    hideAll() {
+        for (let i = 0; i < this._osdWindows.length; i++)
+            this._osdWindows[i].cancel();
+    }
+};

js/ui/overview.js

@@ -0,0 +1,702 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Overview */
+
+const { Clutter, GLib, GObject, Meta, Shell, St } = imports.gi;
+const Signals = imports.signals;
+
+const Background = imports.ui.background;
+const DND = imports.ui.dnd;
+const LayoutManager = imports.ui.layout;
+const Lightbox = imports.ui.lightbox;
+const Main = imports.ui.main;
+const MessageTray = imports.ui.messageTray;
+const OverviewControls = imports.ui.overviewControls;
+const Params = imports.misc.params;
+const WorkspaceThumbnail = imports.ui.workspaceThumbnail;
+
+// Time for initial animation going into Overview mode
+var ANIMATION_TIME = 250;
+
+// Must be less than ANIMATION_TIME, since we switch to
+// or from the overview completely after ANIMATION_TIME,
+// and don't want the shading animation to get cut off
+var SHADE_ANIMATION_TIME = 200;
+
+var DND_WINDOW_SWITCH_TIMEOUT = 750;
+
+var OVERVIEW_ACTIVATION_TIMEOUT = 0.5;
+
+var ShellInfo = class {
+    constructor() {
+        this._source = null;
+        this._undoCallback = null;
+    }
+
+    _onUndoClicked() {
+        if (this._undoCallback)
+            this._undoCallback();
+        this._undoCallback = null;
+
+        if (this._source)
+            this._source.destroy();
+    }
+
+    setMessage(text, options) {
+        options = Params.parse(options, {
+            undoCallback: null,
+            forFeedback: false,
+        });
+
+        let undoCallback = options.undoCallback;
+        let forFeedback = options.forFeedback;
+
+        if (this._source == null) {
+            this._source = new MessageTray.SystemNotificationSource();
+            this._source.connect('destroy', () => {
+                this._source = null;
+            });
+            Main.messageTray.add(this._source);
+        }
+
+        let notification = null;
+        if (this._source.notifications.length == 0) {
+            notification = new MessageTray.Notification(this._source, text, null);
+            notification.setTransient(true);
+            notification.setForFeedback(forFeedback);
+        } else {
+            notification = this._source.notifications[0];
+            notification.update(text, null, { clear: true });
+        }
+
+        this._undoCallback = undoCallback;
+        if (undoCallback)
+            notification.addAction(_("Undo"), this._onUndoClicked.bind(this));
+
+        this._source.showNotification(notification);
+    }
+};
+
+var OverviewActor = GObject.registerClass(
+class OverviewActor extends St.BoxLayout {
+    _init() {
+        super._init({
+            name: 'overview',
+            /* Translators: This is the main view to select
+                activities. See also note for "Activities" string. */
+            accessible_name: _("Overview"),
+            vertical: true,
+        });
+
+        this.add_constraint(new LayoutManager.MonitorConstraint({ primary: true }));
+
+        // Add a clone of the panel to the overview so spacing and such is
+        // automatic
+        let panelGhost = new St.Bin({
+            child: new Clutter.Clone({ source: Main.panel }),
+            reactive: false,
+            opacity: 0,
+        });
+        this.add_actor(panelGhost);
+
+        this._searchEntry = new St.Entry({
+            style_class: 'search-entry',
+            /* Translators: this is the text displayed
+               in the search entry when no search is
+               active; it should not exceed ~30
+               characters. */
+            hint_text: _('Type to search'),
+            track_hover: true,
+            can_focus: true,
+        });
+        this._searchEntry.set_offscreen_redirect(Clutter.OffscreenRedirect.ALWAYS);
+        let searchEntryBin = new St.Bin({
+            child: this._searchEntry,
+            x_align: Clutter.ActorAlign.CENTER,
+        });
+        this.add_actor(searchEntryBin);
+
+        this._controls = new OverviewControls.ControlsManager(this._searchEntry);
+
+        // Add our same-line elements after the search entry
+        this.add_child(this._controls);
+    }
+
+    get dash() {
+        return this._controls.dash;
+    }
+
+    get searchEntry() {
+        return this._searchEntry;
+    }
+
+    get viewSelector() {
+        return this._controls.viewSelector;
+    }
+});
+
+var Overview = class {
+    constructor() {
+        this._initCalled = false;
+        this._visible = false;
+
+        Main.sessionMode.connect('updated', this._sessionUpdated.bind(this));
+        this._sessionUpdated();
+    }
+
+    get dash() {
+        return this._overview.dash;
+    }
+
+    get dashIconSize() {
+        logError(new Error('Usage of Overview.\'dashIconSize\' is deprecated, ' +
+            'use \'dash.iconSize\' property instead'));
+        return this.dash.iconSize;
+    }
+
+    get viewSelector() {
+        return this._overview.viewSelector;
+    }
+
+    get animationInProgress() {
+        return this._animationInProgress;
+    }
+
+    get visible() {
+        return this._visible;
+    }
+
+    get visibleTarget() {
+        return this._visibleTarget;
+    }
+
+    _createOverview() {
+        if (this._overview)
+            return;
+
+        if (this.isDummy)
+            return;
+
+        // The main Background actors are inside global.window_group which are
+        // hidden when displaying the overview, so we create a new
+        // one. Instances of this class share a single CoglTexture behind the
+        // scenes which allows us to show the background with different
+        // rendering options without duplicating the texture data.
+        this._backgroundGroup = new Meta.BackgroundGroup({ reactive: true });
+        Main.layoutManager.overviewGroup.add_child(this._backgroundGroup);
+        this._bgManagers = [];
+
+        this._desktopFade = new St.Widget();
+        Main.layoutManager.overviewGroup.add_child(this._desktopFade);
+
+        this._activationTime = 0;
+
+        this._visible = false;          // animating to overview, in overview, animating out
+        this._shown = false;            // show() and not hide()
+        this._modal = false;            // have a modal grab
+        this._animationInProgress = false;
+        this._visibleTarget = false;
+
+        // During transitions, we raise this to the top to avoid having the overview
+        // area be reactive; it causes too many issues such as double clicks on
+        // Dash elements, or mouseover handlers in the workspaces.
+        this._coverPane = new Clutter.Actor({ opacity: 0,
+                                              reactive: true });
+        Main.layoutManager.overviewGroup.add_child(this._coverPane);
+        this._coverPane.connect('event', () => Clutter.EVENT_STOP);
+        this._coverPane.hide();
+
+        // XDND
+        this._dragMonitor = {
+            dragMotion: this._onDragMotion.bind(this),
+        };
+
+
+        Main.layoutManager.overviewGroup.connect('scroll-event',
+                                                 this._onScrollEvent.bind(this));
+        Main.xdndHandler.connect('drag-begin', this._onDragBegin.bind(this));
+        Main.xdndHandler.connect('drag-end', this._onDragEnd.bind(this));
+
+        global.display.connect('restacked', this._onRestacked.bind(this));
+
+        this._windowSwitchTimeoutId = 0;
+        this._windowSwitchTimestamp = 0;
+        this._lastActiveWorkspaceIndex = -1;
+        this._lastHoveredWindow = null;
+
+        if (this._initCalled)
+            this.init();
+    }
+
+    _updateBackgrounds() {
+        for (let i = 0; i < this._bgManagers.length; i++)
+            this._bgManagers[i].destroy();
+
+        this._bgManagers = [];
+
+        for (let i = 0; i < Main.layoutManager.monitors.length; i++) {
+            let bgManager = new Background.BackgroundManager({ container: this._backgroundGroup,
+                                                               monitorIndex: i,
+                                                               vignette: true });
+            this._bgManagers.push(bgManager);
+        }
+    }
+
+    _unshadeBackgrounds() {
+        let backgrounds = this._backgroundGroup.get_children();
+        for (let i = 0; i < backgrounds.length; i++) {
+            backgrounds[i].ease_property('brightness', 1.0, {
+                duration: SHADE_ANIMATION_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            });
+            backgrounds[i].ease_property('vignette-sharpness', 0.0, {
+                duration: SHADE_ANIMATION_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            });
+        }
+    }
+
+    _shadeBackgrounds() {
+        let backgrounds = this._backgroundGroup.get_children();
+        for (let i = 0; i < backgrounds.length; i++) {
+            backgrounds[i].ease_property('brightness', Lightbox.VIGNETTE_BRIGHTNESS, {
+                duration: SHADE_ANIMATION_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            });
+            backgrounds[i].ease_property('vignette-sharpness', Lightbox.VIGNETTE_SHARPNESS, {
+                duration: SHADE_ANIMATION_TIME,
+                mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            });
+        }
+    }
+
+    _sessionUpdated() {
+        const { hasOverview } = Main.sessionMode;
+        if (!hasOverview)
+            this.hide();
+
+        this.isDummy = !hasOverview;
+        this._createOverview();
+    }
+
+    // The members we construct that are implemented in JS might
+    // want to access the overview as Main.overview to connect
+    // signal handlers and so forth. So we create them after
+    // construction in this init() method.
+    init() {
+        this._initCalled = true;
+
+        if (this.isDummy)
+            return;
+
+        this._overview = new OverviewActor();
+        this._overview._delegate = this;
+        Main.layoutManager.overviewGroup.add_child(this._overview);
+
+        this._shellInfo = new ShellInfo();
+
+        Main.layoutManager.connect('monitors-changed', this._relayout.bind(this));
+        this._relayout();
+    }
+
+    addSearchProvider(provider) {
+        this.viewSelector.addSearchProvider(provider);
+    }
+
+    removeSearchProvider(provider) {
+        this.viewSelector.removeSearchProvider(provider);
+    }
+
+    //
+    // options:
+    //  - undoCallback (function): the callback to be called if undo support is needed
+    //  - forFeedback (boolean): whether the message is for direct feedback of a user action
+    //
+    setMessage(text, options) {
+        if (this.isDummy)
+            return;
+
+        this._shellInfo.setMessage(text, options);
+    }
+
+    _onDragBegin() {
+        this._inXdndDrag = true;
+
+        DND.addDragMonitor(this._dragMonitor);
+        // Remember the workspace we started from
+        let workspaceManager = global.workspace_manager;
+        this._lastActiveWorkspaceIndex = workspaceManager.get_active_workspace_index();
+    }
+
+    _onDragEnd(time) {
+        this._inXdndDrag = false;
+
+        // In case the drag was canceled while in the overview
+        // we have to go back to where we started and hide
+        // the overview
+        if (this._shown) {
+            let workspaceManager = global.workspace_manager;
+            workspaceManager.get_workspace_by_index(this._lastActiveWorkspaceIndex).activate(time);
+            this.hide();
+        }
+        this._resetWindowSwitchTimeout();
+        this._lastHoveredWindow = null;
+        DND.removeDragMonitor(this._dragMonitor);
+        this.endItemDrag();
+    }
+
+    _resetWindowSwitchTimeout() {
+        if (this._windowSwitchTimeoutId != 0) {
+            GLib.source_remove(this._windowSwitchTimeoutId);
+            this._windowSwitchTimeoutId = 0;
+        }
+    }
+
+    _onDragMotion(dragEvent) {
+        let targetIsWindow = dragEvent.targetActor &&
+                             dragEvent.targetActor._delegate &&
+                             dragEvent.targetActor._delegate.metaWindow &&
+                             !(dragEvent.targetActor._delegate instanceof WorkspaceThumbnail.WindowClone);
+
+        this._windowSwitchTimestamp = global.get_current_time();
+
+        if (targetIsWindow &&
+            dragEvent.targetActor._delegate.metaWindow == this._lastHoveredWindow)
+            return DND.DragMotionResult.CONTINUE;
+
+        this._lastHoveredWindow = null;
+
+        this._resetWindowSwitchTimeout();
+
+        if (targetIsWindow) {
+            this._lastHoveredWindow = dragEvent.targetActor._delegate.metaWindow;
+            this._windowSwitchTimeoutId = GLib.timeout_add(
+                GLib.PRIORITY_DEFAULT,
+                DND_WINDOW_SWITCH_TIMEOUT,
+                () => {
+                    this._windowSwitchTimeoutId = 0;
+                    Main.activateWindow(dragEvent.targetActor._delegate.metaWindow,
+                                        this._windowSwitchTimestamp);
+                    this.hide();
+                    this._lastHoveredWindow = null;
+                    return GLib.SOURCE_REMOVE;
+                });
+            GLib.Source.set_name_by_id(this._windowSwitchTimeoutId, '[gnome-shell] Main.activateWindow');
+        }
+
+        return DND.DragMotionResult.CONTINUE;
+    }
+
+    _onScrollEvent(actor, event) {
+        this.emit('scroll-event', event);
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    addAction(action) {
+        if (this.isDummy)
+            return;
+
+        this._backgroundGroup.add_action(action);
+    }
+
+    _getDesktopClone() {
+        let windows = global.get_window_actors().filter(
+            w => w.meta_window.get_window_type() == Meta.WindowType.DESKTOP
+        );
+        if (windows.length == 0)
+            return null;
+
+        let window = windows[0];
+        let clone = new Clutter.Clone({ source: window,
+                                        x: window.x, y: window.y });
+        clone.source.connect('destroy', () => {
+            clone.destroy();
+        });
+        return clone;
+    }
+
+    _relayout() {
+        // To avoid updating the position and size of the workspaces
+        // we just hide the overview. The positions will be updated
+        // when it is next shown.
+        this.hide();
+
+        this._coverPane.set_position(0, 0);
+        this._coverPane.set_size(global.screen_width, global.screen_height);
+
+        this._updateBackgrounds();
+    }
+
+    _onRestacked() {
+        let stack = global.get_window_actors();
+        let stackIndices = {};
+
+        for (let i = 0; i < stack.length; i++) {
+            // Use the stable sequence for an integer to use as a hash key
+            stackIndices[stack[i].get_meta_window().get_stable_sequence()] = i;
+        }
+
+        this.emit('windows-restacked', stackIndices);
+    }
+
+    beginItemDrag(_source) {
+        this.emit('item-drag-begin');
+        this._inItemDrag = true;
+    }
+
+    cancelledItemDrag(_source) {
+        this.emit('item-drag-cancelled');
+    }
+
+    endItemDrag(_source) {
+        if (!this._inItemDrag)
+            return;
+        this.emit('item-drag-end');
+        this._inItemDrag = false;
+    }
+
+    beginWindowDrag(window) {
+        this.emit('window-drag-begin', window);
+        this._inWindowDrag = true;
+    }
+
+    cancelledWindowDrag(window) {
+        this.emit('window-drag-cancelled', window);
+    }
+
+    endWindowDrag(window) {
+        if (!this._inWindowDrag)
+            return;
+        this.emit('window-drag-end', window);
+        this._inWindowDrag = false;
+    }
+
+    focusSearch() {
+        this.show();
+        this._overview.searchEntry.grab_key_focus();
+    }
+
+    fadeInDesktop() {
+        this._desktopFade.opacity = 0;
+        this._desktopFade.show();
+        this._desktopFade.ease({
+            opacity: 255,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            duration: ANIMATION_TIME,
+        });
+    }
+
+    fadeOutDesktop() {
+        if (!this._desktopFade.get_n_children()) {
+            let clone = this._getDesktopClone();
+            if (!clone)
+                return;
+
+            this._desktopFade.add_child(clone);
+        }
+
+        this._desktopFade.opacity = 255;
+        this._desktopFade.show();
+        this._desktopFade.ease({
+            opacity: 0,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            duration: ANIMATION_TIME,
+        });
+    }
+
+    // Checks if the Activities button is currently sensitive to
+    // clicks. The first call to this function within the
+    // OVERVIEW_ACTIVATION_TIMEOUT time of the hot corner being
+    // triggered will return false. This avoids opening and closing
+    // the overview if the user both triggered the hot corner and
+    // clicked the Activities button.
+    shouldToggleByCornerOrButton() {
+        if (this._animationInProgress)
+            return false;
+        if (this._inItemDrag || this._inWindowDrag)
+            return false;
+        if (!this._activationTime ||
+            GLib.get_monotonic_time() / GLib.USEC_PER_SEC - this._activationTime > OVERVIEW_ACTIVATION_TIMEOUT)
+            return true;
+        return false;
+    }
+
+    _syncGrab() {
+        // We delay grab changes during animation so that when removing the
+        // overview we don't have a problem with the release of a press/release
+        // going to an application.
+        if (this._animationInProgress)
+            return true;
+
+        if (this._shown) {
+            let shouldBeModal = !this._inXdndDrag;
+            if (shouldBeModal && !this._modal) {
+                let actionMode = Shell.ActionMode.OVERVIEW;
+                if (Main.pushModal(this._overview, { actionMode })) {
+                    this._modal = true;
+                } else {
+                    this.hide();
+                    return false;
+                }
+            }
+        } else {
+            // eslint-disable-next-line no-lonely-if
+            if (this._modal) {
+                Main.popModal(this._overview);
+                this._modal = false;
+            }
+        }
+        return true;
+    }
+
+    // show:
+    //
+    // Animates the overview visible and grabs mouse and keyboard input
+    show() {
+        if (this.isDummy)
+            return;
+        if (this._shown)
+            return;
+        this._shown = true;
+
+        if (!this._syncGrab())
+            return;
+
+        Main.layoutManager.showOverview();
+        this._animateVisible();
+    }
+
+
+    _animateVisible() {
+        if (this._visible || this._animationInProgress)
+            return;
+
+        this._visible = true;
+        this._animationInProgress = true;
+        this._visibleTarget = true;
+        this._activationTime = GLib.get_monotonic_time() / GLib.USEC_PER_SEC;
+
+        Meta.disable_unredirect_for_display(global.display);
+        this.viewSelector.show();
+
+        this._overview.opacity = 0;
+        this._overview.ease({
+            opacity: 255,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            duration: ANIMATION_TIME,
+            onComplete: () => this._showDone(),
+        });
+        this._shadeBackgrounds();
+
+        Main.layoutManager.overviewGroup.set_child_above_sibling(
+            this._coverPane, null);
+        this._coverPane.show();
+        this.emit('showing');
+    }
+
+    _showDone() {
+        this._animationInProgress = false;
+        this._desktopFade.hide();
+        this._coverPane.hide();
+
+        this.emit('shown');
+        // Handle any calls to hide* while we were showing
+        if (!this._shown)
+            this._animateNotVisible();
+
+        this._syncGrab();
+        global.sync_pointer();
+    }
+
+    // hide:
+    //
+    // Reverses the effect of show()
+    hide() {
+        if (this.isDummy)
+            return;
+
+        if (!this._shown)
+            return;
+
+        let event = Clutter.get_current_event();
+        if (event) {
+            let type = event.type();
+            let button = type == Clutter.EventType.BUTTON_PRESS ||
+                          type == Clutter.EventType.BUTTON_RELEASE;
+            let ctrl = (event.get_state() & Clutter.ModifierType.CONTROL_MASK) != 0;
+            if (button && ctrl)
+                return;
+        }
+
+        this._shown = false;
+
+        this._animateNotVisible();
+        this._syncGrab();
+    }
+
+    _animateNotVisible() {
+        if (!this._visible || this._animationInProgress)
+            return;
+
+        this._animationInProgress = true;
+        this._visibleTarget = false;
+
+        this.viewSelector.animateFromOverview();
+
+        // Make other elements fade out.
+        this._overview.ease({
+            opacity: 0,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            duration: ANIMATION_TIME,
+            onComplete: () => this._hideDone(),
+        });
+        this._unshadeBackgrounds();
+
+        Main.layoutManager.overviewGroup.set_child_above_sibling(
+            this._coverPane, null);
+        this._coverPane.show();
+        this.emit('hiding');
+    }
+
+    _hideDone() {
+        // Re-enable unredirection
+        Meta.enable_unredirect_for_display(global.display);
+
+        this.viewSelector.hide();
+        this._desktopFade.hide();
+        this._coverPane.hide();
+
+        this._visible = false;
+        this._animationInProgress = false;
+
+        this.emit('hidden');
+        // Handle any calls to show* while we were hiding
+        if (this._shown)
+            this._animateVisible();
+        else
+            Main.layoutManager.hideOverview();
+
+        this._syncGrab();
+    }
+
+    toggle() {
+        if (this.isDummy)
+            return;
+
+        if (this._visible)
+            this.hide();
+        else
+            this.show();
+    }
+
+    getShowAppsButton() {
+        logError(new Error('Usage of Overview.\'getShowAppsButton\' is deprecated, ' +
+            'use \'dash.showAppsButton\' property instead'));
+
+        return this.dash.showAppsButton;
+    }
+
+    get searchEntry() {
+        return this._overview.searchEntry;
+    }
+};
+Signals.addSignalMethods(Overview.prototype);

js/ui/overviewControls.js

@@ -0,0 +1,538 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported ControlsManager */
+
+const { Clutter, GObject, Meta, St } = imports.gi;
+
+const Dash = imports.ui.dash;
+const Main = imports.ui.main;
+const Params = imports.misc.params;
+const ViewSelector = imports.ui.viewSelector;
+const WorkspaceThumbnail = imports.ui.workspaceThumbnail;
+
+var SIDE_CONTROLS_ANIMATION_TIME = 160;
+
+function getRtlSlideDirection(direction, actor) {
+    let rtl = actor.text_direction == Clutter.TextDirection.RTL;
+    if (rtl) {
+        direction = direction == SlideDirection.LEFT
+            ? SlideDirection.RIGHT : SlideDirection.LEFT;
+    }
+    return direction;
+}
+
+var SlideDirection = {
+    LEFT: 0,
+    RIGHT: 1,
+};
+
+var SlideLayout = GObject.registerClass({
+    Properties: {
+        'slide-x': GObject.ParamSpec.double(
+            'slide-x', 'slide-x', 'slide-x',
+            GObject.ParamFlags.READWRITE,
+            0, 1, 1),
+    },
+}, class SlideLayout extends Clutter.FixedLayout {
+    _init(params) {
+        this._slideX = 1;
+        this._direction = SlideDirection.LEFT;
+
+        super._init(params);
+    }
+
+    vfunc_get_preferred_width(container, forHeight) {
+        let child = container.get_first_child();
+
+        let [minWidth, natWidth] = child.get_preferred_width(forHeight);
+
+        minWidth *= this._slideX;
+        natWidth *= this._slideX;
+
+        return [minWidth, natWidth];
+    }
+
+    vfunc_allocate(container, box, flags) {
+        let child = container.get_first_child();
+
+        let availWidth = Math.round(box.x2 - box.x1);
+        let availHeight = Math.round(box.y2 - box.y1);
+        let [, natWidth] = child.get_preferred_width(availHeight);
+
+        // Align the actor inside the clipped box, as the actor's alignment
+        // flags only determine what to do if the allocated box is bigger
+        // than the actor's box.
+        let realDirection = getRtlSlideDirection(this._direction, child);
+        let alignX = realDirection == SlideDirection.LEFT
+            ? availWidth - natWidth
+            : availWidth - natWidth * this._slideX;
+
+        let actorBox = new Clutter.ActorBox();
+        actorBox.x1 = box.x1 + alignX;
+        actorBox.x2 = actorBox.x1 + (child.x_expand ? availWidth : natWidth);
+        actorBox.y1 = box.y1;
+        actorBox.y2 = actorBox.y1 + availHeight;
+
+        child.allocate(actorBox, flags);
+    }
+
+    // eslint-disable-next-line camelcase
+    set slide_x(value) {
+        if (this._slideX == value)
+            return;
+        this._slideX = value;
+        this.notify('slide-x');
+        this.layout_changed();
+    }
+
+    // eslint-disable-next-line camelcase
+    get slide_x() {
+        return this._slideX;
+    }
+
+    set slideDirection(direction) {
+        this._direction = direction;
+        this.layout_changed();
+    }
+
+    get slideDirection() {
+        return this._direction;
+    }
+});
+
+var SlidingControl = GObject.registerClass(
+class SlidingControl extends St.Widget {
+    _init(params) {
+        params = Params.parse(params, { slideDirection: SlideDirection.LEFT });
+
+        this.layout = new SlideLayout();
+        this.layout.slideDirection = params.slideDirection;
+        super._init({
+            layout_manager: this.layout,
+            style_class: 'overview-controls',
+            clip_to_allocation: true,
+        });
+
+        this._visible = true;
+        this._inDrag = false;
+
+        Main.overview.connect('hiding', this._onOverviewHiding.bind(this));
+
+        Main.overview.connect('item-drag-begin', this._onDragBegin.bind(this));
+        Main.overview.connect('item-drag-end', this._onDragEnd.bind(this));
+        Main.overview.connect('item-drag-cancelled', this._onDragEnd.bind(this));
+
+        Main.overview.connect('window-drag-begin', this._onWindowDragBegin.bind(this));
+        Main.overview.connect('window-drag-cancelled', this._onWindowDragEnd.bind(this));
+        Main.overview.connect('window-drag-end', this._onWindowDragEnd.bind(this));
+    }
+
+    _getSlide() {
+        throw new GObject.NotImplementedError('_getSlide in %s'.format(this.constructor.name));
+    }
+
+    _updateSlide() {
+        this.ease_property('@layout.slide-x', this._getSlide(), {
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            duration: SIDE_CONTROLS_ANIMATION_TIME,
+        });
+    }
+
+    getVisibleWidth() {
+        let child = this.get_first_child();
+        let [, , natWidth] = child.get_preferred_size();
+        return natWidth;
+    }
+
+    _getTranslation() {
+        let child = this.get_first_child();
+        let direction = getRtlSlideDirection(this.layout.slideDirection, child);
+        let visibleWidth = this.getVisibleWidth();
+
+        if (direction == SlideDirection.LEFT)
+            return -visibleWidth;
+        else
+            return visibleWidth;
+    }
+
+    _updateTranslation() {
+        let translationStart = 0;
+        let translationEnd = 0;
+        let translation = this._getTranslation();
+
+        let shouldShow = this._getSlide() > 0;
+        if (shouldShow)
+            translationStart = translation;
+        else
+            translationEnd = translation;
+
+        if (this.translation_x === translationEnd)
+            return;
+
+        this.translation_x = translationStart;
+        this.ease({
+            translation_x: translationEnd,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            duration: SIDE_CONTROLS_ANIMATION_TIME,
+        });
+    }
+
+    _onOverviewHiding() {
+        // We need to explicitly slideOut since showing pages
+        // doesn't imply sliding out, instead, hiding the overview does.
+        this.slideOut();
+    }
+
+    _onWindowDragBegin() {
+        this._onDragBegin();
+    }
+
+    _onWindowDragEnd() {
+        this._onDragEnd();
+    }
+
+    _onDragBegin() {
+        this._inDrag = true;
+        this._updateTranslation();
+        this._updateSlide();
+    }
+
+    _onDragEnd() {
+        this._inDrag = false;
+        this._updateSlide();
+    }
+
+    fadeIn() {
+        this.ease({
+            opacity: 255,
+            duration: SIDE_CONTROLS_ANIMATION_TIME / 2,
+            mode: Clutter.AnimationMode.EASE_IN_QUAD,
+        });
+    }
+
+    fadeHalf() {
+        this.ease({
+            opacity: 128,
+            duration: SIDE_CONTROLS_ANIMATION_TIME / 2,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        });
+    }
+
+    slideIn() {
+        this._visible = true;
+        // we will update slide_x and the translation from pageEmpty
+    }
+
+    slideOut() {
+        this._visible = false;
+        this._updateTranslation();
+        // we will update slide_x from pageEmpty
+    }
+
+    pageEmpty() {
+        // When pageEmpty is received, there's no visible view in the
+        // selector; this means we can now safely set the full slide for
+        // the next page, since slideIn or slideOut might have been called,
+        // changing the visiblity
+        this.remove_transition('@layout.slide-x');
+        this.layout.slide_x = this._getSlide();
+        this._updateTranslation();
+    }
+});
+
+var ThumbnailsSlider = GObject.registerClass(
+class ThumbnailsSlider extends SlidingControl {
+    _init(thumbnailsBox) {
+        super._init({ slideDirection: SlideDirection.RIGHT });
+
+        this._thumbnailsBox = thumbnailsBox;
+
+        this.request_mode = Clutter.RequestMode.WIDTH_FOR_HEIGHT;
+        this.reactive = true;
+        this.track_hover = true;
+        this.add_actor(this._thumbnailsBox);
+
+        Main.layoutManager.connect('monitors-changed', this._updateSlide.bind(this));
+        global.workspace_manager.connect('active-workspace-changed',
+                                         this._updateSlide.bind(this));
+        global.workspace_manager.connect('notify::n-workspaces',
+                                         this._updateSlide.bind(this));
+        this.connect('notify::hover', this._updateSlide.bind(this));
+        this._thumbnailsBox.bind_property('visible', this, 'visible', GObject.BindingFlags.SYNC_CREATE);
+    }
+
+    _getAlwaysZoomOut() {
+        // Always show the pager on hover, during a drag, or if workspaces are
+        // actually used, e.g. there are windows on any non-active workspace
+        let workspaceManager = global.workspace_manager;
+        let alwaysZoomOut = this.hover ||
+                            this._inDrag ||
+                            !Meta.prefs_get_dynamic_workspaces() ||
+                            workspaceManager.n_workspaces > 2 ||
+                            workspaceManager.get_active_workspace_index() != 0;
+
+        if (!alwaysZoomOut) {
+            let monitors = Main.layoutManager.monitors;
+            let primary = Main.layoutManager.primaryMonitor;
+
+            /* Look for any monitor to the right of the primary, if there is
+             * one, we always keep zoom out, otherwise its hard to reach
+             * the thumbnail area without passing into the next monitor. */
+            for (let i = 0; i < monitors.length; i++) {
+                if (monitors[i].x >= primary.x + primary.width) {
+                    alwaysZoomOut = true;
+                    break;
+                }
+            }
+        }
+
+        return alwaysZoomOut;
+    }
+
+    getNonExpandedWidth() {
+        let child = this.get_first_child();
+        return child.get_theme_node().get_length('visible-width');
+    }
+
+    _onDragEnd() {
+        this.sync_hover();
+        super._onDragEnd();
+    }
+
+    _getSlide() {
+        if (!this._visible)
+            return 0;
+
+        let alwaysZoomOut = this._getAlwaysZoomOut();
+        if (alwaysZoomOut)
+            return 1;
+
+        let child = this.get_first_child();
+        let preferredHeight = child.get_preferred_height(-1)[1];
+        let expandedWidth = child.get_preferred_width(preferredHeight)[1];
+
+        return this.getNonExpandedWidth() / expandedWidth;
+    }
+
+    getVisibleWidth() {
+        let alwaysZoomOut = this._getAlwaysZoomOut();
+        if (alwaysZoomOut)
+            return super.getVisibleWidth();
+        else
+            return this.getNonExpandedWidth();
+    }
+});
+
+var DashSlider = GObject.registerClass(
+class DashSlider extends SlidingControl {
+    _init(dash) {
+        super._init({ slideDirection: SlideDirection.LEFT });
+
+        this._dash = dash;
+
+        // SlideLayout reads the actor's expand flags to decide
+        // whether to allocate the natural size to its child, or the whole
+        // available allocation
+        this._dash.x_expand = true;
+
+        this.x_expand = true;
+        this.x_align = Clutter.ActorAlign.START;
+        this.y_expand = true;
+
+        this.add_actor(this._dash);
+
+        this._dash.connect('icon-size-changed', this._updateSlide.bind(this));
+    }
+
+    _getSlide() {
+        if (this._visible || this._inDrag)
+            return 1;
+        else
+            return 0;
+    }
+
+    _onWindowDragBegin() {
+        this.fadeHalf();
+    }
+
+    _onWindowDragEnd() {
+        this.fadeIn();
+    }
+});
+
+var DashSpacer = GObject.registerClass(
+class DashSpacer extends St.Widget {
+    _init(params) {
+        super._init(params);
+
+        this._bindConstraint = null;
+    }
+
+    setDashActor(dashActor) {
+        if (this._bindConstraint) {
+            this.remove_constraint(this._bindConstraint);
+            this._bindConstraint = null;
+        }
+
+        if (dashActor) {
+            this._bindConstraint = new Clutter.BindConstraint({ source: dashActor,
+                                                                coordinate: Clutter.BindCoordinate.SIZE });
+            this.add_constraint(this._bindConstraint);
+        }
+    }
+
+    vfunc_get_preferred_width(forHeight) {
+        if (this._bindConstraint)
+            return this._bindConstraint.source.get_preferred_width(forHeight);
+        return super.vfunc_get_preferred_width(forHeight);
+    }
+
+    vfunc_get_preferred_height(forWidth) {
+        if (this._bindConstraint)
+            return this._bindConstraint.source.get_preferred_height(forWidth);
+        return super.vfunc_get_preferred_height(forWidth);
+    }
+});
+
+var ControlsLayout = GObject.registerClass({
+    Signals: { 'allocation-changed': { flags: GObject.SignalFlags.RUN_LAST } },
+}, class ControlsLayout extends Clutter.BinLayout {
+    vfunc_allocate(container, box, flags) {
+        super.vfunc_allocate(container, box, flags);
+        this.emit('allocation-changed');
+    }
+});
+
+var ControlsManager = GObject.registerClass(
+class ControlsManager extends St.Widget {
+    _init(searchEntry) {
+        let layout = new ControlsLayout();
+        super._init({
+            layout_manager: layout,
+            x_expand: true,
+            y_expand: true,
+            clip_to_allocation: true,
+        });
+
+        this.dash = new Dash.Dash();
+        this._dashSlider = new DashSlider(this.dash);
+        this._dashSpacer = new DashSpacer();
+        this._dashSpacer.setDashActor(this._dashSlider);
+
+        let workspaceManager = global.workspace_manager;
+        let activeWorkspaceIndex = workspaceManager.get_active_workspace_index();
+
+        this._workspaceAdjustment = new St.Adjustment({
+            value: activeWorkspaceIndex,
+            lower: 0,
+            page_increment: 1,
+            page_size: 1,
+            step_increment: 0,
+            upper: workspaceManager.n_workspaces,
+        });
+
+        this._nWorkspacesNotifyId =
+            workspaceManager.connect('notify::n-workspaces',
+                this._updateAdjustment.bind(this));
+
+        this._thumbnailsBox =
+            new WorkspaceThumbnail.ThumbnailsBox(this._workspaceAdjustment);
+        this._thumbnailsSlider = new ThumbnailsSlider(this._thumbnailsBox);
+
+        this.viewSelector = new ViewSelector.ViewSelector(searchEntry,
+            this._workspaceAdjustment, this.dash.showAppsButton);
+        this.viewSelector.connect('page-changed', this._setVisibility.bind(this));
+        this.viewSelector.connect('page-empty', this._onPageEmpty.bind(this));
+
+        this._group = new St.BoxLayout({ name: 'overview-group',
+                                         x_expand: true, y_expand: true });
+        this.add_actor(this._group);
+
+        this.add_actor(this._dashSlider);
+
+        this._group.add_actor(this._dashSpacer);
+        this._group.add_child(this.viewSelector);
+        this._group.add_actor(this._thumbnailsSlider);
+
+        layout.connect('allocation-changed', this._updateWorkspacesGeometry.bind(this));
+
+        Main.overview.connect('showing', this._updateSpacerVisibility.bind(this));
+
+        this.connect('destroy', this._onDestroy.bind(this));
+    }
+
+    _onDestroy() {
+        global.workspace_manager.disconnect(this._nWorkspacesNotifyId);
+    }
+
+    _updateAdjustment() {
+        let workspaceManager = global.workspace_manager;
+        let newNumWorkspaces = workspaceManager.n_workspaces;
+        let activeIndex = workspaceManager.get_active_workspace_index();
+
+        this._workspaceAdjustment.upper = newNumWorkspaces;
+
+        // A workspace might have been inserted or removed before the active
+        // one, causing the adjustment to go out of sync, so update the value
+        this._workspaceAdjustment.value = activeIndex;
+    }
+
+    _updateWorkspacesGeometry() {
+        let [x, y] = this.get_transformed_position();
+        let [width, height] = this.get_transformed_size();
+        let geometry = { x, y, width, height };
+
+        let spacing = this.get_theme_node().get_length('spacing');
+        let dashWidth = this._dashSlider.getVisibleWidth() + spacing;
+        let thumbnailsWidth = this._thumbnailsSlider.getNonExpandedWidth() + spacing;
+
+        geometry.width -= dashWidth;
+        geometry.width -= thumbnailsWidth;
+
+        if (this.get_text_direction() == Clutter.TextDirection.LTR)
+            geometry.x += dashWidth;
+        else
+            geometry.x += thumbnailsWidth;
+
+        this.viewSelector.setWorkspacesFullGeometry(geometry);
+    }
+
+    _setVisibility() {
+        // Ignore the case when we're leaving the overview, since
+        // actors will be made visible again when entering the overview
+        // next time, and animating them while doing so is just
+        // unnecessary noise
+        if (!Main.overview.visible ||
+            (Main.overview.animationInProgress && !Main.overview.visibleTarget))
+            return;
+
+        let activePage = this.viewSelector.getActivePage();
+        let dashVisible = activePage == ViewSelector.ViewPage.WINDOWS ||
+                           activePage == ViewSelector.ViewPage.APPS;
+        let thumbnailsVisible = activePage == ViewSelector.ViewPage.WINDOWS;
+
+        if (dashVisible)
+            this._dashSlider.slideIn();
+        else
+            this._dashSlider.slideOut();
+
+        if (thumbnailsVisible)
+            this._thumbnailsSlider.slideIn();
+        else
+            this._thumbnailsSlider.slideOut();
+    }
+
+    _updateSpacerVisibility() {
+        if (Main.overview.animationInProgress && !Main.overview.visibleTarget)
+            return;
+
+        let activePage = this.viewSelector.getActivePage();
+        this._dashSpacer.visible = activePage == ViewSelector.ViewPage.WINDOWS;
+    }
+
+    _onPageEmpty() {
+        this._dashSlider.pageEmpty();
+        this._thumbnailsSlider.pageEmpty();
+
+        this._updateSpacerVisibility();
+    }
+});

js/ui/pageIndicators.js

@@ -0,0 +1,190 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported PageIndicators, AnimatedPageIndicators */
+
+const { Clutter, GLib, Graphene, GObject, Meta, St } = imports.gi;
+
+const { ANIMATION_TIME_OUT, ANIMATION_MAX_DELAY_OUT_FOR_ITEM, AnimationDirection } = imports.ui.iconGrid;
+
+const INDICATOR_INACTIVE_OPACITY = 128;
+const INDICATOR_INACTIVE_OPACITY_HOVER = 255;
+const INDICATOR_INACTIVE_SCALE = 2 / 3;
+const INDICATOR_INACTIVE_SCALE_PRESSED = 0.5;
+
+var INDICATORS_BASE_TIME = 250;
+var INDICATORS_BASE_TIME_OUT = 125;
+var INDICATORS_ANIMATION_DELAY = 125;
+var INDICATORS_ANIMATION_DELAY_OUT = 62.5;
+var INDICATORS_ANIMATION_MAX_TIME = 750;
+var SWITCH_TIME = 400;
+var INDICATORS_ANIMATION_MAX_TIME_OUT =
+    Math.min(SWITCH_TIME,
+             ANIMATION_TIME_OUT + ANIMATION_MAX_DELAY_OUT_FOR_ITEM);
+
+var ANIMATION_DELAY = 100;
+
+var PageIndicators = GObject.registerClass({
+    Signals: { 'page-activated': { param_types: [GObject.TYPE_INT] } },
+}, class PageIndicators extends St.BoxLayout {
+    _init(orientation = Clutter.Orientation.VERTICAL) {
+        let vertical = orientation == Clutter.Orientation.VERTICAL;
+        super._init({
+            style_class: 'page-indicators',
+            vertical,
+            x_expand: true, y_expand: true,
+            x_align: vertical ? Clutter.ActorAlign.END : Clutter.ActorAlign.CENTER,
+            y_align: vertical ? Clutter.ActorAlign.CENTER : Clutter.ActorAlign.END,
+            reactive: true,
+            clip_to_allocation: true,
+        });
+        this._nPages = 0;
+        this._currentPosition = 0;
+        this._reactive = true;
+        this._reactive = true;
+    }
+
+    vfunc_get_preferred_height(forWidth) {
+        // We want to request the natural height of all our children as our
+        // natural height, so we chain up to St.BoxLayout, but we only request 0
+        // as minimum height, since it's not that important if some indicators
+        // are not shown
+        let [, natHeight] = super.vfunc_get_preferred_height(forWidth);
+        return [0, natHeight];
+    }
+
+    setReactive(reactive) {
+        let children = this.get_children();
+        for (let i = 0; i < children.length; i++)
+            children[i].reactive = reactive;
+
+        this._reactive = reactive;
+    }
+
+    setNPages(nPages) {
+        if (this._nPages == nPages)
+            return;
+
+        let diff = nPages - this._nPages;
+        if (diff > 0) {
+            for (let i = 0; i < diff; i++) {
+                let pageIndex = this._nPages + i;
+                let indicator = new St.Button({ style_class: 'page-indicator',
+                                                button_mask: St.ButtonMask.ONE |
+                                                             St.ButtonMask.TWO |
+                                                             St.ButtonMask.THREE,
+                                                reactive: this._reactive });
+                indicator.child = new St.Widget({
+                    style_class: 'page-indicator-icon',
+                    pivot_point: new Graphene.Point({ x: 0.5, y: 0.5 }),
+                });
+                indicator.connect('clicked', () => {
+                    this.emit('page-activated', pageIndex);
+                });
+                indicator.connect('notify::hover', () => {
+                    this._updateIndicator(indicator, pageIndex);
+                });
+                indicator.connect('notify::pressed', () => {
+                    this._updateIndicator(indicator, pageIndex);
+                });
+                this._updateIndicator(indicator, pageIndex);
+                this.add_actor(indicator);
+            }
+        } else {
+            let children = this.get_children().splice(diff);
+            for (let i = 0; i < children.length; i++)
+                children[i].destroy();
+        }
+        this._nPages = nPages;
+        this.visible = this._nPages > 1;
+    }
+
+    _updateIndicator(indicator, pageIndex) {
+        let progress =
+            Math.max(1 - Math.abs(this._currentPosition - pageIndex), 0);
+
+        let inactiveScale = indicator.pressed
+            ? INDICATOR_INACTIVE_SCALE_PRESSED : INDICATOR_INACTIVE_SCALE;
+        let inactiveOpacity = indicator.hover
+            ? INDICATOR_INACTIVE_OPACITY_HOVER : INDICATOR_INACTIVE_OPACITY;
+
+        let scale = inactiveScale + (1 - inactiveScale) * progress;
+        let opacity = inactiveOpacity + (255 - inactiveOpacity) * progress;
+
+        indicator.child.set_scale(scale, scale);
+        indicator.child.opacity = opacity;
+    }
+
+    setCurrentPosition(currentPosition) {
+        this._currentPosition = currentPosition;
+
+        let children = this.get_children();
+        for (let i = 0; i < children.length; i++)
+            this._updateIndicator(children[i], i);
+    }
+});
+
+var AnimatedPageIndicators = GObject.registerClass(
+class AnimatedPageIndicators extends PageIndicators {
+    _init() {
+        super._init();
+        this.connect('destroy', this._onDestroy.bind(this));
+    }
+
+    _onDestroy() {
+        if (this.animateLater) {
+            Meta.later_remove(this.animateLater);
+            this.animateLater = 0;
+        }
+    }
+
+    vfunc_map() {
+        super.vfunc_map();
+
+        // Implicit animations are skipped for unmapped actors, and our
+        // children aren't mapped yet, so defer to a later handler
+        this.animateLater = Meta.later_add(Meta.LaterType.BEFORE_REDRAW, () => {
+            this.animateLater = 0;
+            this.animateIndicators(AnimationDirection.IN);
+            return GLib.SOURCE_REMOVE;
+        });
+    }
+
+    animateIndicators(animationDirection) {
+        if (!this.mapped)
+            return;
+
+        let children = this.get_children();
+        if (children.length == 0)
+            return;
+
+        for (let i = 0; i < this._nPages; i++)
+            children[i].remove_all_transitions();
+
+        let offset;
+        if (this.get_text_direction() == Clutter.TextDirection.RTL)
+            offset = -children[0].width;
+        else
+            offset = children[0].width;
+
+        let isAnimationIn = animationDirection == AnimationDirection.IN;
+        let delay = isAnimationIn
+            ? INDICATORS_ANIMATION_DELAY
+            : INDICATORS_ANIMATION_DELAY_OUT;
+        let baseTime = isAnimationIn ? INDICATORS_BASE_TIME : INDICATORS_BASE_TIME_OUT;
+        let totalAnimationTime = baseTime + delay * this._nPages;
+        let maxTime = isAnimationIn
+            ? INDICATORS_ANIMATION_MAX_TIME
+            : INDICATORS_ANIMATION_MAX_TIME_OUT;
+        if (totalAnimationTime > maxTime)
+            delay -= (totalAnimationTime - maxTime) / this._nPages;
+
+        for (let i = 0; i < this._nPages; i++) {
+            children[i].translation_x = isAnimationIn ? offset : 0;
+            children[i].ease({
+                translation_x: isAnimationIn ? 0 : offset,
+                duration: baseTime + delay * i,
+                mode: Clutter.AnimationMode.EASE_IN_OUT_QUAD,
+                delay: isAnimationIn ? ANIMATION_DELAY : 0,
+            });
+        }
+    }
+});

js/ui/panelMenu.js

@@ -0,0 +1,229 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Button, SystemIndicator */
+
+const { Atk, Clutter, GObject, St } = imports.gi;
+
+const Main = imports.ui.main;
+const Params = imports.misc.params;
+const PopupMenu = imports.ui.popupMenu;
+
+var ButtonBox = GObject.registerClass(
+class ButtonBox extends St.Widget {
+    _init(params) {
+        params = Params.parse(params, {
+            style_class: 'panel-button',
+            x_expand: true,
+            y_expand: true,
+        }, true);
+
+        super._init(params);
+
+        this._delegate = this;
+
+        this.container = new St.Bin({ child: this });
+
+        this.connect('style-changed', this._onStyleChanged.bind(this));
+        this.connect('destroy', this._onDestroy.bind(this));
+
+        this._minHPadding = this._natHPadding = 0.0;
+    }
+
+    _onStyleChanged(actor) {
+        let themeNode = actor.get_theme_node();
+
+        this._minHPadding = themeNode.get_length('-minimum-hpadding');
+        this._natHPadding = themeNode.get_length('-natural-hpadding');
+    }
+
+    vfunc_get_preferred_width(_forHeight) {
+        let child = this.get_first_child();
+        let minimumSize, naturalSize;
+
+        if (child)
+            [minimumSize, naturalSize] = child.get_preferred_width(-1);
+        else
+            minimumSize = naturalSize = 0;
+
+        minimumSize += 2 * this._minHPadding;
+        naturalSize += 2 * this._natHPadding;
+
+        return [minimumSize, naturalSize];
+    }
+
+    vfunc_get_preferred_height(_forWidth) {
+        let child = this.get_first_child();
+
+        if (child)
+            return child.get_preferred_height(-1);
+
+        return [0, 0];
+    }
+
+    vfunc_allocate(box, flags) {
+        this.set_allocation(box, flags);
+
+        let child = this.get_first_child();
+        if (!child)
+            return;
+
+        let [, natWidth] = child.get_preferred_width(-1);
+
+        let availWidth = box.x2 - box.x1;
+        let availHeight = box.y2 - box.y1;
+
+        let childBox = new Clutter.ActorBox();
+        if (natWidth + 2 * this._natHPadding <= availWidth) {
+            childBox.x1 = this._natHPadding;
+            childBox.x2 = availWidth - this._natHPadding;
+        } else {
+            childBox.x1 = this._minHPadding;
+            childBox.x2 = availWidth - this._minHPadding;
+        }
+
+        childBox.y1 = 0;
+        childBox.y2 = availHeight;
+
+        child.allocate(childBox, flags);
+    }
+
+    _onDestroy() {
+        this.container.child = null;
+        this.container.destroy();
+    }
+});
+
+var Button = GObject.registerClass({
+    Signals: { 'menu-set': {} },
+}, class PanelMenuButton extends ButtonBox {
+    _init(menuAlignment, nameText, dontCreateMenu) {
+        super._init({ reactive: true,
+                      can_focus: true,
+                      track_hover: true,
+                      accessible_name: nameText ? nameText : "",
+                      accessible_role: Atk.Role.MENU });
+
+        if (dontCreateMenu)
+            this.menu = new PopupMenu.PopupDummyMenu(this);
+        else
+            this.setMenu(new PopupMenu.PopupMenu(this, menuAlignment, St.Side.TOP, 0));
+    }
+
+    setSensitive(sensitive) {
+        this.reactive = sensitive;
+        this.can_focus = sensitive;
+        this.track_hover = sensitive;
+    }
+
+    setMenu(menu) {
+        if (this.menu)
+            this.menu.destroy();
+
+        this.menu = menu;
+        if (this.menu) {
+            this.menu.actor.add_style_class_name('panel-menu');
+            this.menu.connect('open-state-changed', this._onOpenStateChanged.bind(this));
+            this.menu.actor.connect('key-press-event', this._onMenuKeyPress.bind(this));
+
+            Main.uiGroup.add_actor(this.menu.actor);
+            this.menu.actor.hide();
+        }
+        this.emit('menu-set');
+    }
+
+    vfunc_event(event) {
+        if (this.menu &&
+            (event.type() == Clutter.EventType.TOUCH_BEGIN ||
+             event.type() == Clutter.EventType.BUTTON_PRESS))
+            this.menu.toggle();
+
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    vfunc_hide() {
+        super.vfunc_hide();
+
+        if (this.menu)
+            this.menu.close();
+    }
+
+    _onMenuKeyPress(actor, event) {
+        if (global.focus_manager.navigate_from_event(event))
+            return Clutter.EVENT_STOP;
+
+        let symbol = event.get_key_symbol();
+        if (symbol == Clutter.KEY_Left || symbol == Clutter.KEY_Right) {
+            let group = global.focus_manager.get_group(this);
+            if (group) {
+                let direction = symbol == Clutter.KEY_Left ? St.DirectionType.LEFT : St.DirectionType.RIGHT;
+                group.navigate_focus(this, direction, false);
+                return Clutter.EVENT_STOP;
+            }
+        }
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    _onOpenStateChanged(menu, open) {
+        if (open)
+            this.add_style_pseudo_class('active');
+        else
+            this.remove_style_pseudo_class('active');
+
+        // Setting the max-height won't do any good if the minimum height of the
+        // menu is higher then the screen; it's useful if part of the menu is
+        // scrollable so the minimum height is smaller than the natural height
+        let workArea = Main.layoutManager.getWorkAreaForMonitor(Main.layoutManager.primaryIndex);
+        let scaleFactor = St.ThemeContext.get_for_stage(global.stage).scale_factor;
+        let verticalMargins = this.menu.actor.margin_top + this.menu.actor.margin_bottom;
+
+        // The workarea and margin dimensions are in physical pixels, but CSS
+        // measures are in logical pixels, so make sure to consider the scale
+        // factor when computing max-height
+        let maxHeight = Math.round((workArea.height - verticalMargins) / scaleFactor);
+        this.menu.actor.style = 'max-height: %spx;'.format(maxHeight);
+    }
+
+    _onDestroy() {
+        super._onDestroy();
+
+        if (this.menu)
+            this.menu.destroy();
+    }
+});
+
+/* SystemIndicator:
+ *
+ * This class manages one system indicator, which are the icons
+ * that you see at the top right. A system indicator is composed
+ * of an icon and a menu section, which will be composed into the
+ * aggregate menu.
+ */
+var SystemIndicator = GObject.registerClass(
+class SystemIndicator extends St.BoxLayout {
+    _init() {
+        super._init({
+            style_class: 'panel-status-indicators-box',
+            reactive: true,
+            visible: false,
+        });
+        this.menu = new PopupMenu.PopupMenuSection();
+    }
+
+    get indicators() {
+        let klass = this.constructor.name;
+        let { stack } = new Error();
+        log(`Usage of indicator.indicators is deprecated for ${klass}\n${stack}`);
+        return this;
+    }
+
+    _syncIndicatorsVisible() {
+        this.visible = this.get_children().some(a => a.visible);
+    }
+
+    _addIndicator() {
+        let icon = new St.Icon({ style_class: 'system-status-icon' });
+        this.add_actor(icon);
+        icon.connect('notify::visible', this._syncIndicatorsVisible.bind(this));
+        this._syncIndicatorsVisible();
+        return icon;
+    }
+});

js/ui/pointerA11yTimeout.js

@@ -0,0 +1,134 @@
+/* exported PointerA11yTimeout */
+const { Clutter, GObject, Meta, St } = imports.gi;
+const Main = imports.ui.main;
+const Cairo = imports.cairo;
+
+const SUCCESS_ZOOM_OUT_DURATION = 150;
+
+var PieTimer = GObject.registerClass({
+    Properties: {
+        'angle': GObject.ParamSpec.double(
+            'angle', 'angle', 'angle',
+            GObject.ParamFlags.READWRITE,
+            0, 2 * Math.PI, 0),
+    },
+}, class PieTimer extends St.DrawingArea {
+    _init() {
+        this._angle = 0;
+        super._init({
+            style_class: 'pie-timer',
+            opacity: 0,
+            visible: false,
+            can_focus: false,
+            reactive: false,
+        });
+
+        this.set_pivot_point(0.5, 0.5);
+    }
+
+    get angle() {
+        return this._angle;
+    }
+
+    set angle(angle) {
+        if (this._angle == angle)
+            return;
+
+        this._angle = angle;
+        this.notify('angle');
+        this.queue_repaint();
+    }
+
+    vfunc_repaint() {
+        let node = this.get_theme_node();
+        let backgroundColor = node.get_color('-pie-background-color');
+        let borderColor = node.get_color('-pie-border-color');
+        let borderWidth = node.get_length('-pie-border-width');
+        let [width, height] = this.get_surface_size();
+        let radius = Math.min(width / 2, height / 2);
+
+        let startAngle = 3 * Math.PI / 2;
+        let endAngle = startAngle + this._angle;
+
+        let cr = this.get_context();
+        cr.setLineCap(Cairo.LineCap.ROUND);
+        cr.setLineJoin(Cairo.LineJoin.ROUND);
+        cr.translate(width / 2, height / 2);
+
+        if (this._angle < 2 * Math.PI)
+            cr.moveTo(0, 0);
+
+        cr.arc(0, 0, radius - borderWidth, startAngle, endAngle);
+
+        if (this._angle < 2 * Math.PI)
+            cr.lineTo(0, 0);
+
+        cr.closePath();
+
+        cr.setLineWidth(0);
+        Clutter.cairo_set_source_color(cr, backgroundColor);
+        cr.fillPreserve();
+
+        cr.setLineWidth(borderWidth);
+        Clutter.cairo_set_source_color(cr, borderColor);
+        cr.stroke();
+
+        cr.$dispose();
+    }
+
+    start(x, y, duration) {
+        this.x = x - this.width / 2;
+        this.y = y - this.height / 2;
+        this.show();
+
+        this.ease({
+            opacity: 255,
+            duration: duration / 4,
+            mode: Clutter.AnimationMode.EASE_IN_QUAD,
+        });
+
+        this.ease_property('angle', 2 * Math.PI, {
+            duration,
+            mode: Clutter.AnimationMode.LINEAR,
+            onComplete: this._onTransitionComplete.bind(this),
+        });
+    }
+
+    _onTransitionComplete() {
+        this.ease({
+            scale_x: 2,
+            scale_y: 2,
+            opacity: 0,
+            duration: SUCCESS_ZOOM_OUT_DURATION,
+            mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+            onStopped: () => this.destroy(),
+        });
+    }
+});
+
+var PointerA11yTimeout = class PointerA11yTimeout {
+    constructor() {
+        let seat = Clutter.get_default_backend().get_default_seat();
+
+        seat.connect('ptr-a11y-timeout-started', (o, device, type, timeout) => {
+            let [x, y] = global.get_pointer();
+
+            this._pieTimer = new PieTimer();
+            Main.uiGroup.add_actor(this._pieTimer);
+            Main.uiGroup.set_child_above_sibling(this._pieTimer, null);
+
+            this._pieTimer.start(x, y, timeout);
+
+            if (type == Clutter.PointerA11yTimeoutType.GESTURE)
+                global.display.set_cursor(Meta.Cursor.CROSSHAIR);
+        });
+
+        seat.connect('ptr-a11y-timeout-stopped', (o, device, type, clicked) => {
+            if (!clicked)
+                this._pieTimer.destroy();
+
+            if (type == Clutter.PointerA11yTimeoutType.GESTURE)
+                global.display.set_cursor(Meta.Cursor.DEFAULT);
+        });
+    }
+};

js/ui/pointerWatcher.js

@@ -0,0 +1,125 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported getPointerWatcher */
+
+const { GLib, Meta } = imports.gi;
+
+// We stop polling if the user is idle for more than this amount of time
+var IDLE_TIME = 1000;
+
+// This file implements a reasonably efficient system for tracking the position
+// of the mouse pointer. We simply query the pointer from the X server in a loop,
+// but we turn off the polling when the user is idle.
+
+let _pointerWatcher = null;
+function getPointerWatcher() {
+    if (_pointerWatcher == null)
+        _pointerWatcher = new PointerWatcher();
+
+    return _pointerWatcher;
+}
+
+var PointerWatch = class {
+    constructor(watcher, interval, callback) {
+        this.watcher = watcher;
+        this.interval = interval;
+        this.callback = callback;
+    }
+
+    // remove:
+    // remove this watch. This function may safely be called
+    // while the callback is executing.
+    remove() {
+        this.watcher._removeWatch(this);
+    }
+};
+
+var PointerWatcher = class {
+    constructor() {
+        this._idleMonitor = Meta.IdleMonitor.get_core();
+        this._idleMonitor.add_idle_watch(IDLE_TIME, this._onIdleMonitorBecameIdle.bind(this));
+        this._idle = this._idleMonitor.get_idletime() > IDLE_TIME;
+        this._watches = [];
+        this.pointerX = null;
+        this.pointerY = null;
+    }
+
+    // addWatch:
+    // @interval: hint as to the time resolution needed. When the user is
+    //   not idle, the position of the pointer will be queried at least
+    //   once every this many milliseconds.
+    // @callback to call when the pointer position changes - takes
+    //   two arguments, X and Y.
+    //
+    // Set up a watch on the position of the mouse pointer. Returns a
+    // PointerWatch object which has a remove() method to remove the watch.
+    addWatch(interval, callback) {
+        // Avoid unreliably calling the watch for the current position
+        this._updatePointer();
+
+        let watch = new PointerWatch(this, interval, callback);
+        this._watches.push(watch);
+        this._updateTimeout();
+        return watch;
+    }
+
+    _removeWatch(watch) {
+        for (let i = 0; i < this._watches.length; i++) {
+            if (this._watches[i] == watch) {
+                this._watches.splice(i, 1);
+                this._updateTimeout();
+                return;
+            }
+        }
+    }
+
+    _onIdleMonitorBecameActive() {
+        this._idle = false;
+        this._updatePointer();
+        this._updateTimeout();
+    }
+
+    _onIdleMonitorBecameIdle() {
+        this._idle = true;
+        this._idleMonitor.add_user_active_watch(this._onIdleMonitorBecameActive.bind(this));
+        this._updateTimeout();
+    }
+
+    _updateTimeout() {
+        if (this._timeoutId) {
+            GLib.source_remove(this._timeoutId);
+            this._timeoutId = 0;
+        }
+
+        if (this._idle || this._watches.length == 0)
+            return;
+
+        let minInterval = this._watches[0].interval;
+        for (let i = 1; i < this._watches.length; i++)
+            minInterval = Math.min(this._watches[i].interval, minInterval);
+
+        this._timeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, minInterval,
+            this._onTimeout.bind(this));
+        GLib.Source.set_name_by_id(this._timeoutId, '[gnome-shell] this._onTimeout');
+    }
+
+    _onTimeout() {
+        this._updatePointer();
+        return GLib.SOURCE_CONTINUE;
+    }
+
+    _updatePointer() {
+        let [x, y] = global.get_pointer();
+        if (this.pointerX == x && this.pointerY == y)
+            return;
+
+        this.pointerX = x;
+        this.pointerY = y;
+
+        for (let i = 0; i < this._watches.length;) {
+            let watch = this._watches[i];
+            watch.callback(x, y);
+            if (watch == this._watches[i]) // guard against self-removal
+                i++;
+        }
+    }
+};

js/ui/remoteSearch.js

@@ -0,0 +1,335 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported loadRemoteSearchProviders */
+
+const { GdkPixbuf, Gio, GLib, Shell, St } = imports.gi;
+
+const FileUtils = imports.misc.fileUtils;
+
+const KEY_FILE_GROUP = 'Shell Search Provider';
+
+const SearchProviderIface = `
+<node>
+<interface name="org.gnome.Shell.SearchProvider">
+<method name="GetInitialResultSet">
+    <arg type="as" direction="in" />
+    <arg type="as" direction="out" />
+</method>
+<method name="GetSubsearchResultSet">
+    <arg type="as" direction="in" />
+    <arg type="as" direction="in" />
+    <arg type="as" direction="out" />
+</method>
+<method name="GetResultMetas">
+    <arg type="as" direction="in" />
+    <arg type="aa{sv}" direction="out" />
+</method>
+<method name="ActivateResult">
+    <arg type="s" direction="in" />
+</method>
+</interface>
+</node>`;
+
+const SearchProvider2Iface = `
+<node>
+<interface name="org.gnome.Shell.SearchProvider2">
+<method name="GetInitialResultSet">
+    <arg type="as" direction="in" />
+    <arg type="as" direction="out" />
+</method>
+<method name="GetSubsearchResultSet">
+    <arg type="as" direction="in" />
+    <arg type="as" direction="in" />
+    <arg type="as" direction="out" />
+</method>
+<method name="GetResultMetas">
+    <arg type="as" direction="in" />
+    <arg type="aa{sv}" direction="out" />
+</method>
+<method name="ActivateResult">
+    <arg type="s" direction="in" />
+    <arg type="as" direction="in" />
+    <arg type="u" direction="in" />
+</method>
+<method name="LaunchSearch">
+    <arg type="as" direction="in" />
+    <arg type="u" direction="in" />
+</method>
+</interface>
+</node>`;
+
+var SearchProviderProxyInfo = Gio.DBusInterfaceInfo.new_for_xml(SearchProviderIface);
+var SearchProvider2ProxyInfo = Gio.DBusInterfaceInfo.new_for_xml(SearchProvider2Iface);
+
+function loadRemoteSearchProviders(searchSettings, callback) {
+    let objectPaths = {};
+    let loadedProviders = [];
+
+    function loadRemoteSearchProvider(file) {
+        let keyfile = new GLib.KeyFile();
+        let path = file.get_path();
+
+        try {
+            keyfile.load_from_file(path, 0);
+        } catch (e) {
+            return;
+        }
+
+        if (!keyfile.has_group(KEY_FILE_GROUP))
+            return;
+
+        let remoteProvider;
+        try {
+            let group = KEY_FILE_GROUP;
+            let busName = keyfile.get_string(group, 'BusName');
+            let objectPath = keyfile.get_string(group, 'ObjectPath');
+
+            if (objectPaths[objectPath])
+                return;
+
+            let appInfo = null;
+            try {
+                let desktopId = keyfile.get_string(group, 'DesktopId');
+                appInfo = Gio.DesktopAppInfo.new(desktopId);
+                if (!appInfo.should_show())
+                    return;
+            } catch (e) {
+                log(`Ignoring search provider ${path}: missing DesktopId`);
+                return;
+            }
+
+            let autoStart = true;
+            try {
+                autoStart = keyfile.get_boolean(group, 'AutoStart');
+            } catch (e) {
+                // ignore error
+            }
+
+            let version = '1';
+            try {
+                version = keyfile.get_string(group, 'Version');
+            } catch (e) {
+                // ignore error
+            }
+
+            if (version >= 2)
+                remoteProvider = new RemoteSearchProvider2(appInfo, busName, objectPath, autoStart);
+            else
+                remoteProvider = new RemoteSearchProvider(appInfo, busName, objectPath, autoStart);
+
+            remoteProvider.defaultEnabled = true;
+            try {
+                remoteProvider.defaultEnabled = !keyfile.get_boolean(group, 'DefaultDisabled');
+            } catch (e) {
+                // ignore error
+            }
+
+            objectPaths[objectPath] = remoteProvider;
+            loadedProviders.push(remoteProvider);
+        } catch (e) {
+            log('Failed to add search provider %s: %s'.format(path, e.toString()));
+        }
+    }
+
+    if (searchSettings.get_boolean('disable-external')) {
+        callback([]);
+        return;
+    }
+
+    FileUtils.collectFromDatadirs('search-providers', false, loadRemoteSearchProvider);
+
+    let sortOrder = searchSettings.get_strv('sort-order');
+
+    // Special case gnome-control-center to be always active and always first
+    sortOrder.unshift('gnome-control-center.desktop');
+
+    loadedProviders = loadedProviders.filter(provider => {
+        let appId = provider.appInfo.get_id();
+
+        if (provider.defaultEnabled) {
+            let disabled = searchSettings.get_strv('disabled');
+            return !disabled.includes(appId);
+        } else {
+            let enabled = searchSettings.get_strv('enabled');
+            return enabled.includes(appId);
+        }
+    });
+
+    loadedProviders.sort((providerA, providerB) => {
+        let idxA, idxB;
+        let appIdA, appIdB;
+
+        appIdA = providerA.appInfo.get_id();
+        appIdB = providerB.appInfo.get_id();
+
+        idxA = sortOrder.indexOf(appIdA);
+        idxB = sortOrder.indexOf(appIdB);
+
+        // if no provider is found in the order, use alphabetical order
+        if ((idxA == -1) && (idxB == -1)) {
+            let nameA = providerA.appInfo.get_name();
+            let nameB = providerB.appInfo.get_name();
+
+            return GLib.utf8_collate(nameA, nameB);
+        }
+
+        // if providerA isn't found, it's sorted after providerB
+        if (idxA == -1)
+            return 1;
+
+        // if providerB isn't found, it's sorted after providerA
+        if (idxB == -1)
+            return -1;
+
+        // finally, if both providers are found, return their order in the list
+        return idxA - idxB;
+    });
+
+    callback(loadedProviders);
+}
+
+var RemoteSearchProvider = class {
+    constructor(appInfo, dbusName, dbusPath, autoStart, proxyInfo) {
+        if (!proxyInfo)
+            proxyInfo = SearchProviderProxyInfo;
+
+        let gFlags = Gio.DBusProxyFlags.DO_NOT_LOAD_PROPERTIES;
+        if (autoStart)
+            gFlags |= Gio.DBusProxyFlags.DO_NOT_AUTO_START_AT_CONSTRUCTION;
+        else
+            gFlags |= Gio.DBusProxyFlags.DO_NOT_AUTO_START;
+
+        this.proxy = new Gio.DBusProxy({ g_bus_type: Gio.BusType.SESSION,
+                                         g_name: dbusName,
+                                         g_object_path: dbusPath,
+                                         g_interface_info: proxyInfo,
+                                         g_interface_name: proxyInfo.name,
+                                         gFlags });
+        this.proxy.init_async(GLib.PRIORITY_DEFAULT, null, null);
+
+        this.appInfo = appInfo;
+        this.id = appInfo.get_id();
+        this.isRemoteProvider = true;
+        this.canLaunchSearch = false;
+    }
+
+    createIcon(size, meta) {
+        let gicon = null;
+        let icon = null;
+
+        if (meta['icon']) {
+            gicon = Gio.icon_deserialize(meta['icon']);
+        } else if (meta['gicon']) {
+            gicon = Gio.icon_new_for_string(meta['gicon']);
+        } else if (meta['icon-data']) {
+            let [width, height, rowStride, hasAlpha,
+                 bitsPerSample, nChannels_, data] = meta['icon-data'];
+            gicon = Shell.util_create_pixbuf_from_data(data, GdkPixbuf.Colorspace.RGB, hasAlpha,
+                                                       bitsPerSample, width, height, rowStride);
+        }
+
+        if (gicon)
+            icon = new St.Icon({ gicon, icon_size: size });
+        return icon;
+    }
+
+    filterResults(results, maxNumber) {
+        if (results.length <= maxNumber)
+            return results;
+
+        let regularResults = results.filter(r => !r.startsWith('special:'));
+        let specialResults = results.filter(r => r.startsWith('special:'));
+
+        return regularResults.slice(0, maxNumber).concat(specialResults.slice(0, maxNumber));
+    }
+
+    _getResultsFinished(results, error, callback) {
+        if (error) {
+            if (error.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+                return;
+
+            log('Received error from DBus search provider %s: %s'.format(this.id, String(error)));
+            callback([]);
+            return;
+        }
+
+        callback(results[0]);
+    }
+
+    getInitialResultSet(terms, callback, cancellable) {
+        this.proxy.GetInitialResultSetRemote(terms,
+                                             (results, error) => {
+                                                 this._getResultsFinished(results, error, callback);
+                                             },
+                                             cancellable);
+    }
+
+    getSubsearchResultSet(previousResults, newTerms, callback, cancellable) {
+        this.proxy.GetSubsearchResultSetRemote(previousResults, newTerms,
+                                               (results, error) => {
+                                                   this._getResultsFinished(results, error, callback);
+                                               },
+                                               cancellable);
+    }
+
+    _getResultMetasFinished(results, error, callback) {
+        if (error) {
+            if (!error.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.CANCELLED))
+                log('Received error from DBus search provider %s during GetResultMetas: %s'.format(this.id, String(error)));
+            callback([]);
+            return;
+        }
+        let metas = results[0];
+        let resultMetas = [];
+        for (let i = 0; i < metas.length; i++) {
+            for (let prop in metas[i]) {
+                // we can use the serialized icon variant directly
+                if (prop != 'icon')
+                    metas[i][prop] = metas[i][prop].deep_unpack();
+            }
+
+            resultMetas.push({ id: metas[i]['id'],
+                               name: metas[i]['name'],
+                               description: metas[i]['description'],
+                               createIcon: size => {
+                                   return this.createIcon(size, metas[i]);
+                               },
+                               clipboardText: metas[i]['clipboardText'] });
+        }
+        callback(resultMetas);
+    }
+
+    getResultMetas(ids, callback, cancellable) {
+        this.proxy.GetResultMetasRemote(ids,
+                                        (results, error) => {
+                                            this._getResultMetasFinished(results, error, callback);
+                                        },
+                                        cancellable);
+    }
+
+    activateResult(id) {
+        this.proxy.ActivateResultRemote(id);
+    }
+
+    launchSearch(_terms) {
+        // the provider is not compatible with the new version of the interface, launch
+        // the app itself but warn so we can catch the error in logs
+        log(`Search provider ${this.appInfo.get_id()} does not implement LaunchSearch`);
+        this.appInfo.launch([], global.create_app_launch_context(0, -1));
+    }
+};
+
+var RemoteSearchProvider2 = class extends RemoteSearchProvider {
+    constructor(appInfo, dbusName, dbusPath, autoStart) {
+        super(appInfo, dbusName, dbusPath, autoStart, SearchProvider2ProxyInfo);
+
+        this.canLaunchSearch = true;
+    }
+
+    activateResult(id, terms) {
+        this.proxy.ActivateResultRemote(id, terms, global.get_current_time());
+    }
+
+    launchSearch(terms) {
+        this.proxy.LaunchSearchRemote(terms, global.get_current_time());
+    }
+};

js/ui/ripples.js

@@ -0,0 +1,104 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Ripples */
+
+const { Clutter, St } = imports.gi;
+
+// Shamelessly copied from the layout "hotcorner" ripples implementation
+var Ripples = class Ripples {
+    constructor(px, py, styleClass) {
+        this._x = 0;
+        this._y = 0;
+
+        this._px = px;
+        this._py = py;
+
+        this._ripple1 = new St.BoxLayout({ style_class: styleClass,
+                                           opacity: 0,
+                                           can_focus: false,
+                                           reactive: false,
+                                           visible: false });
+        this._ripple1.set_pivot_point(px, py);
+
+        this._ripple2 = new St.BoxLayout({ style_class: styleClass,
+                                           opacity: 0,
+                                           can_focus: false,
+                                           reactive: false,
+                                           visible: false });
+        this._ripple2.set_pivot_point(px, py);
+
+        this._ripple3 = new St.BoxLayout({ style_class: styleClass,
+                                           opacity: 0,
+                                           can_focus: false,
+                                           reactive: false,
+                                           visible: false });
+        this._ripple3.set_pivot_point(px, py);
+    }
+
+    destroy() {
+        this._ripple1.destroy();
+        this._ripple2.destroy();
+        this._ripple3.destroy();
+    }
+
+    _animRipple(ripple, delay, duration, startScale, startOpacity, finalScale) {
+        // We draw a ripple by using a source image and animating it scaling
+        // outwards and fading away. We want the ripples to move linearly
+        // or it looks unrealistic, but if the opacity of the ripple goes
+        // linearly to zero it fades away too quickly, so we use a separate
+        // tween to give a non-linear curve to the fade-away and make
+        // it more visible in the middle section.
+
+        ripple.x = this._x;
+        ripple.y = this._y;
+        ripple.visible = true;
+        ripple.opacity = 255 * Math.sqrt(startOpacity);
+        ripple.scale_x = ripple.scale_y = startScale;
+        ripple.set_translation(-this._px * ripple.width, -this._py * ripple.height, 0.0);
+
+        ripple.ease({
+            opacity: 0,
+            delay,
+            duration,
+            mode: Clutter.AnimationMode.EASE_IN_QUAD,
+        });
+        ripple.ease({
+            scale_x: finalScale,
+            scale_y: finalScale,
+            delay,
+            duration,
+            mode: Clutter.AnimationMode.LINEAR,
+            onComplete: () => (ripple.visible = false),
+        });
+    }
+
+    addTo(stage) {
+        if (this._stage !== undefined)
+            throw new Error('Ripples already added');
+
+        this._stage = stage;
+        this._stage.add_actor(this._ripple1);
+        this._stage.add_actor(this._ripple2);
+        this._stage.add_actor(this._ripple3);
+    }
+
+    playAnimation(x, y) {
+        if (this._stage === undefined)
+            throw new Error('Ripples not added');
+
+        this._x = x;
+        this._y = y;
+
+        this._stage.set_child_above_sibling(this._ripple1, null);
+        this._stage.set_child_above_sibling(this._ripple2, this._ripple1);
+        this._stage.set_child_above_sibling(this._ripple3, this._ripple2);
+
+        // Show three concentric ripples expanding outwards; the exact
+        // parameters were found by trial and error, so don't look
+        // for them to make perfect sense mathematically
+
+        //                              delay  time   scale opacity => scale
+        this._animRipple(this._ripple1,   0,    830,   0.25,  1.0,     1.5);
+        this._animRipple(this._ripple2,  50,   1000,   0.0,   0.7,     1.25);
+        this._animRipple(this._ripple3, 350,   1000,   0.0,   0.3,     1);
+    }
+};