clean up

1 files changed, 201 insertions, 67 deletions

diff --git a/ShareFavorites.py b/ShareFavorites.py
index 10d65c8..0c44199 100644
--- a/ShareFavorites.py
+++ b/ShareFavorites.py
@@ -13,22 +13,27 @@
 
 from gi.repository import Gtk
 from gi.repository import Gdk
-from gi.repository import GdkPixbuf
 from gi.repository import GObject
 
-import subprocess
 import os
 
 from sugar3.activity import activity
 from sugar3 import profile
 from sugar3 import env
 
-from sugar3.graphics.toolbarbox import ToolbarBox
 from sugar3.activity.widgets import ActivityToolbarButton
 from sugar3.activity.widgets import StopButton
-from sugar3.graphics.alert import Alert
 
-from toolbar_utils import (button_factory, separator_factory)
+from sugar3.graphics.toolbarbox import ToolbarBox
+from sugar3.graphics.alert import NotifyAlert, Alert
+from sugar3.graphics.icon import Icon, CanvasIcon
+from sugar3.graphics import style
+from sugar3.graphics.xocolor import XoColor
+
+from jarabe.model import bundleregistry
+from jarabe.model.session import get_session_manager
+
+from toolbar_utils import separator_factory
 from gettext import gettext as _
 
 import logging
@@ -55,42 +60,86 @@ class ShareFavorites(activity.Activity):
         ''' Initialize the toolbars and the work surface '''
         super(ShareFavorites, self).__init__(handle)
 
-        self._buddies = [profile.get_nick_name()]
-        self._colors = profile.get_color().to_string().split(',')
-        self._my_colors = self._colors[:]  # Save original colors
         self.initiating = None  # sharing (True) or joining (False)
-
-        self._first_time = True
-
-        self.old_cursor = self.get_window().get_cursor()
+        self._old_cursor = self.get_window().get_cursor()
+        self._buddy_count = 0
+        self._hboxes = []
 
         self._setup_toolbars()
         self._setup_canvas()
-
         self._setup_presence_service()
 
+        # Start with the Neighborhood View icon in the center of the screen
+        self._icon = self._create_icon('#FFFFFF,#000000',
+                                       name='zoom-neighborhood')
+        self._icon.show()
+        self._vbox.pack_end(self._icon, True, True, 0)
+        self._vbox.show()
+
     def _setup_canvas(self):
         ''' Create a canvas '''
-        self.fixed = Gtk.Fixed()
-        self.fixed.show()
-        self.set_canvas(self.fixed)
-
-        self.vbox = Gtk.VBox(False, 0)
-        self.vbox.set_size_request(Gdk.Screen.width(), Gdk.Screen.height())
-        self.fixed.put(self.vbox, 0, 0)
-        self.vbox.show()
-
-        self._canvas = Gtk.DrawingArea()
-        self._canvas.set_size_request(int(Gdk.Screen.width()),
-                                      int(Gdk.Screen.height()))
-        self._canvas.show()
-        self.show_all()
-        self.vbox.pack_end(self._canvas, True, True, 0)
-        self.vbox.show()
+        sw = Gtk.ScrolledWindow()
+        sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+        sw.show()
+
+        self.set_canvas(sw)
+
+        self._vbox = Gtk.VBox(False, 0)
+        self._vbox.set_size_request(Gdk.Screen.width(),
+                                    Gdk.Screen.height() - style.GRID_CELL_SIZE)
+        sw.add(self._vbox)
+        self._vbox.show()
+
+    def _show_bundle_icon(self, icon_path):
+        if self._icon in self._vbox:
+            self._vbox.remove(self._icon)
+        self._icon = CanvasIcon(file_name=icon_path,
+                                xo_color=XoColor('#000000,#FFFFFF'),
+                                pixel_size=style.LARGE_ICON_SIZE)
+        self._vbox.pack_end(self._icon, True, True, 0)
+        self._icon.show()
+
+    def _animate_icons(self, icon_paths):
+        if len(icon_paths) == 0:
+            # Until we set up a dbus method to update the views, we need
+            # to restart
+            # self._restart_alert()
+            self._notify_alert(title=_('Warning'),
+                               msg=_('Changes require restart'))
+            return
+        else:
+            self._show_bundle_icon(icon_paths[-1])
+            icon_paths.remove(icon_paths[-1])
+            GObject.timeout_add(500, self._animate_icons, icon_paths)
+
+    def _create_icon(self, color, name='computer-xo'):
+        return CanvasIcon(icon_name=name,
+                          xo_color=XoColor(color),
+                          pixel_size=style.STANDARD_ICON_SIZE)
+
+    def _add_buddy(self, icon, nick):
+        ''' Add buddies to sharer's canavs to show whom has shared data '''
+
+        n = int(Gdk.Screen.width() / (3 * style.STANDARD_ICON_SIZE))
+        if self._buddy_count % n == 0:
+            self._hboxes.append(Gtk.HBox(False, 0))
+            self._hboxes[-1].show()
+            self._vbox.pack_end(self._hboxes[-1], True, False, 0)
+
+        self._buddy_count += 1
+
+        vbox = Gtk.VBox(False, 0)
+        label = Gtk.Label(nick)
+        vbox.pack_start(icon, False, False, 0)
+        vbox.pack_start(label, False, False, 10)
+        icon.show()
+        label.show()
+        vbox.show()
+        self._hboxes[-1].pack_end(vbox, True, False, 0)
 
     def _setup_toolbars(self):
         ''' Setup the toolbars. '''
-        self.max_participants = 25  # sharing
+        self.max_participants = 5
 
         toolbox = ToolbarBox()
 
@@ -117,42 +166,107 @@ class ShareFavorites(activity.Activity):
         ''' No longer waiting, so restore standard cursor. '''
         if not hasattr(self, 'get_window'):
             return
-        self.get_window().set_cursor(self.old_cursor)
+        self.get_window().set_cursor(self._old_cursor)
 
     def _waiting_cursor(self):
         ''' Waiting, so set watch cursor. '''
         if not hasattr(self, 'get_window'):
             return
-        self.old_cursor = self.get_window().get_cursor()
+        self._old_cursor = self.get_window().get_cursor()
         self.get_window().set_cursor(Gdk.Cursor.new(Gdk.CursorType.WATCH))
 
-    def _dump(self, favorites):
-        ''' Dump favorites for sharing. '''
-        _logger.debug('dumping %s' % (json.dumps(favorites)))
-        return json.dumps(favorites)
-
-    def _load(self, data):
-        ''' Load favorites from a sharer. '''
-        favorites = json.loads(data)
+    def _restart_alert(self):
+        alert = Alert()
+        alert.props.title = _('Warning')
+        alert.props.msg = _('Changes require restart')
+
+        icon = Icon(icon_name='dialog-cancel')
+        alert.add_button(Gtk.ResponseType.CANCEL, _('Cancel changes'), icon)
+        icon.show()
+
+        icon = Icon(icon_name='dialog-ok')
+        alert.add_button(Gtk.ResponseType.ACCEPT, _('Later'), icon)
+        icon.show()
+
+        icon = Icon(icon_name='system-restart')
+        alert.add_button(Gtk.ResponseType.APPLY, _('Restart now'), icon)
+        icon.show()
+
+        alert.connect('response', self.__response_cb)
+        self.add_alert(alert)
+        alert.show()
+
+    def __response_cb(self, alert, response_id):
+        self.remove_alert(alert)
+
+        if response_id is Gtk.ResponseType.CANCEL:
+            pass
+        elif response_id is Gtk.ResponseType.ACCEPT:
+            pass
+        elif response_id is Gtk.ResponseType.APPLY:
+            session_manager = get_session_manager()
+            session_manager.logout()
+
+    def _notify_alert(self, title='', msg='', action=None):
+        ''' Notify user when xfer is completed '''
+
+        def _notification_alert_response_cb(alert, response_id, self, action):
+            self.remove_alert(alert)
+            if action is not None:
+                action()
+
+        alert = NotifyAlert()
+        alert.props.title = title
+        alert.connect('response', _notification_alert_response_cb, self,
+                      action)
+        alert.props.msg = msg
+        self.add_alert(alert)
+        alert.show()
 
     # When favorites are shared, the sharer sends out list; joiners
     # receive the list.
     def _read_favorites(self):
         favorites_path = os.path.join(env.get_profile_path(),
                                       'favorite_activities')
-        logging.debug('read favorities: %s' % (favorites_path))
-        fd = open(favorites_path, 'r')
-        data = fd.read()
-        fd.close()
-        return self._dump(data)
+        favorites = json.load(open(favorites_path))
+        return favorites
 
     def _save_favorites(self, favorites):
         favorites_path = os.path.join(env.get_profile_path(),
                                       'favorite_activities')
-        logging.debug('save favorities: %s' % (favorites_path))
-        fd = open(favorites_path, 'w')
-        fd.write(favorites)
-        fd.close()
+        json.dump(favorites, open(favorites_path, 'w'), indent=1)
+
+    def _unset_favorites(self, favorites_data):
+        favorites = favorites_data['favorites']
+        keys = favorites.keys()
+        registry = bundleregistry.get_registry()
+        for bundle in keys:
+            bundle = bundle.encode('ascii', 'replace')
+            bundle_id, version = bundle.split(' ')
+            logging.debug('removing %s' % (bundle_id))
+            registry.set_bundle_favorite(bundle_id, version, False)
+
+    def _set_favorites(self, data):
+        # data is coming over tube, so it needs to be decoded
+        favorites_data = json.loads(data)
+        favorites = favorites_data['favorites']
+        keys = favorites.keys()
+        registry = bundleregistry.get_registry()
+        icon_paths = []
+        for bundle in keys:
+            bundle = bundle.encode('ascii', 'replace')
+            bundle_id, version = bundle.split(' ')
+            try:
+                logging.debug('adding %s' % (bundle_id))
+                registry.set_bundle_favorite(bundle_id, version, True)
+                icon_path = registry.get_bundle(bundle_id).get_icon()
+                if os.path.exists(icon_path):
+                    icon_paths.append(icon_path)
+            except:
+                logging.debug('bundle %s version %s not available' %
+                              (bundle_id, version))
+
+        self._animate_icons(icon_paths)
 
     def _setup_presence_service(self):
         ''' Setup the Presence Service. '''
@@ -184,10 +298,11 @@ class ShareFavorites(activity.Activity):
             'NewTube', self._new_tube_cb)
 
         _logger.debug('This is my activity: making a tube...')
-        id = self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].OfferDBusTube(
+        self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].OfferDBusTube(
             SERVICE, {})
 
-        self._share_favorites()  # delete me
+        if self._icon in self._vbox:
+            self._vbox.remove(self._icon)
 
     def _joined_cb(self, activity):
         ''' ...or join an exisiting share. '''
@@ -203,7 +318,7 @@ class ShareFavorites(activity.Activity):
         self.tubes_chan = self.shared_activity.telepathy_tubes_chan
         self.text_chan = self.shared_activity.telepathy_text_chan
 
-        self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].connect_to_signal(\
+        self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].connect_to_signal(
             'NewTube', self._new_tube_cb)
 
         _logger.debug('I am joining an activity: waiting for a tube...')
@@ -214,6 +329,13 @@ class ShareFavorites(activity.Activity):
         self.waiting = True
         self._waiting_cursor()
 
+        if self._icon in self._vbox:
+            self._vbox.remove(self._icon)
+
+        self._notify_alert(title=_('Share Favorites'),
+                           msg=_('Downloading favorites... please wait.'),
+                           action=self._share_favorites)
+
     def _list_tubes_reply_cb(self, tubes):
         ''' Reply to a list request. '''
         for tube_info in tubes:
@@ -226,20 +348,22 @@ class ShareFavorites(activity.Activity):
     def _new_tube_cb(self, id, initiator, type, service, params, state):
         ''' Create a new tube. '''
         _logger.debug('New tube: ID=%d initator=%d type=%d service=%s '
-                     'params=%r state=%d', id, initiator, type, service,
-                     params, state)
+                      'params=%r state=%d', id, initiator, type, service,
+                      params, state)
 
         if (type == telepathy.TUBE_TYPE_DBUS and service == SERVICE):
             if state == telepathy.TUBE_STATE_LOCAL_PENDING:
-                self.tubes_chan[ \
-                              telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(id)
+                self.tubes_chan[
+                    telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(id)
 
-            tube_conn = TubeConnection(self.conn,
-                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES], id, \
+            tube_conn = TubeConnection(
+                self.conn,
+                self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
+                id,
                 group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])
 
-            self.chattube = ChatTube(tube_conn, self.initiating, \
-                self.event_received_cb)
+            self.chattube = ChatTube(tube_conn, self.initiating,
+                                     self.event_received_cb)
 
     def event_received_cb(self, text):
         ''' Data is passed as tuples: cmd:text '''
@@ -253,16 +377,26 @@ class ShareFavorites(activity.Activity):
         if self.initiating:
             self._share_favorites()
 
-    def _update_favorites(self, data):
-        favorites = self._dump(data)
-        self._save_favorites(favorities)
+    def _update_favorites(self, favorites):
+        self._set_favorites(favorites)
         self._restore_cursor()
-        # TODO: Update homeview
 
-    def _share_favorites(self):
+    def _share_favorites(self, data=None):
+        logging.debug('SHARE FAVORITES %s' % (str(self.initiating)))
         if self.initiating:
-            _logger.debug('sharing favorites')
-            self._send_event('F:%s' % (self._read_favorites()))
+            favorites = self._read_favorites()
+            self._send_event('F:%s' % (json.dumps(favorites)))
+            data_array = json.loads(data)
+            nick = data_array[0]
+            colors = data_array[1].encode('ascii', 'replace')
+            icon = self._create_icon(colors)
+            self._add_buddy(icon, nick)
+        else:
+            favorites_data = self._read_favorites()
+            self._unset_favorites(favorites_data)
+            nick = profile.get_nick_name()
+            colors = profile.get_color().to_string()
+            self._send_event('f:%s' % (json.dumps([nick, colors])))
 
     def _send_event(self, text):
         ''' Send event through the tube. '''