Ticket #4758: sugar-toolkit-gtk3.diff

.olpcau.x86_64/usr/bin/sugar-activity-web

@@ -17 +17 @@
 # Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 # Boston, MA 02111-1307, USA.
 
-exec sugar-activity sugar3.activity.webactivity.WebActivity $@
+if [ "$SUGAR_USE_WEBKIT1" == "yes" ]; then
+    exec sugar-activity sugar3.activity.webkit1.WebActivity $@
+else
+    exec sugar-activity sugar3.activity.webactivity.WebActivity $@
+fi

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/activity/activityfactory.py

@@ -124 +124 @@
         if os.path.exists(absolute_path):
             command[0] = absolute_path
 
-    logging.debug('launching: %r', command)
+    logging.debug('launching: %r' % command)
 
     return command
 
@@ -265 +265 @@
         pass
 
     def _notify_launch_failure_error_handler(self, err):
-        logging.error('Notify launch failure failed %s', err)
+        logging.error('Notify launch failure failed %s' % err)
 
     def _notify_launch_error_handler(self, err):
-        logging.debug('Notify launch failed %s', err)
+        logging.debug('Notify launch failed %s' % err)
 
     def _activate_reply_handler(self, activated):
         if not activated:
             self._create_activity()
 
     def _activate_error_handler(self, err):
-        logging.error('Activity activation request failed %s', err)
+        logging.error('Activity activation request failed %s' % err)
 
     def _create_reply_handler(self):
-        logging.debug('Activity created %s (%s).',
-                      self._handle.activity_id, self._service_name)
+        logging.debug('Activity created %s (%s).' %
+                      (self._handle.activity_id, self._service_name))
 
     def _create_error_handler(self, err):
-        logging.error("Couldn't create activity %s (%s): %s",
-                      self._handle.activity_id, self._service_name, err)
+        logging.error("Couldn't create activity %s (%s): %s" %
+                      (self._handle.activity_id, self._service_name, err))
         self._shell.NotifyLaunchFailure(
             self._handle.activity_id, reply_handler=self._no_reply_handler,
             error_handler=self._notify_launch_failure_error_handler)
@@ -296 +296 @@
         self._launch_activity()
 
     def _find_object_error_handler(self, err):
-        logging.error('Datastore find failed %s', err)
+        logging.error('Datastore find failed %s' % err)
         self._launch_activity()
 
 

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/activity/activity.py

@@ -58 +58 @@
 import cairo
 import json
 
-from gi.repository import GConf
 from gi.repository import Gtk
 from gi.repository import Gdk
 from gi.repository import GObject
+from gi.repository import Gio
 import dbus
 import dbus.service
 from dbus import PROPERTIES_IFACE
@@ -74 +74 @@
 from telepathy.constants import CONNECTION_HANDLE_TYPE_ROOM
 
 from sugar3 import util
+from sugar3 import power
 from sugar3.presence import presenceservice
 from sugar3.activity.activityservice import ActivityService
 from sugar3.graphics import style
@@ -81 +82 @@
 from sugar3.graphics.alert import Alert
 from sugar3.graphics.icon import Icon
 from sugar3.datastore import datastore
+from sugar3.bundle.activitybundle import ActivityBundle
 from gi.repository import SugarExt
 
 _ = lambda msg: gettext.dgettext('sugar-toolkit-gtk3', msg)
@@ -93 +95 @@
 J_DBUS_PATH = '/org/laptop/Journal'
 J_DBUS_INTERFACE = 'org.laptop.Journal'
 
-POWERD_INHIBIT_DIR = '/var/run/powerd-inhibit-suspend'
+N_BUS_NAME = 'org.freedesktop.Notifications'
+N_OBJ_PATH = '/org/freedesktop/Notifications'
+N_IFACE_NAME = 'org.freedesktop.Notifications'
 
 CONN_INTERFACE_ACTIVITY_PROPERTIES = 'org.laptop.Telepathy.ActivityProperties'
 
@@ -161 +165 @@
 
         1. implement an __init__() method for your Activity class.
 
-           Use your init method to create your own ActivityToolbar which will
-           contain some standard buttons:
-                toolbox = activity.ActivityToolbox(self)
+           Use your init method to create your own ToolbarBox.
+           This is the code to make a basic toolbar with the activity
+           toolbar and a stop button.
+                from sugar3.graphics.toolbarbox import ToolbarBox
+                from sugar3.activity.widgets import ActivityToolbarButton
+                from sugar3.activity.widgets import StopButton
+
+                ...
+
+                toolbar_box = ToolbarBox()
+                activity_button = ActivityToolbarButton(self)
+                toolbar_box.toolbar.insert(activity_button, 0)
+                activity_button.show()
+
+                ... Your toolbars ...
+
+                separator = Gtk.SeparatorToolItem(draw=False)
+                separator.set_expand(True)
+                toolbar_box.toolbar.insert(separator, -1)
+                separator.show()
+
+                stop_button = StopButton(self)
+                toolbar_box.toolbar.insert(stop_button, -1)
+                stop_button.show()
+
+                self.set_toolbar_box(toolbar_box)
+                toolbar_box.show()
 
            Add extra Toolbars to your toolbox.
 
@@ -197 +225 @@
            Usually, you will also need the standard EditToolbar. This is the
            one which has the standard copy and paste buttons. You need to
            derive your own EditToolbar class from sugar3.EditToolbar:
-                class EditToolbar(activity.EditToolbar):
+                from sugar3.activity.widgets import EditToolbar
+
+                class MyEditToolbar(EditToolbar):
                     ...
 
            See EditToolbar for the methods you should implement in your class.
@@ -377 +407 @@
 
     def _initialize_journal_object(self):
         title = _('%s Activity') % get_bundle_name()
-        client = GConf.Client.get_default()
-        icon_color = client.get_string('/desktop/sugar/user/color')
+        settings = Gio.Settings('org.sugarlabs.user')
+        icon_color = settings.get_string('color')
 
         jobject = datastore.create()
         jobject.metadata['title'] = title
@@ -406 +436 @@
 
     def _set_up_sharing(self, mesh_instance, share_scope):
         # handle activity share/join
-        logging.debug('*** Act %s, mesh instance %r, scope %s',
-                      self._activity_id, mesh_instance, share_scope)
+        logging.debug('*** Act %s, mesh instance %r, scope %s' %
+                      (self._activity_id, mesh_instance, share_scope))
         if mesh_instance is not None:
             # There's already an instance on the mesh, join it
-            logging.debug('*** Act %s joining existing mesh instance %r',
-                          self._activity_id, mesh_instance)
+            logging.debug('*** Act %s joining existing mesh instance %r' %
+                          (self._activity_id, mesh_instance))
             self.shared_activity = mesh_instance
             self.shared_activity.connect('notify::private',
                                          self.__privacy_changed_cb)
@@ -423 +453 @@
                 self.__joined_cb(self.shared_activity, True, None)
         elif share_scope != SCOPE_PRIVATE:
             logging.debug('*** Act %s no existing mesh instance, but used to '
-                          'be shared, will share', self._activity_id)
+                          'be shared, will share' % self._activity_id)
             # no existing mesh instance, but activity used to be shared, so
             # restart the share
             if share_scope == SCOPE_INVITE_ONLY:
@@ -431 +461 @@
             elif share_scope == SCOPE_NEIGHBORHOOD:
                 self.share(private=False)
             else:
-                logging.debug('Unknown share scope %r', share_scope)
+                logging.debug('Unknown share scope %r' % share_scope)
 
     def __got_channel_cb(self, wait_loop, connection_path, channel_path,
                          handle_type):
@@ -546 +576 @@
         pass
 
     def __jobject_error_cb(self, err):
-        logging.debug('Error creating activity datastore object: %s', err)
+        logging.debug('Error creating activity datastore object: %s' % err)
 
     def get_activity_root(self):
         """ FIXME: Deprecated. This part of the API has been moved
@@ -608 +638 @@
         """
         raise NotImplementedError
 
+    def notify_user(self, summary, body):
+        """
+        Display a notification with the given summary and body.
+        The notification will go under the activities icon in the frame.
+        """
+        bundle = ActivityBundle(get_bundle_path())
+        icon = bundle.get_icon()
+
+        bus = dbus.SessionBus()
+        notify_obj = bus.get_object(N_BUS_NAME, N_OBJ_PATH)
+        notifications = dbus.Interface(notify_obj, N_IFACE_NAME)
+
+        notifications.Notify(self.get_id(), 0, '', summary, body, [],
+                             {'x-sugar-icon-file-name': icon}, -1)
+
     def __save_cb(self):
         logging.debug('Activity.__save_cb')
         self._updating_jobject = False
@@ -624 +669 @@
         if self._closing:
             self._show_keep_failed_dialog()
             self._closing = False
-        raise RuntimeError('Error saving activity object to datastore: %s',
+        raise RuntimeError('Error saving activity object to datastore: %s' %
                            err)
 
     def _cleanup_jobject(self):
         if self._jobject:
             if self._owns_file and os.path.isfile(self._jobject.file_path):
-                logging.debug('_cleanup_jobject: removing %r',
+                logging.debug('_cleanup_jobject: removing %r' %
                               self._jobject.file_path)
                 os.remove(self._jobject.file_path)
             self._owns_file = False
@@ -717 +762 @@
             logging.debug('Cannot save, no journal object.')
             return
 
-        logging.debug('Activity.save: %r', self._jobject.object_id)
+        logging.debug('Activity.save: %r' % self._jobject.object_id)
 
         if self._updating_jobject:
             logging.info('Activity.save: still processing a previous request.')
@@ -764 +809 @@
         Activities should not override this method. Instead, like save() do any
         copy work that needs to be done in write_file()
         """
-        logging.debug('Activity.copy: %r', self._jobject.object_id)
+        logging.debug('Activity.copy: %r' % self._jobject.object_id)
         self.save()
         self._jobject.object_id = None
 
     def __privacy_changed_cb(self, shared_activity, param_spec):
-        logging.debug('__privacy_changed_cb %r', shared_activity.props.private)
+        logging.debug('__privacy_changed_cb %r' %
+                      shared_activity.props.private)
         if shared_activity.props.private:
             self._jobject.metadata['share-scope'] = SCOPE_INVITE_ONLY
         else:
             self._jobject.metadata['share-scope'] = SCOPE_NEIGHBORHOOD
 
-    def _inhibit_suspend(self):
-        if not os.path.exists(POWERD_INHIBIT_DIR):
-            return
-
-        path = os.path.join(POWERD_INHIBIT_DIR, str(os.getpid()))
-        try:
-            fd = open(path, 'w')
-        except IOError:
-            logging.error("Inhibit Suspend: Could not create file %s", path)
-        else:
-            fd.close()
-
     def __joined_cb(self, activity, success, err):
         """Callback when join has finished"""
-        logging.debug('Activity.__joined_cb %r', success)
+        logging.debug('Activity.__joined_cb %r' % success)
         self.shared_activity.disconnect(self._join_id)
         self._join_id = None
         if not success:
-            logging.debug('Failed to join activity: %s', err)
+            logging.debug('Failed to join activity: %s' % err)
             return
 
-        self._inhibit_suspend()
+        power_manager = power.get_power_manager()
+        if power_manager.suspend_breaks_collaboration():
+            power_manager.inhibit_suspend()
 
         self.reveal()
         self.emit('joined')
@@ -817 +853 @@
 
     def __share_cb(self, ps, success, activity, err):
         if not success:
-            logging.debug('Share of activity %s failed: %s.',
-                          self._activity_id, err)
+            logging.debug('Share of activity %s failed: %s.' %
+                          (self._activity_id, err))
             return
 
-        logging.debug('Share of activity %s successful, PS activity is %r.',
-                      self._activity_id, activity)
+        logging.debug('Share of activity %s successful, PS activity is %r.' %
+                      (self._activity_id, activity))
 
         activity.props.name = self._jobject.metadata['title']
 
-        self._inhibit_suspend()
+        power_manager = power.get_power_manager()
+        if power_manager.suspend_breaks_collaboration():
+            power_manager.inhibit_suspend()
 
         self.shared_activity = activity
         self.shared_activity.connect('notify::private',
@@ -880 +918 @@
             raise RuntimeError('Activity %s already shared.' %
                                self._activity_id)
         verb = private and 'private' or 'public'
-        logging.debug('Requesting %s share of activity %s.', verb,
-                      self._activity_id)
+        logging.debug('Requesting %s share of activity %s.' % (verb,
+                      self._activity_id))
         pservice = presenceservice.get_instance()
         pservice.connect('activity-shared', self.__share_cb)
         pservice.share_activity(self, private=private)
@@ -943 +981 @@
         # Make the exported object inaccessible
         dbus.service.Object.remove_from_connection(self._bus)
 
-        if os.path.exists(POWERD_INHIBIT_DIR):
-            path = os.path.join(POWERD_INHIBIT_DIR, str(os.getpid()))
-            if os.path.exists(path):
-                os.unlink(path)
-
         self._session.unregister(self)
+        power.get_power_manager().shutdown()
 
     def close(self, skip_save=False):
         """Request that the activity be stopped and saved to the Journal
@@ -1032 +1066 @@
             CHANNEL + '.TargetHandleType': CONNECTION_HANDLE_TYPE_CONTACT,
         }
         filter_dict = dbus.Dictionary(filters, signature='sv')
-        logging.debug('__get_filters_cb %r', dbus.Array([filter_dict],
-                                                        signature='a{sv}'))
+        logging.debug('__get_filters_cb %r' % dbus.Array([filter_dict],
+                      signature='a{sv}'))
         return dbus.Array([filter_dict], signature='a{sv}')
 
     @dbus.service.method(dbus_interface=CLIENT_HANDLER,
                          in_signature='ooa(oa{sv})aota{sv}', out_signature='')
     def HandleChannels(self, account, connection, channels, requests_satisfied,
                        user_action_time, handler_info):
-        logging.debug('HandleChannels\n\t%r\n\t%r\n\t%r\n\t%r\n\t%r\n\t%r',
-                      account, connection, channels, requests_satisfied,
-                      user_action_time, handler_info)
+        logging.debug('HandleChannels\n\t%r\n\t%r\n\t%r\n\t%r\n\t%r\n\t%r' %
+                      (account, connection, channels, requests_satisfied,
+                          user_action_time, handler_info))
         try:
             for object_path, properties in channels:
                 channel_type = properties[CHANNEL + '.ChannelType']

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/activity/bundlebuilder.py

@@ -19 +19 @@
 STABLE.
 """
 
+import argparse
 import operator
 import os
 import sys
 import zipfile
 import tarfile
+import unittest
 import shutil
 import subprocess
 import re
 import gettext
-from optparse import OptionParser
 import logging
 from fnmatch import fnmatch
 
@@ -64 +65 @@
 
 class Config(object):
 
-    def __init__(self, source_dir):
+    def __init__(self, source_dir, dist_dir=None, dist_name=None):
         self.source_dir = source_dir
         self.build_dir = os.getcwd()
-        self.dist_dir = os.path.join(self.build_dir, 'dist')
+        self.dist_dir = dist_dir or os.path.join(self.build_dir, 'dist')
+        self.dist_name = dist_name
         self.bundle = None
         self.version = None
         self.activity_name = None
@@ -91 +93 @@
         self.bundle_name = reduce(operator.add, self.activity_name.split())
         self.bundle_root_dir = self.bundle_name + '.activity'
         self.tar_root_dir = '%s-%s' % (self.bundle_name, self.version)
-        self.xo_name = '%s-%s.xo' % (self.bundle_name, self.version)
-        self.tar_name = '%s-%s.tar.bz2' % (self.bundle_name, self.version)
+        if self.dist_name:
+            self.xo_name = '%s.xo' % self.dist_name
+            self.tar_name = '%s.tar.bz2' % self.dist_name
+        else:
+            self.xo_name = '%s-%s.xo' % (self.bundle_name, self.version)
+            self.tar_name = '%s-%s.tar.bz2' % (self.bundle_name, self.version)
 
 
 class Builder(object):
@@ -258 +264 @@
         self.config.bundle.install_mime_type(self.config.source_dir)
 
 
-def cmd_dev(config, args):
-    """Setup for development"""
+def cmd_check(config, options):
+    """Run tests for the activity"""
+
+    run_unit_test = True
+    run_integration_test = True
 
-    if args:
-        print 'Usage: %prog dev'
-        return
+    if options.choice == 'unit':
+        run_integration_test = False
+    if options.choice == 'integration':
+        run_unit_test = False
+
+    print "Running Tests"
+
+    test_path = os.path.join(config.source_dir, "tests")
+
+    if os.path.isdir(test_path):
+        unit_test_path = os.path.join(test_path, "unit")
+        integration_test_path = os.path.join(test_path, "integration")
+        sys.path.append(config.source_dir)
+
+        # Run Tests
+        if os.path.isdir(unit_test_path) and run_unit_test:
+            all_tests = unittest.defaultTestLoader.discover(unit_test_path)
+            unittest.TextTestRunner(verbosity=options.verbose).run(all_tests)
+        elif not run_unit_test:
+            print "Not running unit tests"
+        else:
+            print 'No "unit" directory found.'
+
+        if os.path.isdir(integration_test_path) and run_integration_test:
+            all_tests = unittest.defaultTestLoader.discover(
+                integration_test_path)
+            unittest.TextTestRunner(verbosity=options.verbose).run(all_tests)
+        elif not run_integration_test:
+            print "Not running integration tests"
+        else:
+            print 'No "integration" directory found.'
+
+        print "Finished testing"
+    else:
+        print "Error: No tests/ directory"
+
+
+def cmd_dev(config, options):
+    """Setup for development"""
 
     bundle_path = env.get_user_activities_path()
     if not os.path.isdir(bundle_path):
@@ -278 +323 @@
             print 'ERROR - A bundle with the same name is already installed.'
 
 
-def cmd_dist_xo(config, args):
+def cmd_dist_xo(config, options):
     """Create a xo bundle package"""
 
-    if args:
-        print 'Usage: %prog dist_xo'
-        return
-
     packager = XOPackager(Builder(config))
     packager.package()
 
 
-def cmd_fix_manifest(config, args):
+def cmd_fix_manifest(config, options):
     '''Add missing files to the manifest (OBSOLETE)'''
 
     print 'WARNING: The fix_manifest command is obsolete.'
@@ -297 +338 @@
     print '         please remove it.'
 
 
-def cmd_dist_source(config, args):
+def cmd_dist_source(config, options):
     """Create a tar source package"""
 
-    if args:
-        print 'Usage: %prog dist_source'
-        return
-
     packager = SourcePackager(config)
     packager.package()
 
 
-def cmd_install(config, args):
+def cmd_install(config, options):
     """Install the activity in the system"""
 
-    parser = OptionParser(usage='usage: %prog install [options]')
-    parser.add_option('--prefix', dest='prefix', default=sys.prefix,
-                      help='Prefix to install files to')
-    (suboptions, subargs) = parser.parse_args(args)
-    if subargs:
-        parser.print_help()
-        return
-
     installer = Installer(Builder(config))
-    installer.install(suboptions.prefix)
+    installer.install(options.prefix)
 
 
-def cmd_genpot(config, args):
+def cmd_genpot(config, options):
     """Generate the gettext pot file"""
 
-    if args:
-        print 'Usage: %prog genpot'
-        return
-
     os.chdir(config.source_dir)
 
     po_path = os.path.join(config.source_dir, 'po')
@@ -371 +396 @@
         print 'ERROR - xgettext failed with return code %i.' % retcode
 
 
-def cmd_build(config, args):
+def cmd_build(config, options):
     """Build generated files"""
 
-    if args:
-        print 'Usage: %prog build'
-        return
-
     builder = Builder(config)
     builder.build()
 
 
-def print_commands():
-    print 'Available commands:\n'
-
-    for name, func in globals().items():
-        if name.startswith('cmd_'):
-            print '%-20s %s' % (name.replace('cmd_', ''), func.__doc__)
-
-    print '\n(Type "./setup.py <command> --help" for help about a ' \
-          'particular command\'s options.'
-
-
 def start():
-    parser = OptionParser(usage='[action] [options]')
-    parser.disable_interspersed_args()
-    (options_, args) = parser.parse_args()
+    parser = argparse.ArgumentParser(prog='./setup.py')
+    subparsers = parser.add_subparsers(
+        dest="command", help="Options for %(prog)s")
+
+    install_parser = subparsers.add_parser(
+        "install", help="Install the activity in the system")
+    install_parser.add_argument(
+        "--prefix", dest="prefix", default=sys.prefix,
+        help="Path for installing")
+
+    check_parser = subparsers.add_parser(
+        "check", help="Run tests for the activity")
+    check_parser.add_argument("choice", nargs='?',
+                              choices=['unit', 'integration'],
+                              help="run unit/integration test")
+    check_parser.add_argument("--verbosity", "-v", dest="verbose",
+                              type=int, choices=range(0, 3),
+                              default=1, nargs='?',
+                              help="verbosity for the unit tests")
+
+    subparsers.add_parser("dist_xo", help="Create a xo bundle package")
+    subparsers.add_parser("dist_source", help="Create a tar source package")
+    subparsers.add_parser("build", help="Build generated files")
+    subparsers.add_parser(
+        "fix_manifest", help="Add missing files to the manifest (OBSOLETE)")
+    subparsers.add_parser("genpot", help="Generate the gettext pot file")
+    subparsers.add_parser("dev", help="Setup for development")
+
+    options = parser.parse_args()
 
     source_dir = os.path.abspath(os.path.dirname(sys.argv[0]))
     config = Config(source_dir)
 
     try:
-        globals()['cmd_' + args[0]](config, args[1:])
+        globals()['cmd_' + options.command](config, options)
     except (KeyError, IndexError):
-        print_commands()
+        parser.print_help()
 
 
 if __name__ == '__main__':

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/activity/webactivity.py

@@ -19 +19 @@
 import os
 import logging
 
-from gi.repository import GObject
-GObject.threads_init()
-
 from gi.repository import Gdk
 from gi.repository import Gio
-from gi.repository import WebKit
+from gi.repository import WebKit2
 from gi.repository import Gtk
 from gi.repository import GdkX11
 assert GdkX11
 
-import socket
-from threading import Thread
-
-from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
-import SocketServer
-import select
-import errno
-import mimetypes
-
+from sugar3.graphics.objectchooser import ObjectChooser
 from gi.repository import SugarExt
 from sugar3.activity import activity
 
 
-class LocalRequestHandler(BaseHTTPRequestHandler):
+class FilePicker(ObjectChooser):
+    def __init__(self, parent):
+        ObjectChooser.__init__(self, parent)
+
+    def run(self):
+        jobject = None
+        _file = None
+        try:
+            result = ObjectChooser.run(self)
+            if result == Gtk.ResponseType.ACCEPT:
+                jobject = self.get_selected_object()
+                logging.debug('FilePicker.run: %r', jobject)
+
+                if jobject and jobject.file_path:
+                    _file = jobject.file_path
+                    logging.debug('FilePicker.run: file=%r', _file)
+        finally:
+            if jobject is not None:
+                jobject.destroy()
 
-    #Handler for the GET requests
-    def do_GET(self):
-        new_path = self.server.path + '/' + self.path
-        f = open(new_path)
-        content = f.read()
-        f.close()
-        self.send_response(200)
-        mime, _encding = mimetypes.guess_type(self.path)
-        self.send_header("Content-type", mime)
-        self.end_headers()
-        self.wfile.write(content)
-        return False
-
-
-class LocalHTTPServer(HTTPServer):
-
-    def __init__(self, server_address, request_handler, path):
-        self.path = path
-        HTTPServer.__init__(self, server_address, request_handler)
-
-    def serve_forever(self, poll_interval=0.5):
-        """Overridden version of BaseServer.serve_forever that does not fail
-        to work when EINTR is received.
-        """
-        self._BaseServer__serving = True
-        self._BaseServer__is_shut_down.clear()
-        while self._BaseServer__serving:
-
-            # XXX: Consider using another file descriptor or
-            # connecting to the socket to wake this up instead of
-            # polling. Polling reduces our responsiveness to a
-            # shutdown request and wastes cpu at all other times.
-            try:
-                r, w, e = select.select([self], [], [], poll_interval)
-            except select.error, e:
-                if e[0] == errno.EINTR:
-                    logging.debug("got eintr")
-                    continue
-                raise
-            if r:
-                self._handle_request_noblock()
-        self._BaseServer__is_shut_down.set()
-
-    def server_bind(self):
-        """Override server_bind in HTTPServer to not use
-        getfqdn to get the server name because is very slow."""
-        SocketServer.TCPServer.server_bind(self)
-        host, port = self.socket.getsockname()[:2]
-        self.server_name = 'localhost'
-        self.server_port = port
+        return _file
 
 
 class WebActivity(Gtk.Window):
@@ -109 +67 @@
         self.set_decorated(False)
         self.maximize()
 
-        #self.connect("key-press-event", self._key_press_event_cb)
+        self.connect("key-press-event", self._key_press_event_cb)
         self.connect('realize', self._realize_cb)
         self.connect('destroy', self._destroy_cb)
 
-        # Get a free socket
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
-        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        sock.bind(('', 0))
-        sock.listen(socket.SOMAXCONN)
-        _ipaddr, self.port = sock.getsockname()
-        sock.shutdown(socket.SHUT_RDWR)
-        logging.error('Using port %d', self.port)
-
-        httpd = LocalHTTPServer(('', self.port),
-                                lambda *args: LocalRequestHandler(*args),
-                                activity.get_bundle_path())
-        self._server = Thread(target=httpd.serve_forever)
-        self._server.setDaemon(True)
-        self._server.start()
-
-        self._web_view = WebKit.WebView()
-        self._web_view.connect("notify::load-status", self._loading_changed_cb)
-        self._web_view.connect("resource-request-starting",
-                               self._resource_request_starting_cb)
+        context = WebKit2.WebContext.get_default()
+        context.register_uri_scheme("activity", self._app_scheme_cb, None)
+
+        self._web_view = WebKit2.WebView()
+        self._web_view.connect("load-changed", self._loading_changed_cb)
+        self._web_view.connect('run-file-chooser', self.__run_file_chooser)
 
         self.add(self._web_view)
         self._web_view.show()
 
-        #settings = self._web_view.get_settings()
-        #settings.set_property("enable-developer-extras", True)
+        settings = self._web_view.get_settings()
+        settings.set_property("enable-developer-extras", True)
 
         self._web_view.load_uri("activity://%s/index.html" % self._bundle_id)
 
@@ -156 +100 @@
         self.destroy()
         Gtk.main_quit()
 
-    def _resource_request_starting_cb(self, webview, web_frame, web_resource,
-                                      request, response):
-        uri = web_resource.get_uri()
-        if uri.startswith('activity://'):
-            prefix = "activity://%s" % self._bundle_id
-            new_prefix = "http://0.0.0.0:%d" % self.port
-            new_uri = new_prefix + uri[len(prefix):]
-
-            request.set_uri(new_uri)
-
-    def _loading_changed_cb(self, web_view, load_status):
-        status = web_view.get_load_status()
-
-        if status == WebKit.LoadStatus.FINISHED:
-
+    def _loading_changed_cb(self, web_view, load_event):
+        if load_event == WebKit2.LoadEvent.FINISHED:
             key = os.environ["SUGAR_APISOCKET_KEY"]
             port = os.environ["SUGAR_APISOCKET_PORT"]
 
@@ -194 +125 @@
                          window.sugar.onEnvironmentSet();
                     """ % env_json
 
-            self._web_view.execute_script(script)
+            self._web_view.run_javascript(script, None, None, None)
+
+    def __run_file_chooser(self, browser, request):
+        picker = FilePicker(self)
+        chosen = picker.run()
+        picker.destroy()
+
+        if chosen:
+            request.select_files([chosen])
+        else:
+            request.cancel()
+        return True
 
     def _key_press_event_cb(self, window, event):
         key_name = Gdk.keyval_name(event.keyval)

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/activity/widgets.py

@@ -20 +20 @@
 from gi.repository import Gdk
 from gi.repository import Gtk
 import gettext
-from gi.repository import GConf
 
 from sugar3.graphics.toolbutton import ToolButton
 from sugar3.graphics.toolbarbox import ToolbarButton
@@ -31 +30 @@
 from sugar3.bundle.activitybundle import ActivityBundle
 from sugar3.graphics import style
 from sugar3.graphics.palettemenu import PaletteMenuBox
+from sugar3 import profile
 
 
 _ = lambda msg: gettext.dgettext('sugar-toolkit-gtk3', msg)
@@ -40 +40 @@
     if metadata is not None and metadata.get('icon-color'):
         color = XoColor(metadata['icon-color'])
     else:
-        client = GConf.Client.get_default()
-        color = XoColor(client.get_string('/desktop/sugar/user/color'))
+        color = profile.get_color()
 
     from sugar3.activity.activity import get_bundle_path
     bundle = ActivityBundle(get_bundle_path())

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/bundle/activitybundle.py

@@ -108 +108 @@
         self._tags = None
         self._activity_version = '0'
         self._summary = None
-        self._maximum_instances = None
+        self._single_instance = False
 
         info_file = self.get_file('activity/activity.info')
         if info_file is None:
@@ -129 +129 @@
         if cp.has_option(section, 'bundle_id'):
             self._bundle_id = cp.get(section, 'bundle_id')
         else:
-            raise MalformedBundleException(
-                'Activity bundle %s does not specify a bundle id' %
-                self._path)
+            if cp.has_option(section, 'service_name'):
+                self._bundle_id = cp.get(section, 'service_name')
+                logging.error('ATTENTION: service_name property in the '
+                              'activity.info file is deprecated, should be '
+                              ' changed to bundle_id')
+            else:
+                raise MalformedBundleException(
+                    'Activity bundle %s does not specify a bundle id' %
+                    self._path)
+
+        if ' ' in self._bundle_id:
+            raise MalformedBundleException('Space in bundle_id')
 
         if cp.has_option(section, 'name'):
             self._name = cp.get(section, 'name')
@@ -174 +183 @@
         if cp.has_option(section, 'summary'):
             self._summary = cp.get(section, 'summary')
 
-        if cp.has_option(section, 'maximum_instances'):
-            maximum_instances = cp.get(section, 'maximum_instances')
-            try:
-                self._maximum_instances = int(maximum_instances)
-            except ValueError:
-                logging.error(
-                    'Activity bundle %s has invalid maximum_instances %s' %
-                    (self._path, maximum_instances))
-                self._maximum_instances = None
+        if cp.has_option(section, 'single_instance'):
+            if cp.get(section, 'single_instance') == 'yes':
+                self._single_instance = True
 
     def _get_linfo_file(self):
         # Using method from gettext.py, first find languages from environ
@@ -284 +287 @@
         """Get the summary that describe the activity"""
         return self._summary
 
-    def get_maximum_instances(self):
-        """Get the summary that describe the activity"""
-        return self._maximum_instances
+    def get_single_instance(self):
+        """Get whether there should be a single instance for the activity"""
+        return self._single_instance
 
     def get_show_launcher(self):
         """Get whether there should be a visible launcher for the activity"""
@@ -345 +348 @@
             return
         if not os.path.islink(dst) and os.path.exists(dst):
             raise RuntimeError('Do not remove %s if it was not '
-                               'installed by sugar', dst)
-        logging.debug('Link resource %s to %s', src, dst)
+                               'installed by sugar' % dst)
+        logging.debug('Link resource %s to %s' % (src, dst))
         if os.path.lexists(dst):
             logging.debug('Relink %s', dst)
             os.unlink(dst)

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/bundle/bundle.py

@@ -117 +117 @@
             try:
                 f = open(path, 'rb')
             except IOError:
+                logging.debug("cannot open path %s" % path)
                 return None
         else:
             path = os.path.join(self._zip_root_dir, filename)
@@ -124 +125 @@
                 data = self._zip_file.read(path)
                 f = StringIO.StringIO(data)
             except KeyError:
-                logging.debug('%s not found.', filename)
+                logging.debug('%s not found in zip %s.' % (filename, path))
+                return None
 
         return f
 
@@ -161 +163 @@
         installed."""
         return self._installation_time
 
+    def get_show_launcher(self):
+        return True
+
     def _unzip(self, install_dir):
         if self._zip_file is None:
             raise AlreadyInstalledException

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/bundle/contentbundle.py

@@ -97 +97 @@
             self._icon = cp.get(section, 'icon')
 
         # Compatibility with old content bundles
-        if not self._global_name is None \
+        if self._global_name is not None \
                 and cp.has_option(section, 'bundle_class'):
             self._global_name = cp.get(section, 'bundle_class')
 

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/datastore/datastore.py

@@ -26 +26 @@
 import os
 import tempfile
 from gi.repository import GObject
-from gi.repository import GConf
 from gi.repository import Gio
 import dbus
 
@@ -168 +167 @@
         self._metadata.update(properties)
 
     def get_metadata(self):
-        if self._metadata is None and not self.object_id is None:
+        if self._metadata is None and self.object_id is not None:
             properties = _get_data_store().get_properties(self.object_id)
             metadata = DSMetadata(properties)
             self._metadata = metadata
@@ -181 +180 @@
     metadata = property(get_metadata, set_metadata)
 
     def get_file_path(self, fetch=True):
-        if fetch and self._file_path is None and not self.object_id is None:
+        if fetch and self._file_path is None and self.object_id is not None:
             self.set_file_path(_get_data_store().get_filename(self.object_id))
             self._owns_file = True
         return self._file_path
@@ -225 +224 @@
 
     def __init__(self, file_path):
         stat = os.stat(file_path)
-        client = GConf.Client.get_default()
+        settings = Gio.Settings('org.sugarlabs.user')
         metadata = {
             'uid': file_path,
             'title': os.path.basename(file_path),
@@ -233 +232 @@
             'mime_type': Gio.content_type_guess(file_path, None)[0],
             'activity': '',
             'activity_id': '',
-            'icon-color': client.get_string('/desktop/sugar/user/color'),
+            'icon-color': settings.get_string('color'),
             'description': file_path,
         }
 

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/graphics/icon.py

@@ -32 +32 @@
 from gi.repository import Rsvg
 import cairo
 
+from sugar3.graphics import style
 from sugar3.graphics.xocolor import XoColor
 from sugar3.util import LRU
 
@@ -99 +100 @@
         self.height = None
         self.cache = False
         self.scale = 1.0
+        self.pixbuf = None
 
     def _get_cache_key(self, sensitive):
         if self.background_color is None:
@@ -106 +108 @@
         else:
             color = (self.background_color.red, self.background_color.green,
                      self.background_color.blue)
-        return (self.icon_name, self.file_name, self.fill_color,
+
+        return (self.icon_name, self.file_name, self.pixbuf, self.fill_color,
                 self.stroke_color, self.badge_name, self.width, self.height,
                 color, sensitive)
 
@@ -238 +241 @@
         icon_source.set_direction_wildcarded(False)
         icon_source.set_size_wildcarded(False)
 
-        style = widget.get_style()
-        pixbuf = style.render_icon(icon_source, widget.get_direction(),
-                                   Gtk.StateType.INSENSITIVE, -1, widget,
-                                   'sugar-icon')
+        widget_style = widget.get_style()
+        pixbuf = widget_style.render_icon(
+            icon_source, widget.get_direction(),
+            Gtk.StateType.INSENSITIVE, -1, widget,
+            'sugar-icon')
 
         return pixbuf
 
@@ -250 +254 @@
         if cache_key in self._surface_cache:
             return self._surface_cache[cache_key]
 
-        # We run two attempts at finding the icon. First, we try the icon
-        # requested by the user. If that fails, we fall back on
-        # document-generic. If that doesn't work out, bail.
-        icon_width = None
-        for (file_name, icon_name) in ((self.file_name, self.icon_name),
-                                      (None, 'document-generic')):
-            icon_info = self._get_icon_info(file_name, icon_name)
-            if icon_info.file_name is None:
-                return None
-
-            is_svg = icon_info.file_name.endswith('.svg')
-
-            if is_svg:
-                try:
-                    handle = self._load_svg(icon_info.file_name)
-                    icon_width = handle.props.width
-                    icon_height = handle.props.height
-                    break
-                except IOError:
-                    pass
-            else:
-                try:
-                    path = icon_info.file_name
-                    pixbuf = GdkPixbuf.Pixbuf.new_from_file(path)
-                    icon_width = pixbuf.get_width()
-                    icon_height = pixbuf.get_height()
-                    break
-                except GObject.GError:
-                    pass
+        if self.pixbuf:
+            # We alredy have the pixbuf for this icon.
+            pixbuf = self.pixbuf
+            icon_width = pixbuf.get_width()
+            icon_height = pixbuf.get_height()
+            icon_info = self._get_icon_info(self.file_name, self.icon_name)
+            is_svg = False
+        else:
+            # We run two attempts at finding the icon. First, we try the icon
+            # requested by the user. If that fails, we fall back on
+            # document-generic. If that doesn't work out, bail.
+            icon_width = None
+            for (file_name, icon_name) in ((self.file_name, self.icon_name),
+                                           (None, 'document-generic')):
+                icon_info = self._get_icon_info(file_name, icon_name)
+                if icon_info.file_name is None:
+                    return None
+
+                is_svg = icon_info.file_name.endswith('.svg')
+
+                if is_svg:
+                    try:
+                        handle = self._load_svg(icon_info.file_name)
+                        icon_width = handle.props.width
+                        icon_height = handle.props.height
+                        break
+                    except IOError:
+                        pass
+                else:
+                    try:
+                        path = icon_info.file_name
+                        pixbuf = GdkPixbuf.Pixbuf.new_from_file(path)
+                        icon_width = pixbuf.get_width()
+                        icon_height = pixbuf.get_height()
+                        break
+                    except GObject.GError:
+                        pass
 
         if icon_width is None:
             # Neither attempt found an icon for us to use
@@ -335 +347 @@
 
     __gtype_name__ = 'SugarIcon'
 
+    # FIXME: deprecate icon_size
+    _MENU_SIZES = (Gtk.IconSize.MENU, Gtk.IconSize.DND,
+                   Gtk.IconSize.SMALL_TOOLBAR, Gtk.IconSize.BUTTON)
+
     def __init__(self, **kwargs):
         self._buffer = _IconBuffer()
         # HACK: need to keep a reference to the path so it doesn't get garbage
@@ -344 +360 @@
         self._alpha = 1.0
         self._scale = 1.0
 
+        # FIXME: deprecate icon_size
+        if 'icon_size' in kwargs:
+            logging.warning("icon_size is deprecated. Use pixel_size instead.")
+
         GObject.GObject.__init__(self, **kwargs)
 
     def get_file(self):
@@ -355 +375 @@
 
     file = GObject.property(type=object, setter=set_file, getter=get_file)
 
+    def get_pixbuf(self):
+        return self._buffer.pixbuf
+
+    def set_pixbuf(self, pixbuf):
+        self._buffer.pixbuf = pixbuf
+
+    pixbuf = GObject.property(type=object, setter=set_pixbuf,
+                              getter=get_pixbuf)
+
     def _sync_image_properties(self):
         if self._buffer.icon_name != self.props.icon_name:
             self._buffer.icon_name = self.props.icon_name
@@ -362 +391 @@
         if self._buffer.file_name != self.props.file:
             self._buffer.file_name = self.props.file
 
+        # FIXME: deprecate icon_size
+        pixel_size = None
         if self.props.pixel_size == -1:
-            valid_, width, height = Gtk.icon_size_lookup(self.props.icon_size)
+            if self.props.icon_size in self._MENU_SIZES:
+                pixel_size = style.SMALL_ICON_SIZE
+            else:
+                pixel_size = style.STANDARD_ICON_SIZE
         else:
-            width = height = self.props.pixel_size
+            pixel_size = self.props.pixel_size
+
+        width = height = pixel_size
+
         if self._buffer.width != width or self._buffer.height != height:
             self._buffer.width = width
             self._buffer.height = height
@@ -416 +453 @@
 
         allocation = self.get_allocation()
         x = math.floor(xpad +
-                      (allocation.width - requisition.width) * xalign)
+                       (allocation.width - requisition.width) * xalign)
         y = math.floor(ypad +
-                      (allocation.height - requisition.height) * yalign)
+                       (allocation.height - requisition.height) * yalign)
 
         if self._scale != 1.0:
             cr.scale(self._scale, self._scale)

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/graphics/menuitem.py

@@ -26 +26 @@
 from gi.repository import Gtk
 
 from sugar3.graphics.icon import Icon
+from sugar3.graphics import style
 
 
 class MenuItem(Gtk.ImageMenuItem):
 
-    def __init__(self, text_label=None, icon_name=None, text_maxlen=60,
-                 xo_color=None, file_name=None):
+    def __init__(self, text_label=None, icon_name=None,
+                 text_maxlen=style.MENU_WIDTH_CHARS, xo_color=None,
+                 file_name=None):
         GObject.GObject.__init__(self)
         self._accelerator = None
 

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/graphics/objectchooser.py

@@ -228 +228 @@
     def __chooser_response_cb(self, chooser_id, object_id):
         if chooser_id != self._chooser_id:
             return
-        logging.debug('ObjectChooser.__chooser_response_cb: %r', object_id)
+        logging.debug('ObjectChooser.__chooser_response_cb: %r' % object_id)
         self._response_code = Gtk.ResponseType.ACCEPT
         self._object_id = object_id
         self._cleanup()
@@ -236 +236 @@
     def __chooser_cancelled_cb(self, chooser_id):
         if chooser_id != self._chooser_id:
             return
-        logging.debug('ObjectChooser.__chooser_cancelled_cb: %r', chooser_id)
+        logging.debug('ObjectChooser.__chooser_cancelled_cb: %r' % chooser_id)
         self._response_code = Gtk.ResponseType.CANCEL
         self._cleanup()
 

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/graphics/palettegroup.py

@@ -75 +75 @@
         self._sig_ids[palette].append(sid)
 
     def remove(self, palette):
-        if not palette in self._palettes:
+        if palette not in self._palettes:
             # This happens when converting a window based palette to a menu
             # based one.
             return

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/graphics/palettemenu.py

@@ -78 +78 @@
     }
 
     def __init__(self, text_label=None, icon_name=None, text_maxlen=60,
-                 xo_color=None, file_name=None):
+                 xo_color=None, file_name=None, accelerator=None):
+
+        """
+            text_label -- str
+                a text to display in the menu.
+
+            icon_name -- str
+                the name of a sugar icon to be displayed. Takse precedence
+                over file_name.
+
+            text_maxlen -- int
+                the desired maximum width of the label, in characters.
+                By default is 60.
+
+            xo_color -- sugar.graphics.XoColor
+                the color to be applied to the icon.
+
+            file_name -- str
+                the path to a svg file used as icon.
+
+            accelerator -- str
+                a text used to display the keyboard shortcut associated
+                to the menu.
+
+        """
 
         Gtk.EventBox.__init__(self)
         self.set_above_child(True)
@@ -120 +144 @@
         self._hbox.pack_start(align, expand=True, fill=True,
                               padding=style.DEFAULT_PADDING)
 
+        self._accelerator_label = Gtk.AccelLabel('')
+        if accelerator is not None:
+            self._accelerator_label.set_text(accelerator)
+        self._hbox.pack_start(self._accelerator_label, expand=False,
+                              fill=False, padding=style.DEFAULT_PADDING)
+
         self.id_bt_release_cb = self.connect('button-release-event',
                                              self.__button_release_cb)
         self.id_enter_notify_cb = self.connect('enter-notify-event',
@@ -150 +180 @@
                               padding=style.DEFAULT_PADDING)
         self._hbox.reorder_child(icon, 0)
 
+    def set_accelerator(self, text):
+        self._accelerator_label.set_text(text)
+
     def set_sensitive(self, sensitive):
         is_sensitive = bool(not self.get_state_flags() &
                             Gtk.StateFlags.INSENSITIVE)

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/graphics/palette.py

@@ -22 +22 @@
 """
 STABLE.
 """
-
 from gi.repository import Gtk
+from gi.repository import Gdk
 from gi.repository import GObject
 from gi.repository import Pango
 
@@ -101 +101 @@
     __gtype_name__ = 'SugarPalette'
 
     def __init__(self, label=None, accel_path=None,
-                 text_maxlen=60, **kwargs):
+                 text_maxlen=style.MENU_WIDTH_CHARS, **kwargs):
         # DEPRECATED: label is passed with the primary-text property,
         # accel_path is set via the invoker property
 
@@ -111 +111 @@
         self._icon_visible = True
         self._palette_state = self.PRIMARY
 
+        self._primary_event_box = Gtk.EventBox()
+        self._primary_event_box.show()
         self._primary_box = Gtk.HBox()
+        self._primary_event_box.add(self._primary_box)
         self._primary_box.show()
 
         self._icon_box = Gtk.HBox()
@@ -135 +138 @@
             self._label.set_max_width_chars(text_maxlen)
             self._label.set_ellipsize(Pango.EllipsizeMode.MIDDLE)
         labels_box.pack_start(self._label, True, True, 0)
+        self._primary_event_box.connect('button-release-event',
+                                        self.__button_release_event_cb)
+        self._primary_event_box.set_events(Gdk.EventMask.BUTTON_RELEASE_MASK)
 
         self._secondary_label = Gtk.Label()
         self._secondary_label.set_alignment(0, 0.5)
@@ -255 +261 @@
                                     getter=get_primary_text,
                                     setter=set_primary_text)
 
+    def __button_release_event_cb(self, widget, event):
+        if self.props.invoker is not None:
+            self.props.invoker.primary_text_clicked()
+
     def set_secondary_text(self, label):
         if label is not None:
             label = label.split('\n', 1)[0]
@@ -334 +344 @@
             self._setup_widget()
 
             self._palette_box = Gtk.VBox()
-            self._palette_box.pack_start(self._primary_box, False, True, 0)
+            self._palette_box.pack_start(self._primary_event_box, False, True,
+                                         0)
             self._palette_box.pack_start(self._secondary_box, True, True, 0)
 
             self._widget.add(self._palette_box)
             self._palette_box.show()
             height = style.GRID_CELL_SIZE - 2 * self._widget.get_border_width()
-            self._primary_box.set_size_request(-1, height)
+            self._primary_event_box.set_size_request(-1, height)
 
         if self._content.get_children():
             self._content.remove(self._content.get_children()[0])
@@ -405 +416 @@
         if self._widget is None \
                 or not isinstance(self._widget, _PaletteMenuWidget):
             if self._widget is not None:
-                self._palette_box.remove(self._primary_box)
+                self._palette_box.remove(self._primary_event_box)
                 self._palette_box.remove(self._secondary_box)
                 self._teardown_widget()
                 self._widget.destroy()
 
             self._widget = _PaletteMenuWidget()
 
-            self._label_menuitem = _HeaderItem(self._primary_box)
+            self._label_menuitem = _HeaderItem(self._primary_event_box)
             self._label_menuitem.show()
             self._widget.append(self._label_menuitem)
 

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/graphics/palettewindow.py

@@ -1052 +1052 @@
         if not self.props.cache_palette:
             self.set_palette(None)
 
+    def primary_text_clicked(self):
+        """Implemented by invokers that can be clicked"""
+        pass
+
 
 class WidgetInvoker(Invoker):
 
@@ -1345 +1349 @@
         else:
             return self.LEFT + self.RIGHT
 
+    def primary_text_clicked(self):
+        self._widget.emit('clicked')
+
 
 class CellRendererInvoker(Invoker):
 

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/graphics/style.py

@@ -27 +27 @@
 
 from gi.repository import Gdk
 from gi.repository import Pango
-from gi.repository import GConf
+from gi.repository import Gio
 
 
 FOCUS_LINE_WIDTH = 2
@@ -110 +110 @@
 LINE_WIDTH = zoom(2)
 
 STANDARD_ICON_SIZE = zoom(55)
-SMALL_ICON_SIZE = zoom(55 * 0.5)
+SMALL_ICON_SIZE = zoom(33)
 MEDIUM_ICON_SIZE = zoom(55 * 1.5)
 LARGE_ICON_SIZE = zoom(55 * 2.0)
 XLARGE_ICON_SIZE = zoom(55 * 2.75)
 
-client = GConf.Client.get_default()
-FONT_SIZE = client.get_float('/desktop/sugar/font/default_size')
-FONT_FACE = client.get_string('/desktop/sugar/font/default_face')
+settings = Gio.Settings('org.sugarlabs.font')
+FONT_SIZE = settings.get_double('default-size')
+FONT_FACE = settings.get_string('default-face')
 
 FONT_NORMAL = Font('%s %f' % (FONT_FACE, FONT_SIZE))
 FONT_BOLD = Font('%s bold %f' % (FONT_FACE, FONT_SIZE))
@@ -145 +145 @@
 PALETTE_CURSOR_DISTANCE = zoom(10)
 
 TOOLBAR_ARROW_SIZE = zoom(24)
+
+MENU_WIDTH_CHARS = 60

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/graphics/toolbarbox.py

@@ -171 +171 @@
         return self.toolbar.get_nth_item(self._expanded_button_index)
 
     def set_expanded_button(self, button):
-        if not button in self.toolbar:
+        if button not in self.toolbar:
             self._expanded_button_index = -1
             return
         self._expanded_button_index = self.toolbar.get_item_index(button)

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/graphics/window.py

@@ -92 +92 @@
         self.set_decorated(False)
         self.maximize()
         self.connect('realize', self.__window_realize_cb)
-        self.connect('key-press-event', self.__key_press_cb)
+        self.connect_after('key-press-event', self.__key_press_cb)
 
         # OSK support: canvas auto panning based on input focus
         if GObject.signal_lookup('request-clear-area', Window) != 0 and \
@@ -145 +145 @@
             timestamp = GdkX11.x11_get_server_time(window)
         window.focus(timestamp)
 
+    def is_fullscreen(self):
+        return self._is_fullscreen
+
     def fullscreen(self):
         palettegroup.popdown_all()
         if self._toolbar_box is not None:

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/graphics/xocolor.py

@@ -22 +22 @@
 import random
 import logging
 
-from gi.repository import GConf
+from gi.repository import Gio
 
 colors = [['#B20008', '#FF2B34'],
           ['#FF2B34', '#B20008'],
@@ -229 +229 @@
         parsed_color = None
 
         if color_string is None:
-            client = GConf.Client.get_default()
-            color_string = client.get_string('/desktop/sugar/user/color')
+            settings = Gio.Settings('org.sugarlabs.user')
+            color_string = settings.get_string('color')
 
         if color_string is not None:
             parsed_color = _parse_string(color_string)

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/logger.py

@@ -61 +61 @@
     try:
         logging.getLogger('').setLevel(int(level))
     except ValueError:
-        logging.warning('Invalid log level: %r', level)
+        logging.warning('Invalid log level: %r' % level)
 
 
 # pylint: disable-msg=E1101,F0401
@@ -235 +235 @@
         try:
             res = f(*args, **kwargs)
         except:
-            trace_logger.exception("Exception occured in %s", f.__name__)
+            trace_logger.exception("Exception occured in %s" % f.__name__)
             raise
 
         trace_logger.log(TRACE, "%s(%s) returned %s", f.__name__,

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/mime.py

@@ -29 +29 @@
 from gi.repository import GdkPixbuf
 from gi.repository import Gio
 
-from gi.repository import SugarExt
-
 _ = lambda msg: gettext.dgettext('sugar-toolkit-gtk3', msg)
 
 GENERIC_TYPE_TEXT = 'Text'
@@ -38 +36 @@
 GENERIC_TYPE_AUDIO = 'Audio'
 GENERIC_TYPE_VIDEO = 'Video'
 GENERIC_TYPE_LINK = 'Link'
+GENERIC_TYPE_BUNDLE = 'Bundle'
 
 
 def _get_supported_image_mime_types():
@@ -49 +48 @@
 
 _extensions = {}
 _globs_timestamps = []
+_subclasses = {}
+_subclasses_timestamps = []
+
 _generic_types = [{
     'id': GENERIC_TYPE_TEXT,
     'name': _('Text'),
@@ -84 +86 @@
     'name': _('Link'),
     'icon': 'text-uri-list',
     'types': ['text/x-moz-url', 'text/uri-list'],
+}, {
+    'id': GENERIC_TYPE_BUNDLE,
+    'name': _('Bundle'),
+    'icon': 'user-documents',
+    'types': ['application/vnd.olpc-sugar'],
 }]
 
 
@@ -118 +125 @@
 
     file_name = os.path.realpath(file_name)
 
-    mime_type = SugarExt.mime_get_mime_type_for_file(file_name, None)
-    if mime_type == 'application/octet-stream':
-        if _file_looks_like_text(file_name):
-            return 'text/plain'
-        else:
-            return 'application/octet-stream'
+    f = Gio.File.new_for_path(file_name)
+    try:
+        info = f.query_info(Gio.FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE, 0, None)
+        mime_type = info.get_content_type()
+    except GLib.GError:
+        mime_type = Gio.content_type_guess(file_name, None)[0]
 
     return mime_type
 
 
 def get_from_file_name(file_name):
-    return SugarExt.mime_get_mime_type_from_file_name(file_name)
+    """
+    DEPRECATED: 0.102 (removed in 4 releases)
+    Use Gio.content_type_guess(file_name, None)[0] instead.
+    """
+    return Gio.content_type_guess(file_name, None)[0]
 
 
 def get_mime_icon(mime_type):
@@ -149 +160 @@
 
 
 def get_mime_parents(mime_type):
-    return SugarExt.mime_list_mime_parents(mime_type)
+    global _subclasses
+    global _subclasses_timestamps
 
+    dirs = _get_mime_data_directories()
 
-def get_primary_extension(mime_type):
-    global _extensions
-    global _globs_timestamps
+    timestamps = []
+    subclasses_path_list = []
+    for f in dirs:
+        subclasses_path = os.path.join(f, 'mime', 'subclasses')
+        try:
+            mtime = os.stat(subclasses_path).st_mtime
+            timestamps.append([subclasses_path, mtime])
+            subclasses_path_list.append(subclasses_path)
+        except OSError:
+            pass
+
+    if timestamps != _subclasses_timestamps:
+        _subclasses = {}
+        for subclasses_path in subclasses_path_list:
+            with open(subclasses_path) as parents_file:
+                for line in parents_file:
+                    subclass, parent = line.split()
+                    if subclass not in _subclasses.keys():
+                        _subclasses[subclass] = [parent]
+                    else:
+                        _subclasses[subclass].append(parent)
+
+        _subclasses_timestamps = timestamps
+
+    if mime_type in _subclasses.keys():
+        return _subclasses[mime_type]
+    else:
+        return []
 
+
+def _get_mime_data_directories():
     dirs = []
 
     if 'XDG_DATA_HOME' in os.environ:
@@ -167 +207 @@
         dirs.extend(os.environ['XDG_DATA_DIRS'].split(':'))
     else:
         dirs.extend(['/usr/local/share/', '/usr/share/'])
+    return dirs
+
+
+def get_primary_extension(mime_type):
+    global _extensions
+    global _globs_timestamps
+
+    dirs = _get_mime_data_directories()
 
     timestamps = []
     globs_path_list = []
@@ -252 +300 @@
     return GLib.uri_list_extract_uris(uri_list)
 
 
-def _file_looks_like_text(file_name):
-    f = open(file_name, 'r')
-    try:
-        sample = f.read(256)
-    finally:
-        f.close()
-
-    if '\000' in sample:
-        return False
-
-    for encoding in ('ascii', 'latin_1', 'utf_8', 'utf_16'):
-        try:
-            unicode(sample, encoding)
-            return True
-        except Exception:
-            pass
-
-    return False
-
-
 def _get_generic_type_for_mime(mime_type):
     for generic_type in _generic_types:
         if mime_type in generic_type['types']:

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/presence/activity.py

@@ -114 +114 @@
         self._joined_buddies = {}
 
         self._get_properties_call = None
-        if not self.room_handle is None:
+        if self.room_handle is not None:
             self._start_tracking_properties()
 
     def _start_tracking_properties(self):
@@ -138 +138 @@
             dbus_interface=CONN_INTERFACE_ACTIVITY_PROPERTIES)
 
     def __activity_properties_changed_cb(self, room_handle, properties):
-        _logger.debug('%r: Activity properties changed to %r', self,
-                      properties)
+        _logger.debug('%r: Activity properties changed to %r' % (self,
+                      properties))
         self._update_properties(properties)
 
     def __got_properties_cb(self, properties):
-        _logger.debug('__got_properties_cb %r', properties)
+        _logger.debug('__got_properties_cb %r' % properties)
         self._get_properties_call = None
         self._update_properties(properties)
 
     def __error_handler_cb(self, error):
-        _logger.debug('__error_handler_cb %r', error)
+        _logger.debug('__error_handler_cb %r' % error)
 
     def _update_properties(self, new_props):
         val = new_props.get('name', self._name)
@@ -188 +188 @@
 
         if self._get_properties_call is not None:
             _logger.debug('%r: Blocking on GetProperties() because someone '
-                          'wants property %s', self, pspec.name)
+                          'wants property %s' % (self, pspec.name))
             self._get_properties_call.block()
 
         if pspec.name == 'id':
@@ -218 +218 @@
         elif pspec.name == 'private':
             self._private = val
         else:
-            raise ValueError('Unknown property %r', pspec.name)
+            raise ValueError('Unknown property %r' % pspec.name)
 
         self._publish_properties()
 
     def set_private(self, val, reply_handler, error_handler):
-        _logger.debug('set_private %r', val)
+        _logger.debug('set_private %r' % val)
         self._activity.SetProperties({'private': bool(val)},
                                      reply_handler=reply_handler,
                                      error_handler=error_handler)
@@ -271 +271 @@
         raise NotImplementedError()
 
     def __joined_cb(self, join_command, error):
-        _logger.debug('%r: Join finished %r', self, error)
+        _logger.debug('%r: Join finished %r' % (self, error))
         if error is not None:
             self.emit('joined', error is None, str(error))
         self.telepathy_text_chan = join_command.text_channel
@@ -295 +295 @@
         channel.connect_to_signal('Closed', self.__text_channel_closed_cb)
 
     def __get_all_members_cb(self, members, local_pending, remote_pending):
-        _logger.debug('__get_all_members_cb %r %r', members,
-                      self._text_channel_group_flags)
+        _logger.debug('__get_all_members_cb %r %r' % (members,
+                      self._text_channel_group_flags))
         if self._channel_self_handle in members:
             members.remove(self._channel_self_handle)
 
@@ -324 +324 @@
             get_handle_owners_cb(input_handles)
 
     def _add_initial_buddies(self, contact_ids):
-        _logger.debug('__add_initial_buddies %r', contact_ids)
+        _logger.debug('__add_initial_buddies %r' % contact_ids)
         for contact_id in contact_ids:
             self._buddies[contact_id] = self._get_buddy(contact_id)
             self._joined_buddies[contact_id] = self._get_buddy(contact_id)
@@ -335 +335 @@
     def __text_channel_members_changed_cb(self, message, added, removed,
                                           local_pending, remote_pending,
                                           actor, reason):
-        _logger.debug('__text_channel_members_changed_cb %r',
+        _logger.debug('__text_channel_members_changed_cb %r' %
                       [added, message, added, removed, local_pending,
                        remote_pending, actor, reason])
         if self._channel_self_handle in added:
@@ -382 +382 @@
             self.emit('joined', True, None)
             return
 
-        _logger.debug('%r: joining', self)
+        _logger.debug('%r: joining' % self)
 
         self._join_command = _JoinCommand(self.telepathy_conn,
                                           self.room_handle)
@@ -390 +390 @@
         self._join_command.run()
 
     def share(self, share_activity_cb, share_activity_error_cb):
-        if not self.room_handle is None:
+        if self.room_handle is not None:
             raise ValueError('Already have a room handle')
 
         self._share_command = _ShareCommand(self.telepathy_conn, self._id)
@@ -402 +402 @@
 
     def __shared_cb(self, share_activity_cb, share_activity_error_cb,
                     share_command, error):
-        _logger.debug('%r: Share finished %r', self, error)
+        _logger.debug('%r: Share finished %r' % (self, error))
         if error is None:
             self._joined = True
             self.room_handle = share_command.room_handle
@@ -438 +438 @@
             dbus_interface=CONN_INTERFACE_ACTIVITY_PROPERTIES)
 
     def __share_error_cb(self, share_activity_error_cb, error):
-        logging.debug('%r: Share failed because: %s', self, error)
+        logging.debug('%r: Share failed because: %s' % (self, error))
         share_activity_error_cb(self, error)
 
     # GetChannels() wrapper
@@ -459 +459 @@
         channels = [self.telepathy_text_chan.object_path,
                     self.telepathy_tubes_chan.object_path]
 
-        _logger.debug('%r: bus name is %s, connection is %s, channels are %r',
-                      self, bus_name, connection_path, channels)
+        _logger.debug('%r: bus name is %s, connection is %s, channels are %r' %
+                      (self, bus_name, connection_path, channels))
         return bus_name, connection_path, channels
 
     # Leaving
@@ -470 +470 @@
 
     def leave(self):
         """Leave this shared activity"""
-        _logger.debug('%r: leaving', self)
+        _logger.debug('%r: leaving' % self)
         self.telepathy_text_chan.Close()
 
 
@@ -511 +511 @@
             dbus_interface=CONNECTION)
 
     def __got_handles_cb(self, handles):
-        logging.debug('__got_handles_cb %r', handles)
+        logging.debug('__got_handles_cb %r' % handles)
         self.room_handle = handles[0]
 
         self._join_command = _JoinCommand(self._connection, self.room_handle)
@@ -519 +519 @@
         self._join_command.run()
 
     def __joined_cb(self, join_command, error):
-        _logger.debug('%r: Join finished %r', self, error)
+        _logger.debug('%r: Join finished %r' % (self, error))
         if error is not None:
             self._finished = True
             self.emit('finished', error)
@@ -597 +597 @@
         self.emit('finished', error)
 
     def __tubes_channel_ready_cb(self, channel):
-        _logger.debug('%r: Tubes channel %r is ready', self, channel)
+        _logger.debug('%r: Tubes channel %r is ready' % (self, channel))
         self.tubes_channel = channel
         self._tubes_ready()
 
     def __text_channel_ready_cb(self, channel):
-        _logger.debug('%r: Text channel %r is ready', self, channel)
+        _logger.debug('%r: Text channel %r is ready' % (self, channel))
         self.text_channel = channel
         self._tubes_ready()
 
@@ -611 +611 @@
                 self.tubes_channel is None:
             return
 
-        _logger.debug('%r: finished setting up tubes', self)
+        _logger.debug('%r: finished setting up tubes' % self)
 
         self._add_self_to_channel()
 
     def __text_channel_group_flags_changed_cb(self, added, removed):
-        _logger.debug('__text_channel_group_flags_changed_cb %r %r', added,
-                      removed)
+        _logger.debug('__text_channel_group_flags_changed_cb %r %r' % (added,
+                      removed))
         self.text_channel_group_flags |= added
         self.text_channel_group_flags &= ~removed
 
@@ -629 +629 @@
 
         def got_all_members(members, local_pending, remote_pending):
             _logger.debug('got_all_members members %r local_pending %r '
-                          'remote_pending %r', members, local_pending,
-                          remote_pending)
+                          'remote_pending %r' % (members, local_pending,
+                                                 remote_pending))
 
             if self.text_channel_group_flags & \
                     CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES:
@@ -639 +639 @@
                 self_handle = self._global_self_handle
 
             if self_handle in local_pending:
-                _logger.debug('%r: We are in local pending - entering', self)
+                _logger.debug('%r: We are in local pending - entering' % self)
                 group.AddMembers([self_handle], '',
                                  reply_handler=lambda: None,
                                  error_handler=lambda e: self._join_failed_cb(
@@ -675 +675 @@
                                           actor, reason):
         _logger.debug('__text_channel_members_changed_cb added %r removed %r '
                       'local_pending %r remote_pending %r channel_self_handle '
-                      '%r', added, removed, local_pending, remote_pending,
-                      self.channel_self_handle)
+                      '%r' % (added, removed, local_pending, remote_pending,
+                              self.channel_self_handle))
 
         if self.text_channel_group_flags & \
                 CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES:

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/presence/buddy.py

@@ -24 +24 @@
 import logging
 
 from gi.repository import GObject
+from gi.repository import Gio
 import dbus
-from gi.repository import GConf
 from telepathy.interfaces import CONNECTION, \
     CONNECTION_INTERFACE_ALIASING, \
     CONNECTION_INTERFACE_CONTACTS
@@ -243 +243 @@
     def __init__(self):
         BaseBuddy.__init__(self)
 
-        client = GConf.Client.get_default()
-        self.props.nick = client.get_string('/desktop/sugar/user/nick')
-        self.props.color = client.get_string('/desktop/sugar/user/color')
+        settings = Gio.Settings('org.sugarlabs.user')
+        self.props.nick = settings.get_string('nick')
+        self.props.color = settings.get_string('color')

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/presence/presenceservice.py

@@ -81 +81 @@
             for account_path, connection in connections_per_account.items():
                 if not connection.connected:
                     continue
-                logging.debug('Calling GetActivity on %s', account_path)
+                logging.debug('Calling GetActivity on %s' % account_path)
                 try:
                     room_handle = connection.connection.GetActivity(
                         activity_id,
@@ -90 +90 @@
                     name = 'org.freedesktop.Telepathy.Error.NotAvailable'
                     if e.get_dbus_name() == name:
                         logging.debug("There's no shared activity with the id "
-                                      "%s", activity_id)
+                                      "%s" % activity_id)
                     else:
                         raise
                 else:
@@ -162 +162 @@
                     dbus_interface=CONNECTION)
                 return self.get_buddy(account_path, contact_ids[0])
 
-        raise ValueError('Unknown buddy in connection %s with handle %d',
-                         tp_conn_path, handle)
+        raise ValueError('Unknown buddy in connection %s with handle %d' %
+                         (tp_conn_path, handle))
 
     def get_owner(self):
         """Retrieves the laptop Buddy object."""
@@ -198 +198 @@
         properties['private'] = private
 
         if self._activity_cache is not None:
-            raise ValueError('Activity %s is already tracked',
+            raise ValueError('Activity %s is already tracked' %
                              activity.get_id())
 
         connection_manager = get_connection_manager()

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/profile.py

@@ -16 +16 @@
 # Boston, MA 02111-1307, USA.
 
 """User settings/configuration loading.
-
-DEPRECATED. We are using GConf now to store preferences.
 """
 
-from gi.repository import GConf
+from gi.repository import Gio
 import os
 import logging
 from ConfigParser import ConfigParser
@@ -36 +34 @@
 class Profile(object):
     """Local user's current options/profile information
 
-    User settings were previously stored in an INI-style
-    configuration file. We moved to gconf now. The deprected
-    API is kept around to not break activities still using it.
-
     The profile is also responsible for loading the user's
     public and private ssh keys from disk.
 
@@ -68 +62 @@
     privkey_hash = property(fget=_get_privkey_hash)
 
     def is_valid(self):
-        client = GConf.Client.get_default()
-        nick = client.get_string('/desktop/sugar/user/nick')
-        color = client.get_string('/desktop/sugar/user/color')
+        settings = Gio.Settings('org.sugarlabs.user')
+        nick = settings.get_string('nick')
+        color = settings.get_string('color')
 
         return nick is not '' and \
             color is not '' and \
@@ -140 +134 @@
         path = os.path.join(env.get_profile_path(), 'config')
         cp.read([path])
 
-        client = GConf.Client.get_default()
-
+        settings = Gio.Settings('org.sugarlabs.user')
         if cp.has_option('Buddy', 'NickName'):
             name = cp.get('Buddy', 'NickName')
             # decode nickname from ascii-safe chars to unicode
             nick = name.decode('utf-8')
-            client.set_string('/desktop/sugar/user/nick', nick)
+            settings.set_string('nick', nick)
         if cp.has_option('Buddy', 'Color'):
             color = cp.get('Buddy', 'Color')
-            client.set_string('/desktop/sugar/user/color', color)
+            settings.set_string('color', color)
+
         if cp.has_option('Jabber', 'Server'):
             server = cp.get('Jabber', 'Server')
-            client.set_string('/desktop/sugar/collaboration/jabber_server',
-                              server)
+            settings = Gio.Settings('org.sugarlabs.collaboration')
+            settings.set_string('jabber-server', server)
+
         if cp.has_option('Date', 'Timezone'):
             timezone = cp.get('Date', 'Timezone')
-            client.set_string('/desktop/sugar/date/timezone', timezone)
+            settings = Gio.Settings('org.sugarlabs.date')
+            settings.set_string('timezone', timezone)
+
+        settings = Gio.Settings('org.sugarlabs.frame')
         if cp.has_option('Frame', 'HotCorners'):
             delay = float(cp.get('Frame', 'HotCorners'))
-            client.set_int('/desktop/sugar/frame/corner_delay', int(delay))
+            settings.set_int('corner-delay', int(delay))
         if cp.has_option('Frame', 'WarmEdges'):
             delay = float(cp.get('Frame', 'WarmEdges'))
-            client.set_int('/desktop/sugar/frame/edge_delay', int(delay))
+            settings.set_int('edge-delay', int(delay))
+
         if cp.has_option('Server', 'Backup1'):
             backup1 = cp.get('Server', 'Backup1')
-            client.set_string('/desktop/sugar/backup_url', backup1)
+            settings = Gio.Settings('org.sugarlabs')
+            settings.set_string('backup-url', backup1)
+
         if cp.has_option('Sound', 'Volume'):
             volume = float(cp.get('Sound', 'Volume'))
-            client.set_int('/desktop/sugar/sound/volume', int(volume))
+            settings = Gio.Settings('org.sugarlabs.sound')
+            settings.set_int('volume', int(volume))
+
+        settings = Gio.Settings('org.sugarlabs.power')
         if cp.has_option('Power', 'AutomaticPM'):
             state = cp.get('Power', 'AutomaticPM')
             if state.lower() == 'true':
-                client.set_bool('/desktop/sugar/power/automatic', True)
+                settings.set_boolean('automatic', True)
         if cp.has_option('Power', 'ExtremePM'):
             state = cp.get('Power', 'ExtremePM')
             if state.lower() == 'true':
-                client.set_bool('/desktop/sugar/power/extreme', True)
+                settings.set_boolean('extreme', True)
+
         if cp.has_option('Shell', 'FavoritesLayout'):
             layout = cp.get('Shell', 'FavoritesLayout')
-            client.set_string('/desktop/sugar/desktop/favorites_layout',
-                              layout)
+            settings = Gio.Settings('org.sugarlabs.desktop')
+            settings.set_string('favorites-layout', layout)
         del cp
         try:
             os.unlink(path)
@@ -199 +204 @@
 
 
 def get_nick_name():
-    client = GConf.Client.get_default()
-    return client.get_string('/desktop/sugar/user/nick')
+    settings = Gio.Settings('org.sugarlabs.user')
+    return settings.get_string('nick')
 
 
 def get_color():
-    client = GConf.Client.get_default()
-    color = client.get_string('/desktop/sugar/user/color')
+    settings = Gio.Settings('org.sugarlabs.user')
+    color = settings.get_string('color')
     return XoColor(color)
 
 

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/test/uitree.py

@@ -47 +47 @@
                 if e.code == Atspi.Error.IPC:
                     continue
 
-                logging.error("GError code %d", e.code)
+                logging.error("GError code %d" % e.code)
                 raise
 
             expect_none = kwargs.get("expect_none", False)

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/test/unittest.py

@@ -28 +28 @@
 
 from sugar3.test import uitree
 
+import dbus
+from dbus.mainloop.glib import DBusGMainLoop
+DBusGMainLoop(set_as_default=True)
+bus = dbus.SessionBus()
+
 
 class UITestCase(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(UITestCase, self).__init__(*args, **kwargs)
+        self.bundle_id = None
+
     def setUp(self):
         logger = logging.getLogger()
         self._orig_level = logger.getEffectiveLevel()
@@ -46 +56 @@
 
         try:
             yield
+        except:
+            logging.debug(uitree.get_root().dump())
+            raise
+        finally:
+            process.terminate()
+
+    @contextmanager
+    def run_activity(self):
+        if self.bundle_id is not None:
+            process = subprocess.Popen(["sugar-launch", self.bundle_id])
+        else:
+            print "No bundle_id specified."
+            return
+
+        try:
+            yield
         except:
             logging.debug(uitree.get_root().dump())
             raise

.olpcau.x86_64/usr/lib/python2.7/site-packages/sugar3/util.py

@@ -307 +307 @@
         if path is None:
             fd, path = tempfile.mkstemp()
             os.close(fd)
-        logging.debug('TempFilePath created %r', path)
+        logging.debug('TempFilePath created %r' % path)
 
         if path in _tracked_paths:
             _tracked_paths[path] += 1
@@ -322 +322 @@
 
             if os.path.exists(self):
                 os.unlink(self)
-                logging.debug('TempFilePath deleted %r', self)
+                logging.debug('TempFilePath deleted %r' % self)
             else:
-                logging.warning('TempFilePath already deleted %r', self)
+                logging.warning('TempFilePath already deleted %r' % self)
         else:
             _tracked_paths[self] -= 1