Merge lp:~kvalo/indicator-network/settings-vala-convert into lp:~indicator-applet-developers/indicator-network/indicator-network

[Kalle Valo]

Replace pygtk version of indicator-network-settings with a similar vala version. Currently frontend only works, backend needs to be implemented still. The backend will use libconnman.

Original author of the vala code is and471. I did the merge to indicator-network and autotools part.

[Mikkel Kamstrup Erlandsen (kamstrup)]

* src/settings/app.vala:

 - Can NetworkSettings.get_widgets() check that this.builder is a Gtk.Builder, as this kinda code always tends to regress when you refactor it...

 - Why is [CCode (instance_pos = -1)] needed on the callbacks? If it's really needed, can it get a comment in the code?

* src/settings/backend/connection.vala:

 - Why are all the fields on WifiConnection not properties? That would give change notifications for free.

* src/settings/backend/device.vala

 - Why does the Device class not use properties for it's two fields - given that, it would need the change notification signal, but could just you the standard GObject 'notify' signal (with details for the state).

* src/settings/frontend/utils.vala

 - Please make sure that you (Andrew) have the copyrights on this code (and not the Clutter project), so that you can legally contribute it

* ToggleSwitch and InfoBox. Can you add a quick comment in the class headers on why you are not using the Gtk counterparts?

Approved conditionally - given that there are good answers to the questions.

Super impressive work Andrew! This is an awesome first stab at a network dialog! :-D

review: Approve (code review)

[Mikkel Kamstrup Erlandsen (kamstrup)]

I just went over the points with Andrew on IRC and everything should be cleared up. About the copyright issue we need some sort of reimplementation as Andrew said it was mostly copy-paste. I gathered from other discussions today that we may have something in lp:unity we can replace it with.

So; kvalo should merge and471's newest changes and pull in the unity color stuff and we should be good

[Kalle Valo (kvalo)]

Mikkel Kamstrup Erlandsen <email address hidden> writes:

> I just went over the points with Andrew on IRC and everything should
> be cleared up.

Excellent, thank you for that.

> About the copyright issue we need some sort of reimplementation as
> Andrew said it was mostly copy-paste. I gathered from other
> discussions today that we may have something in lp:unity we can
> replace it with.
>
> So; kvalo should merge and471's newest changes and pull in the unity
> color stuff and we should be good

Ok. I'll do so that I'll find a replacement implementation and update
this merge request.

Thanks.

--
Kalle Valo

[lp:~kvalo/indicator-network/settings-vala-convert]

135. By Kalle Valo on 2011-01-07

settings: replace rgb to hsl functions with copies from libunity

The author for the functions is Gordon Allot.

The original implementation used hsl, but the new functions use instead hsv.
Hopefully this isn't a problem, at least I didn't notice any difference
in testing.

[Kalle Valo (kvalo)]

I now pushed new functions for the rgb transformations. Please note the hsv/hsl difference, I hope I didn't break anything.

[lp:~kvalo/indicator-network/settings-vala-convert]

136. By Kalle Valo on 2011-01-07

settings: add missing glade files to potfiles to fix distcheck

[Andrew (and471)]

All looks good I approve!

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2010-12-09 09:03:43 +0000
+++ .bzrignore	2011-01-07 16:06:25 +0000
@@ -89,3 +89,24 @@
 tests/libconnman-tool
 src/libconnman/libconnman_la-connman-service.lo
 py-compile
+src/settings/app.c
+src/settings/enums.c
+src/settings/indicator-network-settings-2
+src/settings/indicator_network_settings_2_vala.stamp
+src/settings/logger.c
+src/settings/main.c
+src/settings/backend/connection.c
+src/settings/backend/device.c
+src/settings/frontend/utils.c
+src/settings/frontend/pages/connections.c
+src/settings/frontend/widgets/cellrenderers.c
+src/settings/frontend/widgets/infobox.c
+src/settings/frontend/widgets/stores.c
+src/settings/frontend/widgets/toggleswitch.c
+src/settings/frontend/widgets/treeviews.c
+src/settings/frontend/widgets/device-boxes/base.c
+src/settings/frontend/widgets/device-boxes/bluetooth.c
+src/settings/frontend/widgets/device-boxes/mobile.c
+src/settings/frontend/widgets/device-boxes/wired.c
+src/settings/frontend/widgets/device-boxes/wireless.c
+src/settings/frontend/widgets/dialogs/edit-connection.c
 
=== modified file 'configure.ac'
--- configure.ac	2010-12-16 19:30:22 +0000
+++ configure.ac	2011-01-07 16:06:25 +0000
@@ -17,9 +17,9 @@
 AM_PROG_CC_C_O
 AC_STDC_HEADERS
 AC_PROG_LIBTOOL
-AM_PATH_PYTHON
 AC_PROG_LN_S
 AC_PROG_MKDIR_P
+AM_PROG_VALAC
 
 AC_SUBST(VERSION)
 AC_CONFIG_MACRO_DIR([m4])
@@ -154,12 +154,6 @@
 src/agent/Makefile
 src/settings/Makefile
 src/settings/ui/Makefile
-src/settings/indicatorNetworkSettings/Makefile
-src/settings/indicatorNetworkSettings/backend/Makefile
-src/settings/indicatorNetworkSettings/frontend/Makefile
-src/settings/indicatorNetworkSettings/frontend/pages/Makefile
-src/settings/indicatorNetworkSettings/frontend/widgets/Makefile
-src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/Makefile
 data/Makefile
 po/Makefile.in
 scripts/Makefile
 
=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2010-12-13 14:04:06 +0000
+++ po/POTFILES.in	2011-01-07 16:06:25 +0000
@@ -8,9 +8,8 @@
 src/agent/pin-dialog.c
 scripts/indicator-network-settings
 scripts/indicator-network-mobile-wizard
-src/settings/indicatorNetworkSettings/enums.py
-src/settings/indicatorNetworkSettings/frontend/widgets/connectionview.py
-src/settings/indicatorNetworkSettings/frontend/widgets/deviceview.py
-src/settings/ui/indicator-network-settings.ui
+src/settings/ui/edit_connection_dialog.ui
+src/settings/ui/main.ui
 src/settings/ui/mobile_box.ui
+src/settings/ui/sample.ui
 src/settings/ui/wireless_box.ui
 
=== modified file 'src/settings/Makefile.am'
--- src/settings/Makefile.am	2010-12-13 13:55:55 +0000
+++ src/settings/Makefile.am	2011-01-07 16:06:25 +0000
@@ -1,16 +1,47 @@
 SUBDIRS = \
-	indicatorNetworkSettings \
 	ui
 
-dist_pkgdata_SCRIPTS = \
-	indicator-network-settings
-
-# create a symbolic link to bindir
-# FIXME: it will have suffix -2 until new settings window is usable
-#
-# Note: ln -f is not portable
-install-exec-hook:
-	$(MKDIR_P) $(DESTDIR)$(bindir) && \
-	cd $(DESTDIR)$(bindir) && \
-	$(LN_S) -f $(pkgdatadir)/indicator-network-settings \
-			indicator-network-settings-2
+bin_PROGRAMS = indicator-network-settings-2
+
+indicator_network_settings_2_SOURCES = \
+	main.vala \
+	app.vala \
+	enums.vala \
+	logger.vala \
+	backend/device.vala \
+	backend/connection.vala \
+	frontend/utils.vala \
+	frontend/pages/connections.vala \
+	frontend/widgets/cellrenderers.vala \
+	frontend/widgets/stores.vala \
+	frontend/widgets/treeviews.vala \
+	frontend/widgets/infobox.vala \
+	frontend/widgets/toggleswitch.vala \
+	frontend/widgets/device-boxes/base.vala \
+	frontend/widgets/device-boxes/mobile.vala \
+	frontend/widgets/device-boxes/bluetooth.vala \
+	frontend/widgets/device-boxes/wired.vala \
+	frontend/widgets/device-boxes/wireless.vala \
+	frontend/widgets/dialogs/edit-connection.vala
+
+VALAFLAGS = \
+	--vapidir=$(srcdir)/vapi \
+        --pkg=gmodule-2.0 \
+        --pkg=gtk+-2.0 \
+        --pkg=gdk-2.0 \
+        --pkg=gio-2.0 \
+        --pkg=gee-1.0 \
+        --pkg=pango \
+        --pkg=cairo \
+	--pkg=config \
+	--fatal-warnings
+
+# -w is needed to disable gcc warnings because of valac
+indicator_network_settings_2_CFLAGS = \
+	$(GTK_CFLAGS) \
+	-w \
+	-DLOCALEDIR=\""$(localedir)"\" \
+	-DPKGDATADIR=\""$(pkgdatadir)"\"
+
+indicator_network_settings_2_LDADD = \
+	$(GTK_LIBS)
 
=== added file 'src/settings/app.vala'
--- src/settings/app.vala	1970-01-01 00:00:00 +0000
+++ src/settings/app.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,76 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public class NetworkSettings : Object {
+
+    // Widgets from GTKBuilder
+    private Gtk.Window window_main;
+    private Gtk.Notebook notebook_main;
+    private Gtk.Alignment alignment_connections;
+    private Gtk.ScrolledWindow scrolledwindow_c_devices;
+    private Gtk.Notebook notebook_c_right;
+
+    private Gtk.IconTheme icons = Gtk.IconTheme.get_default();
+    private ConnectionsPage[] pages;
+    public Gtk.Builder builder;
+
+    public NetworkSettings(string datadir) {
+        this.builder = Utils.Gui.new_builder(datadir + "/ui/main.ui");
+
+        this.get_widgets();
+
+        var page_connection = new ConnectionsPage(datadir, this.icons,
+                                        this.alignment_connections,
+                                        this.scrolledwindow_c_devices,
+                                        this.notebook_c_right);
+                            
+        this.pages = {page_connection};
+        
+        this.window_main.show_all();
+        this.on_notebook_main_page_switched(null, 0);
+    }
+
+    /* Private Functions */
+    private void get_widgets() {
+        this.window_main = this.builder.get_object("window_main") as Gtk.Window;
+        this.notebook_main = this.builder.get_object("notebook_main") as Gtk.Notebook;
+        this.alignment_connections = this.builder.get_object("alignment_connections") as Gtk.Alignment;
+        this.scrolledwindow_c_devices = this.builder.get_object("scrolledwindow_c_devices") as Gtk.ScrolledWindow;
+        this.notebook_c_right = this.builder.get_object("notebook_c_right") as Gtk.Notebook;
+    }
+    
+    /* Callbacks */
+    [CCode (instance_pos = -1)]
+    public bool on_window_main_delete_event(Gdk.Event event) {
+        Gtk.main_quit();
+        return true;
+    }
+    
+    [CCode (instance_pos = -1)]
+    public void on_notebook_main_page_switched(Gtk.NotebookPage? notebook_page, int page_num) {
+        var page_alignment = this.notebook_main.get_nth_page(page_num);
+
+        foreach (ConnectionsPage page in this.pages) {
+            if (page.alignment == page_alignment && page.viewed == false) {
+                page.on_first_expose();
+            }
+        }
+    }
+}
 
=== added directory 'src/settings/backend'
=== added file 'src/settings/backend/connection.vala'
--- src/settings/backend/connection.vala	1970-01-01 00:00:00 +0000
+++ src/settings/backend/connection.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,63 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public class WifiConnection : GLib.Object {
+    public string network;
+    public double signal;
+    public string last_used;
+    public string name;
+    public string ssid;
+    public string? bssid;
+    public WirelessMode mode = WirelessMode.INFRASTRUCTURE;
+    public bool autoconnect = false;
+    public bool share_settings = false;
+
+    public void connect_(string key) {
+        var network = this.network;
+        stdout.printf(@"Connecting to $network\n");
+    }
+}
+
+public WifiConnection[] get_remembered_wireless_connections(Device device) {
+    // Dummy Connections (temporary)
+    var connection1 = new WifiConnection();
+    connection1.name = "Downstairs Router (above the biscuit tin)";
+    connection1.signal = (double) 0.75;
+    connection1.last_used = "1/1/1";
+    connection1.ssid = "BTHomeHub-193209";
+    connection1.bssid = "BBTHomeHub-193209";
+    connection1.mode = WirelessMode.INFRASTRUCTURE;
+    connection1.autoconnect = true;
+    connection1.share_settings = true;
+    
+    var connection2 = new WifiConnection();
+    connection2.name = "SKY-001";
+    connection2.signal = (double) 0.55;
+    connection2.last_used = "1/1/1";
+    connection2.ssid = "SKY-001";
+    
+    var connection3 = new WifiConnection();
+    connection3.name = "Starbucks OpenAccess";
+    connection3.signal = (double) 0.2;
+    connection3.last_used = "1/1/1";
+    connection3.ssid = "Starbucks-1223Open";
+    //
+    return {connection1, connection2, connection3};
+}
 
=== added file 'src/settings/backend/device.vala'
--- src/settings/backend/device.vala	1970-01-01 00:00:00 +0000
+++ src/settings/backend/device.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,78 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public class Device : GLib.Object {
+
+    public signal void state_changed(DeviceState selected);
+
+    public DeviceType type;
+    public DeviceState state;
+    
+    public Device() {
+    }
+
+    public void set_state(DeviceState state) {
+        this.state = state;
+        this.state_changed(this.state);
+    }
+
+    public DeviceState get_state() {
+        return this.state;
+    }
+}
+
+public static Device[] get_wired_devices() {
+    // Populate Device View (temporary)
+    var device1 = new Device();
+    device1.type = DeviceType.WIRED;
+    device1.state = DeviceState.OFFLINE;
+    //
+    return {device1};
+}
+    
+public static Device[] get_wireless_devices() {
+    // Populate Device View (temporary)
+    var device1 = new Device();
+    device1.type = DeviceType.WIRELESS;
+    device1.state = DeviceState.ONLINE;
+    var device2 = new Device();
+    device2.type = DeviceType.WIRELESS;
+    device2.state = DeviceState.OFF;
+    //
+    return {device1, device2};
+}
+    
+public static Device[] get_mobile_devices() {
+    // Populate Device View (temporary)
+    var device3 = new Device();
+    device3.type = DeviceType.MOBILE;
+    device3.state = DeviceState.CONNECTED;
+    //
+    return {device3};
+}    
+    
+public static Device[] get_bluetooth_devices() {
+    // Populate Device View (temporary)
+    var device4 = new Device();
+    device4.type = DeviceType.BLUETOOTH;
+    device4.state = DeviceState.OFF;
+    //
+    return {device4};
+}
 
=== added file 'src/settings/enums.vala'
--- src/settings/enums.vala	1970-01-01 00:00:00 +0000
+++ src/settings/enums.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,115 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public enum DeviceType {
+    WIRED,
+    WIRELESS,
+    BLUETOOTH,
+    MOBILE,
+    GENERIC; // Shouldn't be used manually
+    
+    public string get_name() {
+        switch (this) {
+            case WIRED:
+                return ("Wired");
+            case WIRELESS:
+                return ("Wireless");
+            case BLUETOOTH:
+                return ("Bluetooth");
+            case MOBILE:
+                return ("Mobile Broadband");
+            case GENERIC:
+                return ("Wired");
+            default:
+                assert_not_reached();
+        }
+    }
+    
+    public string get_lname() {
+        switch (this) {
+            case WIRED:
+                return "wired";
+            case WIRELESS:
+                return "wireless";
+            case BLUETOOTH:
+                return "bluetooth";
+            case MOBILE:
+                return "mobile";
+            default:
+                assert_not_reached();
+        }
+    }
+    
+    public string get_icon_name() {
+        switch (this) {
+            case WIRED:
+                return "network-wired";
+            case WIRELESS:
+                return "network-wireless";
+            case BLUETOOTH:
+                return "bluetooth-active";
+            case MOBILE:
+                return "gsm-3g-high";
+            case GENERIC:
+                return "network-wired";
+            default:
+                assert_not_reached();
+        }
+    }
+}
+
+public enum DeviceState {
+    OFF,
+    OFFLINE,
+    CONNECTED,
+    ONLINE;
+
+    public string get_name() {
+        switch (this) {
+            case OFF:
+                return ("Off");
+            case OFFLINE:
+                return ("Offline");
+            case CONNECTED:
+                return ("Connected");
+            case ONLINE:
+                return ("Online");
+            default:
+             assert_not_reached();
+            }
+    }
+}
+
+public enum WirelessMode {
+    INFRASTRUCTURE,
+    ADHOC;
+    
+    public string get_name() {
+        switch (this) {
+            case INFRASTRUCTURE:
+                return ("Infrastructure");
+            case ADHOC:
+                return ("Ad-hoc");
+            default:
+             assert_not_reached();
+            }
+    }
+    
+}
 
=== added directory 'src/settings/frontend'
=== added directory 'src/settings/frontend/pages'
=== added file 'src/settings/frontend/pages/connections.vala'
--- src/settings/frontend/pages/connections.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/pages/connections.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,120 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public class ConnectionsPage : Object {
+
+    public Gtk.Alignment alignment;
+    public Gtk.Notebook notebook_right;
+    public bool viewed = false;
+
+    private DeviceView treeview_devices;
+
+    public ConnectionsPage(string datadir, Gtk.IconTheme icons,
+                            Gtk.Alignment alignment,
+                            Gtk.ScrolledWindow scrolledwindow_devices,
+                            Gtk.Notebook notebook_right) {
+                                
+        this.alignment = alignment;
+        this.notebook_right = notebook_right;
+
+        // Create LHS
+        /// Create device view
+        var device_store = new DeviceStore(icons);
+        this.treeview_devices = new DeviceView(device_store);
+        /// Pack it
+        scrolledwindow_devices.add(this.treeview_devices);
+        /// Connect signals to callbacks
+        this.treeview_devices.get_selection().changed.connect(
+            this.on_treeview_devices_selection_changed);
+        this.treeview_devices.reordered.connect(
+            this.on_treeview_devices_reordered);
+
+        Device[] wired_devices = get_wired_devices();
+        Device[] wireless_devices = get_wireless_devices();
+        Device[] mobile_devices = get_mobile_devices();
+        Device[] bluetooth_devices = get_bluetooth_devices();
+
+        foreach (var device in wireless_devices) {
+            var box = new WirelessBox(device, datadir);
+            notebook_right.append_page(box, null);
+            this.add_device(device, box);
+        }
+
+        foreach (var device in mobile_devices) {
+            var box = new MobileBox(device, datadir);
+            notebook_right.append_page(box, null);
+            this.add_device(device, box);
+        }
+            
+        foreach (var device in wired_devices) {
+            var box = new WiredBox(device, datadir);
+            notebook_right.append_page(box, null);
+            this.add_device(device, box);
+        }
+            
+        foreach (var device in bluetooth_devices) {
+            var box = new BluetoothBox(device, datadir);
+            notebook_right.append_page(box, null);
+            this.add_device(device, box);
+        }
+
+        // Order the RHS notebook pages inaccordance with the deviceview
+        this.on_treeview_devices_reordered();
+        
+    }
+
+    public void add_device(Device device, DeviceBox box) {
+        var liststore = this.treeview_devices.get_model() as DeviceStore;
+        liststore.add_device(device, box);
+    }
+
+    public void on_first_expose() {
+        if (!this.viewed) {
+            this.treeview_devices.get_selection().select_path(new Gtk.TreePath.first());
+            this.viewed = true;
+        }
+    }
+
+    private void on_treeview_devices_selection_changed() {
+        var selection = this.treeview_devices.get_selection();
+        Gtk.TreeModel model;
+        Gtk.TreeIter? iter;
+        selection.get_selected(out model, out iter);
+
+        if (iter != null) {
+            int i = model.get_path(iter).get_indices()[0];
+            this.notebook_right.set_current_page(i);
+        }
+    }
+    
+    private void on_treeview_devices_reordered() {
+        var i = 0;
+        var model = this.treeview_devices.get_model();
+        model.foreach((model, path, iter) => {
+            GLib.Value value;
+            model.get_value(iter, DeviceStoreCol.SETTINGS_BOX, out value);
+            Gtk.VBox page = value.get_object() as Gtk.VBox;
+            this.notebook_right.reorder_child(page, i);
+            i += 1;
+            return false;
+        });
+    }
+
+}
 
=== added file 'src/settings/frontend/utils.vala'
--- src/settings/frontend/utils.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/utils.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,199 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ * Gordon Allott <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+namespace Utils.Color {
+	/* from libunity */
+	public static void rgb_to_hsv (float r, float g, float b,
+								   out float hue, out float sat, out float val)
+	{
+		float min, max = 0.0f;
+		if (r > g)
+			max = (r > b) ? r : b;
+		else
+			max = (g > b) ? g : b;
+		if (r < g)
+			min = (r < b) ? r : b;
+		else
+			min = (g < b) ? g : b;
+
+		val = max;
+
+		float delta = max - min;
+		if (delta > 0.000001)
+		{
+			sat = delta / max;
+			hue = 0.0f;
+			if (r == max)
+			{
+				hue = (g - b) / delta;
+				if (hue < 0.0f)
+					hue += 6.0f;
+			}
+			else if (g == max)
+			{
+				hue = 2.0f + (b - r) / delta;
+			}
+			else if (b == max)
+			{
+				hue = 4.0f + (r - g) / delta;
+			}
+			hue /= 6.0f;
+		}
+		else
+		{
+			sat = 0.0f;
+			hue = 0.0f;
+		}
+	}
+
+	/* from libunity */
+	public static void hsv_to_rgb (float hue, float sat, float val,
+								   out float r, out float g, out float b)
+	{
+		int    i;
+		float f, w, q, t;
+
+		if (sat == 0.0)
+		{
+			r = g = b = val;
+		}
+		else
+		{
+			if (hue == 1.0)
+				hue = 0.0f;
+
+			hue *= 6.0f;
+
+			i = (int) hue;
+			f = hue - i;
+			w = val * (1.0f - sat);
+			q = val * (1.0f - (sat * f));
+			t = val * (1.0f - (sat * (1.0f - f)));
+
+			switch (i)
+			{
+			case 0:
+				r = val;
+				g = t;
+				b = w;
+				break;
+			case 1:
+				r = q;
+				g = val;
+				b = w;
+				break;
+			case 2:
+				r = w;
+				g = val;
+				b = t;
+				break;
+			case 3:
+				r = w;
+				g = q;
+				b = val;
+				break;
+			case 4:
+				r = t;
+				g = w;
+				b = val;
+				break;
+			case 5:
+				r = val;
+				g = w;
+				b = q;
+				break;
+			}
+		}
+	}
+
+    static void color_to_hls(Gdk.Color color, out float hue, out float luminance, out float saturation) {
+        float red, green, blue;
+        float h, l, v;
+        
+        red = color.red / 65535.0f;
+        green = color.green / 65535.0f;
+        blue = color.blue / 65535.0f;
+
+		rgb_to_hsv(red, green, blue, out h, out l, out v);
+
+        hue = h;
+        luminance = l;
+        saturation = v;
+    }
+
+    static void color_from_hls(float hue, float luminance, float saturation, out Gdk.Color color) {
+		float red, green, blue;
+
+		hsv_to_rgb(hue, luminance, saturation, out red, out green, out blue);
+
+        color.red = (uint16) Math.floorf(red * 65535.0f + 0.5f);
+        color.green = (uint16) Math.floorf(green * 65535.0f + 0.5f);
+        color.blue = (uint16) Math.floorf(blue * 65535.0f + 0.5f);
+    }
+
+    static Gdk.Color shade(Gdk.Color color) {
+        float h;
+        float l;
+        float s;
+        float factor;
+        Utils.Color.color_to_hls(color, out h, out l, out s);
+
+        if (l > 0.5) {
+            // Colour is light, lets darken it
+            factor = 0.6f;
+        } else {
+            // Colour is dark, lets lighten it
+            factor = 1.4f;
+        }
+    
+        l *= factor;
+        if (l > 1.0f) {
+            l = 1.0f;
+        } else if (l < 0) {
+            l = 0;
+        }
+    
+        s*= factor;
+        if (s > 1.0f) {
+            s= 1.0f;
+        } else if (s < 0) {
+            s = 0;
+        }
+
+        Gdk.Color new_color;
+        Utils.Color.color_from_hls(h, l, s, out new_color);
+        
+        return new_color;
+    }
+}
+
+namespace Utils.Gui {
+    static Gtk.Builder new_builder(string path) {
+        var builder = new Gtk.Builder();
+        try {
+            builder.add_from_file(path);
+        } catch (Error e) {
+            logger.debug(@"Can't find $path.");
+        }
+        builder.set_translation_domain("indicator-network-settings");
+        return builder;
+    }
+}
 
=== added directory 'src/settings/frontend/widgets'
=== added file 'src/settings/frontend/widgets/cellrenderers.vala'
--- src/settings/frontend/widgets/cellrenderers.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/widgets/cellrenderers.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,224 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public const double PI = 3.1415926535897931;
+public const double PI_OVER_180 = 0.017453292519943295;
+
+class PinCellRenderer : Gtk.CellRenderer {
+
+    public string color { get; set; }
+
+    private const string RED_FILL = "#ef2929";
+    private const string RED_STROKE = "#a40000";
+    private const string GREEN_FILL = "#8ae234";
+    private const string GREEN_STROKE = "#4e9a06";
+    private const string YELLOW_FILL = "#fce94f";
+    private const string YELLOW_STROKE = "#c4a000";
+    private const string GREY_FILL = "#d3d7cf";
+    private const string GREY_STROKE = "#555753";
+
+    // Minimum size + (minimum padding times 2)
+    private const int MIN_CELL_WIDTH = 8 + (4 * 2);
+    private const int MIN_CELL_HEIGHT = 8 + (4 * 2);
+
+    // Ratio of radius of pin to width/height of cell
+    private const double PIN_RADIUS = 0.5;
+
+    public PinCellRenderer() {
+        GLib.Object ();
+    }
+    
+    public override void get_size(Gtk.Widget widget, Gdk.Rectangle? cell_area,
+                                   out int x_offset, out int y_offset,
+                                   out int width, out int height) {
+        if (&x_offset != null) x_offset = 0;
+        if (&y_offset != null) y_offset = 0;
+        if (&width != null) width = this.MIN_CELL_WIDTH;
+        if (&height != null) height = this.MIN_CELL_HEIGHT;
+    }
+
+    public override void render(Gdk.Window window, Gtk.Widget widget,
+                                    Gdk.Rectangle background_area,
+                                    Gdk.Rectangle cell_area,
+                                    Gdk.Rectangle expose_area,
+                                    Gtk.CellRendererState flags) {
+                                        
+        var cr = Gdk.cairo_create(window);
+        
+        var x = cell_area.x;
+        var y = cell_area.y;
+        var width = cell_area.width;
+        var height = cell_area.height;
+
+        var lower_dimension = this.get_lower_dimension(width, height);
+        var pin_radius = (int) lower_dimension * this.PIN_RADIUS;
+
+        var x_offset = (width - lower_dimension) / 2;
+        var y_offset = (height - lower_dimension) / 2;
+
+        cr.arc(x+x_offset+pin_radius, y+y_offset+pin_radius, pin_radius/2, 0, 2 * Math.PI);
+
+        var stroke_string = "";
+        var fill_string = "";
+
+        switch (this.color) {
+            case "red":
+                stroke_string = this.RED_STROKE;
+                fill_string = this.RED_FILL;
+                break;
+            case "green":
+                stroke_string = this.GREEN_STROKE;
+                fill_string = this.GREEN_FILL;
+                break;
+            case "yellow":
+                stroke_string = this.YELLOW_STROKE;
+                fill_string = this.YELLOW_FILL;
+                break;
+            case "grey":
+                stroke_string = this.GREY_STROKE;
+                fill_string = this.GREY_FILL;
+                break;
+        }
+        
+        var stroke = Gdk.Color();
+        stroke.parse(stroke_string, out stroke);
+        var fill = Gdk.Color();
+        fill.parse(fill_string, out fill);
+
+        cr.set_source_rgb((double) stroke.red / 65535.0,
+                        (double) stroke.green / 65535.0,
+                        (double) stroke.blue / 65535.0);
+        cr.stroke_preserve();
+
+        cr.set_source_rgb((double) fill.red / 65535.0,
+                        (double) fill.green / 65535.0,
+                        (double) fill.blue / 65535.0);  
+        cr.fill();
+    }
+
+    private float get_lower_dimension(float n1, float n2) {
+        if (n1 > n2) {
+            return n2;
+        }
+        return n1;
+    }
+}
+
+
+class SignalStrengthCellRenderer : Gtk.CellRenderer {
+    
+    public double strength { get; set; }
+
+    private Gtk.Widget style_widget;
+    private Gtk.Widget state_widget;
+    
+    // Minimum size + (minimum padding times 2)
+    private const int MIN_CELL_WIDTH = 20 + (5 * 2);
+    private const int MIN_CELL_HEIGHT = 8 + (6 * 2);
+
+    // Ratio of width/height of bar to width/height of cell
+    private const double BAR_WIDTH = 0.8;
+    private const double BAR_HEIGHT = 0.45;
+
+    private const int CORNER_RADIUS = 3;
+
+    public SignalStrengthCellRenderer(Gtk.Widget style_widget, Gtk.Widget state_widget) {
+        GLib.Object();
+        this.style_widget = style_widget;
+        this.state_widget = state_widget;
+    }
+
+    public override void get_size(Gtk.Widget widget, Gdk.Rectangle? cell_area,
+                                   out int x_offset, out int y_offset,
+                                   out int width, out int height) {
+        if (&x_offset != null) x_offset = 0;
+        if (&y_offset != null) y_offset = 0;
+        if (&width != null) width = this.MIN_CELL_WIDTH;
+        if (&height != null) height = this.MIN_CELL_HEIGHT;
+    }
+
+    public override void render(Gdk.Window window, Gtk.Widget widget,
+                                    Gdk.Rectangle background_area,
+                                    Gdk.Rectangle cell_area,
+                                    Gdk.Rectangle expose_area,
+                                    Gtk.CellRendererState flags) {
+
+        var cr = Gdk.cairo_create(window);
+        
+        var x = (int) cell_area.x;
+        var y = (int) cell_area.y;
+        var width = (int) cell_area.width;
+        var height = (int) cell_area.height;
+        
+        var bar_width = (int) (width * this.BAR_WIDTH);
+        var bar_height = (int) (height * this.BAR_HEIGHT);
+
+        var x_offset = (int) ((width - bar_width) / 2);
+        var y_offset = (int) ((height - bar_height) / 2);
+
+        var state = this.state_widget.state;
+
+        var bg_fill = this.style_widget.style.bg[state];
+        var bg_stroke = this.style_widget.style.dark[state];
+        
+        var fg_fill = this.style_widget.style.mid[state];
+        var fg_stroke = this.style_widget.style.dark[state];
+
+        this.draw_rounded_rectangle(cr, x+x_offset, y+y_offset,
+            x+x_offset+bar_width, y+y_offset+bar_height,
+            bg_fill, bg_stroke);
+
+        if (this.strength == 0) {
+            stdout.printf("strength = 0\n\n");
+        }
+        
+            
+        this.draw_rounded_rectangle(cr, x+x_offset, y+y_offset,
+            x+x_offset+((int) (bar_width*this.strength)), y+y_offset+bar_height,
+            fg_fill, fg_stroke);
+    }
+
+    private void draw_rounded_rectangle(Cairo.Context cr, int x, int y,
+                        int w, int h, Gdk.Color fill, Gdk.Color stroke) {
+        this.layout_rounded_rectangle(cr, x, y, w, h);
+
+        cr.set_source_rgb((double) stroke.red / 65535.0,
+                        (double) stroke.green / 65535.0,
+                        (double) stroke.blue / 65535.0);
+        cr.stroke_preserve();
+        
+        cr.set_source_rgb((double) fill.red / 65535.0,
+                        (double) fill.green / 65535.0,
+                        (double) fill.blue / 65535.0);  
+        cr.fill();
+    }
+        
+    private void layout_rounded_rectangle(Cairo.Context cr, int x, int y,
+                                            int w, int h) {
+        var r = this.CORNER_RADIUS;
+
+        cr.new_sub_path();
+        cr.arc(r+x, r+y, r, PI, 270*PI_OVER_180);
+        cr.arc(w-r, r+y, r, 270*PI_OVER_180, 0);
+        cr.arc(w-r, h-r, r, 0, 90*PI_OVER_180);
+        cr.arc(r+x, h-r, r, 90*PI_OVER_180, PI);
+        cr.close_path();
+    }
+}
 
=== added directory 'src/settings/frontend/widgets/device-boxes'
=== added file 'src/settings/frontend/widgets/device-boxes/base.vala'
--- src/settings/frontend/widgets/device-boxes/base.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/widgets/device-boxes/base.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,26 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public abstract class DeviceBox : Gtk.VBox {
+    /* A gtk.VBox which holds all of the widgets to control a device */
+
+    public DeviceBox() {}
+    public abstract void on_device_state_changed(DeviceState state);
+}
 
=== added file 'src/settings/frontend/widgets/device-boxes/bluetooth.vala'
--- src/settings/frontend/widgets/device-boxes/bluetooth.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/widgets/device-boxes/bluetooth.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,35 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+class BluetoothBox : DeviceBox {
+
+    /* A Gtk.VBox which holds all of the widgets to control a bluetooth
+      device. */
+
+    private Device device;
+
+    public BluetoothBox(Device device, string datadir) {
+        this.set_spacing(12);
+        this.device = device;
+        this.device.state_changed.connect(this.on_device_state_changed);
+    }
+
+    public override void on_device_state_changed(DeviceState state) {}
+}
 
=== added file 'src/settings/frontend/widgets/device-boxes/mobile.vala'
--- src/settings/frontend/widgets/device-boxes/mobile.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/widgets/device-boxes/mobile.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,151 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+class MobileBox : DeviceBox {
+
+    /* A Gtk.VBox which holds all of the widgets to control a mobile
+      device. It contains an InfoBox and ToggleSwitch to control and
+      monitor the state of the mobile device, and a set of widgets
+      to enter details about the mobile network to connect to. */
+
+    private Device device;
+    private InfoBox infobox;
+    private ToggleSwitch toggleswitch;
+    private Gtk.Label label_status;
+    private Gtk.Builder builder;
+    private Gtk.Table table_settings;
+    private Gtk.Entry entry_pin;
+    private Gtk.CheckButton checkbutton_show_pin;
+
+    private bool device_editable;
+    private bool settings_editable;
+
+    private const string[] sensitive_widgets = {"label_apn_place", "label_apn",
+                                        "label_pin_auth", "checkbutton_show_pin"};
+
+    public MobileBox(Device device, string datadir) {
+        this.set_spacing(12);
+        this.device = device;
+        this.device.state_changed.connect(this.on_device_state_changed);
+
+        // Infobox and Togglswitch
+        /// Creation
+        this.infobox = new InfoBox(false, 12);
+        this.toggleswitch = new ToggleSwitch();
+        this.label_status = new Gtk.Label(null);
+        /// Padding and alignment
+        this.label_status.set_alignment(0, 0.5f);
+        this.infobox.set_border_width(10);
+        /// Packing
+        this.infobox.pack_start(this.label_status, true, true);
+        this.infobox.pack_start(this.toggleswitch, false, true);
+        this.pack_start(this.infobox, false, false);
+        /// Connect signals;
+        this.toggleswitch.toggled.connect(this.on_toggleswitch_toggled);
+
+        // Network Settings
+        /// Creation
+        this.builder = Utils.Gui.new_builder(datadir+"ui/mobile_box.ui");
+        this.get_widgets();
+        this.connect_signals();
+        /// Packing
+        this.pack_start(this.table_settings, true, true);
+
+        this.update_widget_states(this.device.get_state());
+        this.on_checkbutton_show_pin_toggled();
+    }
+
+    private void get_widgets() {
+        this.table_settings = this.builder.get_object("table_settings") as Gtk.Table;
+        this.entry_pin = this.builder.get_object("entry_pin") as Gtk.Entry;
+        this.checkbutton_show_pin = this.builder.get_object("checkbutton_show_pin") as Gtk.CheckButton;
+    }
+    
+    private void connect_signals() {
+        this.checkbutton_show_pin.toggled.connect(this.on_checkbutton_show_pin_toggled);
+    }
+
+    private void update_widget_states(DeviceState state) {
+        bool toggleswitch_state = false;
+        string status_text = "";
+
+        switch (state) {
+            case DeviceState.CONNECTED:
+                this.device_editable = true;
+                this.settings_editable = false;
+                toggleswitch_state = true;
+                status_text = ("Connected to “Vodafone UK”.");
+                break;
+            case DeviceState.ONLINE:
+                this.device_editable = true;
+                this.settings_editable = false;
+                toggleswitch_state = true;
+                status_text = ("Connected to the Internet on “Vodafone UK”.");
+                break;
+            case DeviceState.OFF:
+                this.device_editable = false;
+                this.settings_editable = true;
+                toggleswitch_state = false;
+                status_text = ("The Mobile Broadband device is powered off.");
+                break;
+            case DeviceState.OFFLINE:
+                this.device_editable = true;
+                this.settings_editable = true;
+                toggleswitch_state = false;
+                status_text = ("Mobile Broadband is offline.");
+                break;
+        }
+            
+        this.toggleswitch.set_sensitive(this.device_editable);
+        this.toggleswitch.set_active(toggleswitch_state);
+        this.label_status.set_text(status_text);
+
+        this.table_settings.foreach(this.sensitise_widgets);
+        }
+
+    private void sensitise_widgets(Gtk.Widget widget) {
+        
+        var name = widget.get_name();
+        if (name in this.sensitive_widgets) {
+            widget.set_sensitive(this.device_editable);
+        } else if (!(widget is Gtk.Box)) {
+            widget.set_sensitive(this.settings_editable);
+        } else {
+            var container = widget as Gtk.Container;
+            container.foreach(this.sensitise_widgets);
+        }
+    }
+    
+    public override void on_device_state_changed(DeviceState state) {
+        this.update_widget_states(state);
+    }
+    
+    private void on_toggleswitch_toggled() {
+        if (this.toggleswitch.get_active()) {
+            this.device.set_state(DeviceState.CONNECTED);
+        } else {
+            this.device.set_state(DeviceState.OFFLINE);
+        }
+    }
+
+    private void on_checkbutton_show_pin_toggled() {
+        this.entry_pin.set_visibility(this.checkbutton_show_pin.get_active());
+    }
+}
 
=== added file 'src/settings/frontend/widgets/device-boxes/wired.vala'
--- src/settings/frontend/widgets/device-boxes/wired.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/widgets/device-boxes/wired.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,35 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+class WiredBox : DeviceBox {
+
+    /* A Gtk.VBox which holds all of the widgets to control a wired
+      device. */
+
+    private Device device;
+
+    public WiredBox(Device device, string datadir) {
+        this.set_spacing(12);
+        this.device = device;
+        this.device.state_changed.connect(this.on_device_state_changed);
+    }
+
+    public override void on_device_state_changed(DeviceState state) {}
+}
 
=== added file 'src/settings/frontend/widgets/device-boxes/wireless.vala'
--- src/settings/frontend/widgets/device-boxes/wireless.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/widgets/device-boxes/wireless.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,183 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public class WirelessBox : DeviceBox {
+
+    /* A Gtk.VBox which holds all of the widgets to control a wireless
+      device. It contains an InfoBox and ToggleSwitch to control and
+      monitor the state of the wireless device, and a
+      WirelessConnectionView to connect to and remember details for
+      wireless networks. */
+
+    private string datadir;
+    private Device device;
+    private InfoBox infobox;
+    private ToggleSwitch toggleswitch;
+    private Gtk.Label label_status;
+    private Gtk.Builder builder;
+    private WirelessConnectionView treeview_connections;
+    private Gtk.VBox vbox_connections;
+    private Gtk.Button button_connect;
+    private Gtk.Button button_forget;
+    private Gtk.Button button_edit;
+    private Gtk.ScrolledWindow scrolledwindow_connections;
+
+    public WirelessBox(Device device, string datadir) {
+        this.set_spacing(12);
+        this.datadir = datadir;
+        this.device = device;
+        this.device.state_changed.connect(this.on_device_state_changed);
+
+        // Infobox and Togglswitch
+        /// Creation
+        this.infobox = new InfoBox(false, 12);
+        this.toggleswitch = new ToggleSwitch();
+        this.label_status = new Gtk.Label(null);
+        /// Padding and alignment
+        this.label_status.set_alignment(0, 0.5f);
+        this.infobox.set_border_width(10);
+        /// Packing
+        this.infobox.pack_start(this.label_status, true, true);
+        this.infobox.pack_start(this.toggleswitch, false, true);
+        this.pack_start(this.infobox, false, false);
+        /// Connect signals;
+        this.toggleswitch.toggled.connect(this.on_toggleswitch_toggled);
+
+        // Network Settings
+        /// Creation
+        this.builder = Utils.Gui.new_builder(datadir+"ui/wireless_box.ui");
+        this.get_widgets();
+        this.connect_signals();
+        /// Packing
+        this.pack_start(this.vbox_connections, true, true);
+
+        // Connection View
+        /// Creation
+        var connection_store = new WirelessConnectionStore();
+        this.treeview_connections = new WirelessConnectionView(connection_store,
+                                                this.button_connect);
+        /// Packing
+        this.scrolledwindow_connections.add(this.treeview_connections);
+        /// Connect signals
+        this.treeview_connections.get_selection().changed.connect(this.on_treeview_connections_selection_changed);
+        /// Population
+        var connections = get_remembered_wireless_connections(device);
+        foreach (var connection in connections) {
+            this.add_connection(connection);
+        }
+
+        this.update_widget_states(this.device.get_state());
+        this.on_treeview_connections_selection_changed();
+    }
+
+    private void get_widgets() {
+        this.vbox_connections = this.builder.get_object("vbox_connections") as Gtk.VBox;
+        this.button_connect = this.builder.get_object("button_connect") as Gtk.Button;
+        this.button_forget = this.builder.get_object("button_forget") as Gtk.Button;
+        this.button_edit = this.builder.get_object("button_edit") as Gtk.Button;
+        this.scrolledwindow_connections = this.builder.get_object("scrolledwindow_connections") as Gtk.ScrolledWindow;
+    }
+
+    private void connect_signals() {
+        this.button_connect.clicked.connect(this.on_button_connect_clicked);
+        this.button_edit.clicked.connect(this.on_button_edit_clicked);
+    }
+
+    private void update_widget_states(DeviceState state) {
+        bool device_editable = false;
+        bool settings_editable = false;
+        bool toggleswitch_state = false;
+        string status_text = "";
+        
+        switch (state) {
+            case DeviceState.CONNECTED:
+                device_editable = true;
+                settings_editable = true;
+                toggleswitch_state = true;
+                status_text = ("Wi-fi is on but not connected to the Internet.");
+                break;
+            case DeviceState.ONLINE:
+                device_editable = true;
+                settings_editable = true;
+                toggleswitch_state = true;
+                status_text = ("Wi-fi is on and connected to the Internet.");
+                break;
+            case DeviceState.OFF:
+                device_editable = false;
+                settings_editable = false;
+                toggleswitch_state = false;
+                status_text = ("The Wi-fi device is powered off.");
+                break;
+            case DeviceState.OFFLINE:
+                device_editable = true;
+                settings_editable = false;
+                toggleswitch_state = false;
+                status_text = ("Wi-fi is offline.");
+                break;
+        }
+
+        this.vbox_connections.set_sensitive(settings_editable);
+        this.toggleswitch.set_sensitive(device_editable);
+        this.toggleswitch.set_active(toggleswitch_state);
+        this.label_status.set_text(status_text);
+    }
+
+    private void add_connection(WifiConnection connection) {
+        var name = connection.name;
+        var signal = connection.signal;
+        var last_used = connection.last_used;
+
+        var liststore = this.treeview_connections.get_model() as WirelessConnectionStore;
+        liststore.add_connection(connection, name, signal, last_used);
+    }
+    
+    public override void on_device_state_changed(DeviceState state) {
+        this.update_widget_states(state);
+    }
+
+    private void on_toggleswitch_toggled() {
+        if (this.toggleswitch.get_active()) {
+            this.device.set_state(DeviceState.CONNECTED);
+        } else {
+            this.device.set_state(DeviceState.OFFLINE);
+        }
+    }
+
+   private void on_button_connect_clicked() {
+        var connection = this.treeview_connections.get_selected_connection();
+        connection.connect_("password");
+    }
+    
+   private void on_button_edit_clicked() {
+        var connection = this.treeview_connections.get_selected_connection();
+        var dialog = new EditConnectionDialog(connection, this.datadir);
+        //FIXME: make this work
+        //dialog.response.connect(() => { delete dialog; });
+        dialog.run();
+    }
+
+    private void on_treeview_connections_selection_changed() {
+        bool path_is_selected = (this.treeview_connections.get_selected_connection() != null);
+        
+        this.button_connect.set_sensitive(path_is_selected);
+        this.button_forget.set_sensitive(path_is_selected);
+        this.button_edit.set_sensitive(path_is_selected);
+    }
+}
 
=== added directory 'src/settings/frontend/widgets/dialogs'
=== added file 'src/settings/frontend/widgets/dialogs/edit-connection.vala'
--- src/settings/frontend/widgets/dialogs/edit-connection.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/widgets/dialogs/edit-connection.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,165 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public class EditConnectionDialog : GLib.Object {
+
+    public signal void response(int type);
+
+    private WifiConnection connection;
+    private Gtk.Builder builder;
+
+    private Gtk.Window dialog;
+    private Gtk.Table table_main;
+    private Gtk.Button button_save;
+    private Gtk.Button button_cancel;
+    private Gtk.Entry entry_name;
+    private Gtk.Entry entry_ssid;
+    private Gtk.Entry entry_bssid;
+    private Gtk.ComboBox combobox_mode;
+    private Gtk.CheckButton checkbutton_autoconnect;
+    private Gtk.CheckButton checkbutton_share_settings;
+
+    private string[] hint_labels = {"label_hint_name", "label_hint_ssid",
+                                    "label_hint_bssid","label_hint_mode"};
+
+    public EditConnectionDialog(WifiConnection connection, string datadir) {
+        this.connection = connection;
+
+        /// Creation
+        this.builder = Utils.Gui.new_builder(datadir+"ui/edit_connection_dialog.ui");
+        this.get_widgets();
+        this.create_extra_widgets();
+        
+        this.connect_signals();
+        this.update_widget_values();
+    }
+
+    private void create_extra_widgets() {
+        // Creation
+        this.combobox_mode = new Gtk.ComboBox.text();
+
+        // Population
+        WirelessMode[] wireless_modes = {WirelessMode.INFRASTRUCTURE, WirelessMode.ADHOC};
+        foreach (var mode in wireless_modes) {
+            this.combobox_mode.append_text(mode.get_name());
+        }
+
+        // Packing
+        this.table_main.attach(this.combobox_mode, 1, 2, 6, 7, Gtk.AttachOptions.FILL, Gtk.AttachOptions.FILL, 0, 0);
+
+        // Setup hint labels
+        foreach (var hint_label in this.hint_labels) {
+            var hint_label_widget = this.builder.get_object(hint_label) as Gtk.Label;
+            hint_label_widget.realize.connect(() => {
+                                                    var state = hint_label_widget.get_state();
+                                                    var color = hint_label_widget.style.fg[state];
+                                                    var new_color = Utils.Color.shade(color);
+                                                    hint_label_widget.modify_fg(state, new_color);
+                                                    });
+        }
+    }
+
+    private void get_widgets() {
+        this.dialog = this.builder.get_object("window_main") as Gtk.Window;
+        this.table_main = this.builder.get_object("table_main") as Gtk.Table;
+        this.button_save = this.builder.get_object("button_save") as Gtk.Button;
+        this.button_cancel = this.builder.get_object("button_cancel") as Gtk.Button;
+        
+        this.entry_name = this.builder.get_object("entry_name") as Gtk.Entry;
+        this.entry_ssid = this.builder.get_object("entry_ssid") as Gtk.Entry;
+        this.entry_bssid = this.builder.get_object("entry_bssid") as Gtk.Entry;
+        this.checkbutton_autoconnect = this.builder.get_object("checkbutton_autoconnect") as Gtk.CheckButton;
+        this.checkbutton_share_settings = this.builder.get_object("checkbutton_share_settings") as Gtk.CheckButton;
+    }
+
+    private void connect_signals() {
+        this.button_save.clicked.connect(this.on_button_save_clicked);
+        this.button_cancel.clicked.connect(this.on_button_cancel_clicked);
+    }
+
+    private void update_widget_values() {
+        var name = this.connection.name;
+        var ssid = this.connection.ssid;
+        var bssid = this.connection.bssid;
+        var mode = this.connection.mode;
+        var autoconnect = this.connection.autoconnect;
+        var share_settings = this.connection.share_settings;
+
+        if (name == null) {
+            this.entry_name.set_text("");
+        } else {
+            this.entry_name.set_text(name);
+        }
+        if (ssid == null) {
+            this.entry_ssid.set_text("");
+        } else {
+            this.entry_ssid.set_text(ssid);
+        }
+        if (bssid == null) {
+            this.entry_bssid.set_text("");
+        } else {
+            this.entry_bssid.set_text(bssid);
+        }
+        
+        this.combobox_mode.set_active(mode);
+        this.checkbutton_autoconnect.set_active(autoconnect);
+        this.checkbutton_share_settings.set_active(share_settings);
+    }
+    
+    private void save_widget_values() {
+        string? name = this.entry_name.get_text();
+        string? ssid = this.entry_ssid.get_text();
+        string? bssid = this.entry_bssid.get_text();
+        WirelessMode mode = (WirelessMode) this.combobox_mode.get_active();
+        var autoconnect = this.checkbutton_autoconnect.get_active();
+        var share_settings = this.checkbutton_share_settings.get_active();
+
+        if (name == "") {
+           name = null;
+        } if (ssid == "") {
+            ssid = null;
+        } if (bssid == "") {
+            bssid = null;
+        }
+
+        this.connection.name = name;
+        this.connection.ssid = ssid;
+        this.connection.bssid = bssid;
+        this.connection.mode = mode;
+        this.connection.autoconnect = autoconnect;
+        this.connection.share_settings = share_settings;
+    }
+
+    private void on_button_save_clicked() {
+        this.save_widget_values();
+        this.dialog.destroy();
+        this.response(Gtk.ResponseType.APPLY);
+    }
+    
+    private void on_button_cancel_clicked() {
+        this.dialog.destroy();
+        this.response(Gtk.ResponseType.CANCEL);
+    }
+
+    public int run() {
+        this.dialog.show_all();
+		return 0;
+    }
+}
 
=== added file 'src/settings/frontend/widgets/infobox.vala'
--- src/settings/frontend/widgets/infobox.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/widgets/infobox.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,63 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+class InfoBox : Gtk.HBox {
+    
+    /* A gtk.HBox that is filled with the mid-colour and stroked with
+    the dark colour from a user's gtk theme so that it stands out. */
+
+    private const int YPAD = 1;
+    private const int XPAD = 1;
+    
+    public InfoBox(bool homogeneous=false, int spacing=0) {
+        this.set_homogeneous(homogeneous);
+        this.set_spacing(spacing);
+        this.expose_event.connect(this.on_expose_event);
+    }
+
+    public bool on_expose_event(Gdk.EventExpose event) {
+        var cr = Gdk.cairo_create(window);
+
+        // Get geometry
+        var x = (int) (this.allocation.x + this.XPAD);
+        var y = (int) (this.allocation.y + this.YPAD);
+        var width = (int) (this.allocation.width - (this.XPAD * 2));
+        var height = (int) (this.allocation.height - (this.YPAD * 2));
+
+        // Fill with the mid color from the current gtk theme
+        var fill = this.style.mid[this.state];
+        // Fill with the dark color from the current gtk theme
+        var stroke = this.style.dark[this.state];
+
+        // Layout the rectangle
+        cr.rectangle(x, y, width, height);
+        // Stroke the outline
+        cr.set_source_rgb((double) stroke.red / 65535.0,
+                        (double) stroke.green / 65535.0,
+                        (double) stroke.blue / 65535.0);
+        cr.stroke_preserve();
+        // Fill it in
+        cr.set_source_rgb((double) fill.red / 65535.0,
+                        (double) fill.green / 65535.0,
+                        (double) fill.blue / 65535.0);  
+        cr.fill();
+        return false;
+    }
+}
 
=== added file 'src/settings/frontend/widgets/stores.vala'
--- src/settings/frontend/widgets/stores.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/widgets/stores.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,143 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public enum DeviceStoreCol {
+    DEVICE_OBJ,
+    SETTINGS_BOX,
+    PIN,
+    ICON,
+    LABEL
+}
+
+class DeviceStore : Gtk.ListStore {
+
+    private Gtk.IconTheme icons;
+    
+    private Gtk.TreeIter? device_iter;
+    
+    public DeviceStore(Gtk.IconTheme icons) {
+        Type[] column_types;
+        column_types = {typeof(Device), typeof(Gtk.VBox),
+                                typeof(string), typeof(Gdk.Pixbuf),
+                                typeof(string)};
+        this.set_column_types(column_types);
+        this.icons = icons;
+    }
+
+    public void add_device(Device device, Gtk.VBox settings_box) {
+        device.state_changed.connect(this.on_device_state_changed);
+        
+        var pin_color = this.get_pin_color(device.state);
+        var caption = device.state.get_name();
+        var label = device.type.get_name();
+        var icon = device.type.get_icon_name();
+        var markup = this.get_markup(label, caption);
+
+        Gdk.Pixbuf icon_pixbuf = null;
+        try {
+            icon_pixbuf = this.icons.load_icon(icon, 16, Gtk.IconLookupFlags.USE_BUILTIN);
+        } catch (Error e) {
+            var fallback_icon = DeviceType.GENERIC.get_icon_name();
+            logger.debug(@"Can't find '$icon' icon in your Gtk IconTheme, using '$fallback_icon' instead.");
+			try {
+				icon_pixbuf = this.icons.load_icon(fallback_icon, 16,
+												   Gtk.IconLookupFlags.USE_BUILTIN);
+			} catch (Error e) {
+				logger.info("Failed to load fallback icon.");
+			}
+        }
+
+        Gtk.TreeIter iter;
+        this.append(out iter);
+        this.set(iter, 0, device, 1, settings_box, 2, pin_color, 3, icon_pixbuf, 4, markup);
+    }
+
+    private void on_device_state_changed(Device device, DeviceState state) {
+        var iter = this.get_iter_for_device(device);
+        var pin_color = this.get_pin_color(state);
+        var caption = state.get_name();
+        var label = device.type.get_name();
+        
+        var markup = this.get_markup(label, caption);
+        
+        this.set_value(iter, DeviceStoreCol.PIN, pin_color);
+        this.set_value(iter, DeviceStoreCol.LABEL, markup);
+    }
+
+    private Gtk.TreeIter get_iter_for_device(Device device) {
+        this.device_iter = null;
+        this.foreach((model, path, iter) => {
+            GLib.Value value;
+            model.get_value(iter, DeviceStoreCol.DEVICE_OBJ, out value);
+            if ((value.get_object() as Device) == device) {
+                this.device_iter = iter;
+                return true;
+            }
+            return false;
+        });
+        return this.device_iter;
+    }
+
+    private string get_pin_color(DeviceState state) {
+        switch (state) {
+        case DeviceState.OFF:
+            return "grey";
+        case DeviceState.OFFLINE:
+            return "red";
+        case DeviceState.CONNECTED:
+            return "yellow";
+        case DeviceState.ONLINE:
+            return "green";
+        default:
+            assert_not_reached();
+        }
+    }
+
+    private string get_markup(string label, string caption) {
+        return @"$label\n<span font_size='small'>$caption</span>";
+    }
+}
+
+
+public enum WirelessConnectionStoreCol {
+    CONNECTION_OBJ,
+    NETWORK,
+    SIGNAL,
+    LAST_USED
+}
+
+class WirelessConnectionStore : Gtk.ListStore {
+
+    public WirelessConnectionStore() {
+        Type[] column_types;
+        column_types = {typeof(WifiConnection), typeof(string),
+                                typeof(double), typeof(string)};
+        this.set_column_types(column_types);
+    }
+
+    public void add_connection(WifiConnection obj, string network,
+                                double signal, string last_used) {
+        Gtk.TreeIter iter;
+        this.append(out iter);
+        this.set(iter, 0, obj, 1, network, 2, signal, 3, last_used);
+    }
+}
+
+
 
=== added file 'src/settings/frontend/widgets/toggleswitch.vala'
--- src/settings/frontend/widgets/toggleswitch.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/widgets/toggleswitch.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,356 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public class ToggleSwitch : Gtk.EventBox {
+
+    // A switch containing the values ON and OFF (or user-inputed) that
+    // hides the inactive value. It can be clicked or dragged to change
+    // state, or through an enter/return keypress.
+    
+    public signal void clicked();
+    public signal void toggled();
+
+    // (In relation to the height of the slider)
+    private double LINE_HEIGHT_RATIO = 9.0/25.0;
+    private double LINE_SPACING_RATIO = 5.0/38.0;
+    private double CORNER_RADIUS = 3.0;
+
+    // (In relation to the width/height of the text)
+    private double TEXT_XPAD = 0.4;
+    private double TEXT_YPAD = 0.35;
+
+    private string[] values={"ON", "OFF"};
+    private Pango.Layout? layout = null;
+    private Atk.Object? atk = null;
+
+    public bool active = false;
+    
+   public ToggleSwitch() {
+        this.set_visible_window(false);
+        this.app_paintable = true;
+        this.double_buffered = false;
+
+        // Set events for the widget to receive
+        this.set_can_focus(true);
+        this.set_events(Gdk.EventMask.KEY_PRESS_MASK|
+                        Gdk.EventMask.ENTER_NOTIFY_MASK|
+                        Gdk.EventMask.LEAVE_NOTIFY_MASK|
+                        Gdk.EventMask.BUTTON_PRESS_MASK|
+                        Gdk.EventMask.BUTTON_RELEASE_MASK);
+
+        // Connect signls and callbacks
+        this.style_set.connect(this.on_style_set);
+        this.expose_event.connect(this.on_expose_event);
+        this.button_press_event.connect(this.on_press);
+        this.button_release_event.connect(this.on_release);
+        this.key_release_event.connect(this.on_key_release);
+        this.enter_notify_event.connect(this.on_enter);
+        this.leave_notify_event.connect(this.on_leave);
+        this.motion_notify_event.connect(this.on_motion_notify_event);
+
+        // Calculate the best size
+        int calc_width;
+        int calc_height;
+        this.calculate_size(out calc_width, out calc_height);
+        this.set_size_request(calc_width, calc_height);
+
+        this.update_atk();
+    }
+
+    private void calculate_size(out int width, out int height) {
+        // Calculate the best size for the toggleswitch based on the
+        // dimensions of the user's default font.
+        this.layout = this.create_pango_layout(null);
+        
+        this.layout.set_text(this.values[0], -1);
+
+        Pango.Rectangle extents;
+        
+        this.layout.get_pixel_extents(null, out extents);
+        var text_width = extents.width;
+        var text_height = extents.height;
+
+        width = (int) ((text_width+(text_width*this.TEXT_XPAD*2))*2);
+        height = (int) (text_height+(text_height*this.TEXT_YPAD*2));
+    }
+
+    
+    private void draw_widget() {
+        // Do the drawing of the actual widget.
+        var cr = Gdk.cairo_create(this.window);
+
+        // Draw the main background
+        this.draw_background(cr);
+        
+        // Draw the text
+        this.draw_text();
+
+        // Draw the slider
+        this.draw_slider(cr);
+    }
+
+    private void draw_background(Cairo.Context cr) {       
+        int x = this.allocation.x;
+        int y = this.allocation.y;
+        int width = this.allocation.width;
+        int height = this.allocation.height;
+
+        var state = this.state;
+        // Don't change colour of main background on hover or press
+        if ((this.state == Gtk.StateType.PRELIGHT) | (this.state == Gtk.StateType.ACTIVE)) {
+            state = Gtk.StateType.NORMAL;
+        }
+
+        // Get colours from theme
+        var bg_fill = this.style.base[state];
+        var bg_stroke = this.style.dark[state];
+        var left_fill = this.style.light[Gtk.StateType.SELECTED];
+        var left_stroke = this.style.mid[Gtk.StateType.SELECTED];
+        var right_fill = this.style.base[state];
+        var right_stroke = this.style.dark[state];
+
+        // Draw the background of the whole widget
+        this.draw_flat_rounded_rectangle(cr, x, y, width, height, bg_stroke, bg_fill);
+        
+        // Draw the left (highlighted) part
+        this.draw_flat_rounded_rectangle(cr, x, y, width/2, height, left_stroke, left_fill);
+        
+        // Draw the right (normal) part
+        this.draw_flat_rounded_rectangle(cr, x+width/2, y, width/2, height, right_stroke, right_fill);
+    }
+        
+    private void draw_slider(Cairo.Context cr) {
+        int x = this.allocation.x;
+        int y = this.allocation.y;
+        int width = this.allocation.width;
+        int height = this.allocation.height;
+        int x_offset = 0;
+
+        if (this.active) {
+            x_offset = width/2;
+        }
+
+        var stroke = this.style.dark[this.state];
+        Gdk.Color fill1_rectangle;
+        Gdk.Color fill2_rectangle;
+
+        // Don't draw a gradient if insensitive
+        if (this.state == Gtk.StateType.INSENSITIVE) {
+            fill1_rectangle = this.style.bg[this.state];
+            fill2_rectangle = this.style.bg[this.state];
+        } else {
+            fill1_rectangle = this.style.light[this.state];
+            fill2_rectangle = this.style.mid[this.state];
+        }
+
+        // Draw the slider
+        this.draw_rounded_rectangle(cr, x+x_offset, y, width/2, height, stroke, fill1_rectangle, fill2_rectangle);
+
+        // Draw the vertical lines
+        this.draw_vertical_lines(cr, x+x_offset, y, width, height);
+
+    }
+
+    private void draw_vertical_lines(Cairo.Context cr, int x, int y, int width, int height) {
+        var fill_line_dark = this.style.dark[this.state];
+        var fill_line_light = this.style.light[this.state];
+        var line_height = (int) height*this.LINE_HEIGHT_RATIO;
+        var line_spacing = (int) (this.LINE_SPACING_RATIO * (width / 2));
+        
+        var x_offset = ((width / 2) - (6+(line_spacing*2)))/2 + 2;
+        var y_offset = (height  - line_height)/2;
+                         
+        double c_spacing = 0;
+        for (int i=0; i<3; i++) {
+            cr.rectangle(x+x_offset+c_spacing+1, y+y_offset, 1, line_height);
+            cr.set_source_rgb((double) fill_line_dark.red / 65535.0,
+                                (double) fill_line_dark.green / 65535.0,
+                                (double) fill_line_dark.blue / 65535.0);
+            cr.fill();
+            cr.rectangle(x+x_offset+c_spacing, y+y_offset, 1, line_height);
+            cr.set_source_rgb((double) fill_line_light.red / 65535.0,
+                                (double) fill_line_light.green / 65535.0,
+                                (double) fill_line_light.blue / 65535.0);
+            cr.fill();
+            c_spacing += line_spacing;
+        }
+    }
+
+    private void draw_text() {
+        this.draw_centered_text(this.values[0], "left");
+        this.draw_centered_text(this.values[1], "right");
+    }
+
+    private void draw_centered_text(string text, string gravity) {
+        if (this.layout == null) {
+            this.layout = this.create_pango_layout(null);
+        }
+
+        int x = this.allocation.x;
+        int y = this.allocation.y;
+        int width = this.allocation.width;
+        int height = this.allocation.height;
+
+        int x_offset;
+        int y_offset;
+        Pango.Rectangle extents;
+
+        this.layout.set_text(text, -1);
+        this.layout.get_pixel_extents(null, out extents);
+        var text_width = extents.width;
+        var text_height = extents.height;
+
+        x_offset = (width/2 - text_width) / 2;
+        
+        if (gravity == "right") {
+            x_offset += width/2;
+        }
+        
+        y_offset = (height - text_height) / 2;
+        
+        this.style.draw_layout(this.window, this.get_state(), true,
+                                {x, y, width, height},
+                                this, "", x+x_offset, y+y_offset,
+                                this.layout);
+    }
+        
+
+    private void draw_rounded_rectangle(Cairo.Context cr, double x,
+            double y, double w, double h, Gdk.Color stroke, Gdk.Color fill1, Gdk.Color fill2) {
+                
+        var r = this.CORNER_RADIUS;
+        cr.new_sub_path();
+        cr.arc(r+x, r+y, r, PI, 270*PI_OVER_180);
+        cr.arc(x+w-r, r+y, r, 270*PI_OVER_180, 0);
+        cr.arc(x+w-r, y+h-r, r, 0, 90*PI_OVER_180);
+        cr.arc(r+x, y+h-r, r, 90*PI_OVER_180, PI);
+        cr.close_path();
+        
+        cr.set_source_rgb((double) stroke.red / 65535.0,
+                        (double) stroke.green / 65535.0,
+                        (double) stroke.blue / 65535.0);  
+        cr.stroke_preserve();
+
+        var linear = new Cairo.Pattern.linear(x, y, x, y+h);
+        linear.add_color_stop_rgba(0.00, (double) fill1.red / 65535.0,
+                (double) fill1.green / 65535.0, (double) fill1.blue / 65535.0, 1);  
+        linear.add_color_stop_rgba(0.8, (double) fill2.red / 65535.0,
+                (double) fill2.green / 65535.0, (double) fill2.blue / 65535.0, 1);  
+        cr.set_source(linear);
+        cr.fill();
+    }
+    
+    private void draw_flat_rounded_rectangle(Cairo.Context cr, double x,
+            double y, double w, double h, Gdk.Color stroke, Gdk.Color fill) {
+                
+        var r = this.CORNER_RADIUS;
+        cr.new_sub_path();
+        cr.arc(r+x, r+y, r, PI, 270*PI_OVER_180);
+        cr.arc(x+w-r, r+y, r, 270*PI_OVER_180, 0);
+        cr.arc(x+w-r, y+h-r, r, 0, 90*PI_OVER_180);
+        cr.arc(r+x, y+h-r, r, 90*PI_OVER_180, PI);
+        cr.close_path();
+        
+        cr.set_source_rgb((double) stroke.red / 65535.0,
+                        (double) stroke.green / 65535.0,
+                        (double) stroke.blue / 65535.0);  
+        cr.stroke_preserve();
+
+        cr.set_source_rgb((double) fill.red / 65535.0,
+                        (double) fill.green / 65535.0,
+                        (double) fill.blue / 65535.0);  
+        cr.fill();
+    }
+
+    private void update_atk() {
+        // Accessibility info
+        if (this.atk == null) {
+            this.atk = this.get_accessible();
+            this.atk.set_role(Atk.Role.CHECK_BOX);
+        }
+        
+        // Update ATK description, based on state
+        if (this.active) {
+            this.atk.set_name(this.values[0]);
+        } else {
+            this.atk.set_name(this.values[1]);
+        }
+    }
+
+    private void on_style_set(Gtk.Style? style) {
+        int calc_width;
+        int calc_height;
+        
+        this.calculate_size(out calc_width, out calc_height);
+        this.set_size_request(calc_width, calc_height);
+    }
+
+    private bool on_expose_event(Gdk.EventExpose event) {
+        this.draw_widget();
+        return true;
+    }
+
+    private bool on_press(Gdk.EventButton event) {
+        this.set_state(Gtk.StateType.ACTIVE);
+        this.grab_focus();
+        return false;
+    }
+    
+    private bool on_release(Gdk.EventButton event) {
+        this.set_state(Gtk.StateType.PRELIGHT);
+        this.active = !this.active;
+        this.toggled();
+        return false;
+    }
+            
+    private bool on_motion_notify_event(Gdk.EventMotion event) {
+        this.queue_draw();
+        return false;
+    }
+        
+    private bool on_key_release(Gdk.EventKey event) {
+        if (this.has_focus) {
+            if ((Gdk.keyval_name(event.keyval) == "Return") | (Gdk.keyval_name(event.keyval) == "Enter")) {
+                this.toggled();
+            }
+        }
+        return false;
+    }
+
+    private bool on_enter(Gdk.EventCrossing event) {
+        this.set_state(Gtk.StateType.PRELIGHT);
+        return false;
+    }
+
+    private bool on_leave(Gdk.EventCrossing event) {
+        this.set_state(Gtk.StateType.NORMAL);
+		return false;
+    }
+
+    public bool get_active() {
+        return this.active;
+    }
+        
+    public void set_active(bool active) {
+        this.active = active;
+        this.queue_draw();
+    }
+
+}
 
=== added file 'src/settings/frontend/widgets/treeviews.vala'
--- src/settings/frontend/widgets/treeviews.vala	1970-01-01 00:00:00 +0000
+++ src/settings/frontend/widgets/treeviews.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,133 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+class DeviceView : Gtk.TreeView {
+    
+    public signal void reordered();
+
+    private bool dragging = false;
+    
+    public DeviceView (DeviceStore store) {
+        this.set_model(store);
+        
+        // Device (main) Column (contains pin icon, type icon and label)
+        var column = new Gtk.TreeViewColumn();
+        column.set_title(("Device"));
+        var cr_pin = new PinCellRenderer();
+        var cr_icon = new Gtk.CellRendererPixbuf();
+        var cr_label = new Gtk.CellRendererText();
+        column.pack_start(cr_pin, false);
+        column.set_attributes(cr_pin, "color", DeviceStoreCol.PIN);
+        column.pack_start(cr_icon, false);
+        column.set_attributes(cr_icon, "pixbuf", DeviceStoreCol.ICON);
+        column.pack_start(cr_label, true);
+        column.set_attributes(cr_label, "markup", DeviceStoreCol.LABEL);
+        cr_label.set_property("ellipsize", Pango.EllipsizeMode.END);
+        this.append_column(column);
+
+        this.set_headers_visible(false);
+        /* FIXME: when get gtk errors if we enable reordering and
+           try to get the selected path
+        this.set_reorderable(true);*/
+
+        this.drag_begin.connect(this.on_drag_begin);
+        this.drag_end.connect(this.on_drag_end);
+        this.drag_failed.connect(this.on_drag_failed);
+    }
+        
+    private void on_drag_begin(Gdk.DragContext drag_context) {
+        this.dragging = true;
+    }
+
+    private bool on_drag_failed(Gdk.DragContext drag_context, Gtk.DragResult drag_result) {
+        this.dragging = false;
+        return true;
+    }
+
+    private void on_drag_end(Gdk.DragContext drag_context) {
+        if (this.dragging) {
+            this.reordered();
+        }
+    }
+
+/* FIXME: unused for now so comment it out 
+
+    public Device? get_selected_device() {
+        Gtk.TreeModel model;
+        Gtk.TreeIter? iter;
+        this.get_selection().get_selected(out model, out iter);
+        if (iter == null) {
+            return null;
+        } else {
+            GLib.Value value;
+            model.get_value(iter, 0, out value);
+            return value.get_object() as Device;
+        }
+        
+    }
+*/
+
+}
+
+class WirelessConnectionView : Gtk.TreeView {
+
+    public WirelessConnectionView(WirelessConnectionStore store, Gtk.Widget style_widget) {
+        this.set_model(store);
+        
+        // Network Column (contains label)
+        var network_column = new Gtk.TreeViewColumn();
+        network_column.set_title(("Network"));
+        var cr_label_network = new Gtk.CellRendererText();
+        network_column.pack_start(cr_label_network, true);
+        network_column.set_attributes(cr_label_network, "markup", WirelessConnectionStoreCol.NETWORK);
+        network_column.set_expand(true);
+        this.append_column(network_column);
+        
+        // Signal Column (contains signal indicator)
+        var signal_column = new Gtk.TreeViewColumn();
+        signal_column.set_title(("Signal"));
+        var cr_signal = new SignalStrengthCellRenderer(style_widget, this);
+        signal_column.pack_start(cr_signal, true);
+        signal_column.set_attributes(cr_signal, "strength", 2);
+        signal_column.set_clickable(true);
+        signal_column.set_sort_column_id(2);
+        this.append_column(signal_column);
+        
+        // Last Used Column (contains label)
+        var last_used_column = new Gtk.TreeViewColumn();
+        last_used_column.set_title(("Last Used"));
+        var cr_label_last_used = new Gtk.CellRendererText();
+        last_used_column.pack_start(cr_label_last_used, true);
+        last_used_column.set_attributes(cr_label_last_used, "markup", WirelessConnectionStoreCol.LAST_USED);
+        this.append_column(last_used_column);
+    }
+
+    public WifiConnection? get_selected_connection() {
+        Gtk.TreeModel model;
+        Gtk.TreeIter? iter;
+        this.get_selection().get_selected(out model, out iter);
+        if (iter != null) {
+            GLib.Value value;
+            model.get_value(iter, WirelessConnectionStoreCol.CONNECTION_OBJ, out value);
+            return value.get_object() as WifiConnection;
+        }
+        return null;
+    }
+}
 
=== removed file 'src/settings/indicator-network-settings'
--- src/settings/indicator-network-settings	2010-12-13 13:44:21 +0000
+++ src/settings/indicator-network-settings	1970-01-01 00:00:00 +0000
@@ -1,61 +0,0 @@
-#!/usr/bin/python
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import pygtk
-pygtk.require ("2.0")
-import gtk
-
-import gettext
-import logging
-import os
-import sys
-
-from optparse import OptionParser
-from indicatorNetworkSettings.enums import *
-from indicatorNetworkSettings.version import *
-
-if __name__ == "__main__":
-    parser = OptionParser("usage: %prog [options]", version="%prog "+VERSION)
-    parser.add_option("--debug", action="store_true",
-                      help="enable debug mode", default=False)
-    parser.add_option("--force-rtl", action="store_true",
-                      help="force rtl mode (useful for debugging)", 
-                      default=False)
-    (options, args) = parser.parse_args()
-        
-    if options.debug:
-        logging.basicConfig(level=logging.DEBUG)
-    else:
-        logging.basicConfig(level=logging.INFO)
-    
-    # Override text direction for testing purposes
-    if options.force_rtl:
-        gtk.widget_set_default_direction(gtk.TEXT_DIR_RTL)
-
-    if os.path.exists("./ui/indicator-network-settings.ui"):
-        logging.info("Running locally")
-        datadir = "./"
-    else:
-        datadir = "/usr/share/indicator-network/"
-    
-    from indicatorNetworkSettings.app import NetworkSettingsApp
-
-    app = NetworkSettingsApp(datadir)
-    app.run()
-
 
=== removed directory 'src/settings/indicatorNetworkSettings'
=== removed file 'src/settings/indicatorNetworkSettings/Makefile.am'
--- src/settings/indicatorNetworkSettings/Makefile.am	2010-12-13 13:55:55 +0000
+++ src/settings/indicatorNetworkSettings/Makefile.am	1970-01-01 00:00:00 +0000
@@ -1,13 +0,0 @@
-SUBDIRS = \
-	backend \
-	frontend
-
-# indicator-network-settings
-insdir = $(pkgdatadir)/indicatorNetworkSettings
-ins_PYTHON = \
-	app.py \
-	enums.py \
-	 __init__.py \
-	SimpleGtkbuilderApp.py \
-	utils.py \
-	version.py
 
=== removed file 'src/settings/indicatorNetworkSettings/SimpleGtkbuilderApp.py'
--- src/settings/indicatorNetworkSettings/SimpleGtkbuilderApp.py	2010-12-13 13:45:08 +0000
+++ src/settings/indicatorNetworkSettings/SimpleGtkbuilderApp.py	1970-01-01 00:00:00 +0000
@@ -1,58 +0,0 @@
-"""
- SimpleGtkbuilderApp.py
- Module that provides an object oriented abstraction to pygtk and gtkbuilder
- Copyright (C) 2009 Canonical
- Author Michael Vogt
- based on ideas from SimpleGladeBuilder by Sandino Flores Moreno
-"""
-
-# This library 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; version 3.
-#
-# 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, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
-# USA
-
-import sys
-import gtk
-
-class SimpleGtkbuilderApp(object):
-    def __init__(self, path, domain):
-        self.builder = gtk.Builder()
-        self.builder.set_translation_domain(domain)
-        self.builder.add_from_file(path)
-        self.builder.connect_signals(self)
-        for o in self.builder.get_objects():
-            if issubclass(type(o), gtk.Buildable):
-                name = gtk.Buildable.get_name(o)
-                setattr(self, name, o)
-            else:
-                print >> sys.stderr, "WARNING: can not get name for '%s'" % o
-
-    def run(self):
-        """
-        Starts the main loop of processing events checking for Control-C.
-
-        The default implementation checks wheter a Control-C is pressed,
-        then calls on_keyboard_interrupt().
-
-        Use this method for starting programs.
-        """
-        try:
-            gtk.main()
-        except KeyboardInterrupt:
-            self.on_keyboard_interrupt()
-
-    def on_keyboard_interrupt(self):
-        """
-        This method is called by the default implementation of run()
-        after a program is finished by pressing Control-C.
-        """
-        pass
 
=== removed file 'src/settings/indicatorNetworkSettings/__init__.py'
--- src/settings/indicatorNetworkSettings/__init__.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-
 
=== removed file 'src/settings/indicatorNetworkSettings/app.py'
--- src/settings/indicatorNetworkSettings/app.py	2010-12-13 14:18:58 +0000
+++ src/settings/indicatorNetworkSettings/app.py	1970-01-01 00:00:00 +0000
@@ -1,78 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import locale
-import gtk
-import os
-import gettext
-
-from indicatorNetworkSettings.enums import *
-from indicatorNetworkSettings.version import *
-from indicatorNetworkSettings.frontend.pages.connections import \
-    ConnectionsPage
-from indicatorNetworkSettings.backend.devicemanager import \
-    DeviceManager
-from indicatorNetworkSettings.SimpleGtkbuilderApp import \
-    SimpleGtkbuilderApp
-
-class NetworkSettingsApp(SimpleGtkbuilderApp):
-    def __init__(self, datadir):
-        SimpleGtkbuilderApp.__init__(self,
-            os.path.join(datadir, "ui", "indicator-network-settings.ui"), 
-            "indicator-network-settings")
-
-        # Useful variables
-        self.datadir = datadir
-        self.icons = gtk.icon_theme_get_default()
-
-        # Setup Translations
-        self._setup_translations()
-
-        self.devicemanager = DeviceManager()
-
-        # Setup Pages
-        self.page_connections = ConnectionsPage(self, datadir)
-        self.pages = [self.page_connections]
-
-        self.on_notebook_main_page_switched(None, None, 0)
-
-    # Callbacks
-    def on_window_main_delete_event(self, widget, event):
-        gtk.main_quit()
-
-    def on_notebook_main_page_switched(self, widget, move_focus, page_num):
-        page_alignment = self.notebook_main.get_nth_page(page_num)
-
-        for page in self.pages:
-            if page.alignment == page_alignment:
-                page.on_first_expose()
-        
-    # Private Functions
-    def _setup_translations(self):
-        gettext.bindtextdomain("indicator-network-settings",
-                                "/usr/share/locale")
-        gettext.textdomain("indicator-network-settings")
-        try:
-            locale.setlocale(locale.LC_ALL, "")
-        except Exception:
-            print "setlocale failed"
-
-    # Public Functions
-    def run(self):
-        self.window_main.show_all()
-        super(NetworkSettingsApp, self).run()
 
=== removed directory 'src/settings/indicatorNetworkSettings/backend'
=== removed file 'src/settings/indicatorNetworkSettings/backend/Makefile.am'
--- src/settings/indicatorNetworkSettings/backend/Makefile.am	2010-12-13 13:55:55 +0000
+++ src/settings/indicatorNetworkSettings/backend/Makefile.am	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-# indicator-network-settings
-insdir = $(pkgdatadir)/indicatorNetworkSettings/backend
-ins_PYTHON = \
-	connection.py \
-	device.py \
-	__init__.py
 
=== removed file 'src/settings/indicatorNetworkSettings/backend/__init__.py'
--- src/settings/indicatorNetworkSettings/backend/__init__.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/backend/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-
 
=== removed file 'src/settings/indicatorNetworkSettings/backend/connection.py'
--- src/settings/indicatorNetworkSettings/backend/connection.py	2010-12-13 14:18:58 +0000
+++ src/settings/indicatorNetworkSettings/backend/connection.py	1970-01-01 00:00:00 +0000
@@ -1,31 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#       
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import datetime
-
-class WifiConnection(object):
-    def __init__(self):
-        self.network = None
-        self.signal = None
-        self.last_used = None
-
-    def connect_(self, key):
-        print "Connecting to %s" % self.network
 
=== removed file 'src/settings/indicatorNetworkSettings/backend/connmanmanager.py'
--- src/settings/indicatorNetworkSettings/backend/connmanmanager.py	2010-12-13 18:48:43 +0000
+++ src/settings/indicatorNetworkSettings/backend/connmanmanager.py	1970-01-01 00:00:00 +0000
@@ -1,160 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#       
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Kalle Valo
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gobject
-import dbus
-import dbus.mainloop.glib
-
-from indicatorNetworkSettings.backend.service import create_service
-
-class ConnmanManager(gobject.GObject):
-    def get_properties(self):
-        return self.properties
-
-    def is_available(self, technology):
-        if technology in self.properties["AvailableTechnologies"]:
-            return True
-
-        return False
-
-    def is_enabled(self, technology):
-        if technology in self.properties["EnabledTechnologies"]:
-            return True
-
-        return False
-
-    def is_connected(self, technology):
-        if technology in self.properties["ConnectedTechnologies"]:
-            return True
-
-        return False
-
-    def enable_technology(self, technology):
-        if not self.is_available(technology):
-            return
-
-        if self.is_enabled(technology):
-            return
-
-        self.manager.EnableTechnology(technology)
-
-    def disable_technology(self, technology):
-        if not self.is_available(technology):
-            return
-
-        if not self.is_enabled(technology):
-            return
-
-        self.manager.DisableTechnology(technology)
-
-    def get_available_technologies(self):
-        return self.properties["AvailableTechnologies"]
-
-    def get_enabled_technologies(self):
-        return self.properties["EnabledTechnologies"]
-
-    def get_connected_technologies(self):
-        return self.properties["ConnectedTechnologies"]
-
-    def request_scan(self, technology=""):
-        self.manager.RequestScan(technology)
-
-    def service_property_changed(self, name, value, path, interface):
-        service = self.get_service(path)
-
-        if not service:
-            return
-
-        service.update_property(name, value)
-
-    def manager_property_changed(self, name, value, path, interface):
-        self.properties[name] = value
-
-        if name == "Services":
-            self.update_services()
-            self.emit("services-changed")
-        elif name in ["AvailableTechnologies", "EnabledTechnologies",
-                      "ConnectedTechnologies"]:
-            self.emit("technologies-changed")
-
-    def add_service(self, service):
-        self.services[service.get_path()] = service
-
-    def get_services(self):
-        return self.services.values()
-
-    def get_services_by_technology(self, technology):
-        result = []
-        for service in self.get_services():
-            if service.get_type() == technology:
-                result.append(service)
-
-        return result
-
-    def get_service(self, path):
-        if path not in self.services:
-            return None
-
-        return self.services[path]
-
-    def update_services(self):
-        self.services = {}
-
-        for path in self.properties["Services"]:
-            service = create_service(path)
-            self.add_service(service)
-
-    def __init__(self):
-        self.__gobject_init__()
-        self.services = {}
-        dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
-	self.bus = dbus.SystemBus()
-
-        self.bus.add_signal_receiver(self.service_property_changed,
-                                     bus_name="net.connman",
-                                     dbus_interface="net.connman.Service",
-                                     signal_name = "PropertyChanged",
-                                     path_keyword="path",
-                                     interface_keyword="interface")
-
-	self.manager = dbus.Interface(self.bus.get_object("net.connman",
-                                                          "/"),
-                                      "net.connman.Manager")
-        self.bus.add_signal_receiver(self.manager_property_changed,
-                                     bus_name="net.connman",
-                                     dbus_interface="net.connman.Manager",
-                                     signal_name = "PropertyChanged",
-                                     path_keyword="path",
-                                     interface_keyword="interface")
-
-        self.properties = self.manager.GetProperties()
-
-        # FIXME: handle if connmand disappears
-        # FIXME: how to handle ordering and other changes in service list?
-
-        self.update_services()
-
-
-gobject.type_register(ConnmanManager)
-gobject.signal_new("technologies-changed", ConnmanManager,
-                   gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ())
-gobject.signal_new("services-changed", ConnmanManager,
-                   gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ())
 
=== removed file 'src/settings/indicatorNetworkSettings/backend/device.py'
--- src/settings/indicatorNetworkSettings/backend/device.py	2010-12-13 21:12:32 +0000
+++ src/settings/indicatorNetworkSettings/backend/device.py	1970-01-01 00:00:00 +0000
@@ -1,75 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#       
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gobject
-
-from indicatorNetworkSettings.enums import *
-
-class UnknownDeviceTypeError(Exception):
-    def __init__(self, devicetype):
-        self.devicetype
-
-    def __str__(self):
-        return self.devicetype
-
-class Device(gobject.GObject):
-
-    __gsignals__ = {
-        "state-changed" : (gobject.SIGNAL_RUN_LAST,
-                                   gobject.TYPE_NONE,
-                                   ([gobject.TYPE_PYOBJECT]),
-                                  ),
-    }
-    
-    
-    def __init__(self, devicetype, connman):
-        super(Device, self).__init__()
-        self.type = devicetype
-        self.state = DEVICE_STATE_OFF
-        self.connman = connman
-
-        if self.type == DEVICE_TYPE_WIRED:
-            self.typestring = "ethernet"
-        elif self.type == DEVICE_TYPE_WIRELESS:
-            self.typestring = "wifi"
-        elif self.type == DEVICE_TYPE_MOBILE:
-            self.typestring = "cellular"
-        elif self.type == DEVICE_TYPE_BLUETOOTH:
-            self.typestring = "bluetooth"
-        else:
-            raise UnknownDeviceTypeError(self.type)
-
-    def set_state(self, state):
-
-        if self.state == state:
-            return
-
-        self.state = state
-        self.emit("state-changed", self.state)
-
-    def get_state(self):
-        return self.state
-
-    def enable(self):
-        self.connman.enable_technology(self.typestring)
-
-    def disable(self):
-        self.connman.disable_technology(self.typestring)
 
=== removed file 'src/settings/indicatorNetworkSettings/backend/devicemanager.py'
--- src/settings/indicatorNetworkSettings/backend/devicemanager.py	2010-12-14 12:24:54 +0000
+++ src/settings/indicatorNetworkSettings/backend/devicemanager.py	1970-01-01 00:00:00 +0000
@@ -1,153 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#       
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#  Kalle Valo
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gobject
-
-from indicatorNetworkSettings.backend.device import Device
-from indicatorNetworkSettings.backend.connmanmanager import ConnmanManager
-from indicatorNetworkSettings.enums import *
-
-class DeviceManager(gobject.GObject):
-
-    __gsignals__ = {
-        "devices-changed" : (gobject.SIGNAL_RUN_LAST,
-                             gobject.TYPE_NONE,
-                             (),
-                             ),
-    }
-
-    def __init__(self):
-        super(DeviceManager, self).__init__()
-        self.connman = ConnmanManager()
-
-        self.ethernet_device = Device(DEVICE_TYPE_WIRED, self.connman)
-        self.wifi_device = Device(DEVICE_TYPE_WIRELESS, self.connman)
-        self.cellular_device = Device(DEVICE_TYPE_MOBILE, self.connman)
-        self.bluetooth_device = Device(DEVICE_TYPE_BLUETOOTH, self.connman)
-
-        self.ethernet_available = False
-        self.wifi_available = False
-        self.cellular_available = False
-        self.bluetooth_available = False
-
-        self.connman.connect("technologies-changed", self.technologies_updated)
-        self.technologies_updated(self.connman)
-
-    def update_availability(self):
-        techs = self.connman.get_available_technologies()
-        changed = False
-
-        avail = "ethernet" in techs
-        if avail != self.ethernet_available:
-            self.ethernet_available = avail
-            changed = True
-
-        avail = "wifi" in techs
-        if avail != self.wifi_available:
-            self.wifi_available = avail
-            changed = True
-
-        avail = "cellular" in techs
-        if avail != self.cellular_available:
-            self.cellular_available = avail
-            changed = True
-
-        avail = "bluetooth" in techs
-        if avail != self.bluetooth_available:
-            self.bluetooth_available = avail
-            changed = True
-
-        if not changed:
-            return
-
-        self.emit("devices-changed")
-
-    def update_state(self):
-        enabled = self.connman.get_enabled_technologies()
-        connected = self.connman.get_connected_technologies()
-
-        if "ethernet" in connected:
-            self.ethernet_device.set_state(DEVICE_STATE_CONNECTED)
-        elif "ethernet" in enabled:
-            self.ethernet_device.set_state(DEVICE_STATE_ON)
-        else:
-            self.ethernet_device.set_state(DEVICE_STATE_OFF)
-
-        if "wifi" in connected:
-            self.wifi_device.set_state(DEVICE_STATE_CONNECTED)
-        elif "wifi" in enabled:
-            self.wifi_device.set_state(DEVICE_STATE_ON)
-        else:
-            self.wifi_device.set_state(DEVICE_STATE_OFF)
-
-        if "cellular" in connected:
-            self.cellular_device.set_state(DEVICE_STATE_CONNECTED)
-        elif "cellular" in enabled:
-            self.cellular_device.set_state(DEVICE_STATE_ON)
-        else:
-            self.cellular_device.set_state(DEVICE_STATE_OFF)
-
-        if "bluetooth" in connected:
-            self.bluetooth_device.set_state(DEVICE_STATE_CONNECTED)
-        elif "bluetooth" in enabled:
-            self.bluetooth_device.set_state(DEVICE_STATE_ON)
-        else:
-            self.bluetooth_device.set_state(DEVICE_STATE_OFF)
-
-    def technologies_updated(self, connman):
-        self.update_availability()
-        self.update_state()
-
-    def get_wired_devices(self):
-        devices = []
-
-        if self.ethernet_available:
-            devices.append(self.ethernet_device)
-        
-        return devices
-    
-    def get_wireless_devices(self):
-        devices = []
-
-        if self.wifi_available:
-            devices.append(self.wifi_device)
-
-        return devices
-    
-    def get_mobile_devices(self):
-        devices = []
-
-        if self.cellular_available:
-            devices.append(self.cellular_device)
-
-        return devices
-    
-    def get_bluetooth_devices(self):
-        devices = []
-
-        if self.bluetooth_available:
-            devices.append(self.bluetooth_device)
-
-        return devices
-
-    def get_remembered_wireless_connections(self):
-        return self.connman.get_services_by_technology("wifi")
 
=== removed file 'src/settings/indicatorNetworkSettings/backend/service.py'
--- src/settings/indicatorNetworkSettings/backend/service.py	2010-12-13 18:48:43 +0000
+++ src/settings/indicatorNetworkSettings/backend/service.py	1970-01-01 00:00:00 +0000
@@ -1,195 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#       
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Kalle Valo
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import dbus
-
-# FIXME: translate these
-IPV4_METHOD_DHCP = "dhcp"
-IPV4_METHOD_MANUAL = "manual"
-
-def create_service(path):
-    bus = dbus.SystemBus()
-    proxy = dbus.Interface(bus.get_object("net.connman", path),
-                           "net.connman.Service")
-
-    try:
-        properties = proxy.GetProperties()
-    except dbus.exceptions.DBusException as e:
-        print "GetProperties failed for service %s: %s" % (path, e)
-        return
-
-    service_type = properties["Type"]
-    if service_type == "ethernet":
-        service = EthernetService(proxy, path, properties)
-    elif service_type == "wifi":
-        service = WifiService(proxy, path, properties)
-    elif service_type == "bluetooth":
-        service = BluetoothService(proxy, path, properties)
-    elif service_type == "cellular":
-        service = CellularService(proxy, path, properties)
-    else:
-        s = "unknown service type '%s': %s" % (service_type, path)
-        raise Exception(s)
-
-    return service
-
-class Service():
-
-    def get_name(self):
-        return self.properties["Name"]
-
-    def get_path(self):
-        return self.path
-
-    def get_strength(self):
-        if "Strength" not in self.properties:
-            return 0
-
-        return int(self.properties["Strength"])
-
-    def get_autoconnect(self):
-        return self.properties["AutoConnect"] == dbus.Boolean(1)
-
-    def set_autoconnect(self, autoconnect):
-        if autoconnect:
-            value = dbus.Boolean(True)
-        else:
-            value = dbus.Boolean(False)
-
-        self.service.SetProperty("AutoConnect", value);
-
-    def get_nameservers_configuration(self):
-        val = self.properties["Nameservers.Configuration"]
-        if val != None:
-            return " ".join(val)
-        else:
-            return ""
-
-    def set_nameservers_configuration(self, nameservers):
-        value = nameservers.split()
-        self.service.SetProperty("Nameservers.Configuration",
-                                 dbus.Array(value, signature="s"))
-
-    def get_domains_configuration(self):
-        val = self.properties["Domains.Configuration"]
-        if val != None:
-            return " ".join(val)
-        else:
-            return ""
-
-    def set_domains_configuration(self, domains):
-        value = domains.split()
-        self.service.SetProperty("Domains.Configuration",
-                                 dbus.Array(value, signature="s"))
-
-    def get_ipv4_configuration_method(self):
-        d = self.properties["IPv4.Configuration"]
-        if d.has_key('Method'):
-            return d['Method']
-        else:
-            return ""
-
-    def get_ipv4_configuration_address(self):
-        d = self.properties["IPv4.Configuration"]
-        if d.has_key('Address'):
-            return d['Address']
-        else:
-            return ""
-
-    def get_ipv4_configuration_netmask(self):
-        d = self.properties["IPv4.Configuration"]
-        if d.has_key('Netmask'):
-            return d['Netmask']
-        else:
-            return ""
-
-    def get_ipv4_configuration_gateway(self):
-        d = self.properties["IPv4.Configuration"]
-        if d.has_key('Gateway'):
-            return d['Gateway']
-        else:
-            return ""
-
-    def set_ipv4_configuration(self, ipv4):
-        self.service.SetProperty("IPv4.Configuration", ipv4)
-
-    def remove(self):
-        if not self.is_favorite():
-            return
-
-        self.service.Remove()
-
-    def is_favorite(self):
-        if not "Favorite" in self.properties:
-            return False
-
-        return self.properties["Favorite"] == dbus.Boolean(1)
-
-    def connect(self):
-        self.service.Connect()
-
-    def update_property(self, name, value):
-        self.properties[name] = value
-        # FIXME: emit property-changed signal
-
-    def __init__(self, service, path, properties):
-        self.service = service
-        self.path = path
-        self.properties = properties
-
-class EthernetService(Service):
-
-    def get_type(self):
-        return "ethernet"
-
-class WifiService(Service):
-
-    def get_type(self):
-        return "wifi"
-
-    def uses_passphrase(self):
-        return self.properties["Security"] != "none"
-
-    def get_passphrase(self):
-        if "Passphrase" not in self.properties:
-            return ""
-
-        return self.properties["Passphrase"]
-
-    def set_passphrase(self, passphrase):
-        self.service.SetProperty("Passphrase", passphrase);
-
-class BluetoothService(Service):
-
-    def get_type(self):
-        return "bluetooth"
-
-class CellularService(Service):
-
-    def get_type(self):
-        return "cellular"
-
-    def get_apn(self):
-        return self.properties["APN"]
-
-    def set_apn(self, apn):
-        self.service.SetProperty("APN", apn);
-
 
=== removed file 'src/settings/indicatorNetworkSettings/enums.py'
--- src/settings/indicatorNetworkSettings/enums.py	2010-12-13 19:38:26 +0000
+++ src/settings/indicatorNetworkSettings/enums.py	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-from gettext import gettext as _
-
-DEVICE_TYPES = (DEVICE_TYPE_WIRED, DEVICE_TYPE_WIRELESS, \
-                DEVICE_TYPE_BLUETOOTH, DEVICE_TYPE_MOBILE) = range(4)
-                
-DEVICE_TYPE_NAMES = {DEVICE_TYPE_WIRED:_("Wired"),
-                    DEVICE_TYPE_WIRELESS:_("Wireless"),
-                    DEVICE_TYPE_BLUETOOTH:_("Bluetooth"),
-                    DEVICE_TYPE_MOBILE:_("Mobile Broadband")}
-                    
-DEVICE_TYPE_LNAMES = {DEVICE_TYPE_WIRED:"wired",
-                    DEVICE_TYPE_WIRELESS:"wireless",
-                    DEVICE_TYPE_BLUETOOTH:"bluetooth",
-                    DEVICE_TYPE_MOBILE:"mobile"}
-                    
-DEVICE_TYPE_ICONS = {DEVICE_TYPE_WIRED:"network-wired",
-                    DEVICE_TYPE_WIRELESS:"network-wireless",
-                    DEVICE_TYPE_BLUETOOTH:"bluetooth-active",
-                    DEVICE_TYPE_MOBILE:"gsm-3g-high"}
-
-DEVICE_STATE_OFF, DEVICE_STATE_ON, DEVICE_STATE_CONNECTED, = range(3)
-
-
-GENERIC_DEVICE_ICON = DEVICE_TYPE_ICONS[DEVICE_TYPE_WIRED]
 
=== removed directory 'src/settings/indicatorNetworkSettings/frontend'
=== removed file 'src/settings/indicatorNetworkSettings/frontend/Makefile.am'
--- src/settings/indicatorNetworkSettings/frontend/Makefile.am	2010-12-13 13:55:55 +0000
+++ src/settings/indicatorNetworkSettings/frontend/Makefile.am	1970-01-01 00:00:00 +0000
@@ -1,9 +0,0 @@
-SUBDIRS = \
-	pages \
-	widgets
-
-# indicator-network-settings
-insdir = $(pkgdatadir)/indicatorNetworkSettings/frontend
-ins_PYTHON = \
-	__init__.py \
-	utils.py
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/__init__.py'
--- src/settings/indicatorNetworkSettings/frontend/__init__.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/frontend/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-
 
=== removed directory 'src/settings/indicatorNetworkSettings/frontend/pages'
=== removed file 'src/settings/indicatorNetworkSettings/frontend/pages/Makefile.am'
--- src/settings/indicatorNetworkSettings/frontend/pages/Makefile.am	2010-12-13 13:55:55 +0000
+++ src/settings/indicatorNetworkSettings/frontend/pages/Makefile.am	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-# indicator-network-settings
-insdir = $(pkgdatadir)/indicatorNetworkSettings/frontend/pages
-ins_PYTHON = \
-	connections.py \
-	__init__.py
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/pages/__init__.py'
=== removed file 'src/settings/indicatorNetworkSettings/frontend/pages/connections.py'
--- src/settings/indicatorNetworkSettings/frontend/pages/connections.py	2010-12-13 14:18:58 +0000
+++ src/settings/indicatorNetworkSettings/frontend/pages/connections.py	1970-01-01 00:00:00 +0000
@@ -1,111 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gobject
-
-from indicatorNetworkSettings.frontend.widgets.device_boxes.wired \
-    import WiredBox
-from indicatorNetworkSettings.frontend.widgets.device_boxes.wireless \
-    import WirelessBox
-from indicatorNetworkSettings.frontend.widgets.device_boxes.bluetooth \
-    import BluetoothBox
-from indicatorNetworkSettings.frontend.widgets.device_boxes.mobile \
-    import MobileBox
-from indicatorNetworkSettings.frontend.widgets.deviceview \
-    import DeviceView, DeviceStore
-
-from indicatorNetworkSettings.backend.device import *
-from indicatorNetworkSettings.enums import *
-
-class ConnectionsPage(gobject.GObject):
-    def __init__(self, app, datadir):
-        super(ConnectionsPage, self).__init__()
-
-        self.app = app
-        self.alignment = app.alignment_connections
-        self.viewed = False
-
-        # Create LHS
-        ## Create device view
-        device_store = DeviceStore(app.icons)
-        self.treeview_devices = DeviceView(device_store)
-        ## Pack it
-        app.scrolledwindow_c_devices.add(self.treeview_devices)
-        ## Connect signals to callbacks
-        self.treeview_devices.connect("selection-changed",
-            self._on_treeview_devices_selection_changed)
-        self.treeview_devices.connect("reordered",
-            self._on_treeview_devices_reordered)
-
-        wired_devices = app.devicemanager.get_wired_devices()
-        wireless_devices = app.devicemanager.get_wireless_devices()
-        mobile_devices = app.devicemanager.get_mobile_devices()
-        bluetooth_devices = app.devicemanager.get_bluetooth_devices()
-            
-        for device in wired_devices:
-            box = WiredBox(device, datadir)
-            self.app.notebook_c_right.append_page(box)
-            self.add_device(device, box)
-            
-        for device in wireless_devices:
-            box = WirelessBox(device, app, datadir)
-            self.app.notebook_c_right.append_page(box)
-            self.add_device(device, box)
-            
-        for device in mobile_devices:
-            box = MobileBox(device, datadir)
-            self.app.notebook_c_right.append_page(box)
-            self.add_device(device, box)
-            
-        for device in bluetooth_devices:
-            box = BluetoothBox(device, datadir)
-            self.app.notebook_c_right.append_page(box)
-            self.add_device(device, box)
-
-        # Order the RHS notebook pages inaccordance with the deviceview
-        self._on_treeview_devices_reordered(self.treeview_devices)
-
-    # Private Functions
-
-    # Public Functions
-
-    def add_device(self, device, box):
-        liststore = self.treeview_devices.get_model()
-        liststore.append(device, box)
-
-    # Callbacks
-
-    def on_first_expose(self):
-        if not self.viewed:
-            self.treeview_devices.get_selection().select_path((0,))
-            self.viewed = True
-
-    def _on_treeview_devices_selection_changed(self, widget, selection):
-        (model, iter_) = selection.get_selected()
-
-        if iter_:
-            i = model.get_path(iter_)[0]
-            self.app.notebook_c_right.set_current_page(i)
-
-    def _on_treeview_devices_reordered(self, widget):
-        i = 0
-        model = widget.get_model()
-        for device in model:
-            page = device[DeviceStore.COL_SETTINGS_BOX]
-            self.app.notebook_c_right.reorder_child(page, i)
-            i += 1
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/utils.py'
--- src/settings/indicatorNetworkSettings/frontend/utils.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/frontend/utils.py	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import os
-import sys
-import gtk
-
-def setup_ui(self, datadir, name):
-    builder = gtk.Builder()
-    builder.set_translation_domain("indicator-network-settings")
-    path = os.path.join(datadir, "ui", "%s.ui" % name)
-    builder.add_from_file(path)
-    builder.connect_signals(self)
-    for object_ in builder.get_objects():
-        if issubclass(type(object_), gtk.Buildable):
-            name = gtk.Buildable.get_name(object_)
-            setattr(self, name, object_)
-        else:
-            print >> sys.stderr, "WARNING: can not get name for '%s'" % object_
 
=== removed directory 'src/settings/indicatorNetworkSettings/frontend/widgets'
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/Makefile.am'
--- src/settings/indicatorNetworkSettings/frontend/widgets/Makefile.am	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/Makefile.am	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-SUBDIRS = device_boxes
-
-# indicator-network-settings
-insdir = $(pkgdatadir)/indicatorNetworkSettings/frontend/widgets
-ins_PYTHON = cellrenderers.py deviceview.py toggleswitch.py connectionview.py  __init__.py
-
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/__init__.py'
--- src/settings/indicatorNetworkSettings/frontend/widgets/__init__.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/cellrenderers.py'
--- src/settings/indicatorNetworkSettings/frontend/widgets/cellrenderers.py	2010-12-09 12:26:46 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/cellrenderers.py	1970-01-01 00:00:00 +0000
@@ -1,210 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#       
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gtk
-import gobject
-
-from math import pi
-
-PI =            3.1415926535897931
-PI_OVER_180 =   0.017453292519943295
-
-class PinCellRenderer(gtk.GenericCellRenderer):
-    __gproperties__ = {
-                        'color': (gobject.TYPE_STRING,
-                        'The color of the pin.',
-                        'The color of the pin.',
-                        '#FFFFFF',
-                        gobject.PARAM_READWRITE
-                        ),
-                    }
-
-    RED_FILL = "#ef2929"
-    RED_STROKE = "#a40000"
-    GREEN_FILL = "#8ae234"
-    GREEN_STROKE = "#4e9a06"
-    YELLOW_FILL = "#fce94f"
-    YELLOW_STROKE = "#c4a000"
-    GREY_FILL = "#d3d7cf"
-    GREY_STROKE = "#555753"
-
-    PIN_WIDTH = 8
-    PIN_HEIGHT = 8
-
-    PIN_XPAD = 8
-    PIN_YPAD = 8
-
-    CELL_WIDTH = PIN_WIDTH + PIN_XPAD
-    CELL_HEIGHT = PIN_HEIGHT + PIN_YPAD
-
-    def __init__(self):
-        super(PinCellRenderer, self).__init__()
-    
-    def on_get_size(self, widget, cell_area):
-        return 0, 0, self.CELL_WIDTH, self.CELL_HEIGHT
-
-    def do_set_property(self, pspec, value):
-        setattr(self, pspec.name, value)
-
-    def do_get_property(self, pspec):
-        return getattr(self, pspec.name)
-
-    def on_render(self, window, widget, background_area, cell_area,
-                    expose_area, flags):
-        cr = window.cairo_create()
-        
-        x = cell_area.x
-        y = cell_area.y
-
-        y_offset = (cell_area.height - self.CELL_HEIGHT) / 2
-
-        cr.arc(self.CELL_WIDTH/2+x, self.CELL_HEIGHT/2+y+y_offset,
-                self.PIN_WIDTH/2, 0, 2 * pi)
-        
-        stroke_string = getattr(self, "%s_STROKE" % self.color.upper())
-        stroke = gtk.gdk.Color(stroke_string)
-        fill_string = getattr(self, "%s_FILL" % self.color.upper())
-        fill = gtk.gdk.Color(fill_string)
-
-        cr.set_source_rgb(stroke.red / 65535.,
-                        stroke.green / 65535.,
-                        stroke.blue / 65535.)
-        cr.stroke_preserve()
-        cr.set_source_rgb(fill.red / 65535.,
-                        fill.green / 65535.,
-                        fill.blue / 65535.)
-        cr.fill()
-        
-class SignalStrengthCellRenderer(gtk.GenericCellRenderer):
-    __gproperties__ = {
-                        'signal': (gobject.TYPE_STRING,
-                        'The color of the pin.',
-                        'The color of the pin.',
-                        '#FFFFFF',
-                        gobject.PARAM_READWRITE
-                        ),
-                    }
-
-    BG_FILL = "#f2f1f0"
-    BG_STROKE = "#ada9a4"
-    FG_FILL = "#d6d4d2"
-    FG_STROKE = "#ada9a4"
-
-    BAR_WIDTH = 50
-    BAR_HEIGHT = 12
-
-    BAR_XPAD = 4
-    BAR_YPAD = 5
-
-    CELL_WIDTH = BAR_WIDTH + BAR_XPAD * 2
-    CELL_HEIGHT = BAR_HEIGHT + BAR_YPAD * 2
-
-    CORNER_RADIUS = 3
-
-    def __init__(self):
-        super(SignalStrengthCellRenderer, self).__init__()
-    
-    def on_get_size(self, widget, cell_area):
-        return (0, 0, self.CELL_WIDTH, self.CELL_HEIGHT)
-
-    def do_set_property(self, pspec, value):
-        setattr(self, pspec.name, value)
-
-    def do_get_property(self, pspec):
-        return getattr(self, pspec.name)
-
-    def on_render(self, window, widget, background_area, cell_area,
-                    expose_area, flags):
-        cr = window.cairo_create()
-        
-        x = cell_area.x
-        y = cell_area.y
-
-        x_offset = self.BAR_XPAD
-        y_offset = self.BAR_YPAD
-
-        self._draw_rounded_rectangle(cr, x+x_offset, y+y_offset,
-            x+x_offset+self.BAR_WIDTH, y+y_offset+self.BAR_HEIGHT,
-            self.BG_FILL, self.BG_STROKE)
-            
-        self._draw_rounded_rectangle(cr, x+x_offset, y+y_offset,
-            x+x_offset+(int(self.BAR_WIDTH*float(self.signal))), y+y_offset+self.BAR_HEIGHT,
-            self.FG_FILL, self.FG_STROKE)
-
-    def _draw_rounded_rectangle(self, cr, x, y, w, h, fill, stroke):
-        self._layout_rounded_rectangle(cr, x, y, w, h)
-        
-        stroke = gtk.gdk.Color(stroke)
-        fill = gtk.gdk.Color(fill)
-        
-        cr.set_source_rgb(stroke.red / 65535.,
-                        stroke.green / 65535.,
-                        stroke.blue / 65535.)
-        cr.stroke_preserve()
-        
-        cr.set_source_rgb(fill.red / 65535.,
-                        fill.green / 65535.,
-                        fill.blue / 65535.)
-        cr.fill()
-        
-    def _layout_rounded_rectangle(self, cr, x, y, w, h):
-        r = self.CORNER_RADIUS
-        cr.new_sub_path()
-        cr.arc(r+x, r+y, r, PI, 270*PI_OVER_180)
-        cr.arc(w-r, r+y, r, 270*PI_OVER_180, 0)
-        cr.arc(w-r, h-r, r, 0, 90*PI_OVER_180)
-        cr.arc(r+x, h-r, r, 90*PI_OVER_180, PI)
-        cr.close_path()
-
-
-        
-gobject.type_register(PinCellRenderer)
-gobject.type_register(SignalStrengthCellRenderer)
-
-if __name__ == "__main__":    
-    window = gtk.Window()
-    
-    treeview = gtk.TreeView()
-    
-    # Main Column
-    column = gtk.TreeViewColumn("Main")
-    cr = PinCellRenderer()
-    crs = SignalStrengthCellRenderer()
-    crt = gtk.CellRendererText()
-    column.pack_start(cr)
-    column.pack_start(crs)
-    column.pack_start(crt)
-    column.set_attributes(cr, color=0)
-    column.set_attributes(crs, signal=1)
-    column.set_attributes(crt, text=2)
-    treeview.append_column(column)
-
-    store = gtk.ListStore(str, float, str)
-    store.append(["green", 0.25, "Hey"])
-    store.append(["red", 0.5, "hi"])
-    store.append(["yellow", 0.75, "ho"])
-    store.append(["grey", 1.0, "ha"])
-    treeview.set_model(store)
-    
-    window.add(treeview)
-    window.show_all()
-    gtk.main()
-
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/connectionview.py'
--- src/settings/indicatorNetworkSettings/frontend/widgets/connectionview.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/connectionview.py	1970-01-01 00:00:00 +0000
@@ -1,78 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gtk
-import gobject
-
-from indicatorNetworkSettings.enums import *
-from indicatorNetworkSettings.frontend.widgets.cellrenderers \
-    import SignalStrengthCellRenderer
-
-from gettext import gettext as _
-
-class WirelessConnectionView(gtk.TreeView):
-    def __init__(self, store):
-        super(WirelessConnectionView, self).__init__()
-        self.set_model(store)
-        
-        # Network Column (contains label)
-        column = gtk.TreeViewColumn(_("Network"))
-        cr_label = gtk.CellRendererText()
-        column.pack_start(cr_label, True)
-        column.set_attributes(cr_label,
-                            markup=WirelessConnectionStore.COL_NETWORK)
-        column.set_expand(True)
-        self.append_column(column)
-        
-        # Signal Column (contains signal indicator)
-        column = gtk.TreeViewColumn(_("Signal"))
-        cr_signal = SignalStrengthCellRenderer()
-        column.pack_start(cr_signal, True)
-        column.set_attributes(cr_signal,
-                            signal=WirelessConnectionStore.COL_SIGNAL)
-        column.set_clickable(True)
-        column.set_sort_column_id(WirelessConnectionStore.COL_SIGNAL)
-        self.append_column(column)
-        
-        # Last Used Column (contains label)
-        column = gtk.TreeViewColumn(_("Last Used"))
-        cr_label = gtk.CellRendererText()
-        column.pack_start(cr_label, True)
-        column.set_attributes(cr_label,
-                        markup=WirelessConnectionStore.COL_LAST_USED)
-        self.append_column(column)
-
-    def get_selected_connection(self):
-        (model, iter_) = self.get_selection().get_selected()
-        if iter_:
-            return model.get_value(iter_, 0)
-        return None
-
-        
-class WirelessConnectionStore(gtk.ListStore):
-    
-    (COL_OBJ, COL_NETWORK, COL_SIGNAL, COL_LAST_USED) = range(4)
-    
-    def __init__(self):
-        super(WirelessConnectionStore, self).__init__(
-            gobject.TYPE_PYOBJECT, str, str, str)
-        
-    def append(self, obj, network, signal, last_used):
-        row_data = [obj, network, signal, last_used]
-        return super(WirelessConnectionStore, self).append(row_data)
-
 
=== removed directory 'src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes'
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/Makefile.am'
--- src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/Makefile.am	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/Makefile.am	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-# indicator-network-settings
-insdir = $(pkgdatadir)/indicatorNetworkSettings/frontend/widgets/device_boxes
-ins_PYTHON = bluetooth.py  __init__.py  mobile.py  wired.py  wireless.py
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/__init__.py'
--- src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/__init__.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,30 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gtk
-
-class DeviceBox(gtk.VBox):
-    """A gtk.VBox which holds all of the widgets to control a device."""
-
-    def __init__(self, device, datadir):
-        super(DeviceBox, self).__init__(spacing=12)
-        self.device = device
-        self.device.connect("state-changed", self._on_device_state_changed)
-
-    def _on_device_state_changed(self, device, state):
-        pass
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/bluetooth.py'
--- src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/bluetooth.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/bluetooth.py	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gtk
-import locale
-
-from indicatorNetworkSettings.enums import *
-
-from gettext import gettext as _
-
-class BluetoothBox(gtk.VBox):
-
-    """A gtk.VBox which holds all of thw widgets to control a bluetooth
-      device."""
-    
-    def __init__(self, device, datadir):
-        super(BluetoothBox, self).__init__(spacing=12)
-        self.device = device
-
-    # Callbacks
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/mobile.py'
--- src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/mobile.py	2010-12-13 19:53:47 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/mobile.py	1970-01-01 00:00:00 +0000
@@ -1,116 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gtk
-
-from indicatorNetworkSettings.frontend.widgets.device_boxes \
-    import DeviceBox
-from indicatorNetworkSettings.frontend.widgets.toggleswitch \
-    import InfoBox, ToggleSwitch
-
-from indicatorNetworkSettings.enums import *
-import indicatorNetworkSettings.frontend.utils as utils
-
-from gettext import gettext as _
-
-class MobileBox(DeviceBox):
-
-    """A gtk.VBox which holds all of the widgets to control a mobile
-      device. It contains an InfoBox and ToggleSwitch to control and
-      monitor the state of the mobile device, and a set of widgets
-      to enter details about the mobile network to connect to."""
-
-    SENSITIVE_WIDGETS = ["label_apn_place", "label_apn",
-                        "label_pin_auth", "checkbutton_show_pin"]
-
-    def __init__(self, device, datadir):
-        super(MobileBox, self).__init__(device, datadir)
-
-        # Infobox and Togglswitch
-        ## Creation
-        self.infobox = InfoBox(spacing=12)
-        self.toggleswitch = ToggleSwitch((_("ON"), _("OFF")))
-        self.label_status = gtk.Label()
-        ## Padding and alignment
-        self.label_status.set_alignment(0, 0.5)
-        self.infobox.set_border_width(10)
-        ## Packing
-        self.infobox.pack_start(self.label_status, True, True)
-        self.infobox.pack_start(self.toggleswitch, False, True)
-        self.pack_start(self.infobox, False, False)
-        ## Connect signals
-        self.toggleswitch.connect("toggled", self._on_toggleswitch_toggled)
-
-        # Network Settings
-        ## Creation
-        utils.setup_ui(self, datadir, "mobile_box")
-        ## Packing
-        self.pack_start(self.table_settings, True, True)
-
-        self._update_widget_states(self.device.get_state())
-        self._on_checkbutton_show_pin_toggled(self.checkbutton_show_pin)
-
-    # Private Functions
-    def _update_widget_states(self, state):
-        if state == DEVICE_STATE_CONNECTED:
-            device_editable = True
-            settings_editable = False
-            toggleswitch_state = True
-            status_text = _("Connected to “Vodafone UK”.")
-        elif state == DEVICE_STATE_ON:
-            device_editable = True
-            settings_editable = False
-            toggleswitch_state = True
-            status_text = _("Not connected.")
-        elif state == DEVICE_STATE_OFF:
-            device_editable = False
-            settings_editable = True
-            toggleswitch_state = False
-            status_text = _("The Mobile Broadband device is powered off.")
-            
-        self.toggleswitch.set_sensitive(device_editable)
-        self.toggleswitch.set_active(toggleswitch_state)
-        self.label_status.set_text(status_text)
-
-        self.table_settings.foreach(self._sensitise_widgets,
-            (device_editable, settings_editable))
-
-    def _sensitise_widgets(self, widget, data):
-        (device_editable, settings_editable) = data
-        name = gtk.Buildable.get_name(widget)
-        if name in self.SENSITIVE_WIDGETS:
-            widget.set_sensitive(device_editable)
-        elif not isinstance(widget, gtk.Box):
-            widget.set_sensitive(settings_editable)
-        else:
-            widget.foreach(self._sensitise_widgets,
-                (device_editable, settings_editable))
-    
-    # Callbacks
-    def _on_device_state_changed(self, device, state):
-        self._update_widget_states(state)
-    
-    def _on_toggleswitch_toggled(self, widget):
-        if widget.get_active():
-            self.device.enable()
-        else:
-            self.device.disable()
-
-    def _on_checkbutton_show_pin_toggled(self, widget):
-        self.entry_pin.set_visibility(widget.get_active())
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/wired.py'
--- src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/wired.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/wired.py	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gtk
-import locale
-
-from indicatorNetworkSettings.enums import *
-
-from gettext import gettext as _
-
-class WiredBox(gtk.VBox):
-
-    """A gtk.VBox which holds all of the widgets to control a wired
-      device."""
-    
-    def __init__(self, device, datadir):
-        super(WiredBox, self).__init__(spacing=12)
-        self.device = device
-
-    # Callbacks
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/wireless.py'
--- src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/wireless.py	2010-12-13 20:01:43 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/wireless.py	1970-01-01 00:00:00 +0000
@@ -1,130 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gtk
-import locale
-
-from indicatorNetworkSettings.frontend.widgets.device_boxes \
-    import DeviceBox
-from indicatorNetworkSettings.frontend.widgets.connectionview \
-    import WirelessConnectionView, WirelessConnectionStore
-from indicatorNetworkSettings.frontend.widgets.toggleswitch \
-    import InfoBox, ToggleSwitch
-    
-from indicatorNetworkSettings.enums import *
-import indicatorNetworkSettings.frontend.utils as utils
-
-from gettext import gettext as _
-
-class WirelessBox(DeviceBox):
-
-    """A gtk.VBox which holds all of the widgets to control a wireless
-      device. It contains an InfoBox and ToggleSwitch to control and
-      monitor the state of the wireless device, and a
-      WirelessConnectionView to connect to and remember details for
-      wireless networks."""
-
-    def __init__(self, device, app, datadir):
-        super(WirelessBox, self).__init__(device, datadir)
-
-        # Infobox and Togglswitch
-        ## Creation
-        self.infobox = InfoBox(spacing=12)
-        self.toggleswitch = ToggleSwitch((_("ON"), _("OFF")))
-        self.label_status = gtk.Label()
-        ## Padding and alignment
-        self.label_status.set_alignment(0, 0.5)
-        self.infobox.set_border_width(10)
-        ## Packing
-        self.infobox.pack_start(self.label_status, True, True)
-        self.infobox.pack_start(self.toggleswitch, False, True)
-        self.pack_start(self.infobox, False, False)
-        ## Connect signals
-        self.toggleswitch.connect("toggled", self._on_toggleswitch_toggled)
-
-        # Network Settings
-        ## Creation
-        utils.setup_ui(self, datadir, "wireless_box")
-        ## Packing
-        self.pack_start(self.vbox_connections, True, True)
-
-        # Connection View
-        ## Creation
-        connection_store = WirelessConnectionStore()
-        self.treeview_connections = WirelessConnectionView(connection_store)
-        ## Packing
-        self.scrolledwindow_connections.add(self.treeview_connections)
-        ## Population
-        connections = app.devicemanager.get_remembered_wireless_connections()
-        for connection in connections:
-            self._add_connection(connection)
-
-        self._update_widget_states(self.device.get_state())
-
-    # Private Functions
-    def _update_widget_states(self, state):
-        if state == DEVICE_STATE_ON:
-            device_editable = True
-            settings_editable = True
-            toggleswitch_state = True
-            status_text = _("Wi-fi is on but not connected to the Internet.")
-        elif state == DEVICE_STATE_CONNECTED:
-            device_editable = True
-            settings_editable = True
-            toggleswitch_state = True
-            status_text = _("Wi-fi is on and connected to the Internet.")
-        elif state == DEVICE_STATE_OFF:
-            device_editable = False
-            settings_editable = False
-            toggleswitch_state = False
-            status_text = _("The Wi-fi device is powered off.")
-
-        self.vbox_connections.set_sensitive(settings_editable)
-        self.toggleswitch.set_sensitive(device_editable)
-        self.toggleswitch.set_active(toggleswitch_state)
-        self.label_status.set_text(status_text)
-
-    def _add_connection(self, connection):
-        network = connection.get_name()
-        signal = float(connection.get_strength()) / 100
-
-        # FIXME: implement
-        # if connection.last_used:
-        #     date_format = locale.nl_langinfo(locale.D_FMT)
-        #     last_used = connection.last_used.strftime(date_format)
-        # else:
-        #     last_used = _("Never")
-
-        last_used = _("N/A")
-
-        liststore = self.treeview_connections.get_model()
-        liststore.append(connection, network, signal, last_used)
-
-    # Callbacks
-    def _on_device_state_changed(self, device, state):
-        self._update_widget_states(state)
-
-    def _on_toggleswitch_toggled(self, widget):
-        if widget.get_active():
-            self.device.disable()
-        else:
-            self.device.enable()
-
-    def _on_button_connect_clicked(self, widget):
-        connection = self.treeview_connections.get_selected_connection()
-        connection.connect()
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/deviceview.py'
--- src/settings/indicatorNetworkSettings/frontend/widgets/deviceview.py	2010-12-13 19:38:26 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/deviceview.py	1970-01-01 00:00:00 +0000
@@ -1,153 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import gtk
-import glib
-import gobject
-import pango
-
-from indicatorNetworkSettings.enums import *
-from indicatorNetworkSettings.frontend.widgets.cellrenderers \
-    import PinCellRenderer
-
-from gettext import gettext as _
-
-class DeviceView(gtk.TreeView):
-
-    __gsignals__ = {
-        "selection-changed" : (gobject.SIGNAL_RUN_LAST,
-                                   gobject.TYPE_NONE,
-                                   ([gobject.TYPE_PYOBJECT]),
-                                  ),
-        "reordered" : (gobject.SIGNAL_RUN_LAST,
-                                   gobject.TYPE_NONE,
-                                   (),
-                                  ),
-    }
-    
-    def __init__(self, store):
-        super(DeviceView, self).__init__()
-        self.set_model(store)
-        
-        # Device (main) Column (contains pin icon, type icon and label)
-        column = gtk.TreeViewColumn("Device")
-        cr_pin = PinCellRenderer()
-        cr_icon = gtk.CellRendererPixbuf()
-        cr_label = gtk.CellRendererText()
-        column.pack_start(cr_pin, False)
-        column.set_attributes(cr_pin, color=DeviceStore.COL_PIN)
-        column.pack_start(cr_icon, False)
-        column.set_attributes(cr_icon, pixbuf=DeviceStore.COL_ICON)
-        column.pack_start(cr_label, True)
-        column.set_attributes(cr_label, markup=DeviceStore.COL_LABEL)
-        cr_label.set_property("ellipsize", pango.ELLIPSIZE_END)
-        self.append_column(column)
-
-        self.set_headers_visible(False)
-        self.set_reorderable(True)
-
-        self._dragging = False
-
-        self.get_selection().connect("changed", self._on_selection_changed)
-        self.connect("drag-begin", self._on_drag_begin)
-        self.connect("drag-end", self._on_drag_end)
-        self.connect("drag-failed", self._on_drag_failed)
-
-    def _on_selection_changed(self, selection):
-        self.emit("selection-changed", selection)
-        
-    def _on_drag_begin(self, drag_context, *data):
-        self._dragging = True
-        
-    def _on_drag_failed(self, drag_context, *data):
-        self._dragging = False
-        
-    def _on_drag_end(self, drag_context, *data):
-        if self._dragging:
-            self.emit("reordered")
-
-    def get_selected_device(self):
-        (model, iter_) = self.get_selection().get_selected()
-        if iter_:
-            return model.get_value(iter_, 0)
-        return None
-        
-class DeviceStore(gtk.ListStore):
-    
-    (COL_DEVICE_OBJ, COL_SETTINGS_BOX, COL_PIN, COL_ICON, COL_LABEL) = range(5)
-    
-    def __init__(self, icons):
-        super(DeviceStore, self).__init__(gobject.TYPE_PYOBJECT,
-                                            gobject.TYPE_PYOBJECT, str,
-                                            gtk.gdk.Pixbuf, str)
-        self.icons = icons
-        
-    def append(self, device, settings_box):
-        device.connect("state-changed", self._on_device_state_changed)
-        
-        pin_color = self._get_pin_color(device.state)
-        caption = self._get_device_caption(device.state)
-        label = DEVICE_TYPE_NAMES[device.type]
-        icon = DEVICE_TYPE_ICONS[device.type]
-        
-        markup = self._get_markup(label, caption)
-        try:
-            icon_pixbuf = self.icons.load_icon(icon, 16, 16)
-        except glib.GError:
-            icon_pixbuf = self.icons.load_icon(GENERIC_DEVICE_ICON, 16, 16)
-        
-        row_data = [device, settings_box, pin_color, icon_pixbuf, markup]
-        
-        return super(DeviceStore, self).append(row_data)
-
-    def _on_device_state_changed(self, device, state):
-        iter_ = self._get_iter_for_device(device)
-        pin_color = self._get_pin_color(state)
-        caption = self._get_device_caption(state)
-        label = DEVICE_TYPE_NAMES[device.type]
-        
-        markup = self._get_markup(label, caption)
-        
-        self.set_value(iter_, self.COL_PIN, pin_color)
-        self.set_value(iter_, self.COL_LABEL, markup)
-
-    def _get_iter_for_device(self, device):
-        for row in self:
-            if row[0] == device:
-                return row.iter
-        
-    def _get_pin_color(self, state):
-        if state == DEVICE_STATE_OFF:
-            return "grey"
-        elif state == DEVICE_STATE_ON:
-            return "yellow"
-        elif state == DEVICE_STATE_CONNECTED:
-            return "green"
-        
-    def _get_device_caption(self, state):
-        if state == DEVICE_STATE_OFF:
-            return _("Off")
-        elif state == DEVICE_STATE_ON:
-            return _("Not Connected")
-        elif state == DEVICE_STATE_CONNECTED:
-            return _("Connected")
-
-    def _get_markup(self, label, caption):
-        return "%s\n<span font_size=\"small\">%s</span>" % (label, caption)
-
-
 
=== removed file 'src/settings/indicatorNetworkSettings/frontend/widgets/toggleswitch.py'
--- src/settings/indicatorNetworkSettings/frontend/widgets/toggleswitch.py	2010-12-09 12:26:46 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/toggleswitch.py	1970-01-01 00:00:00 +0000
@@ -1,529 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#       
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-import atk
-import gtk
-import gobject
-import cairo
-
-from gettext import gettext as _
-
-PI =            3.1415926535897931
-PI_OVER_180 =   0.017453292519943295
-
-class ToggleSwitch(gtk.EventBox):
-
-    """A switch containing the values ON and OFF (or user-inputed) that
-    hides the inactive value. It can be clicked or dragged to change
-    state, or through an enter/return keypress."""
-    
-    __gsignals__ = {
-        "clicked" : (gobject.SIGNAL_RUN_LAST,
-                                   gobject.TYPE_NONE,
-                                   (),
-                                  ),
-        "toggled" : (gobject.SIGNAL_RUN_LAST,
-                                   gobject.TYPE_NONE,
-                                   (),
-                                  ),
-    }
-
-    # (In relation to the height of the covering rectangle)
-    LINE_HEIGHT_RATIO = 9/25.0
-    LINE_SPACING_RATIO = 5/38.0
-    CORNER_RADIUS = 3
-    
-    ANIMATION_DURATION = 800
-
-    STATE_ACTIVE, STATE_INACTIVE = (True, False)
-
-    # (In relation to the width/height of the text)
-    TEXT_XPAD = 0.5
-    TEXT_YPAD = 0.55
-
-    # Used for storing Geometry of Widget
-    GEO = {}
-    
-    def __init__(self, values=(_("ON"), _("OFF")), active=False):
-        super(ToggleSwitch, self).__init__()
-            
-        self.set_visible_window(False)
-
-        # Accessibility info
-        self.atk = self.get_accessible()
-        self.atk.set_role(atk.ROLE_CHECK_BOX)
-
-        # Set events for the widget to receive
-        self.set_flags(gtk.CAN_FOCUS)
-        self.set_events(gtk.gdk.KEY_PRESS_MASK|
-                        gtk.gdk.ENTER_NOTIFY_MASK|
-                        gtk.gdk.LEAVE_NOTIFY_MASK|
-                        gtk.gdk.BUTTON_PRESS_MASK|
-                        gtk.gdk.BUTTON_RELEASE_MASK)
-
-        # Connect signls and callbacks
-        self.connect('style-set', self._on_style_set)
-        self.connect('expose-event', self._on_expose_event)
-        self.connect('button-press-event', self._on_press)
-        self.connect('button-release-event', self._on_release)
-        self.connect('key-release-event', self._on_key_release)
-        self.connect('enter-notify-event', self._on_enter)
-        self.connect('leave-notify-event', self._on_leave)
-        self.connect('motion-notify-event', self._on_motion_notify_event)
-
-        # Set values of the widget
-        self.set_values(values)
-        # Set default state of widget
-        self.state_ = active
-        # Allocate variables that will be used later
-        self._layout = None
-        self._animating = False
-        self._pressed = False
-
-        # If the covering rectangle needs to start on the right
-        # set the offset to -1
-        if self.state_ == self.STATE_ACTIVE:
-            self.x_movement_offset = -1
-        else:
-            self.x_movement_offset = 0
-
-        # Calculate the best size
-        calc_width, calc_height = self._calculate_size()
-        self.set_size_request(calc_width, calc_height)
-
-    # Private functions
-
-    def _calculate_size(self):
-        """Calculate the best size for the toggleswitch based on the
-           dimensions of the user's default font."""
-        self._layout = self.create_pango_layout('')
-        
-        self._layout.set_text("ON")
-        text_width, text_height = self._layout.get_pixel_extents()[1][2:]
-
-        width = (text_width+(text_width*self.TEXT_XPAD*2))*2
-        height = text_height+(text_height*self.TEXT_YPAD*2)
-
-        return (int(width), int(height))
-
-    
-    def _draw_widget(self, widget):
-        """Do the drawing of the actual widget."""
-        cr = widget.window.cairo_create()
-
-        # Store the dimensions of the widget for access throughout
-        self.GEO["x"] = widget.allocation.x
-        self.GEO["y"] = widget.allocation.y
-        self.GEO["x1"] = widget.allocation.x + 1
-        self.GEO["y1"] = widget.allocation.y + 1
-        self.GEO["width"] = widget.allocation.width - 3
-        self.GEO["height"] = widget.allocation.height - 3
-        self.GEO["x2"] = widget.allocation.x + 1 + widget.allocation.width - 5
-        self.GEO["y2"] = widget.allocation.y + 1 + widget.allocation.height - 5
-
-        # Draw clipping rectangle
-        self._layout_rounded_rectangle(cr, self.GEO["x"],
-                                self.GEO["y"],
-                                self.GEO["x"] + widget.allocation.width,
-                                self.GEO["y"] + widget.allocation.height)
-        cr.clip()
-
-        # Draw the main background
-        self._draw_main_background(cr)
-        
-        # Draw the text
-        self._draw_on_text()
-        self._draw_off_text()
-
-        # Draw the covering rectangle
-        self._draw_covering_rectangle(cr)
-
-        # Update ATK description, based on state
-        if self.state_ == self.STATE_ACTIVE:
-            self.atk.set_name(self.values[0])
-        else:
-            self.atk.set_name(self.values[1])
-
-    def _draw_main_background(self, cr):
-        x1 = self.GEO["x1"]
-        y1 = self.GEO["y1"]
-        x2 = self.GEO["x2"]
-        y2 = self.GEO["y2"]
-
-        # Don't change colour of background on hover or press
-        if self.state == gtk.STATE_PRELIGHT or self.state == gtk.STATE_ACTIVE:
-            state = gtk.STATE_NORMAL
-        else:
-            state = self.state
-
-        # Layout the outline of the whole widget
-        self._layout_rounded_rectangle(cr, x1, y1, x2, y2)
-        ## Select colours
-        fill = self.style.base[state]
-        stroke = self.style.dark[state]
-        ## Stroke and then fill it in
-        self._stroke_rounded_rectangle(cr, stroke)
-        self._fill_rounded_rectangle(cr, fill)
-        
-        # Layout the left (highlighted) part
-        x1 = self.GEO["x1"]
-        x2 = self.GEO["x1"] + (self.GEO["width"]/2)
-        self._layout_rounded_rectangle(cr, x1, y1, x2, y2)
-        ## Select colours
-        fill = self.style.light[gtk.STATE_SELECTED]
-        stroke = self.style.mid[gtk.STATE_SELECTED]
-        ## Stroke and then fill it in
-        self._stroke_rounded_rectangle(cr, stroke)
-        self._fill_rounded_rectangle(cr, fill)
-        
-        # Layout the right (normal) part
-        x1 = self.GEO["x2"] - (self.GEO["width"]/2)
-        x2 = self.GEO["x2"] 
-        self._layout_rounded_rectangle(cr, x1, y1, x2, y2)
-        ## Select colours
-        fill = self.style.base[state]
-        stroke = self.style.dark[state]
-        ## Stroke and then fill it in
-        self._stroke_rounded_rectangle(cr, stroke)
-        self._fill_rounded_rectangle(cr, fill)
-        
-
-    def _draw_covering_rectangle(self, cr, x_offset=0):
-        if self.x_movement_offset == -1:
-            self.x_movement_offset = self.GEO["width"] / 2 - 1
-        x1 = self.GEO["x1"] + self.x_movement_offset
-        x2 = (self.GEO["width"] / 2) + self.GEO["x1"] + self.x_movement_offset
-
-        y1 = self.GEO["y1"]
-        y2 = self.GEO["y2"]
-        
-        stroke = self.style.dark[self.state]
-        self._layout_rounded_rectangle(cr, x1, y1, x2, y2)
-        self._stroke_rounded_rectangle(cr, stroke)
-        
-        if self.state == gtk.STATE_INSENSITIVE:
-            fill = self.style.bg[self.state]
-            self._fill_rounded_rectangle(cr, fill)
-        else:
-            fill1 = self.style.light[self.state]
-            fill2 = self.style.mid[self.state]
-            linear = self._create_vertical_gradient(fill1, fill2, x1, x2, y1, y2)
-            self._fill_gradient_rounded_rectangle(cr, linear)
-
-        # Draw the vertical lines
-        fill_dark = self.style.dark[self.state]
-        fill_light = self.style.light[self.state]
-        height = round(self.GEO["height"]*self.LINE_HEIGHT_RATIO)
-        width = 1
-
-        spacing = int(self.LINE_SPACING_RATIO * (self.GEO["width"] / 2))
-        c_spacing = 0
-        
-        x_offset = ((self.GEO["width"] / 2) - (6+(spacing*2)))/2 + 2
-        y_offset = (self.GEO["height"]  - height)/2
-        
-        for i in range(3):
-            self._draw_vertical_line(cr, x1+x_offset+c_spacing,
-                                y1+y_offset, width, height, fill_dark)
-            self._draw_vertical_line(cr, x1+x_offset+c_spacing+1,
-                                y1+y_offset, width, height, fill_light)
-            c_spacing += spacing
-
-
-    def _draw_vertical_line(self, cr, x1, y1, width, height, fill):
-        """Draw a vertical line on the covering rectangle"""
-        cr.rectangle(x1, y1, width, height)
-        cr.set_source_rgb(fill.red_float, fill.green_float, fill.blue_float)
-        cr.fill()
-
-    def _draw_on_text(self):
-        """Draw the ON (or otherwise) text"""
-        text = self.values[0]
-        gravity = "left"
-        self._draw_text_centered_text(text, gravity)
-
-    def _draw_off_text(self):
-        """Draw the OFF (or otherwise) text"""
-        text = self.values[1]
-        gravity = "right"
-        self._draw_text_centered_text(text, gravity)
-
-    def _draw_text_centered_text(self, text, gravity):
-        if not self._layout:
-            self._layout = self.create_pango_layout('')
-        
-        self._layout.set_text(text)
-        text_width, text_height = self._layout.get_pixel_extents()[1][2:]
-        
-        if self.x_movement_offset == -1:
-            if gravity == "right":
-                text_x_offset = (((self.GEO["width"]/2) - text_width) / 2) + (self.GEO["width"]/2)
-            elif gravity == "left":
-                text_x_offset = (((self.GEO["width"]/2) - text_width) / 2) + self.x_movement_offset
-        else:
-            if gravity == "right":
-                text_x_offset = (((self.GEO["width"]/2) - text_width) / 2) + (self.GEO["width"]/2) + self.x_movement_offset
-            elif gravity == "left":
-                text_x_offset = (((self.GEO["width"]/2) - text_width) / 2) + (self.x_movement_offset-(self.GEO["width"]/2))
-        
-        text_y_offset = ((self.GEO["height"] - text_height) / 2)
-        
-        self.style.paint_layout(self.window, self.state, True,
-                                (self.GEO["x"], self.GEO["y"],
-                                self.GEO["width"], self.GEO["height"]),
-                                self, '',         
-                                int(self.GEO["x1"]+text_x_offset),
-                                int(self.GEO["y1"]+text_y_offset),
-                                self._layout)
-        
-
-    def _layout_rounded_rectangle(self, cr, x, y, w, h):
-        r = self.CORNER_RADIUS
-        cr.new_sub_path()
-        cr.arc(r+x, r+y, r, PI, 270*PI_OVER_180)
-        cr.arc(w-r, r+y, r, 270*PI_OVER_180, 0)
-        cr.arc(w-r, h-r, r, 0, 90*PI_OVER_180)
-        cr.arc(r+x, h-r, r, 90*PI_OVER_180, PI)
-        cr.close_path()
-
-    def _fill_rounded_rectangle(self, cr, fill):
-        cr.set_source_rgb(fill.red_float,
-                          fill.green_float,
-                          fill.blue_float)
-        cr.fill()
-
-    def _fill_gradient_rounded_rectangle(self, cr, fill):
-        cr.set_source(fill)
-        cr.fill()
-        
-    def _stroke_rounded_rectangle(self, cr, stroke):
-        cr.set_source_rgb(stroke.red_float,
-                            stroke.green_float,
-                            stroke.blue_float)
-        cr.stroke_preserve()
-
-    def _create_vertical_gradient(self, color1, color2, x1, x2, y1, y2):
-        linear = cairo.LinearGradient(x1, y1, x1, y2)
-        linear.add_color_stop_rgba(0.00, color1.red_float,
-                                    color1.green_float,
-                                    color1.blue_float, 1)
-        linear.add_color_stop_rgba(0.8, color2.red_float,
-                                    color2.green_float,
-                                    color2.blue_float, 1)
-        return linear
-
-    def _increment_movement(self, state):
-        if state == self.STATE_ACTIVE:
-            increment = 1
-            criterion = self.x_movement_offset == (self.GEO["x2"] - (self.GEO["width"]/2) - self.GEO["x1"])
-        else:
-            increment = -1
-            criterion = self.x_movement_offset == 0
-            
-        if criterion:
-            self._animating = False
-            self.queue_draw()
-            return False
-        else:
-            self.x_movement_offset += increment
-            self.queue_draw()
-            return True
-
-    # Callbacks
-    def _on_style_set(self, widget, event):
-        # Re-calculate the best size
-        calc_width, calc_height = self._calculate_size()
-        self.set_size_request(calc_width, calc_height)
-
-    def _on_expose_event(self, widget, event):
-        self._draw_widget(widget)
-
-    def _on_press(self, widget, event):
-        self.set_state(gtk.STATE_ACTIVE)
-        if event.x < self.GEO["width"]/2:
-            self.offset = event.x
-        elif event.x > self.GEO["width"]/2:
-            self.offset =  event.x - self.GEO["width"]/2
-    
-    def _on_release(self, widget, event):
-        if not self._animating:
-            if self._pressed:
-                if self.x_movement_offset <= self.GEO["width"] / 4:
-                    gobject.timeout_add(5, self._increment_movement,
-                                        self.STATE_INACTIVE)
-                    self.state_ = self.STATE_INACTIVE
-                    self.emit('toggled')
-                elif self.x_movement_offset >= self.GEO["width"] / 4:
-                    gobject.timeout_add(5, self._increment_movement,
-                                        self.STATE_ACTIVE)
-                    self.state_ = self.STATE_ACTIVE
-                    self.emit('toggled')
-                self._pressed = False
-                self.offset = 0
-            else:
-                self.set_state(gtk.STATE_PRELIGHT)
-                self.state_ = not self.state_
-                self.emit('clicked')
-                self.emit('toggled')
-                gobject.timeout_add(5, self._increment_movement,
-                                    self.state_)
-                self._pressed = False
-            self._animating = True
-            
-    def _on_motion_notify_event(self, widget, event):
-        self._pressed = True
-        if event.x - self.offset < 0:
-            self.x_movement_offset = 0
-        elif event.x - self.offset >= (self.GEO["width"]/2 - 1):
-            self.x_movement_offset = self.GEO["width"]/2 -1
-        else:
-            self.x_movement_offset = event.x - self.offset
-        self.queue_draw()
-        
-    def _on_key_release(self, widget, event):
-        if widget.has_focus():
-            if event.keyval == gtk.keysyms.Return or  \
-                event.keyval == gtk.keysyms.KP_Enter:
-                self.toggled()
-
-    def _on_enter(self, widget, event):
-        self.set_state(gtk.STATE_PRELIGHT)
-
-    def _on_leave(self, widget, event):
-        self.set_state(gtk.STATE_NORMAL)
-
-    # Public functions
-
-    def get_active(self):
-        return self.state_
-        
-    def set_active(self, state):
-        # If the widget is not yet realized, don't bother animating
-        if self.get_window() == None:
-            if state:
-                self.x_movement_offset = -1
-            else:
-                self.x_movement_offset = 0
-            self.queue_draw()
-            self.state_ = state
-        # Otherwise if we are not already animating, change the state
-        elif not self._animating:
-            self._animating = True
-            self._on_release(self, None)
-        
-    def set_values(self, values):
-        # If the variable values is a tuple of length 2, and type string
-        # set the widget's values property to it.
-        if (len(values) == 2) and (type(values) == tuple):
-            if (type(values[0]) == str) and (type(values[1]) == str):
-                self.values = values
-                return
-        # Otherwise raise a Type error
-        raise TypeError("ToggleSwitch.set_values() argument 1 must be " + \
-                        "String Tuple of length 2, not %s." % type(values))
-        
-    def toggled(self):
-        self._on_release(self, None)
-
-    def pressed(self):
-        self._on_press(self, None)
-
-    def clicked(self):
-        self._on_release(self, None)
-        
-    def enter(self):
-        self._on_enter(self, None)
-        
-    def leave(self):
-        self._on_leave(self, None)
-        
-class InfoBox(gtk.HBox):
-    """A gtk.HBox that is filled with the mid-colour and stroked with
-    the dark colour from a user's gtk theme so that it stands out."""
-
-    YPAD = 1
-    XPAD = 1
-    
-    def __init__(self, homogeneous=False, spacing=0):
-        super(InfoBox, self).__init__(homogeneous, spacing)
-        self.connect('expose-event', self._on_expose_event)
-
-    def _on_expose_event(self, widget, event):
-        cr = widget.window.cairo_create()
-
-        # Get geometry
-        x = widget.allocation.x + self.XPAD
-        y = widget.allocation.y + self.YPAD
-        width = widget.allocation.width - (self.XPAD * 2)
-        height = widget.allocation.height - (self.YPAD * 2)
-
-        # Fill with the mid color from the current gtk theme
-        fill = self.style.mid[self.state]
-        # Fill with the dark color from the current gtk theme
-        stroke = self.style.dark[self.state]
-
-        # Layout the rectangle
-        cr.rectangle(x, y, width, height)
-        # Stroke the outline
-        cr.set_source_rgb(stroke.red_float, stroke.green_float,
-                            stroke.blue_float)
-        cr.stroke_preserve()
-        # Fill it in
-        cr.set_source_rgb(fill.red_float, fill.green_float,
-                            fill.blue_float)
-        cr.fill()
-        
-if __name__ == "__main__":
-    def on_toggle_switch_clicked(widget):
-        print widget.get_active()
-
-    def do():
-        s.toggled()
-        return True
-    
-    w = gtk.Window()
-    v = gtk.VBox()
-    h = gtk.HBox()
-    i = InfoBox(spacing=12)
-    s = ToggleSwitch()
-    si = ToggleSwitch()
-    si.set_sensitive(False)
-    l = gtk.Label("Wi-fi is on and connected to the Internet.")
-    
-    gobject.timeout_add(3000, do)
-
-    w.connect("delete-event", gtk.main_quit)
-    s.connect("clicked", on_toggle_switch_clicked)
-
-    v.set_border_width(10)
-    w.set_default_size(200, 200)
-
-    i.pack_start(l, False)
-    i.pack_start(s, False, False)
-    i.pack_start(si, False, False)
-    i.set_border_width(12)
-    h.pack_start(i)
-    v.pack_start(h, False, False)
-    w.add(v)
-
-    w.show_all()
-    gtk.main()
-    
 
=== removed file 'src/settings/indicatorNetworkSettings/utils.py'
--- src/settings/indicatorNetworkSettings/utils.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/utils.py	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#
-# 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; version 3.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
 
=== removed file 'src/settings/indicatorNetworkSettings/version.py'
--- src/settings/indicatorNetworkSettings/version.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/version.py	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-
-VERSION = '0.01'
-CODENAME = 'UNRELEASED'
-DISTRO = 'Ubuntu'
-RELEASE = '11.04'
 
=== added file 'src/settings/logger.vala'
--- src/settings/logger.vala	1970-01-01 00:00:00 +0000
+++ src/settings/logger.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,44 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2010-2011 Canonical Ltd.
+ *
+ * Authors:
+ * Andrew Higginson
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+public enum LogLevel {
+	NONE,
+    INFO,
+    DEBUG
+}
+
+public class Logger : Object {
+    
+    public LogLevel level {get; set;}
+
+    public void debug(string text) {
+        if (this.level >= LogLevel.DEBUG) {
+            var msg = @"DEBUG: $text\n";
+            stdout.printf(msg);
+        }
+    }
+
+    public void info(string text) {
+        if (this.level >= LogLevel.INFO) {
+            var msg = @"INFO: $text\n";
+            stdout.printf(msg);
+        }
+    }
+}
 
=== added file 'src/settings/main.vala'
--- src/settings/main.vala	1970-01-01 00:00:00 +0000
+++ src/settings/main.vala	2011-01-07 16:06:25 +0000
@@ -0,0 +1,68 @@
+/*
+ * indicator-network - user interface for connman