Merge lp:~dobey/ubuntuone-client/updown-visibility into lp:ubuntuone-client

[dobey]

Handle the new ContentQueue signal
Maintain state for transfer status information
Change the left click behavior to open a menu by default
Update a menu item in the left click menu with transfer status
Pop up notifications to signal start and end of transfers

[John O'Brien (jdobrien)]

changes look good, tests run, and it doesn't break ubunet....who could ask for anything more!

[John O'Brien (jdobrien)]

...except that the reviewer select "Approve"

review: Approve

[Joshua Blount (jblount)]

review: Approve

=== modified file 'bin/ubuntuone-client-applet'
--- bin/ubuntuone-client-applet	2009-08-18 19:47:56 +0000
+++ bin/ubuntuone-client-applet	2009-08-24 01:12:37 +0000
@@ -40,6 +40,7 @@
 from dbus.mainloop.glib import DBusGMainLoop
 from ubuntuone.oauthdesktop.main import Login
 from xdg.BaseDirectory import xdg_config_home
+from threading import Lock
 from urllib import quote
 
 from ubuntuone.oauthdesktop.logger import setupLogging
@@ -311,8 +312,9 @@
             self.__size = 24
             self.__size_changed(self, self.__size)
 
-            self.__items = {}
-            self.__menu = self.__build_menus()
+            self.__litems = {}
+            self.__ritems = {}
+            self.__status_menu, self.__config_menu = self.__build_menus()
 
             self.__connected = False
             self.__need_update = False
@@ -321,10 +323,15 @@
             pynotify.init("Ubuntu One")
 
             # Managing applet visibility
-            self.__persist = True
             self.__visible = True
             self.__visible_id = 0
 
+            # Up/Dn status
+            self.__lock = Lock()
+            self.__updating = 0
+            self.__total = 0
+            self.__last_id = 0
+
             self.__bus = dbus.SessionBus()
 
             self.__bus.add_signal_receiver(
@@ -332,28 +339,140 @@
                   signal_name="StatusChanged",
                   dbus_interface=DBUS_IFACE_STATUS_NAME)
 
+            self.__bus.add_signal_receiver(
+                  handler_function=self.__queue_changed,
+                  signal_name="ContentQueueChanged",
+                  dbus_interface=DBUS_IFACE_STATUS_NAME)
+            self.__bus.add_signal_receiver(
+                  handler_function=self.__transfer_started,
+                  signal_name="UploadStarted",
+                  dbus_interface=DBUS_IFACE_STATUS_NAME)
+            self.__bus.add_signal_receiver(
+                  handler_function=self.__transfer_started,
+                  signal_name="DownloadStarted",
+                  dbus_interface=DBUS_IFACE_STATUS_NAME)
+
             gobject.idle_add(self.__get_root)
 
+      def __update_transfer_status(self, done=False):
+            """Update the status display."""
+            with self.__lock:
+                  text = "Updating %(transfers)d of %(total)d files..." % (
+                        { 'transfers' : self.__updating,
+                          'total' : self.__total})
+            label = self.__litems["status"].get_child()
+            if done:
+                  self.set_tooltip(_("Files updated."))
+                  label.set_text(_("Your files are up to date."))
+            else:
+                  label.set_markup("<i>%s</i>" % text)
+
+      def __queue_changed(self, queue):
+            """Handle ContentQueueChanged."""
+            total = 0
+            d = queue.get('Download', None)
+            if d is not None:
+                  total += int(d.get('count', 0))
+            d = queue.get('Upload', None)
+            if d is not None:
+                  total += int(d.get('count', 0))
+            first = False
+            last = False
+            self.__visible = True
+            self.set_tooltip(_("Updating files..."))
+            self.__update_visibility()
+            with self.__lock:
+                  if self.__total == 0:
+                        first = True
+                        last = False
+                  if self.__total != 0 and total == 0:
+                        first = False
+                        last = True
+                  self.__total = total + self.__updating
+            if first:
+                  n = pynotify.Notification(
+                        "Updating Files...",
+                        _("Ubuntu One is now updating your files."))
+                  pixbuf = self.__theme.load_icon(
+                        "ubuntuone-client", 24,
+                        gtk.ICON_LOOKUP_GENERIC_FALLBACK)
+                  n.set_icon_from_pixbuf(pixbuf)
+                  n.show()
+            if last:
+                  if self.__last_id != 0:
+                        gobject.source_remove(self.__last_id)
+                        self.__last_id = 0
+                  self.__last_id = gobject.timeout_add_seconds(
+                        15, self.__updating_completed)
+
+      def __updating_completed(self):
+            """Timeout to avoid multiple started/finished notifications."""
+            really_last = False
+            n = None
+            with self.__lock:
+                  done = self.__total - self.__updating
+                  if done == 0:
+                        really_last = True
+            if not really_last:
+                  return False
+
+            with self.__lock:
+                  n = pynotify.Notification(
+                        "Updating Finished",
+                        _("Ubuntu One finished updating %(total)d files.") %
+                        { 'total' : self.__total })
+                  self.__total = 0
+                  self.__updating = 0
+            pixbuf = self.__theme.load_icon(
+                  "ubuntuone-client", 24,
+                  gtk.ICON_LOOKUP_GENERIC_FALLBACK)
+            n.set_icon_from_pixbuf(pixbuf)
+            n.show()
+            self.__update_transfer_status(True)
+            return False
+
+      def __transfer_started(self, path):
+            """Handle the started signals."""
+            with self.__lock:
+                  self.__updating += 1
+            self.__update_transfer_status()
+
+      def __update_visibility(self):
+            """Update the icon's visibility."""
+            if self.__visible_id != 0:
+                  gobject.source_remove(self.__visible_id)
+                  self.__visible_id = 0
+
+            if self.__visible:
+                  self.set_visible(True)
+                  return
+
+            # If the icon is shown, set up a timeout to hide it
+            if self.get_visible():
+                  self.__visible_id = gobject.timeout_add_seconds(
+                        30, self.__hide_icon)
+
       def __status_changed(self, status):
             """The sync daemon status changed."""
             if self.__managed_dir is None:
                 gobject.idle_add(self.__get_root)
 
-            self.__persist = False
-            self.__visible = True
+            self.__visible = False
+            state = status['name']
 
-            if status['name'] == "OFFLINE" or \
-                      status['name'].startswith("INIT") or \
-                      status['name'].startswith("READY"):
+            if state == "OFFLINE" or state.startswith("INIT") or \
+                      state.startswith("READY"):
                   self.set_from_icon_name("ubuntuone-client-offline")
                   self.__connected = False
-                  self.__persist = True
                   self.__visible = True
-            elif status['name'] == "AUTH_FAILED":
+            elif state == "IDLE" or state.startswith("READING") or \
+                      state.startswith("SCANNING"):
+                  self.__connected = True
+                  self.__visible = False
+            elif state == "AUTH_FAILED":
                   self.set_from_icon_name("ubuntuone-client-error")
                   self.set_tooltip(_("Authentication failed"))
                   self.__connected = False
-                  self.__persist = True
                   self.__visible = True
                   try:
                         def reauthorize_error(error):
@@ -374,17 +493,16 @@
                                           error_handler=reauthorize_error)
                   except DBusException:
                         pass
-            elif status['name'] == "UNKNOWN_ERROR":
+            elif state == "UNKNOWN_ERROR":
                   # Disable some menu items
-                  self.__items["connect"].set_sensitive(False)
-                  self.__items["disconnect"].set_sensitive(False)
+                  self.__litems["connect"].set_sensitive(False)
+                  self.__litems["disconnect"].set_sensitive(False)
                   # Change the behavior to file a bug
                   if self.__fatal_error:
                         return
 
                   self.__fatal_error = True
-                  self.__persist = True
-                  self.__visibile = True
+                  self.__visible = True
 
                   # Pop up a notification
                   n = pynotify.Notification(
@@ -402,45 +520,28 @@
                   # Set the tooltip and icon on the applet
                   self.set_tooltip(_("Fatal Error"))
                   self.set_from_icon_name("ubuntuone-client-error")
-                  if self.__visible_id != 0:
-                        gobject.source_remove(self.__visible_id)
-                        self.__visible_id = 0
-                  self.set_visible(True)
-                  return
             else:
                   self.__connected = True
                   self.set_from_icon_name("ubuntuone-client")
-                  self.__visible = True
-                  if status['name'].startswith("CONNECTING") or \
-                            status['name'].startswith("START_CONNECTING") or \
-                            status['name'].startswith("AUTHENTICATING") or \
-                            status['name'].startswith("CONNECTED"):
-                        self.set_from_icon_name("ubuntuone-client-offline")
+                  if state.startswith("CONNECTING") or \
+                            state.startswith("START_CONNECTING") or \
+                            state.startswith("AUTHENTICATING") or \
+                            state.startswith("CONNECTED") or \
+                            state.startswith("START_CONNECTED"):
+                        self.set_from_icon_name("ubuntuone-client")
                         self.set_tooltip(_("Connecting"))
-                  else:
-                        self.set_tooltip("Ubuntu One")
-                        self.__visible = False
+                        self.__visible = True
 
-            # If we're visible, set up a reasonable timeout to hide ourself,
-            # and if not shown yet, show ourself
-            if self.__visible:
-                  if not self.get_visible():
-                        self.set_visible(True)
-                  if self.__visible_id != 0:
-                        gobject.source_remove(self.__visible_id)
-                        self.__visible_id = 0
-                  if not self.__persist:
-                        self.__visible_id = gobject.timeout_add_seconds(
-                              30, self.__toggle_visible)
+            self.__update_visibility()
 
             if self.__connected:
-                  self.__items["connect"].hide()
-                  self.__items["disconnect"].show()
+                  self.__litems["connect"].hide()
+                  self.__litems["disconnect"].show()
             else:
-                  self.__items["connect"].show()
-                  self.__items["disconnect"].hide()
+                  self.__litems["connect"].show()
+                  self.__litems["disconnect"].hide()
 
-      def __toggle_visible(self):
+      def __hide_icon(self):
             """Timeout to hide tray icon after a period of inactivity."""
             self.__visible = False
             self.__visible_id = 0
@@ -464,16 +565,16 @@
                   if os.path.isdir(self.__managed_dir) and \
                             os.access(self.__managed_dir,
                                       os.F_OK | os.R_OK):
-                        self.__items["open"].set_sensitive(True)
+                        self.__ritems["open"].set_sensitive(True)
                         self.__add_to_places()
                   else:
-                        self.__items["open"].set_sensitive(False)
+                        self.__ritems["open"].set_sensitive(False)
 
             def got_err(error):
                   """Handle error from the dbus callback."""
                   self.dbus_error(error)
                   self.__managed_dir = None
-                  self.__items["open"].set_sensitive(False)
+                  self.__ritems["open"].set_sensitive(False)
 
             iface.get_rootdir(reply_handler=got_root, error_handler=got_err)
 
@@ -491,49 +592,63 @@
 
       def __build_menus(self):
             """Create the pop-up menu items."""
-            menu = gtk.Menu()
-
-            self.__items["connect"] = gtk.ImageMenuItem(stock_id=gtk.STOCK_CONNECT)
-            menu.append(self.__items["connect"])
-            self.__items["connect"].connect("activate", self.__toggle_state)
-            self.__items["connect"].show()
-
-            self.__items["disconnect"] = gtk.ImageMenuItem(stock_id=gtk.STOCK_DISCONNECT)
-            menu.append(self.__items["disconnect"])
-            self.__items["disconnect"].connect("activate", self.__toggle_state)
-
-            sep = gtk.SeparatorMenuItem()
-            menu.append(sep)
-            sep.show()
-
-            self.__items["bug"] = gtk.MenuItem(label=_("_Report a Problem"))
-            menu.append(self.__items["bug"])
-            self.__items["bug"].connect("activate", self.__report_problem)
-            self.__items["bug"].show()
-
-            self.__items["open"] = gtk.MenuItem(label=_("_Open Folder"))
-            menu.append(self.__items["open"])
-            self.__items["open"].connect("activate", self.__open_folder)
-            self.__items["open"].set_sensitive(False)
-            self.__items["open"].show()
-
-            self.__items["web"] = gtk.MenuItem(label=_("_Go to Web"))
-            menu.append(self.__items["web"])
-            self.__items["web"].connect("activate", self.__open_website)
-            self.__items["web"].show()
-
-            sep = gtk.SeparatorMenuItem()
-            menu.append(sep)
-            sep.show()
-
-            self.__items["quit"] = gtk.ImageMenuItem(stock_id=gtk.STOCK_QUIT)
-            menu.append(self.__items["quit"])
-            self.__items["quit"].connect("activate", self.__quit_applet)
-            self.__items["quit"].show()
-
-            menu.show()
-
-            return menu
+            # Create the left-click menu
+            lmenu = gtk.Menu()
+
+            self.__litems["status"] = gtk.MenuItem(
+                  label=_("Your files are up to date."))
+            lmenu.append(self.__litems["status"])
+            self.__litems["status"].set_sensitive(False)
+            self.__litems["status"].show()
+
+            sep = gtk.SeparatorMenuItem()
+            lmenu.append(sep)
+            sep.show()
+
+            self.__litems["connect"] = gtk.ImageMenuItem(
+                  stock_id=gtk.STOCK_CONNECT)
+            lmenu.append(self.__litems["connect"])
+            self.__litems["connect"].connect("activate", self.__toggle_state)
+            self.__litems["connect"].show()
+
+            self.__litems["disconnect"] = gtk.ImageMenuItem(
+                  stock_id=gtk.STOCK_DISCONNECT)
+            lmenu.append(self.__litems["disconnect"])
+            self.__litems["disconnect"].connect("activate", self.__toggle_state)
+
+            lmenu.show()
+
+            # Create the right-click menu
+            rmenu = gtk.Menu()
+
+            self.__ritems["bug"] = gtk.MenuItem(label=_("_Report a Problem"))
+            rmenu.append(self.__ritems["bug"])
+            self.__ritems["bug"].connect("activate", self.__report_problem)
+            self.__ritems["bug"].show()
+
+            self.__ritems["open"] = gtk.MenuItem(label=_("_Open Folder"))
+            rmenu.append(self.__ritems["open"])
+            self.__ritems["open"].connect("activate", self.__open_folder)
+            self.__ritems["open"].set_sensitive(False)
+            self.__ritems["open"].show()
+
+            self.__ritems["web"] = gtk.MenuItem(label=_("_Go to Web"))
+            rmenu.append(self.__ritems["web"])
+            self.__ritems["web"].connect("activate", self.__open_website)
+            self.__ritems["web"].show()
+
+            sep = gtk.SeparatorMenuItem()
+            rmenu.append(sep)
+            sep.show()
+
+            self.__ritems["quit"] = gtk.ImageMenuItem(stock_id=gtk.STOCK_QUIT)
+            rmenu.append(self.__ritems["quit"])
+            self.__ritems["quit"].connect("activate", self.__quit_applet)
+            self.__ritems["quit"].show()
+
+            rmenu.show()
+
+            return lmenu, rmenu
 
       def __size_changed(self, icon, size, data=None):
             """Callback for when the size changes."""
@@ -550,8 +665,14 @@
 
       def __popup_menu(self, icon, button, timestamp, data=None):
             """Pops up the context menu for the tray icon."""
-            self.__menu.popup(None, None, gtk.status_icon_position_menu,
-                              button, timestamp, icon)
+            if button == 0:
+                  self.__status_menu.popup(None, None,
+                                           gtk.status_icon_position_menu,
+                                           button, timestamp, icon)
+            else:
+                  self.__config_menu.popup(None, None,
+                                           gtk.status_icon_position_menu,
+                                           button, timestamp, icon)
 
       def __quit_applet(self, menuitem, data=None):
             """Quit the daemon and closes the applet."""
@@ -601,7 +722,8 @@
                   do_xdg_open("apt:ubuntuone-storage-protocol?refresh=yes")
                   return
 
-            self.__open_folder()
+            # Popup the status menu
+            self.emit("popup-menu", 0, gtk.get_current_event_time())
 
       def __report_problem(self, data=None):
             """Runs apport to report a problem against our code."""