Add palette to Wireless device on Home view showing channel too

Convert the tooltip to a palette and show the wireless
channel in the palette.

NEWS

@@ -1,3 +1,5 @@
+* Add palette to Wireless device on Home view showing channel (dcbw)
+
 Snapshot 23ad88db0c
 
 * Re-share an activity when it gets launched from the journal if it was

shell/hardware/nmclient.py

@@ -25,6 +25,7 @@ import gobject
 import gtk
 
 from hardware import nminfo
+from sugar.graphics import xocolor
 
 IW_AUTH_ALG_OPEN_SYSTEM = 0x00000001
 IW_AUTH_ALG_SHARED_KEY  = 0x00000002
@@ -138,6 +139,16 @@ class Network(gobject.GObject):
         self._valid = False
         self.emit('initialized', self._valid)
 
+    def get_colors(self):
+        import sha
+        sh = sha.new()
+        data = self._ssid + hex(self._caps) + hex(self._mode)
+        sh.update(data)
+        h = hash(sh.digest())
+        idx = h % len(xocolor._colors)
+        # stroke, fill
+        return (xocolor._colors[idx][0], xocolor._colors[idx][1])
+
     def get_ssid(self):
         return self._ssid
 
@@ -202,25 +213,27 @@ class Device(gobject.GObject):
         self._active = False
         self._act_stage = 0
         self._strength = 0
+        self._freq = 0.0
         self._link = False
         self._valid = False
         self._networks = {}
         self._caps = 0
         self._state = DEVICE_STATE_INACTIVE
         self._active_network = None
+        self._active_net_sigid = 0
 
         obj = sys_bus.get_object(NM_SERVICE, self._op)
-        dev = dbus.Interface(obj, NM_IFACE_DEVICES)
+        self.dev = dbus.Interface(obj, NM_IFACE_DEVICES)
-        dev.getProperties(reply_handler=self._update_reply_cb,
+        self.dev.getProperties(reply_handler=self._update_reply_cb,
                 error_handler=self._update_error_cb)
 
     def _is_activating(self):
-        if self._active and self._act_stage >= 1 and self._act_stage <= 7:
+        if self._active and self._act_stage >= 1 and self._act_stage <= 6:
             return True
         return False
 
     def _is_activated(self):
-        if self._active and self._act_stage == 8:
+        if self._active and self._act_stage == 7:
             return True
         return False
 
@@ -307,6 +320,15 @@ class Device(gobject.GObject):
                 ret.append(net.get_op())
         return ret
 
+    def get_frequency(self):
+        try:
+            freq = self.dev.getFrequency(timeout=3000)
+        except dbus.DBusException, e:
+            pass
+        # Hz -> GHz
+        self._freq = freq / 1000000000
+        return self._freq
+
     def get_strength(self):
         return self._strength
 
@@ -345,9 +367,14 @@ class Device(gobject.GObject):
         # Make sure the old one doesn't get a stuck state
         if self._active_network:
             self._active_network.set_state(NETWORK_STATE_NOTCONNECTED)
+            self._active_network.disconnect(self._active_net_sigid)
 
         self._active_network = network
 
+        if self._active_network:
+            self._active_net_sigid = self._active_network.connect("initialized",
+                    self._active_net_initialized);
+
         # don't emit ssid-changed for networks that are not yet valid
         if self._valid:
             if self._active_network and self._active_network.is_valid():
@@ -355,6 +382,10 @@ class Device(gobject.GObject):
             elif not self._active_network:
                 self.emit('ssid-changed')
 
+    def _active_net_initialized(self, net, user_data=None):
+        if self._active_network and self._active_network.is_valid():
+            self.emit('ssid-changed')
+
     def _get_active_net_cb(self, state, net_op):
         if not self._networks.has_key(net_op):
             self.set_active_network(None)
@@ -390,9 +421,7 @@ class Device(gobject.GObject):
             if state == DEVICE_STATE_INACTIVE:
                 self.set_active_network(None)
             else:
-                obj = sys_bus.get_object(NM_SERVICE, self._op)
+                self.dev.getActiveNetwork(reply_handler=lambda *args: self._get_active_net_cb(state, *args),
-                dev = dbus.Interface(obj, NM_IFACE_DEVICES)
-                dev.getActiveNetwork(reply_handler=lambda *args: self._get_active_net_cb(state, *args),
                             error_handler=self._get_active_net_error_cb)
 
     def get_ssid(self):
@@ -401,6 +430,9 @@ class Device(gobject.GObject):
         elif not self._active_network:
             return None
 
+    def get_active_network(self):
+        return self._active_network
+
     def get_type(self):
         return self._type
 

shell/model/devices/network/wireless.py

@@ -27,7 +27,9 @@ class Device(device.Device):
         'strength' : (int, None, None, 0, 100, 0,
                       gobject.PARAM_READABLE),
         'state'    : (int, None, None, device.STATE_ACTIVATING,
-                      device.STATE_INACTIVE, 0, gobject.PARAM_READABLE)
+                      device.STATE_INACTIVE, 0, gobject.PARAM_READABLE),
+        'frequency': (float, None, None, 0.0, 9999.99, 0.0,
+                      gobject.PARAM_READABLE)
     }
 
     def __init__(self, nm_device):
@@ -60,9 +62,19 @@ class Device(device.Device):
         elif pspec.name == 'state':
             nm_state = self._nm_device.get_state()
             return device._nm_state_to_state[nm_state]
+        elif pspec.name == 'frequency':
+            print "freq: %s" % self._nm_device.get_frequency()
+            return self._nm_device.get_frequency()
 
     def get_type(self):
         return 'network.wireless'
 
     def get_id(self):
         return str(self._nm_device.get_op())
+
+    def get_active_network_colors(self):
+        net = self._nm_device.get_active_network()
+        if not net:
+            return (None, None)
+        return net.get_colors()
+

shell/view/devices/network/wireless.py

@@ -15,9 +15,14 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
+from gettext import gettext as _
+
+import gtk
+
 from sugar.graphics.icon import get_icon_state
 from sugar.graphics.icon import CanvasIcon
 from sugar.graphics import style
+from sugar.graphics.palette import Palette
 
 from model.devices.network import wireless
 from model.devices import device
@@ -28,26 +33,42 @@ class DeviceView(CanvasIcon):
     def __init__(self, model):
         CanvasIcon.__init__(self, size=style.MEDIUM_ICON_SIZE)
         self._model = model
+        self._palette = WirelessPalette(self._get_palette_primary_text())
+        self.set_palette(self._palette)
+        self._counter = 0
+        self._palette.set_frequency(self._model.props.frequency)
 
         model.connect('notify::name', self._name_changed_cb)
         model.connect('notify::strength', self._strength_changed_cb)
         model.connect('notify::state', self._state_changed_cb)
 
-        self.set_tooltip(self._model.props.name)
         self._update_icon()
         self._update_state()
 
+    def _get_palette_primary_text(self):
+        if self._model.props.state == device.STATE_INACTIVE:
+            return _("Disconnected")
+        return self._model.props.name
+
     def _strength_changed_cb(self, model, pspec):
         self._update_icon()
+        # Only update frequency periodically
+        if self._counter % 4 == 0:
+            self._palette.set_frequency(self._model.props.frequency)
+        self._counter += 1
 
     def _name_changed_cb(self, model, pspec):
-        self.palette.set_primary_text(self._model.props.name)
+        self.palette.set_primary_text(self._get_palette_primary_text())
 
     def _state_changed_cb(self, model, pspec):
         self._update_state()
+        self.palette.set_primary_text(self._get_palette_primary_text())
 
     def _update_icon(self):
-        icon_name = get_icon_state(_ICON_NAME, self._model.props.strength)
+        strength = self._model.props.strength
+        if self._model.props.state == device.STATE_INACTIVE:
+            strength = 0
+        icon_name = get_icon_state(_ICON_NAME, strength)
         if icon_name:
             self.props.icon_name = icon_name
 
@@ -58,8 +79,35 @@ class DeviceView(CanvasIcon):
             self.props.fill_color = style.COLOR_INACTIVE_FILL.get_svg()
             self.props.stroke_color = style.COLOR_INACTIVE_STROKE.get_svg()
         elif state == device.STATE_ACTIVATED:
-            self.props.fill_color = None
+            (stroke, fill) = self._model.get_active_network_colors()
-            self.props.stroke_color = None
+            self.props.stroke_color = stroke
+            self.props.fill_color = fill
         elif state == device.STATE_INACTIVE:
             self.props.fill_color = style.COLOR_INACTIVE_FILL.get_svg()
             self.props.stroke_color = style.COLOR_INACTIVE_STROKE.get_svg()
+
+class WirelessPalette(Palette):
+    def __init__(self, primary_text):
+        Palette.__init__(self, primary_text)
+
+        self._chan_label = gtk.Label()
+        self._chan_label.show()
+
+        vbox = gtk.VBox()
+        vbox.pack_start(self._chan_label)
+        vbox.show()
+
+        self.set_content(vbox)
+
+    def set_frequency(self, freq):
+        chans = { 2.412: 1, 2.417: 2, 2.422: 3, 2.427: 4,
+                  2.432: 5, 2.437: 6, 2.442: 7, 2.447: 8,
+                  2.452: 9, 2.457: 10, 2.462: 11, 2.467: 12,
+                  2.472: 13
+                }
+        try:
+            chan = chans[freq]
+        except KeyError:
+            chan = 0
+        self._chan_label.set_text("%s: %d" % (_("Channel"), chan))
+

shell/view/home/MeshBox.py

@@ -49,6 +49,10 @@ class AccessPointView(PulsingIcon):
         model.connect('notify::name', self._name_changed_cb)
         model.connect('notify::state', self._state_changed_cb)
 
+        (stroke, fill) = model.get_nm_network().get_colors()
+        self._device_stroke = stroke
+        self._device_fill = fill
+
         import sha
         sh = sha.new()
         data = self._model.props.name + hex(self._model.props.capabilities) + \