Merge lp:~kvalo/indicator-network/settings-backend-begin into lp:~indicator-applet-developers/indicator-network/indicator-network

[Kalle Valo]

Beginnings of backend implementation for the new settings window.

[Alex Launi (alexlauni)]

1. Make check fails due to an out of date POTFILES.in file. Probably will want to fix this for translators' sake (and for make check's sake).

2. line 239 in 'src/settings/indicatorNetworkSettings/backend/device.py' looks like a good place to define a custom Exception, maybe UnknownDeviceTypeError (type)

3. I don't really like the prints. Is there a python version of g_debug? If this is how you've done the rest of the project then keep going, but a lot of it looks like

review: Needs Fixing

[Kalle Valo (kvalo)]

On 12/13/2010 10:22 PM, Alex Launi wrote:
> Review: Needs Fixing
>
> 1. Make check fails due to an out of date POTFILES.in file. Probably will want to fix this for translators' sake (and for make check's sake).

That was actually fixed already on trunk, I just forgot to merge trunk.
I did that now and the issue is fixed.

> 2. line 239 in 'src/settings/indicatorNetworkSettings/backend/device.py' looks like a good place to define a custom Exception, maybe UnknownDeviceTypeError (type)

Added.

> 3. I don't really like the prints. Is there a python version of g_debug? If this is how you've done the rest of the project then keep going, but a lot of it looks like

Currently there is no proper logging framework in
indicator-network-settings. I'm planning to implement such in the
feature, but not right now due to other tasks. But actually there were
two accidental prints from a debuggin session, I removed those now.

I have now pushed fixes to the branch. Please take a look. Thank you for
the review.

Kalle

[Mikkel Kamstrup Erlandsen (kamstrup)]

Regarding logging you can use the build in 'logging' module of Python. It's highly run-time configurable. But that can wait to another merge request of course.

Looks good to me otherwise.

I can see why you wanna bind libconnman since you have a lot of sync DBus calls in here - it's less catastrophic for an app of course, but it may still lock up the ui.

review: Approve

[Kalle Valo (kvalo)]

Mikkel Kamstrup Erlandsen <email address hidden> writes:

> I can see why you wanna bind libconnman since you have a lot of sync
> DBus calls in here - it's less catastrophic for an app of course, but
> it may still lock up the ui.

Yes, it's driving me crazy to write basically same code twice, first in
C and then in python. My current plan is to write a quick sync dbus
implementation first and then move to libconnman and have proper async
calls.

--
Kalle Valo

[lp:~kvalo/indicator-network/settings-backend-begin]

129. By Kalle Valo on 2010-12-13

settings: simplify device states. Remove offline state, and rename other
states to off, on and connected.

130. By Kalle Valo on 2010-12-13

settings: fix mobile to use new states

131. By Kalle Valo on 2010-12-13

settings: remove leftover fixme

=== modified file 'src/settings/indicatorNetworkSettings/app.py'
--- src/settings/indicatorNetworkSettings/app.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/app.py	2010-12-13 21:15:34 +0000
@@ -25,6 +25,8 @@
 from indicatorNetworkSettings.version import *
 from indicatorNetworkSettings.frontend.pages.connections import \
     ConnectionsPage
+from indicatorNetworkSettings.backend.devicemanager import \
+    DeviceManager
 from indicatorNetworkSettings.SimpleGtkbuilderApp import \
     SimpleGtkbuilderApp
 
@@ -41,6 +43,8 @@
         # Setup Translations
         self._setup_translations()
 
+        self.devicemanager = DeviceManager()
+
         # Setup Pages
         self.page_connections = ConnectionsPage(self, datadir)
         self.pages = [self.page_connections]

=== modified file 'src/settings/indicatorNetworkSettings/backend/connection.py'
--- src/settings/indicatorNetworkSettings/backend/connection.py	2010-12-09 12:26:46 +0000
+++ src/settings/indicatorNetworkSettings/backend/connection.py	2010-12-13 21:15:34 +0000
@@ -29,21 +29,3 @@
 
     def connect_(self, key):
         print "Connecting to %s" % self.network
-
-def get_remembered_wireless_connections(device):
-    ### Dummy Connections (temporary)
-    connection1 = WifiConnection()
-    connection1.network = "BTHomeHub-193209"
-    connection1.signal = "0.75"
-    connection1.last_used = datetime.date(2010, 11, 3)
-    connection2 = WifiConnection()
-    connection2.network = "SKY-001"
-    connection2.signal = "0.55"
-    connection2.last_used = datetime.date(2010, 5, 22)
-    connection3 = WifiConnection()
-    connection3.network = "Starbucks OpenAccess"
-    connection3.signal = "0.2"
-    connection3.last_used = None
-    ###
-    connections = (connection1, connection2, connection3)
-    return connections

=== added file 'src/settings/indicatorNetworkSettings/backend/connmanmanager.py'
--- src/settings/indicatorNetworkSettings/backend/connmanmanager.py	1970-01-01 00:00:00 +0000
+++ src/settings/indicatorNetworkSettings/backend/connmanmanager.py	2010-12-13 21:15:34 +0000
@@ -0,0 +1,160 @@
+#!/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, ())

=== modified file 'src/settings/indicatorNetworkSettings/backend/device.py'
--- src/settings/indicatorNetworkSettings/backend/device.py	2010-12-09 12:26:46 +0000
+++ src/settings/indicatorNetworkSettings/backend/device.py	2010-12-13 21:15:34 +0000
@@ -23,6 +23,13 @@
 
 from indicatorNetworkSettings.enums import *
 
+class UnknownDeviceTypeError(Exception):
+    def __init__(self, devicetype):
+        self.devicetype
+
+    def __str__(self):
+        return self.devicetype
+
 class Device(gobject.GObject):
 
     __gsignals__ = {
@@ -33,54 +40,36 @@
     }
     
     
-    def __init__(self):
+    def __init__(self, devicetype, connman):
         super(Device, self).__init__()
-        self.type = None
-        self.state = None
+        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 get_wired_devices():
-    ### Populate Device View (temporary)
-    device1 = Device()
-    device1.type = DEVICE_TYPE_WIRED
-    device1.state = DEVICE_STATE_OFFLINE
-    ###
-    devices = (device1,)
-    return devices
-    
-def get_wireless_devices():
-    ### Populate Device View (temporary)
-    device1 = Device()
-    device1.type = DEVICE_TYPE_WIRELESS
-    device1.state = DEVICE_STATE_ONLINE
-    device2 = Device()
-    device2.type = DEVICE_TYPE_WIRELESS
-    device2.state = DEVICE_STATE_OFF
-    ###
-    devices = (device1, device2)
-    return devices
-    
-def get_mobile_devices():
-    ### Populate Device View (temporary)
-    device3 = Device()
-    device3.type = DEVICE_TYPE_MOBILE
-    device3.state = DEVICE_STATE_CONNECTED
-    ###
-    devices = (device3,)
-    return devices
-    
-def get_bluetooth_devices():
-    ### Populate Device View (temporary)
-    device4 = Device()
-    device4.type = DEVICE_TYPE_BLUETOOTH
-    device4.state = DEVICE_STATE_OFF
-    ###
-    devices = (device4,)
-    return devices
-    
+    def enable(self):
+        self.connman.enable_technology(self.typestring)
+
+    def disable(self):
+        self.connman.disable_technology(self.typestring)

=== added file 'src/settings/indicatorNetworkSettings/backend/devicemanager.py'
--- src/settings/indicatorNetworkSettings/backend/devicemanager.py	1970-01-01 00:00:00 +0000
+++ src/settings/indicatorNetworkSettings/backend/devicemanager.py	2010-12-13 21:15:34 +0000
@@ -0,0 +1,153 @@
+#!/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_ONLINE)
+        elif "ethernet" in enabled:
+            self.ethernet_device.set_state(DEVICE_STATE_OFFLINE)
+        else:
+            self.ethernet_device.set_state(DEVICE_STATE_OFF)
+
+        if "wifi" in connected:
+            self.wifi_device.set_state(DEVICE_STATE_ONLINE)
+        elif "wifi" in enabled:
+            self.wifi_device.set_state(DEVICE_STATE_OFFLINE)
+        else:
+            self.wifi_device.set_state(DEVICE_STATE_OFF)
+
+        if "cellular" in connected:
+            self.cellular_device.set_state(DEVICE_STATE_ONLINE)
+        elif "cellular" in enabled:
+            self.cellular_device.set_state(DEVICE_STATE_OFFLINE)
+        else:
+            self.cellular_device.set_state(DEVICE_STATE_OFF)
+
+        if "bluetooth" in connected:
+            self.bluetooth_device.set_state(DEVICE_STATE_ONLINE)
+        elif "bluetooth" in enabled:
+            self.bluetooth_device.set_state(DEVICE_STATE_OFFLINE)
+        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")

=== added file 'src/settings/indicatorNetworkSettings/backend/service.py'
--- src/settings/indicatorNetworkSettings/backend/service.py	1970-01-01 00:00:00 +0000
+++ src/settings/indicatorNetworkSettings/backend/service.py	2010-12-13 21:15:34 +0000
@@ -0,0 +1,195 @@
+#!/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);
+

=== modified file 'src/settings/indicatorNetworkSettings/frontend/pages/connections.py'
--- src/settings/indicatorNetworkSettings/frontend/pages/connections.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/frontend/pages/connections.py	2010-12-13 21:15:34 +0000
@@ -52,10 +52,10 @@
         self.treeview_devices.connect("reordered",
             self._on_treeview_devices_reordered)
 
-        wired_devices = get_wired_devices()
-        wireless_devices = get_wireless_devices()
-        mobile_devices = get_mobile_devices()
-        bluetooth_devices = get_bluetooth_devices()
+        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)
@@ -63,7 +63,7 @@
             self.add_device(device, box)
             
         for device in wireless_devices:
-            box = WirelessBox(device, datadir)
+            box = WirelessBox(device, app, datadir)
             self.app.notebook_c_right.append_page(box)
             self.add_device(device, box)
             

=== modified file 'src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/wireless.py'
--- src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/wireless.py	2010-12-07 15:07:37 +0000
+++ src/settings/indicatorNetworkSettings/frontend/widgets/device_boxes/wireless.py	2010-12-13 21:15:34 +0000
@@ -25,9 +25,6 @@
     import WirelessConnectionView, WirelessConnectionStore
 from indicatorNetworkSettings.frontend.widgets.toggleswitch \
     import InfoBox, ToggleSwitch
-
-from indicatorNetworkSettings.backend.connection \
-    import get_remembered_wireless_connections
     
 from indicatorNetworkSettings.enums import *
 import indicatorNetworkSettings.frontend.utils as utils
@@ -42,7 +39,7 @@
       WirelessConnectionView to connect to and remember details for
       wireless networks."""
 
-    def __init__(self, device, datadir):
+    def __init__(self, device, app, datadir):
         super(WirelessBox, self).__init__(device, datadir)
 
         # Infobox and Togglswitch
@@ -73,7 +70,8 @@
         ## Packing
         self.scrolledwindow_connections.add(self.treeview_connections)
         ## Population
-        connections = get_remembered_wireless_connections(device)
+        # FIXME
+        connections = app.devicemanager.get_remembered_wireless_connections()
         for connection in connections:
             self._add_connection(connection)
 
@@ -108,13 +106,17 @@
         self.label_status.set_text(status_text)
 
     def _add_connection(self, connection):
-        network = connection.network
-        signal = connection.signal
-        if connection.last_used:
-            date_format = locale.nl_langinfo(locale.D_FMT)
-            last_used = connection.last_used.strftime(date_format)
-        else:
-            last_used = _("Never")
+        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)
@@ -125,10 +127,10 @@
 
     def _on_toggleswitch_toggled(self, widget):
         if widget.get_active():
-            self.device.set_state(DEVICE_STATE_CONNECTED)
+            self.device.disable()
         else:
-            self.device.set_state(DEVICE_STATE_OFFLINE)
+            self.device.enable()
 
     def _on_button_connect_clicked(self, widget):
         connection = self.treeview_connections.get_selected_connection()
-        connection.connect_("password")
+        connection.connect()