Adding upstream version 3.38.6.upstream/3.38.6upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2101 insertions, 0 deletions

diff --git a/js/ui/status/network.js b/js/ui/status/network.js
new file mode 100644
index 0000000..377f44e
--- /dev/null
+++ b/js/ui/status/network.js
@@ -0,0 +1,2101 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported NMApplet */
+const { Clutter, Gio, GLib, GObject, NM, St } = imports.gi;
+const Signals = imports.signals;
+
+const Animation = imports.ui.animation;
+const Main = imports.ui.main;
+const PanelMenu = imports.ui.panelMenu;
+const PopupMenu = imports.ui.popupMenu;
+const MessageTray = imports.ui.messageTray;
+const ModalDialog = imports.ui.modalDialog;
+const ModemManager = imports.misc.modemManager;
+const Rfkill = imports.ui.status.rfkill;
+const Util = imports.misc.util;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+Gio._promisify(Gio.DBusConnection.prototype, 'call', 'call_finish');
+Gio._promisify(NM.Client, 'new_async', 'new_finish');
+Gio._promisify(NM.Client.prototype,
+    'check_connectivity_async', 'check_connectivity_finish');
+
+const NMConnectionCategory = {
+    INVALID: 'invalid',
+    WIRED: 'wired',
+    WIRELESS: 'wireless',
+    WWAN: 'wwan',
+    VPN: 'vpn',
+};
+
+const NMAccessPointSecurity = {
+    NONE: 1,
+    WEP: 2,
+    WPA_PSK: 3,
+    WPA2_PSK: 4,
+    WPA_ENT: 5,
+    WPA2_ENT: 6,
+};
+
+var MAX_DEVICE_ITEMS = 4;
+
+// small optimization, to avoid using [] all the time
+const NM80211Mode = NM['80211Mode'];
+const NM80211ApFlags = NM['80211ApFlags'];
+const NM80211ApSecurityFlags = NM['80211ApSecurityFlags'];
+
+var PortalHelperResult = {
+    CANCELLED: 0,
+    COMPLETED: 1,
+    RECHECK: 2,
+};
+
+const PortalHelperIface = loadInterfaceXML('org.gnome.Shell.PortalHelper');
+const PortalHelperProxy = Gio.DBusProxy.makeProxyWrapper(PortalHelperIface);
+
+function signalToIcon(value) {
+    if (value > 80)
+        return 'excellent';
+    if (value > 55)
+        return 'good';
+    if (value > 30)
+        return 'ok';
+    if (value > 5)
+        return 'weak';
+    return 'none';
+}
+
+function ssidToLabel(ssid) {
+    let label = NM.utils_ssid_to_utf8(ssid.get_data());
+    if (!label)
+        label = _("<unknown>");
+    return label;
+}
+
+function ensureActiveConnectionProps(active) {
+    if (!active._primaryDevice) {
+        let devices = active.get_devices();
+        if (devices.length > 0) {
+            // This list is guaranteed to have at most one device in it.
+            let device = devices[0]._delegate;
+            active._primaryDevice = device;
+        }
+    }
+}
+
+function launchSettingsPanel(panel, ...args) {
+    const param = new GLib.Variant('(sav)',
+        [panel, args.map(s => new GLib.Variant('s', s))]);
+    const platformData = {
+        'desktop-startup-id': new GLib.Variant('s',
+            '_TIME%s'.format(global.get_current_time())),
+    };
+    try {
+        Gio.DBus.session.call(
+            'org.gnome.ControlCenter',
+            '/org/gnome/ControlCenter',
+            'org.freedesktop.Application',
+            'ActivateAction',
+            new GLib.Variant('(sava{sv})',
+                ['launch-panel', [param], platformData]),
+            null,
+            Gio.DBusCallFlags.NONE,
+            -1,
+            null);
+    } catch (e) {
+        log('Failed to launch Settings panel: %s'.format(e.message));
+    }
+}
+
+var NMConnectionItem = class {
+    constructor(section, connection) {
+        this._section = section;
+        this._connection = connection;
+        this._activeConnection = null;
+        this._activeConnectionChangedId = 0;
+
+        this._buildUI();
+        this._sync();
+    }
+
+    _buildUI() {
+        this.labelItem = new PopupMenu.PopupMenuItem('');
+        this.labelItem.connect('activate', this._toggle.bind(this));
+
+        this.radioItem = new PopupMenu.PopupMenuItem(this._connection.get_id(), false);
+        this.radioItem.connect('activate', this._activate.bind(this));
+    }
+
+    destroy() {
+        this.labelItem.destroy();
+        this.radioItem.destroy();
+    }
+
+    updateForConnection(connection) {
+        // connection should always be the same object
+        // (and object path) as this._connection, but
+        // this can be false if NetworkManager was restarted
+        // and picked up connections in a different order
+        // Just to be safe, we set it here again
+
+        this._connection = connection;
+        this.radioItem.label.text = connection.get_id();
+        this._sync();
+        this.emit('name-changed');
+    }
+
+    getName() {
+        return this._connection.get_id();
+    }
+
+    isActive() {
+        if (this._activeConnection == null)
+            return false;
+
+        return this._activeConnection.state <= NM.ActiveConnectionState.ACTIVATED;
+    }
+
+    _sync() {
+        let isActive = this.isActive();
+        this.labelItem.label.text = isActive ? _("Turn Off") : this._section.getConnectLabel();
+        this.radioItem.setOrnament(isActive ? PopupMenu.Ornament.DOT : PopupMenu.Ornament.NONE);
+        this.emit('icon-changed');
+    }
+
+    _toggle() {
+        if (this._activeConnection == null)
+            this._section.activateConnection(this._connection);
+        else
+            this._section.deactivateConnection(this._activeConnection);
+
+        this._sync();
+    }
+
+    _activate() {
+        if (this._activeConnection == null)
+            this._section.activateConnection(this._connection);
+
+        this._sync();
+    }
+
+    _connectionStateChanged(_ac, _newstate, _reason) {
+        this._sync();
+    }
+
+    setActiveConnection(activeConnection) {
+        if (this._activeConnectionChangedId > 0) {
+            this._activeConnection.disconnect(this._activeConnectionChangedId);
+            this._activeConnectionChangedId = 0;
+        }
+
+        this._activeConnection = activeConnection;
+
+        if (this._activeConnection) {
+            this._activeConnectionChangedId = this._activeConnection.connect('notify::state',
+                                                                             this._connectionStateChanged.bind(this));
+        }
+
+        this._sync();
+    }
+};
+Signals.addSignalMethods(NMConnectionItem.prototype);
+
+var NMConnectionSection = class NMConnectionSection {
+    constructor(client) {
+        if (this.constructor === NMConnectionSection)
+            throw new TypeError('Cannot instantiate abstract type %s'.format(this.constructor.name));
+
+        this._client = client;
+
+        this._connectionItems = new Map();
+        this._connections = [];
+
+        this._labelSection = new PopupMenu.PopupMenuSection();
+        this._radioSection = new PopupMenu.PopupMenuSection();
+
+        this.item = new PopupMenu.PopupSubMenuMenuItem('', true);
+        this.item.menu.addMenuItem(this._labelSection);
+        this.item.menu.addMenuItem(this._radioSection);
+
+        this._notifyConnectivityId = this._client.connect('notify::connectivity', this._iconChanged.bind(this));
+    }
+
+    destroy() {
+        if (this._notifyConnectivityId != 0) {
+            this._client.disconnect(this._notifyConnectivityId);
+            this._notifyConnectivityId = 0;
+        }
+
+        this.item.destroy();
+    }
+
+    _iconChanged() {
+        this._sync();
+        this.emit('icon-changed');
+    }
+
+    _sync() {
+        let nItems = this._connectionItems.size;
+
+        this._radioSection.actor.visible = nItems > 1;
+        this._labelSection.actor.visible = nItems == 1;
+
+        this.item.label.text = this._getStatus();
+        this.item.icon.icon_name = this._getMenuIcon();
+    }
+
+    _getMenuIcon() {
+        return this.getIndicatorIcon();
+    }
+
+    getConnectLabel() {
+        return _("Connect");
+    }
+
+    _connectionValid(_connection) {
+        return true;
+    }
+
+    _connectionSortFunction(one, two) {
+        return GLib.utf8_collate(one.get_id(), two.get_id());
+    }
+
+    _makeConnectionItem(connection) {
+        return new NMConnectionItem(this, connection);
+    }
+
+    checkConnection(connection) {
+        if (!this._connectionValid(connection))
+            return;
+
+        // This function is called every time the connection is added or updated.
+        // In the usual case, we already added this connection and UUID
+        // didn't change. So we need to check if we already have an item,
+        // and update it for properties in the connection that changed
+        // (the only one we care about is the name)
+        // But it's also possible we didn't know about this connection
+        // (eg, during coldplug, or because it was updated and suddenly
+        // it's valid for this device), in which case we add a new item.
+
+        let item = this._connectionItems.get(connection.get_uuid());
+        if (item)
+            this._updateForConnection(item, connection);
+        else
+            this._addConnection(connection);
+    }
+
+    _updateForConnection(item, connection) {
+        let pos = this._connections.indexOf(connection);
+
+        this._connections.splice(pos, 1);
+        pos = Util.insertSorted(this._connections, connection, this._connectionSortFunction.bind(this));
+        this._labelSection.moveMenuItem(item.labelItem, pos);
+        this._radioSection.moveMenuItem(item.radioItem, pos);
+
+        item.updateForConnection(connection);
+    }
+
+    _addConnection(connection) {
+        let item = this._makeConnectionItem(connection);
+        if (!item)
+            return;
+
+        item.connect('icon-changed', () => this._iconChanged());
+        item.connect('activation-failed', (o, reason) => {
+            this.emit('activation-failed', reason);
+        });
+        item.connect('name-changed', this._sync.bind(this));
+
+        let pos = Util.insertSorted(this._connections, connection, this._connectionSortFunction.bind(this));
+        this._labelSection.addMenuItem(item.labelItem, pos);
+        this._radioSection.addMenuItem(item.radioItem, pos);
+        this._connectionItems.set(connection.get_uuid(), item);
+        this._sync();
+    }
+
+    removeConnection(connection) {
+        let uuid = connection.get_uuid();
+        let item = this._connectionItems.get(uuid);
+        if (item == undefined)
+            return;
+
+        item.destroy();
+        this._connectionItems.delete(uuid);
+
+        let pos = this._connections.indexOf(connection);
+        this._connections.splice(pos, 1);
+
+        this._sync();
+    }
+};
+Signals.addSignalMethods(NMConnectionSection.prototype);
+
+var NMConnectionDevice = class NMConnectionDevice extends NMConnectionSection {
+    constructor(client, device) {
+        super(client);
+
+        if (this.constructor === NMConnectionDevice)
+            throw new TypeError('Cannot instantiate abstract type %s'.format(this.constructor.name));
+
+        this._device = device;
+        this._description = '';
+
+        this._autoConnectItem = this.item.menu.addAction(_("Connect"), this._autoConnect.bind(this));
+        this._deactivateItem = this._radioSection.addAction(_("Turn Off"), this.deactivateConnection.bind(this));
+
+        this._stateChangedId = this._device.connect('state-changed', this._deviceStateChanged.bind(this));
+        this._activeConnectionChangedId = this._device.connect('notify::active-connection', this._activeConnectionChanged.bind(this));
+    }
+
+    _canReachInternet() {
+        if (this._client.primary_connection != this._device.active_connection)
+            return true;
+
+        return this._client.connectivity == NM.ConnectivityState.FULL;
+    }
+
+    _autoConnect() {
+        let connection = new NM.SimpleConnection();
+        this._client.add_and_activate_connection_async(connection, this._device, null, null, null);
+    }
+
+    destroy() {
+        if (this._stateChangedId) {
+            GObject.signal_handler_disconnect(this._device, this._stateChangedId);
+            this._stateChangedId = 0;
+        }
+        if (this._activeConnectionChangedId) {
+            GObject.signal_handler_disconnect(this._device, this._activeConnectionChangedId);
+            this._activeConnectionChangedId = 0;
+        }
+
+        super.destroy();
+    }
+
+    _activeConnectionChanged() {
+        if (this._activeConnection) {
+            let item = this._connectionItems.get(this._activeConnection.connection.get_uuid());
+            item.setActiveConnection(null);
+            this._activeConnection = null;
+        }
+
+        this._sync();
+    }
+
+    _deviceStateChanged(device, newstate, oldstate, reason) {
+        if (newstate == oldstate) {
+            log('device emitted state-changed without actually changing state');
+            return;
+        }
+
+        /* Emit a notification if activation fails, but don't do it
+           if the reason is no secrets, as that indicates the user
+           cancelled the agent dialog */
+        if (newstate == NM.DeviceState.FAILED &&
+            reason != NM.DeviceStateReason.NO_SECRETS)
+            this.emit('activation-failed', reason);
+
+        this._sync();
+    }
+
+    _connectionValid(connection) {
+        return this._device.connection_valid(connection);
+    }
+
+    activateConnection(connection) {
+        this._client.activate_connection_async(connection, this._device, null, null, null);
+    }
+
+    deactivateConnection(_activeConnection) {
+        this._device.disconnect(null);
+    }
+
+    setDeviceDescription(desc) {
+        this._description = desc;
+        this._sync();
+    }
+
+    _getDescription() {
+        return this._description;
+    }
+
+    _sync() {
+        let nItems = this._connectionItems.size;
+        this._autoConnectItem.visible = nItems == 0;
+        this._deactivateItem.visible = this._device.state > NM.DeviceState.DISCONNECTED;
+
+        if (this._activeConnection == null) {
+            let activeConnection = this._device.active_connection;
+            if (activeConnection && activeConnection.connection) {
+                let item = this._connectionItems.get(activeConnection.connection.get_uuid());
+                if (item) {
+                    this._activeConnection = activeConnection;
+                    ensureActiveConnectionProps(this._activeConnection);
+                    item.setActiveConnection(this._activeConnection);
+                }
+            }
+        }
+
+        super._sync();
+    }
+
+    _getStatus() {
+        if (!this._device)
+            return '';
+
+        switch (this._device.state) {
+        case NM.DeviceState.DISCONNECTED:
+            /* Translators: %s is a network identifier */
+            return _("%s Off").format(this._getDescription());
+        case NM.DeviceState.ACTIVATED:
+            /* Translators: %s is a network identifier */
+            return _("%s Connected").format(this._getDescription());
+        case NM.DeviceState.UNMANAGED:
+            /* Translators: this is for network devices that are physically present but are not
+               under NetworkManager's control (and thus cannot be used in the menu);
+               %s is a network identifier */
+            return _("%s Unmanaged").format(this._getDescription());
+        case NM.DeviceState.DEACTIVATING:
+            /* Translators: %s is a network identifier */
+            return _("%s Disconnecting").format(this._getDescription());
+        case NM.DeviceState.PREPARE:
+        case NM.DeviceState.CONFIG:
+        case NM.DeviceState.IP_CONFIG:
+        case NM.DeviceState.IP_CHECK:
+        case NM.DeviceState.SECONDARIES:
+            /* Translators: %s is a network identifier */
+            return _("%s Connecting").format(this._getDescription());
+        case NM.DeviceState.NEED_AUTH:
+            /* Translators: this is for network connections that require some kind of key or password; %s is a network identifier */
+            return _("%s Requires Authentication").format(this._getDescription());
+        case NM.DeviceState.UNAVAILABLE:
+            // This state is actually a compound of various states (generically unavailable,
+            // firmware missing), that are exposed by different properties (whose state may
+            // or may not updated when we receive state-changed).
+            if (this._device.firmware_missing) {
+                /* Translators: this is for devices that require some kind of firmware or kernel
+                   module, which is missing; %s is a network identifier */
+                return _("Firmware Missing For %s").format(this._getDescription());
+            }
+            /* Translators: this is for a network device that cannot be activated (for example it
+               is disabled by rfkill, or it has no coverage; %s is a network identifier */
+            return _("%s Unavailable").format(this._getDescription());
+        case NM.DeviceState.FAILED:
+            /* Translators: %s is a network identifier */
+            return _("%s Connection Failed").format(this._getDescription());
+        default:
+            log('Device state invalid, is %d'.format(this._device.state));
+            return 'invalid';
+        }
+    }
+};
+
+var NMDeviceWired = class extends NMConnectionDevice {
+    constructor(client, device) {
+        super(client, device);
+
+        this.item.menu.addSettingsAction(_("Wired Settings"), 'gnome-network-panel.desktop');
+    }
+
+    get category() {
+        return NMConnectionCategory.WIRED;
+    }
+
+    _hasCarrier() {
+        if (this._device instanceof NM.DeviceEthernet)
+            return this._device.carrier;
+        else
+            return true;
+    }
+
+    _sync() {
+        this.item.visible = this._hasCarrier();
+        super._sync();
+    }
+
+    getIndicatorIcon() {
+        if (this._device.active_connection) {
+            let state = this._device.active_connection.state;
+
+            if (state == NM.ActiveConnectionState.ACTIVATING) {
+                return 'network-wired-acquiring-symbolic';
+            } else if (state == NM.ActiveConnectionState.ACTIVATED) {
+                if (this._canReachInternet())
+                    return 'network-wired-symbolic';
+                else
+                    return 'network-wired-no-route-symbolic';
+            } else {
+                return 'network-wired-disconnected-symbolic';
+            }
+        } else {
+            return 'network-wired-disconnected-symbolic';
+        }
+    }
+};
+
+var NMDeviceModem = class extends NMConnectionDevice {
+    constructor(client, device) {
+        super(client, device);
+
+        this.item.menu.addSettingsAction(_("Mobile Broadband Settings"), 'gnome-network-panel.desktop');
+
+        this._mobileDevice = null;
+
+        let capabilities = device.current_capabilities;
+        if (device.udi.indexOf('/org/freedesktop/ModemManager1/Modem') == 0)
+            this._mobileDevice = new ModemManager.BroadbandModem(device.udi, capabilities);
+        else if (capabilities & NM.DeviceModemCapabilities.GSM_UMTS)
+            this._mobileDevice = new ModemManager.ModemGsm(device.udi);
+        else if (capabilities & NM.DeviceModemCapabilities.CDMA_EVDO)
+            this._mobileDevice = new ModemManager.ModemCdma(device.udi);
+        else if (capabilities & NM.DeviceModemCapabilities.LTE)
+            this._mobileDevice = new ModemManager.ModemGsm(device.udi);
+
+        if (this._mobileDevice) {
+            this._operatorNameId = this._mobileDevice.connect('notify::operator-name', this._sync.bind(this));
+            this._signalQualityId = this._mobileDevice.connect('notify::signal-quality', () => {
+                this._iconChanged();
+            });
+        }
+    }
+
+    get category() {
+        return NMConnectionCategory.WWAN;
+    }
+
+    _autoConnect() {
+        launchSettingsPanel('network', 'connect-3g', this._device.get_path());
+    }
+
+    destroy() {
+        if (this._operatorNameId) {
+            this._mobileDevice.disconnect(this._operatorNameId);
+            this._operatorNameId = 0;
+        }
+        if (this._signalQualityId) {
+            this._mobileDevice.disconnect(this._signalQualityId);
+            this._signalQualityId = 0;
+        }
+
+        super.destroy();
+    }
+
+    _getStatus() {
+        if (!this._client.wwan_hardware_enabled)
+            /* Translators: %s is a network identifier */
+            return _("%s Hardware Disabled").format(this._getDescription());
+        else if (!this._client.wwan_enabled)
+            /* Translators: this is for a network device that cannot be activated
+               because it's disabled by rfkill (airplane mode); %s is a network identifier */
+            return _("%s Disabled").format(this._getDescription());
+        else if (this._device.state == NM.DeviceState.ACTIVATED &&
+                 this._mobileDevice && this._mobileDevice.operator_name)
+            return this._mobileDevice.operator_name;
+        else
+            return super._getStatus();
+    }
+
+    getIndicatorIcon() {
+        if (this._device.active_connection) {
+            if (this._device.active_connection.state == NM.ActiveConnectionState.ACTIVATING)
+                return 'network-cellular-acquiring-symbolic';
+
+            return this._getSignalIcon();
+        } else {
+            return 'network-cellular-signal-none-symbolic';
+        }
+    }
+
+    _getSignalIcon() {
+        return 'network-cellular-signal-%s-symbolic'.format(
+            signalToIcon(this._mobileDevice.signal_quality));
+    }
+};
+
+var NMDeviceBluetooth = class extends NMConnectionDevice {
+    constructor(client, device) {
+        super(client, device);
+
+        this.item.menu.addSettingsAction(_("Bluetooth Settings"), 'gnome-network-panel.desktop');
+    }
+
+    get category() {
+        return NMConnectionCategory.WWAN;
+    }
+
+    _getDescription() {
+        return this._device.name;
+    }
+
+    getConnectLabel() {
+        return _("Connect to Internet");
+    }
+
+    getIndicatorIcon() {
+        if (this._device.active_connection) {
+            let state = this._device.active_connection.state;
+            if (state == NM.ActiveConnectionState.ACTIVATING)
+                return 'network-cellular-acquiring-symbolic';
+            else if (state == NM.ActiveConnectionState.ACTIVATED)
+                return 'network-cellular-connected-symbolic';
+            else
+                return 'network-cellular-signal-none-symbolic';
+        } else {
+            return 'network-cellular-signal-none-symbolic';
+        }
+    }
+};
+
+var NMWirelessDialogItem = GObject.registerClass({
+    Signals: {
+        'selected': {},
+    },
+}, class NMWirelessDialogItem extends St.BoxLayout {
+    _init(network) {
+        this._network = network;
+        this._ap = network.accessPoints[0];
+
+        super._init({ style_class: 'nm-dialog-item',
+                      can_focus: true,
+                      reactive: true });
+
+        let action = new Clutter.ClickAction();
+        action.connect('clicked', () => this.grab_key_focus());
+        this.add_action(action);
+
+        let title = ssidToLabel(this._ap.get_ssid());
+        this._label = new St.Label({
+            text: title,
+            x_expand: true,
+        });
+
+        this.label_actor = this._label;
+        this.add_child(this._label);
+
+        this._selectedIcon = new St.Icon({ style_class: 'nm-dialog-icon',
+                                           icon_name: 'object-select-symbolic' });
+        this.add(this._selectedIcon);
+
+        this._icons = new St.BoxLayout({
+            style_class: 'nm-dialog-icons',
+            x_align: Clutter.ActorAlign.END,
+        });
+        this.add_child(this._icons);
+
+        this._secureIcon = new St.Icon({ style_class: 'nm-dialog-icon' });
+        if (this._ap._secType != NMAccessPointSecurity.NONE)
+            this._secureIcon.icon_name = 'network-wireless-encrypted-symbolic';
+        this._icons.add_actor(this._secureIcon);
+
+        this._signalIcon = new St.Icon({ style_class: 'nm-dialog-icon' });
+        this._icons.add_actor(this._signalIcon);
+
+        this._sync();
+    }
+
+    vfunc_key_focus_in() {
+        this.emit('selected');
+    }
+
+    _sync() {
+        this._signalIcon.icon_name = this._getSignalIcon();
+    }
+
+    updateBestAP(ap) {
+        this._ap = ap;
+        this._sync();
+    }
+
+    setActive(isActive) {
+        this._selectedIcon.opacity = isActive ? 255 : 0;
+    }
+
+    _getSignalIcon() {
+        if (this._ap.mode == NM80211Mode.ADHOC) {
+            return 'network-workgroup-symbolic';
+        } else {
+            return 'network-wireless-signal-%s-symbolic'.format(
+                signalToIcon(this._ap.strength));
+        }
+    }
+});
+
+var NMWirelessDialog = GObject.registerClass(
+class NMWirelessDialog extends ModalDialog.ModalDialog {
+    _init(client, device) {
+        super._init({ styleClass: 'nm-dialog' });
+
+        this._client = client;
+        this._device = device;
+
+        this._wirelessEnabledChangedId = this._client.connect('notify::wireless-enabled',
+                                                              this._syncView.bind(this));
+
+        this._rfkill = Rfkill.getRfkillManager();
+        this._airplaneModeChangedId = this._rfkill.connect('airplane-mode-changed',
+                                                           this._syncView.bind(this));
+
+        this._networks = [];
+        this._buildLayout();
+
+        let connections = client.get_connections();
+        this._connections = connections.filter(
+            connection => device.connection_valid(connection));
+
+        this._apAddedId = device.connect('access-point-added', this._accessPointAdded.bind(this));
+        this._apRemovedId = device.connect('access-point-removed', this._accessPointRemoved.bind(this));
+        this._activeApChangedId = device.connect('notify::active-access-point', this._activeApChanged.bind(this));
+
+        // accessPointAdded will also create dialog items
+        let accessPoints = device.get_access_points() || [];
+        accessPoints.forEach(ap => {
+            this._accessPointAdded(this._device, ap);
+        });
+
+        this._selectedNetwork = null;
+        this._activeApChanged();
+        this._updateSensitivity();
+        this._syncView();
+
+        this._scanTimeoutId = GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, 15, this._onScanTimeout.bind(this));
+        GLib.Source.set_name_by_id(this._scanTimeoutId, '[gnome-shell] this._onScanTimeout');
+        this._onScanTimeout();
+
+        let id = Main.sessionMode.connect('updated', () => {
+            if (Main.sessionMode.allowSettings)
+                return;
+
+            Main.sessionMode.disconnect(id);
+            this.close();
+        });
+
+        this.connect('destroy', this._onDestroy.bind(this));
+    }
+
+    _onDestroy() {
+        if (this._apAddedId) {
+            GObject.Object.prototype.disconnect.call(this._device, this._apAddedId);
+            this._apAddedId = 0;
+        }
+        if (this._apRemovedId) {
+            GObject.Object.prototype.disconnect.call(this._device, this._apRemovedId);
+            this._apRemovedId = 0;
+        }
+        if (this._activeApChangedId) {
+            GObject.Object.prototype.disconnect.call(this._device, this._activeApChangedId);
+            this._activeApChangedId = 0;
+        }
+        if (this._wirelessEnabledChangedId) {
+            this._client.disconnect(this._wirelessEnabledChangedId);
+            this._wirelessEnabledChangedId = 0;
+        }
+        if (this._airplaneModeChangedId) {
+            this._rfkill.disconnect(this._airplaneModeChangedId);
+            this._airplaneModeChangedId = 0;
+        }
+
+        if (this._scanTimeoutId) {
+            GLib.source_remove(this._scanTimeoutId);
+            this._scanTimeoutId = 0;
+        }
+    }
+
+    _onScanTimeout() {
+        this._device.request_scan_async(null, null);
+        return GLib.SOURCE_CONTINUE;
+    }
+
+    _activeApChanged() {
+        if (this._activeNetwork)
+            this._activeNetwork.item.setActive(false);
+
+        this._activeNetwork = null;
+        if (this._device.active_access_point) {
+            let idx = this._findNetwork(this._device.active_access_point);
+            if (idx >= 0)
+                this._activeNetwork = this._networks[idx];
+        }
+
+        if (this._activeNetwork)
+            this._activeNetwork.item.setActive(true);
+        this._updateSensitivity();
+    }
+
+    _updateSensitivity() {
+        let connectSensitive = this._client.wireless_enabled && this._selectedNetwork && (this._selectedNetwork != this._activeNetwork);
+        this._connectButton.reactive = connectSensitive;
+        this._connectButton.can_focus = connectSensitive;
+    }
+
+    _syncView() {
+        if (this._rfkill.airplaneMode) {
+            this._airplaneBox.show();
+
+            this._airplaneIcon.icon_name = 'airplane-mode-symbolic';
+            this._airplaneHeadline.text = _("Airplane Mode is On");
+            this._airplaneText.text = _("Wi-Fi is disabled when airplane mode is on.");
+            this._airplaneButton.label = _("Turn Off Airplane Mode");
+
+            this._airplaneButton.visible = !this._rfkill.hwAirplaneMode;
+            this._airplaneInactive.visible = this._rfkill.hwAirplaneMode;
+            this._noNetworksBox.hide();
+        } else if (!this._client.wireless_enabled) {
+            this._airplaneBox.show();
+
+            this._airplaneIcon.icon_name = 'dialog-information-symbolic';
+            this._airplaneHeadline.text = _("Wi-Fi is Off");
+            this._airplaneText.text = _("Wi-Fi needs to be turned on in order to connect to a network.");
+            this._airplaneButton.label = _("Turn On Wi-Fi");
+
+            this._airplaneButton.show();
+            this._airplaneInactive.hide();
+            this._noNetworksBox.hide();
+        } else {
+            this._airplaneBox.hide();
+
+            this._noNetworksBox.visible = this._networks.length == 0;
+        }
+
+        if (this._noNetworksBox.visible)
+            this._noNetworksSpinner.play();
+        else
+            this._noNetworksSpinner.stop();
+    }
+
+    _buildLayout() {
+        let headline = new St.BoxLayout({ style_class: 'nm-dialog-header-hbox' });
+
+        let icon = new St.Icon({ style_class: 'nm-dialog-header-icon',
+                                 icon_name: 'network-wireless-signal-excellent-symbolic' });
+
+        let titleBox = new St.BoxLayout({ vertical: true });
+        let title = new St.Label({ style_class: 'nm-dialog-header',
+                                   text: _("Wi-Fi Networks") });
+        let subtitle = new St.Label({ style_class: 'nm-dialog-subheader',
+                                      text: _("Select a network") });
+        titleBox.add(title);
+        titleBox.add(subtitle);
+
+        headline.add(icon);
+        headline.add(titleBox);
+
+        this.contentLayout.style_class = 'nm-dialog-content';
+        this.contentLayout.add(headline);
+
+        this._stack = new St.Widget({
+            layout_manager: new Clutter.BinLayout(),
+            y_expand: true,
+        });
+
+        this._itemBox = new St.BoxLayout({ vertical: true });
+        this._scrollView = new St.ScrollView({ style_class: 'nm-dialog-scroll-view' });
+        this._scrollView.set_x_expand(true);
+        this._scrollView.set_y_expand(true);
+        this._scrollView.set_policy(St.PolicyType.NEVER,
+                                    St.PolicyType.AUTOMATIC);
+        this._scrollView.add_actor(this._itemBox);
+        this._stack.add_child(this._scrollView);
+
+        this._noNetworksBox = new St.BoxLayout({ vertical: true,
+                                                 style_class: 'no-networks-box',
+                                                 x_align: Clutter.ActorAlign.CENTER,
+                                                 y_align: Clutter.ActorAlign.CENTER });
+
+        this._noNetworksSpinner = new Animation.Spinner(16);
+        this._noNetworksBox.add_actor(this._noNetworksSpinner);
+        this._noNetworksBox.add_actor(new St.Label({ style_class: 'no-networks-label',
+                                                     text: _("No Networks") }));
+        this._stack.add_child(this._noNetworksBox);
+
+        this._airplaneBox = new St.BoxLayout({ vertical: true,
+                                               style_class: 'nm-dialog-airplane-box',
+                                               x_align: Clutter.ActorAlign.CENTER,
+                                               y_align: Clutter.ActorAlign.CENTER });
+        this._airplaneIcon = new St.Icon({ icon_size: 48 });
+        this._airplaneHeadline = new St.Label({ style_class: 'nm-dialog-airplane-headline headline' });
+        this._airplaneText = new St.Label({ style_class: 'nm-dialog-airplane-text' });
+
+        let airplaneSubStack = new St.Widget({ layout_manager: new Clutter.BinLayout() });
+        this._airplaneButton = new St.Button({ style_class: 'modal-dialog-button button' });
+        this._airplaneButton.connect('clicked', () => {
+            if (this._rfkill.airplaneMode)
+                this._rfkill.airplaneMode = false;
+            else
+                this._client.wireless_enabled = true;
+        });
+        airplaneSubStack.add_actor(this._airplaneButton);
+        this._airplaneInactive = new St.Label({ style_class: 'nm-dialog-airplane-text',
+                                                text: _("Use hardware switch to turn off") });
+        airplaneSubStack.add_actor(this._airplaneInactive);
+
+        this._airplaneBox.add_child(this._airplaneIcon);
+        this._airplaneBox.add_child(this._airplaneHeadline);
+        this._airplaneBox.add_child(this._airplaneText);
+        this._airplaneBox.add_child(airplaneSubStack);
+        this._stack.add_child(this._airplaneBox);
+
+        this.contentLayout.add_child(this._stack);
+
+        this._disconnectButton = this.addButton({ action: () => this.close(),
+                                                  label: _("Cancel"),
+                                                  key: Clutter.KEY_Escape });
+        this._connectButton = this.addButton({ action: this._connect.bind(this),
+                                               label: _("Connect"),
+                                               key: Clutter.KEY_Return });
+    }
+
+    _connect() {
+        let network = this._selectedNetwork;
+        if (network.connections.length > 0) {
+            let connection = network.connections[0];
+            this._client.activate_connection_async(connection, this._device, null, null, null);
+        } else {
+            let accessPoints = network.accessPoints;
+            if ((accessPoints[0]._secType == NMAccessPointSecurity.WPA2_ENT) ||
+                (accessPoints[0]._secType == NMAccessPointSecurity.WPA_ENT)) {
+                // 802.1x-enabled APs require further configuration, so they're
+                // handled in gnome-control-center
+                launchSettingsPanel('wifi', 'connect-8021x-wifi',
+                    this._device.get_path(), accessPoints[0].get_path());
+            } else {
+                let connection = new NM.SimpleConnection();
+                this._client.add_and_activate_connection_async(connection, this._device, accessPoints[0].get_path(), null, null);
+            }
+        }
+
+        this.close();
+    }
+
+    _notifySsidCb(accessPoint) {
+        if (accessPoint.get_ssid() != null) {
+            accessPoint.disconnect(accessPoint._notifySsidId);
+            accessPoint._notifySsidId = 0;
+            this._accessPointAdded(this._device, accessPoint);
+        }
+    }
+
+    _getApSecurityType(accessPoint) {
+        if (accessPoint._secType)
+            return accessPoint._secType;
+
+        let flags = accessPoint.flags;
+        let wpaFlags = accessPoint.wpa_flags;
+        let rsnFlags = accessPoint.rsn_flags;
+        let type;
+        if (rsnFlags != NM80211ApSecurityFlags.NONE) {
+            /* RSN check first so that WPA+WPA2 APs are treated as RSN/WPA2 */
+            if (rsnFlags & NM80211ApSecurityFlags.KEY_MGMT_802_1X)
+                type = NMAccessPointSecurity.WPA2_ENT;
+            else if (rsnFlags & NM80211ApSecurityFlags.KEY_MGMT_PSK)
+                type = NMAccessPointSecurity.WPA2_PSK;
+        } else if (wpaFlags != NM80211ApSecurityFlags.NONE) {
+            if (wpaFlags & NM80211ApSecurityFlags.KEY_MGMT_802_1X)
+                type = NMAccessPointSecurity.WPA_ENT;
+            else if (wpaFlags & NM80211ApSecurityFlags.KEY_MGMT_PSK)
+                type = NMAccessPointSecurity.WPA_PSK;
+        } else {
+            // eslint-disable-next-line no-lonely-if
+            if (flags & NM80211ApFlags.PRIVACY)
+                type = NMAccessPointSecurity.WEP;
+            else
+                type = NMAccessPointSecurity.NONE;
+        }
+
+        // cache the found value to avoid checking flags all the time
+        accessPoint._secType = type;
+        return type;
+    }
+
+    _networkSortFunction(one, two) {
+        let oneHasConnection = one.connections.length != 0;
+        let twoHasConnection = two.connections.length != 0;
+
+        // place known connections first
+        // (-1 = good order, 1 = wrong order)
+        if (oneHasConnection && !twoHasConnection)
+            return -1;
+        else if (!oneHasConnection && twoHasConnection)
+            return 1;
+
+        let oneAp = one.accessPoints[0] || null;
+        let twoAp = two.accessPoints[0] || null;
+
+        if (oneAp != null && twoAp == null)
+            return -1;
+        else if (oneAp == null && twoAp != null)
+            return 1;
+
+        let oneStrength = oneAp.strength;
+        let twoStrength = twoAp.strength;
+
+        // place stronger connections first
+        if (oneStrength != twoStrength)
+            return oneStrength < twoStrength ? 1 : -1;
+
+        let oneHasSecurity = one.security != NMAccessPointSecurity.NONE;
+        let twoHasSecurity = two.security != NMAccessPointSecurity.NONE;
+
+        // place secure connections first
+        // (we treat WEP/WPA/WPA2 the same as there is no way to
+        // take them apart from the UI)
+        if (oneHasSecurity && !twoHasSecurity)
+            return -1;
+        else if (!oneHasSecurity && twoHasSecurity)
+            return 1;
+
+        // sort alphabetically
+        return GLib.utf8_collate(one.ssidText, two.ssidText);
+    }
+
+    _networkCompare(network, accessPoint) {
+        if (!network.ssid.equal(accessPoint.get_ssid()))
+            return false;
+        if (network.mode != accessPoint.mode)
+            return false;
+        if (network.security != this._getApSecurityType(accessPoint))
+            return false;
+
+        return true;
+    }
+
+    _findExistingNetwork(accessPoint) {
+        for (let i = 0; i < this._networks.length; i++) {
+            let network = this._networks[i];
+            for (let j = 0; j < network.accessPoints.length; j++) {
+                if (network.accessPoints[j] == accessPoint)
+                    return { network: i, ap: j };
+            }
+        }
+
+        return null;
+    }
+
+    _findNetwork(accessPoint) {
+        if (accessPoint.get_ssid() == null)
+            return -1;
+
+        for (let i = 0; i < this._networks.length; i++) {
+            if (this._networkCompare(this._networks[i], accessPoint))
+                return i;
+        }
+        return -1;
+    }
+
+    _checkConnections(network, accessPoint) {
+        this._connections.forEach(connection => {
+            if (accessPoint.connection_valid(connection) &&
+                !network.connections.includes(connection))
+                network.connections.push(connection);
+        });
+    }
+
+    _accessPointAdded(device, accessPoint) {
+        if (accessPoint.get_ssid() == null) {
+            // This access point is not visible yet
+            // Wait for it to get a ssid
+            accessPoint._notifySsidId = accessPoint.connect('notify::ssid', this._notifySsidCb.bind(this));
+            return;
+        }
+
+        let pos = this._findNetwork(accessPoint);
+        let network;
+
+        if (pos != -1) {
+            network = this._networks[pos];
+            if (network.accessPoints.includes(accessPoint)) {
+                log('Access point was already seen, not adding again');
+                return;
+            }
+
+            Util.insertSorted(network.accessPoints, accessPoint, (one, two) => {
+                return two.strength - one.strength;
+            });
+            network.item.updateBestAP(network.accessPoints[0]);
+            this._checkConnections(network, accessPoint);
+
+            this._resortItems();
+        } else {
+            network = {
+                ssid: accessPoint.get_ssid(),
+                mode: accessPoint.mode,
+                security: this._getApSecurityType(accessPoint),
+                connections: [],
+                item: null,
+                accessPoints: [accessPoint],
+            };
+            network.ssidText = ssidToLabel(network.ssid);
+            this._checkConnections(network, accessPoint);
+
+            let newPos = Util.insertSorted(this._networks, network, this._networkSortFunction);
+            this._createNetworkItem(network);
+            this._itemBox.insert_child_at_index(network.item, newPos);
+        }
+
+        this._syncView();
+    }
+
+    _accessPointRemoved(device, accessPoint) {
+        let res = this._findExistingNetwork(accessPoint);
+
+        if (res == null) {
+            log('Removing an access point that was never added');
+            return;
+        }
+
+        let network = this._networks[res.network];
+        network.accessPoints.splice(res.ap, 1);
+
+        if (network.accessPoints.length == 0) {
+            network.item.destroy();
+            this._networks.splice(res.network, 1);
+        } else {
+            network.item.updateBestAP(network.accessPoints[0]);
+            this._resortItems();
+        }
+
+        this._syncView();
+    }
+
+    _resortItems() {
+        let adjustment = this._scrollView.vscroll.adjustment;
+        let scrollValue = adjustment.value;
+
+        this._itemBox.remove_all_children();
+        this._networks.forEach(network => {
+            this._itemBox.add_child(network.item);
+        });
+
+        adjustment.value = scrollValue;
+    }
+
+    _selectNetwork(network) {
+        if (this._selectedNetwork)
+            this._selectedNetwork.item.remove_style_pseudo_class('selected');
+
+        this._selectedNetwork = network;
+        this._updateSensitivity();
+
+        if (this._selectedNetwork)
+            this._selectedNetwork.item.add_style_pseudo_class('selected');
+    }
+
+    _createNetworkItem(network) {
+        network.item = new NMWirelessDialogItem(network);
+        network.item.setActive(network == this._selectedNetwork);
+        network.item.connect('selected', () => {
+            Util.ensureActorVisibleInScrollView(this._scrollView, network.item);
+            this._selectNetwork(network);
+        });
+        network.item.connect('destroy', () => {
+            let keyFocus = global.stage.key_focus;
+            if (keyFocus && keyFocus.contains(network.item))
+                this._itemBox.grab_key_focus();
+        });
+    }
+});
+
+var NMDeviceWireless = class {
+    constructor(client, device) {
+        this._client = client;
+        this._device = device;
+
+        this._description = '';
+
+        this.item = new PopupMenu.PopupSubMenuMenuItem('', true);
+        this.item.menu.addAction(_("Select Network"), this._showDialog.bind(this));
+
+        this._toggleItem = new PopupMenu.PopupMenuItem('');
+        this._toggleItem.connect('activate', this._toggleWifi.bind(this));
+        this.item.menu.addMenuItem(this._toggleItem);
+
+        this.item.menu.addSettingsAction(_("Wi-Fi Settings"), 'gnome-wifi-panel.desktop');
+
+        this._wirelessEnabledChangedId = this._client.connect('notify::wireless-enabled', this._sync.bind(this));
+        this._wirelessHwEnabledChangedId = this._client.connect('notify::wireless-hardware-enabled', this._sync.bind(this));
+        this._activeApChangedId = this._device.connect('notify::active-access-point', this._activeApChanged.bind(this));
+        this._stateChangedId = this._device.connect('state-changed', this._deviceStateChanged.bind(this));
+        this._notifyConnectivityId = this._client.connect('notify::connectivity', this._iconChanged.bind(this));
+
+        this._sync();
+    }
+
+    get category() {
+        return NMConnectionCategory.WIRELESS;
+    }
+
+    _iconChanged() {
+        this._sync();
+        this.emit('icon-changed');
+    }
+
+    destroy() {
+        if (this._activeApChangedId) {
+            GObject.signal_handler_disconnect(this._device, this._activeApChangedId);
+            this._activeApChangedId = 0;
+        }
+        if (this._stateChangedId) {
+            GObject.signal_handler_disconnect(this._device, this._stateChangedId);
+            this._stateChangedId = 0;
+        }
+        if (this._strengthChangedId > 0) {
+            this._activeAccessPoint.disconnect(this._strengthChangedId);
+            this._strengthChangedId = 0;
+        }
+        if (this._wirelessEnabledChangedId) {
+            this._client.disconnect(this._wirelessEnabledChangedId);
+            this._wirelessEnabledChangedId = 0;
+        }
+        if (this._wirelessHwEnabledChangedId) {
+            this._client.disconnect(this._wirelessHwEnabledChangedId);
+            this._wirelessHwEnabledChangedId = 0;
+        }
+        if (this._dialog) {
+            this._dialog.destroy();
+            this._dialog = null;
+        }
+        if (this._notifyConnectivityId) {
+            this._client.disconnect(this._notifyConnectivityId);
+            this._notifyConnectivityId = 0;
+        }
+
+        this.item.destroy();
+    }
+
+    _deviceStateChanged(device, newstate, oldstate, reason) {
+        if (newstate == oldstate) {
+            log('device emitted state-changed without actually changing state');
+            return;
+        }
+
+        /* Emit a notification if activation fails, but don't do it
+           if the reason is no secrets, as that indicates the user
+           cancelled the agent dialog */
+        if (newstate == NM.DeviceState.FAILED &&
+            reason != NM.DeviceStateReason.NO_SECRETS)
+            this.emit('activation-failed', reason);
+
+        this._sync();
+    }
+
+    _toggleWifi() {
+        this._client.wireless_enabled = !this._client.wireless_enabled;
+    }
+
+    _showDialog() {
+        this._dialog = new NMWirelessDialog(this._client, this._device);
+        this._dialog.connect('closed', this._dialogClosed.bind(this));
+        this._dialog.open();
+    }
+
+    _dialogClosed() {
+        this._dialog = null;
+    }
+
+    _strengthChanged() {
+        this._iconChanged();
+    }
+
+    _activeApChanged() {
+        if (this._activeAccessPoint) {
+            this._activeAccessPoint.disconnect(this._strengthChangedId);
+            this._strengthChangedId = 0;
+        }
+
+        this._activeAccessPoint = this._device.active_access_point;
+
+        if (this._activeAccessPoint) {
+            this._strengthChangedId = this._activeAccessPoint.connect('notify::strength',
+                                                                      this._strengthChanged.bind(this));
+        }
+
+        this._sync();
+    }
+
+    _sync() {
+        this._toggleItem.label.text = this._client.wireless_enabled ? _("Turn Off") : _("Turn On");
+        this._toggleItem.visible = this._client.wireless_hardware_enabled;
+
+        this.item.icon.icon_name = this._getMenuIcon();
+        this.item.label.text = this._getStatus();
+    }
+
+    setDeviceDescription(desc) {
+        this._description = desc;
+        this._sync();
+    }
+
+    _getStatus() {
+        let ap = this._device.active_access_point;
+
+        if (this._isHotSpotMaster())
+            /* Translators: %s is a network identifier */
+            return _("%s Hotspot Active").format(this._description);
+        else if (this._device.state >= NM.DeviceState.PREPARE &&
+                 this._device.state < NM.DeviceState.ACTIVATED)
+            /* Translators: %s is a network identifier */
+            return _("%s Connecting").format(this._description);
+        else if (ap)
+            return ssidToLabel(ap.get_ssid());
+        else if (!this._client.wireless_hardware_enabled)
+            /* Translators: %s is a network identifier */
+            return _("%s Hardware Disabled").format(this._description);
+        else if (!this._client.wireless_enabled)
+            /* Translators: %s is a network identifier */
+            return _("%s Off").format(this._description);
+        else if (this._device.state == NM.DeviceState.DISCONNECTED)
+            /* Translators: %s is a network identifier */
+            return _("%s Not Connected").format(this._description);
+        else
+            return '';
+    }
+
+    _getMenuIcon() {
+        if (this._device.active_connection)
+            return this.getIndicatorIcon();
+        else
+            return 'network-wireless-signal-none-symbolic';
+    }
+
+    _canReachInternet() {
+        if (this._client.primary_connection != this._device.active_connection)
+            return true;
+
+        return this._client.connectivity == NM.ConnectivityState.FULL;
+    }
+
+    _isHotSpotMaster() {
+        if (!this._device.active_connection)
+            return false;
+
+        let connection = this._device.active_connection.connection;
+        if (!connection)
+            return false;
+
+        let ip4config = connection.get_setting_ip4_config();
+        if (!ip4config)
+            return false;
+
+        return ip4config.get_method() == NM.SETTING_IP4_CONFIG_METHOD_SHARED;
+    }
+
+    getIndicatorIcon() {
+        if (this._device.state < NM.DeviceState.PREPARE)
+            return 'network-wireless-disconnected-symbolic';
+        if (this._device.state < NM.DeviceState.ACTIVATED)
+            return 'network-wireless-acquiring-symbolic';
+
+        if (this._isHotSpotMaster())
+            return 'network-wireless-hotspot-symbolic';
+
+        let ap = this._device.active_access_point;
+        if (!ap) {
+            if (this._device.mode != NM80211Mode.ADHOC)
+                log('An active wireless connection, in infrastructure mode, involves no access point?');
+
+            if (this._canReachInternet())
+                return 'network-wireless-connected-symbolic';
+            else
+                return 'network-wireless-no-route-symbolic';
+        }
+
+        if (this._canReachInternet())
+            return 'network-wireless-signal-%s-symbolic'.format(signalToIcon(ap.strength));
+        else
+            return 'network-wireless-no-route-symbolic';
+    }
+};
+Signals.addSignalMethods(NMDeviceWireless.prototype);
+
+var NMVpnConnectionItem = class extends NMConnectionItem {
+    isActive() {
+        if (this._activeConnection == null)
+            return false;
+
+        return this._activeConnection.vpn_state != NM.VpnConnectionState.DISCONNECTED;
+    }
+
+    _buildUI() {
+        this.labelItem = new PopupMenu.PopupMenuItem('');
+        this.labelItem.connect('activate', this._toggle.bind(this));
+
+        this.radioItem = new PopupMenu.PopupSwitchMenuItem(this._connection.get_id(), false);
+        this.radioItem.connect('toggled', this._toggle.bind(this));
+    }
+
+    _sync() {
+        let isActive = this.isActive();
+        this.labelItem.label.text = isActive ? _("Turn Off") : this._section.getConnectLabel();
+        this.radioItem.setToggleState(isActive);
+        this.radioItem.setStatus(this._getStatus());
+        this.emit('icon-changed');
+    }
+
+    _getStatus() {
+        if (this._activeConnection == null)
+            return null;
+
+        switch (this._activeConnection.vpn_state) {
+        case NM.VpnConnectionState.DISCONNECTED:
+        case NM.VpnConnectionState.ACTIVATED:
+            return null;
+        case NM.VpnConnectionState.PREPARE:
+        case NM.VpnConnectionState.CONNECT:
+        case NM.VpnConnectionState.IP_CONFIG_GET:
+            return _("connecting…");
+        case NM.VpnConnectionState.NEED_AUTH:
+            /* Translators: this is for network connections that require some kind of key or password */
+            return _("authentication required");
+        case NM.VpnConnectionState.FAILED:
+            return _("connection failed");
+        default:
+            return 'invalid';
+        }
+    }
+
+    _connectionStateChanged(ac, newstate, reason) {
+        if (newstate == NM.VpnConnectionState.FAILED &&
+            reason != NM.VpnConnectionStateReason.NO_SECRETS) {
+            // FIXME: if we ever want to show something based on reason,
+            // we need to convert from NM.VpnConnectionStateReason
+            // to NM.DeviceStateReason
+            this.emit('activation-failed', reason);
+        }
+
+        this.emit('icon-changed');
+        super._connectionStateChanged();
+    }
+
+    setActiveConnection(activeConnection) {
+        if (this._activeConnectionChangedId > 0) {
+            this._activeConnection.disconnect(this._activeConnectionChangedId);
+            this._activeConnectionChangedId = 0;
+        }
+
+        this._activeConnection = activeConnection;
+
+        if (this._activeConnection) {
+            this._activeConnectionChangedId = this._activeConnection.connect('vpn-state-changed',
+                                                                             this._connectionStateChanged.bind(this));
+        }
+
+        this._sync();
+    }
+
+    getIndicatorIcon() {
+        if (this._activeConnection) {
+            if (this._activeConnection.vpn_state < NM.VpnConnectionState.ACTIVATED)
+                return 'network-vpn-acquiring-symbolic';
+            else
+                return 'network-vpn-symbolic';
+        } else {
+            return '';
+        }
+    }
+};
+
+var NMVpnSection = class extends NMConnectionSection {
+    constructor(client) {
+        super(client);
+
+        this.item.menu.addSettingsAction(_("VPN Settings"), 'gnome-network-panel.desktop');
+
+        this._sync();
+    }
+
+    _sync() {
+        let nItems = this._connectionItems.size;
+        this.item.visible = nItems > 0;
+
+        super._sync();
+    }
+
+    get category() {
+        return NMConnectionCategory.VPN;
+    }
+
+    _getDescription() {
+        return _("VPN");
+    }
+
+    _getStatus() {
+        let values = this._connectionItems.values();
+        for (let item of values) {
+            if (item.isActive())
+                return item.getName();
+        }
+
+        return _("VPN Off");
+    }
+
+    _getMenuIcon() {
+        return this.getIndicatorIcon() || 'network-vpn-symbolic';
+    }
+
+    activateConnection(connection) {
+        this._client.activate_connection_async(connection, null, null, null, null);
+    }
+
+    deactivateConnection(activeConnection) {
+        this._client.deactivate_connection(activeConnection, null);
+    }
+
+    setActiveConnections(vpnConnections) {
+        let connections = this._connectionItems.values();
+        for (let item of connections)
+            item.setActiveConnection(null);
+
+        vpnConnections.forEach(a => {
+            if (a.connection) {
+                let item = this._connectionItems.get(a.connection.get_uuid());
+                item.setActiveConnection(a);
+            }
+        });
+    }
+
+    _makeConnectionItem(connection) {
+        return new NMVpnConnectionItem(this, connection);
+    }
+
+    getIndicatorIcon() {
+        let items = this._connectionItems.values();
+        for (let item of items) {
+            let icon = item.getIndicatorIcon();
+            if (icon)
+                return icon;
+        }
+        return '';
+    }
+};
+Signals.addSignalMethods(NMVpnSection.prototype);
+
+var DeviceCategory = class extends PopupMenu.PopupMenuSection {
+    constructor(category) {
+        super();
+
+        this._category = category;
+
+        this.devices = [];
+
+        this.section = new PopupMenu.PopupMenuSection();
+        this.section.box.connect('actor-added', this._sync.bind(this));
+        this.section.box.connect('actor-removed', this._sync.bind(this));
+        this.addMenuItem(this.section);
+
+        this._summaryItem = new PopupMenu.PopupSubMenuMenuItem('', true);
+        this._summaryItem.icon.icon_name = this._getSummaryIcon();
+        this.addMenuItem(this._summaryItem);
+
+        this._summaryItem.menu.addSettingsAction(_('Network Settings'),
+                                                 'gnome-network-panel.desktop');
+        this._summaryItem.hide();
+
+    }
+
+    _sync() {
+        let nDevices = this.section.box.get_children().reduce(
+            (prev, child) => prev + (child.visible ? 1 : 0), 0);
+        this._summaryItem.label.text = this._getSummaryLabel(nDevices);
+        let shouldSummarize = nDevices > MAX_DEVICE_ITEMS;
+        this._summaryItem.visible = shouldSummarize;
+        this.section.actor.visible = !shouldSummarize;
+    }
+
+    _getSummaryIcon() {
+        switch (this._category) {
+        case NMConnectionCategory.WIRED:
+            return 'network-wired-symbolic';
+        case NMConnectionCategory.WIRELESS:
+        case NMConnectionCategory.WWAN:
+            return 'network-wireless-symbolic';
+        }
+        return '';
+    }
+
+    _getSummaryLabel(nDevices) {
+        switch (this._category) {
+        case NMConnectionCategory.WIRED:
+            return ngettext("%s Wired Connection",
+                            "%s Wired Connections",
+                            nDevices).format(nDevices);
+        case NMConnectionCategory.WIRELESS:
+            return ngettext("%s Wi-Fi Connection",
+                            "%s Wi-Fi Connections",
+                            nDevices).format(nDevices);
+        case NMConnectionCategory.WWAN:
+            return ngettext("%s Modem Connection",
+                            "%s Modem Connections",
+                            nDevices).format(nDevices);
+        }
+        return '';
+    }
+};
+
+var NMApplet = GObject.registerClass(
+class Indicator extends PanelMenu.SystemIndicator {
+    _init() {
+        super._init();
+
+        this._primaryIndicator = this._addIndicator();
+        this._vpnIndicator = this._addIndicator();
+
+        // Device types
+        this._dtypes = { };
+        this._dtypes[NM.DeviceType.ETHERNET] = NMDeviceWired;
+        this._dtypes[NM.DeviceType.WIFI] = NMDeviceWireless;
+        this._dtypes[NM.DeviceType.MODEM] = NMDeviceModem;
+        this._dtypes[NM.DeviceType.BT] = NMDeviceBluetooth;
+
+        // Connection types
+        this._ctypes = { };
+        this._ctypes[NM.SETTING_WIRED_SETTING_NAME] = NMConnectionCategory.WIRED;
+        this._ctypes[NM.SETTING_WIRELESS_SETTING_NAME] = NMConnectionCategory.WIRELESS;
+        this._ctypes[NM.SETTING_BLUETOOTH_SETTING_NAME] = NMConnectionCategory.WWAN;
+        this._ctypes[NM.SETTING_CDMA_SETTING_NAME] = NMConnectionCategory.WWAN;
+        this._ctypes[NM.SETTING_GSM_SETTING_NAME] = NMConnectionCategory.WWAN;
+        this._ctypes[NM.SETTING_VPN_SETTING_NAME] = NMConnectionCategory.VPN;
+
+        this._getClient();
+    }
+
+    async _getClient() {
+        this._client = await NM.Client.new_async(null);
+
+        this._activeConnections = [];
+        this._connections = [];
+        this._connectivityQueue = [];
+
+        this._mainConnection = null;
+        this._mainConnectionIconChangedId = 0;
+        this._mainConnectionStateChangedId = 0;
+
+        this._notification = null;
+
+        this._nmDevices = [];
+        this._devices = { };
+
+        let categories = [NMConnectionCategory.WIRED,
+                          NMConnectionCategory.WIRELESS,
+                          NMConnectionCategory.WWAN];
+        for (let category of categories) {
+            this._devices[category] = new DeviceCategory(category);
+            this.menu.addMenuItem(this._devices[category]);
+        }
+
+        this._vpnSection = new NMVpnSection(this._client);
+        this._vpnSection.connect('activation-failed', this._onActivationFailed.bind(this));
+        this._vpnSection.connect('icon-changed', this._updateIcon.bind(this));
+        this.menu.addMenuItem(this._vpnSection.item);
+
+        this._readConnections();
+        this._readDevices();
+        this._syncNMState();
+        this._syncMainConnection();
+        this._syncVpnConnections();
+
+        this._client.connect('notify::nm-running', this._syncNMState.bind(this));
+        this._client.connect('notify::networking-enabled', this._syncNMState.bind(this));
+        this._client.connect('notify::state', this._syncNMState.bind(this));
+        this._client.connect('notify::primary-connection', this._syncMainConnection.bind(this));
+        this._client.connect('notify::activating-connection', this._syncMainConnection.bind(this));
+        this._client.connect('notify::active-connections', this._syncVpnConnections.bind(this));
+        this._client.connect('notify::connectivity', this._syncConnectivity.bind(this));
+        this._client.connect('device-added', this._deviceAdded.bind(this));
+        this._client.connect('device-removed', this._deviceRemoved.bind(this));
+        this._client.connect('connection-added', this._connectionAdded.bind(this));
+        this._client.connect('connection-removed', this._connectionRemoved.bind(this));
+
+        Main.sessionMode.connect('updated', this._sessionUpdated.bind(this));
+        this._sessionUpdated();
+    }
+
+    _sessionUpdated() {
+        let sensitive = !Main.sessionMode.isLocked && !Main.sessionMode.isGreeter;
+        this.menu.setSensitive(sensitive);
+    }
+
+    _ensureSource() {
+        if (!this._source) {
+            this._source = new MessageTray.Source(_("Network Manager"),
+                                                  'network-transmit-receive');
+            this._source.policy = new MessageTray.NotificationApplicationPolicy('gnome-network-panel');
+
+            this._source.connect('destroy', () => (this._source = null));
+            Main.messageTray.add(this._source);
+        }
+    }
+
+    _readDevices() {
+        let devices = this._client.get_devices() || [];
+        for (let i = 0; i < devices.length; ++i) {
+            try {
+                this._deviceAdded(this._client, devices[i], true);
+            } catch (e) {
+                log('Failed to add device %s: %s'.format(devices[i], e.toString()));
+            }
+        }
+        this._syncDeviceNames();
+    }
+
+    _notify(iconName, title, text, urgency) {
+        if (this._notification)
+            this._notification.destroy();
+
+        this._ensureSource();
+
+        let gicon = new Gio.ThemedIcon({ name: iconName });
+        this._notification = new MessageTray.Notification(this._source, title, text, { gicon });
+        this._notification.setUrgency(urgency);
+        this._notification.setTransient(true);
+        this._notification.connect('destroy', () => {
+            this._notification = null;
+        });
+        this._source.showNotification(this._notification);
+    }
+
+    _onActivationFailed(_device, _reason) {
+        // XXX: nm-applet has no special text depending on reason
+        // but I'm not sure of this generic message
+        this._notify('network-error-symbolic',
+                     _("Connection failed"),
+                     _("Activation of network connection failed"),
+                     MessageTray.Urgency.HIGH);
+    }
+
+    _syncDeviceNames() {
+        let names = NM.Device.disambiguate_names(this._nmDevices);
+        for (let i = 0; i < this._nmDevices.length; i++) {
+            let device = this._nmDevices[i];
+            let description = names[i];
+            if (device._delegate)
+                device._delegate.setDeviceDescription(description);
+        }
+    }
+
+    _deviceAdded(client, device, skipSyncDeviceNames) {
+        if (device._delegate) {
+            // already seen, not adding again
+            return;
+        }
+
+        let wrapperClass = this._dtypes[device.get_device_type()];
+        if (wrapperClass) {
+            let wrapper = new wrapperClass(this._client, device);
+            device._delegate = wrapper;
+            this._addDeviceWrapper(wrapper);
+
+            this._nmDevices.push(device);
+            this._deviceChanged(device, skipSyncDeviceNames);
+
+            device.connect('notify::interface', () => {
+                this._deviceChanged(device, false);
+            });
+        }
+    }
+
+    _deviceChanged(device, skipSyncDeviceNames) {
+        let wrapper = device._delegate;
+
+        if (!skipSyncDeviceNames)
+            this._syncDeviceNames();
+
+        if (wrapper instanceof NMConnectionSection) {
+            this._connections.forEach(connection => {
+                wrapper.checkConnection(connection);
+            });
+        }
+    }
+
+    _addDeviceWrapper(wrapper) {
+        wrapper._activationFailedId = wrapper.connect('activation-failed',
+                                                      this._onActivationFailed.bind(this));
+
+        let section = this._devices[wrapper.category].section;
+        section.addMenuItem(wrapper.item);
+
+        let devices = this._devices[wrapper.category].devices;
+        devices.push(wrapper);
+    }
+
+    _deviceRemoved(client, device) {
+        let pos = this._nmDevices.indexOf(device);
+        if (pos != -1) {
+            this._nmDevices.splice(pos, 1);
+            this._syncDeviceNames();
+        }
+
+        let wrapper = device._delegate;
+        if (!wrapper) {
+            log('Removing a network device that was not added');
+            return;
+        }
+
+        this._removeDeviceWrapper(wrapper);
+    }
+
+    _removeDeviceWrapper(wrapper) {
+        wrapper.disconnect(wrapper._activationFailedId);
+        wrapper.destroy();
+
+        let devices = this._devices[wrapper.category].devices;
+        let pos = devices.indexOf(wrapper);
+        devices.splice(pos, 1);
+    }
+
+    _getMainConnection() {
+        let connection;
+
+        connection = this._client.get_primary_connection();
+        if (connection) {
+            ensureActiveConnectionProps(connection);
+            return connection;
+        }
+
+        connection = this._client.get_activating_connection();
+        if (connection) {
+            ensureActiveConnectionProps(connection);
+            return connection;
+        }
+
+        return null;
+    }
+
+    _syncMainConnection() {
+        if (this._mainConnectionIconChangedId > 0) {
+            this._mainConnection._primaryDevice.disconnect(this._mainConnectionIconChangedId);
+            this._mainConnectionIconChangedId = 0;
+        }
+
+        if (this._mainConnectionStateChangedId > 0) {
+            this._mainConnection.disconnect(this._mainConnectionStateChangedId);
+            this._mainConnectionStateChangedId = 0;
+        }
+
+        this._mainConnection = this._getMainConnection();
+
+        if (this._mainConnection) {
+            if (this._mainConnection._primaryDevice)
+                this._mainConnectionIconChangedId = this._mainConnection._primaryDevice.connect('icon-changed', this._updateIcon.bind(this));
+            this._mainConnectionStateChangedId = this._mainConnection.connect('notify::state', this._mainConnectionStateChanged.bind(this));
+            this._mainConnectionStateChanged();
+        }
+
+        this._updateIcon();
+        this._syncConnectivity();
+    }
+
+    _syncVpnConnections() {
+        let activeConnections = this._client.get_active_connections() || [];
+        let vpnConnections = activeConnections.filter(
+            a => a instanceof NM.VpnConnection);
+        vpnConnections.forEach(a => {
+            ensureActiveConnectionProps(a);
+        });
+        this._vpnSection.setActiveConnections(vpnConnections);
+
+        this._updateIcon();
+    }
+
+    _mainConnectionStateChanged() {
+        if (this._mainConnection.state == NM.ActiveConnectionState.ACTIVATED && this._notification)
+            this._notification.destroy();
+    }
+
+    _ignoreConnection(connection) {
+        let setting = connection.get_setting_connection();
+        if (!setting)
+            return true;
+
+        // Ignore slave connections
+        if (setting.get_master())
+            return true;
+
+        return false;
+    }
+
+    _addConnection(connection) {
+        if (this._ignoreConnection(connection))
+            return;
+        if (connection._updatedId) {
+            // connection was already seen
+            return;
+        }
+
+        connection._updatedId = connection.connect('changed', this._updateConnection.bind(this));
+
+        this._updateConnection(connection);
+        this._connections.push(connection);
+    }
+
+    _readConnections() {
+        let connections = this._client.get_connections();
+        connections.forEach(this._addConnection.bind(this));
+    }
+
+    _connectionAdded(client, connection) {
+        this._addConnection(connection);
+    }
+
+    _connectionRemoved(client, connection) {
+        let pos = this._connections.indexOf(connection);
+        if (pos != -1)
+            this._connections.splice(pos, 1);
+
+        let section = connection._section;
+
+        if (section == NMConnectionCategory.INVALID)
+            return;
+
+        if (section == NMConnectionCategory.VPN) {
+            this._vpnSection.removeConnection(connection);
+        } else {
+            let devices = this._devices[section].devices;
+            for (let i = 0; i < devices.length; i++) {
+                if (devices[i] instanceof NMConnectionSection)
+                    devices[i].removeConnection(connection);
+            }
+        }
+
+        connection.disconnect(connection._updatedId);
+        connection._updatedId = 0;
+    }
+
+    _updateConnection(connection) {
+        let connectionSettings = connection.get_setting_by_name(NM.SETTING_CONNECTION_SETTING_NAME);
+        connection._type = connectionSettings.type;
+        connection._section = this._ctypes[connection._type] || NMConnectionCategory.INVALID;
+
+        let section = connection._section;
+
+        if (section == NMConnectionCategory.INVALID)
+            return;
+
+        if (section == NMConnectionCategory.VPN) {
+            this._vpnSection.checkConnection(connection);
+        } else {
+            let devices = this._devices[section].devices;
+            devices.forEach(wrapper => {
+                if (wrapper instanceof NMConnectionSection)
+                    wrapper.checkConnection(connection);
+            });
+        }
+    }
+
+    _syncNMState() {
+        this.visible = this._client.nm_running;
+        this.menu.actor.visible = this._client.networking_enabled;
+
+        this._updateIcon();
+        this._syncConnectivity();
+    }
+
+    _flushConnectivityQueue() {
+        if (this._portalHelperProxy) {
+            for (let item of this._connectivityQueue)
+                this._portalHelperProxy.CloseRemote(item);
+        }
+
+        this._connectivityQueue = [];
+    }
+
+    _closeConnectivityCheck(path) {
+        let index = this._connectivityQueue.indexOf(path);
+
+        if (index >= 0) {
+            if (this._portalHelperProxy)
+                this._portalHelperProxy.CloseRemote(path);
+
+            this._connectivityQueue.splice(index, 1);
+        }
+    }
+
+    async _portalHelperDone(proxy, emitter, parameters) {
+        let [path, result] = parameters;
+
+        if (result == PortalHelperResult.CANCELLED) {
+            // Keep the connection in the queue, so the user is not
+            // spammed with more logins until we next flush the queue,
+            // which will happen once he chooses a better connection
+            // or we get to full connectivity through other means
+        } else if (result == PortalHelperResult.COMPLETED) {
+            this._closeConnectivityCheck(path);
+        } else if (result == PortalHelperResult.RECHECK) {
+            try {
+                const state = await this._client.check_connectivity_async(null);
+                if (state >= NM.ConnectivityState.FULL)
+                    this._closeConnectivityCheck(path);
+            } catch (e) { }
+        } else {
+            log('Invalid result from portal helper: %s'.format(result));
+        }
+    }
+
+    _syncConnectivity() {
+        if (this._mainConnection == null ||
+            this._mainConnection.state != NM.ActiveConnectionState.ACTIVATED) {
+            this._flushConnectivityQueue();
+            return;
+        }
+
+        let isPortal = this._client.connectivity == NM.ConnectivityState.PORTAL;
+        // For testing, allow interpreting any value != FULL as PORTAL, because
+        // LIMITED (no upstream route after the default gateway) is easy to obtain
+        // with a tethered phone
+        // NONE is also possible, with a connection configured to force no default route
+        // (but in general we should only prompt a portal if we know there is a portal)
+        if (GLib.getenv('GNOME_SHELL_CONNECTIVITY_TEST') != null)
+            isPortal = isPortal || this._client.connectivity < NM.ConnectivityState.FULL;
+        if (!isPortal || Main.sessionMode.isGreeter)
+            return;
+
+        let path = this._mainConnection.get_path();
+        for (let item of this._connectivityQueue) {
+            if (item == path)
+                return;
+        }
+
+        let timestamp = global.get_current_time();
+        if (this._portalHelperProxy) {
+            this._portalHelperProxy.AuthenticateRemote(path, '', timestamp);
+        } else {
+            new PortalHelperProxy(Gio.DBus.session, 'org.gnome.Shell.PortalHelper',
+                                  '/org/gnome/Shell/PortalHelper', (proxy, error) => {
+                                      if (error) {
+                                          log('Error launching the portal helper: %s'.format(error));
+                                          return;
+                                      }
+
+                                      this._portalHelperProxy = proxy;
+                                      proxy.connectSignal('Done', this._portalHelperDone.bind(this));
+
+                                      proxy.AuthenticateRemote(path, '', timestamp);
+                                  });
+        }
+
+        this._connectivityQueue.push(path);
+    }
+
+    _updateIcon() {
+        if (!this._client.networking_enabled) {
+            this._primaryIndicator.visible = false;
+        } else {
+            let dev = null;
+            if (this._mainConnection)
+                dev = this._mainConnection._primaryDevice;
+
+            let state = this._client.get_state();
+            let connected = state == NM.State.CONNECTED_GLOBAL;
+            this._primaryIndicator.visible = (dev != null) || connected;
+            if (dev) {
+                this._primaryIndicator.icon_name = dev.getIndicatorIcon();
+            } else if (connected) {
+                if (this._client.connectivity == NM.ConnectivityState.FULL)
+                    this._primaryIndicator.icon_name = 'network-wired-symbolic';
+                else
+                    this._primaryIndicator.icon_name = 'network-wired-no-route-symbolic';
+            }
+        }
+
+        this._vpnIndicator.icon_name = this._vpnSection.getIndicatorIcon();
+        this._vpnIndicator.visible = this._vpnIndicator.icon_name !== null;
+    }
+});