21 files changed, 1902 insertions, 0 deletions

diff --git a/olpcgames/__init__.py b/olpcgames/__init__.py
new file mode 100755
index 0000000..e27aed4
--- /dev/null
+++ b/olpcgames/__init__.py
@@ -0,0 +1,34 @@
+"""Wrapper/adaptation system for writing/porting PyGame games to OLPC/Sugar
+
+The wrapper system attempts to substitute various pieces of the PyGame 
+implementation in order to make code written without knowledge of the
+OLPC/Sugar environment run "naturally" under the GTK environment of 
+Sugar.  It also provides some convenience mechanisms for dealing with 
+e.g. the Camera and Mesh Network system.
+
+Considerations for Developers:
+
+PyGame programs running under OLPCGames will generally not have
+"hardware" surfaces, and will not be able to have a reduced-resolution 
+full-screen view to optimise rendering.  The PyGame code will run in 
+a secondary thread, with the main GTK UI running in the primary thread.
+A third "mainloop" thread will occasionally be created to handle the 
+GStreamer interface to the camera.
+"""
+# XXX handle configurations that are not running under Sugar and 
+# report proper errors to describe the problem, rather than letting the 
+# particular errors propagate outward.
+# XXX allow use of a particular feature within the library without needing
+# to be running under sugar.  e.g. allow importing mesh or camera without 
+# needing to import the activity machinery.
+from olpcgames.canvas import *
+try:
+    from olpcgames.activity import *
+except ImportError, err:
+    PyGameActivity = None
+from olpcgames import camera
+from olpcgames import pangofont
+from olpcgames import mesh
+
+ACTIVITY = None
+widget = None
diff --git a/olpcgames/__init__.pyc b/olpcgames/__init__.pyc
new file mode 100755
index 0000000..5e7904d
--- /dev/null
+++ b/olpcgames/__init__.pyc
diff --git a/olpcgames/activity.py b/olpcgames/activity.py
new file mode 100755
index 0000000..f159b50
--- /dev/null
+++ b/olpcgames/activity.py
@@ -0,0 +1,162 @@
+"""Embeds the Canvas widget into a Sugar-specific Activity environment"""
+import logging
+logging.root.setLevel( logging.WARN )
+log = logging.getLogger( 'activity' )
+log.setLevel( logging.INFO )
+
+import pygtk
+pygtk.require('2.0')
+import gtk
+import gtk.gdk
+
+from sugar.activity import activity
+from sugar.graphics import style
+from olpcgames.canvas import PyGameCanvas
+from olpcgames import mesh, util
+
+__all__ = ['PyGameActivity']
+
+class PyGameActivity(activity.Activity):
+    """PyGame-specific activity type, provides boilerplate toolbar, creates canvas
+
+    Subclass Overrides:
+
+        game_name -- specifies a fully-qualified name for the game's main-loop
+            format like so:
+                'package.module:main'
+            if not function name is provided, "main" is assumed.
+        game_handler -- alternate specification via direct reference to a main-loop
+            function
+
+        game_size -- two-value tuple specifying the size of the display in pixels,
+            this is currently static, so once the window is created it cannot be
+            changed.
+
+            If None, use the bulk of the screen for the PyGame surface based on
+            the values reported by the gtk.gdk functions.  Note that None is
+            *not* the default value.
+
+        game_title -- title to be displayed in the Sugar Shell UI
+
+        pygame_mode -- chooses the rendering engine used for handling the
+            PyGame drawing mode, 'SDL' chooses the standard PyGame renderer,
+            'Cairo' chooses the experimental pygamecairo renderer.
+
+        PYGAME_CANVAS_CLASS -- normally PyGameCanvas, but can be overridden
+            if you want to provide a different canvas class, e.g. to provide a different
+            internal layout.  Note: only used where pygame_mode == 'SDL'
+
+    The Activity, once created, will be made available as olpcgames.ACTIVITY,
+    and that access mechanism should allow code to test for the presence of the
+    activity before accessing Sugar-specific functionality.
+
+    XXX Note that currently the toolbar and window layout are hard-coded into
+    this super-class, with no easy way of overriding without completely rewriting
+    the __init__ method.  We should allow for customising both the UI layout and
+    the toolbar contents/layout/connection.
+    
+    XXX Note that if you change the title of your activity in the toolbar you may 
+    see the same focus issues as we have patched around in the build_toolbar 
+    method.  If so, please report them to Mike Fletcher.
+    """
+    game_name = None
+    game_title = 'PyGame Game'
+    game_handler = None
+    game_size = (16 * style.GRID_CELL_SIZE,
+                 11 * style.GRID_CELL_SIZE)
+    pygame_mode = 'SDL'
+
+    def __init__(self, handle):
+        """Initialise the Activity with the activity-description handle"""
+        super(PyGameActivity, self).__init__(handle)
+        self.make_global()
+        if self.game_size is None:
+            width,height = gtk.gdk.screen_width(), gtk.gdk.screen_height()
+            log.info( 'Total screen size: %s %s', width,height)
+            # for now just fudge the toolbar size...
+            self.game_size = width, height - (1*style.GRID_CELL_SIZE)
+        self.set_title(self.game_title)
+        toolbar = self.build_toolbar()
+        log.debug( 'Toolbar size: %s', toolbar.get_size_request())
+        canvas = self.build_canvas()
+
+    def make_global( self ):
+        """Hack to make olpcgames.ACTIVITY point to us
+        """
+        import weakref, olpcgames
+        assert not olpcgames.ACTIVITY, """Activity.make_global called twice, have you created two Activity instances in a single process?"""
+        olpcgames.ACTIVITY = weakref.proxy( self )
+
+    def build_toolbar( self ):
+        """Build our Activity toolbar for the Sugar system
+
+        This is a customisation point for those games which want to
+        provide custom toolbars when running under Sugar.
+        """
+        toolbar = activity.ActivityToolbar(self)
+        toolbar.show()
+        self.set_toolbox(toolbar)
+        def shared_cb(*args, **kwargs):
+            log.info( 'shared: %s, %s', args, kwargs )
+            try:
+                mesh.activity_shared(self)
+            except Exception, err:
+                log.error( """Failure signaling activity sharing to mesh module: %s""", util.get_traceback(err) )
+            else:
+                log.info( 'mesh activity shared message sent, trying to grab focus' )
+            try:
+                self._pgc.grab_focus()
+            except Exception, err:
+                log.warn( 'Focus failed: %s', err )
+            else:
+                log.info( 'asserting focus' )
+                assert self._pgc.is_focus(), """Did not successfully set pygame canvas focus"""
+            log.info( 'callback finished' )
+            
+        def joined_cb(*args, **kwargs):
+            log.info( 'joined: %s, %s', args, kwargs )
+            mesh.activity_joined(self)
+            self._pgc.grab_focus()
+        self.connect("shared", shared_cb)
+        self.connect("joined", joined_cb)
+
+        if self.get_shared():
+            # if set at this point, it means we've already joined (i.e.,
+            # launched from Neighborhood)
+            joined_cb()
+
+        toolbar.title.unset_flags(gtk.CAN_FOCUS)
+        return toolbar
+
+    PYGAME_CANVAS_CLASS = PyGameCanvas
+    def build_canvas( self ):
+        """Construct the PyGame or PyGameCairo canvas for drawing"""
+        assert self.game_handler or self.game_name, 'You must specify a game_handler or game_name on your Activity (%r)'%(
+            self.game_handler or self.game_name
+        )
+        if self.pygame_mode != 'Cairo':
+            self._pgc = self.PYGAME_CANVAS_CLASS(*self.game_size)
+            self.set_canvas(self._pgc)
+            self._pgc.grab_focus()
+            self._pgc.connect_game(self.game_handler or self.game_name)
+            gtk.gdk.threads_init()
+            return self._pgc
+        else:
+            import hippo
+            self._drawarea = gtk.DrawingArea()
+            canvas = hippo.Canvas()
+            canvas.grab_focus()
+            self.set_canvas(canvas)
+            self.show_all()
+
+            import pygamecairo
+            pygamecairo.install()
+
+            pygamecairo.display.init(canvas)
+            app = self.game_handler or self.game_name
+            if ':' not in app:
+                app += ':main'
+            mod_name, fn_name = app.split(':')
+            mod = __import__(mod_name, globals(), locals(), [])
+            fn = getattr(mod, fn_name)
+            fn()
diff --git a/olpcgames/activity.pyc b/olpcgames/activity.pyc
new file mode 100755
index 0000000..c01a38d
--- /dev/null
+++ b/olpcgames/activity.pyc
diff --git a/olpcgames/camera.py b/olpcgames/camera.py
new file mode 100755
index 0000000..dfc969a
--- /dev/null
+++ b/olpcgames/camera.py
@@ -0,0 +1,235 @@
+"""Accesses OLPC Camera functionality via gstreamer
+
+Depends upon:
+    pygame 
+    python-gstreamer
+"""
+import threading
+import logging
+import time
+import os
+import pygame
+import gst
+from olpcgames.util import get_activity_root
+
+log = logging.getLogger( 'camera' )
+#log.setLevel( logging.DEBUG )
+
+CAMERA_LOAD = 9917
+CAMERA_LOAD_FAIL = 9918
+
+class CameraSprite(object):
+    """Create gstreamer surface for the camera."""
+    def __init__(self, x, y):
+        import olpcgames
+        if olpcgames.widget:
+            self._init_video(olpcgames.widget, x, y)
+            
+    def _init_video(self, widget, x, y):
+        from olpcgames import video
+        self._vid = video.VideoWidget()
+        widget._fixed.put(self._vid, x, y)
+        self._vid.show()
+        
+        self.player = video.Player(self._vid)
+        self.player.play()
+        
+class Camera(object):
+    """A class representing a still-picture camera
+    
+    Produces a simple gstreamer bus that terminates in a filesink, that is, 
+    it stores the results in a file.  When a picture is "snapped" the gstreamer
+    stream is iterated until it finishes processing and then the file can be 
+    read.
+    
+    There are two APIs available, a synchronous API which can potentially 
+    stall your activity's GUI (and is NOT recommended) and an 
+    asynchronous API which returns immediately and delivers the captured 
+    camera image via a Pygame event.  To be clear, it is recommended 
+    that you use the snap_async method, *not* the snap method.
+    
+    Note:
+    
+        The Camera class is simply a convenience wrapper around a fairly 
+        straightforward gstreamer bus.  If you have more involved 
+        requirements for your camera manipulations you will probably 
+        find it easier to write your own camera implementation than to 
+        use this one.  Basically we provide here the "normal" use case of 
+        snapping a picture into a pygame image.
+    """
+    _aliases = {
+        'camera': 'v4l2src',
+        'test': 'videotestsrc',
+        'testing': 'videotestsrc',
+        'png': 'pngenc',
+        'jpeg': 'jpegenc',
+        'jpg': 'jpegenc',
+    }
+    def __init__(self, source='camera', format='png', filename='snap.png', directory = None):
+        """Initialises the Camera's internal description
+        
+        source -- the gstreamer source for the video to capture, useful values:
+            'v4l2src','camera' -- the camera
+            'videotestsrc','test' -- test pattern generator source
+        format -- the gstreamer encoder to use for the capture, useful values:
+            'pngenc','png' -- PNG format graphic
+            'jpegenc','jpg','jpeg' -- JPEG format graphic
+        filename -- the filename to use for the capture
+        directory -- the directory in which to create the temporary file, defaults 
+            to get_activity_root() + 'tmp'
+        """
+        self.source = self._aliases.get( source, source )
+        self.format = self._aliases.get( format, format )
+        self.filename = filename 
+        self.directory = directory
+    SNAP_PIPELINE = '%(source)s ! ffmpegcolorspace ! %(format)s ! filesink location="%(filename)s"'
+    def _create_pipe( self ):
+        """Method to create the cstreamer pipe from our settings"""
+        if not self.directory:
+            path = os.path.join( get_activity_root(), 'tmp' )
+            try:
+                os.makedirs( path )
+                log.info( 'Created temporary directory: %s', path )
+            except (OSError,IOError), err:
+                pass
+        else:
+            path = self.directory
+        filename = os.path.join( path, self.filename )
+        format = self.format 
+        source = self.source 
+        pipeline = self.SNAP_PIPELINE % locals()
+        log.debug( 'Background thread processing: %s', pipeline )
+        return filename, gst.parse_launch(pipeline)
+        
+    def snap(self):
+        """Snap a picture via the camera by iterating gstreamer until finished
+        
+        Note: this is an unsafe implementation, it will cause the whole 
+        activity to hang if the operation happens to fail!  It is strongly 
+        recommended that you use snap_async instead of snap!
+        """
+        log.debug( 'Starting snap' )
+        filename, pipe = self._create_pipe()
+        pipe.set_state(gst.STATE_PLAYING)
+        bus = pipe.get_bus()
+        tmp = False
+        while True:
+            event = self.bus.poll(gst.MESSAGE_STATE_CHANGED, 5)
+            if event:
+                old, new, pending = event.parse_state_changed()
+                if pending == gst.STATE_VOID_PENDING:
+                    if tmp:
+                        break
+                    else:
+                        tmp = True
+            else:
+                break
+        log.log( 'Ending snap, loading: %s', filename )
+        return self._load_and_clean( filename )
+    def _load_and_clean( self, filename ):
+        """Use pygame to load given filename, delete after loading/attempt"""
+        try:
+            log.info( 'Loading snapshot file: %s', filename )
+            return pygame.image.load(filename)
+        finally:
+            try:
+                os.remove( filename )
+            except (IOError,OSError), err:
+                pass
+    def snap_async( self, token=None ):
+        """Snap a picture asynchronously generating event on success/failure
+        
+        token -- passed back as attribute of the event which signals that capture
+            is finished
+        
+        We return two types of events CAMERA_LOAD and CAMERA_LOAD_FAIL,
+        depending on whether we succeed or not.  Attributes of the events which 
+        are returned:
+        
+            token -- as passed to this method 
+            filename -- the filename in our temporary directory we used to store 
+                the file temporarily 
+            image -- pygame image.load result if successful, None otherwise
+            err -- Exception instance if failed, None otherwise
+        
+        Basically identical to the snap method, save that it posts a message 
+        to the event bus in eventwrap instead of blocking and returning...
+        """
+        log.debug( 'beginning async snap')
+        t = threading.Thread(target=self._background_snap, args=(token,))
+        t.start()
+        log.debug( 'background thread started for gstreamer' )
+        return token
+
+    def _background_snap( 
+        self,
+        token = None,
+    ):
+        """Process gst messages until pipe is finished
+        
+        pipe -- gstreamer pipe definition for parse_launch, normally it will 
+            produce a file into which the camera should store an image
+        
+        We consider pipe to be finished when we have had two "state changed"
+        gstreamer events where the pending state is VOID, the first for when 
+        we begin playing, the second for when we finish.
+        """
+        log.debug( 'Background thread kicking off gstreamer capture begun' )
+        from olpcgames import eventwrap 
+        from pygame.event import Event
+        filename, pipe = self._create_pipe()
+        bus = pipe.get_bus()
+        bus.add_signal_watch()
+        def _background_snap_onmessage( bus, message ):
+            """Handle messages from the picture-snapping bus"""
+            log.debug( 'Message handler for gst messages: %s', message )
+            t = message.type
+            if t == gst.MESSAGE_EOS:
+                pipe.set_state(gst.STATE_NULL)
+                try:
+                    image = self._load_and_clean( filename )
+                    success = True
+                except Exception, err:
+                    success = False
+                    image = None 
+                else:
+                    err = None
+                log.debug( 'Success loading file %r', token )
+                eventwrap.post(Event(
+                    CAMERA_LOAD, 
+                    filename=filename, 
+                    success = success,
+                    token = token, 
+                    image=image, 
+                    err=err
+                ))
+                
+            elif t == gst.MESSAGE_ERROR:
+                log.warn( 'Failure loading file %r: %s', token, message )
+                pipe.set_state(gst.STATE_NULL)
+                err, debug = message.parse_error()
+                eventwrap.post(Event(
+                    CAMERA_LOAD_FAIL, 
+                    filename=filename, 
+                    success = False,
+                    token = token, 
+                    image=None, 
+                    err=err
+                ))
+                return False
+        bus.connect('message', _background_snap_onmessage)
+        pipe.set_state(gst.STATE_PLAYING)
+
+def snap():
+    """Dump a snapshot from the camera to a pygame surface in background thread
+    
+    See Camera.snap
+    """
+    return Camera().snap()
+
+def snap_async( token=None, **named ):
+    """Dump snapshot from camera return asynchronously as event in Pygame
+    
+    See Camera.snap_async
+    """
+    return Camera(**named).snap_async( token )
diff --git a/olpcgames/camera.pyc b/olpcgames/camera.pyc
new file mode 100755
index 0000000..d4c22c6
--- /dev/null
+++ b/olpcgames/camera.pyc
diff --git a/olpcgames/canvas.py b/olpcgames/canvas.py
new file mode 100755
index 0000000..eda64a2
--- /dev/null
+++ b/olpcgames/canvas.py
@@ -0,0 +1,111 @@
+"""Implements bridge connection between Sugar/GTK and PyGame"""
+import os
+import sys
+import threading
+from pprint import pprint
+
+import pygtk
+pygtk.require('2.0')
+import gtk
+import gobject
+import pygame
+
+from olpcgames import gtkEvent, video
+
+__all__ = ['PyGameCanvas']
+
+class PyGameCanvas(gtk.EventBox):
+    """Canvas providing bridge methods to run PyGame in GTK
+    
+    The PyGameCanvas creates a secondary thread in which the Pygame instance will 
+    live, providing synthetic PyGame events to that thread via a Queue.  The GUI 
+    connection is  done by having the PyGame canvas use a GTK Port object as it's 
+    window pointer, it draws to that X-level window in order to produce output.
+    """
+    def __init__(self, width, height):
+        """Initializes the Canvas Object
+        
+        width,height -- passed to the inner EventBox in order to request a given size,
+            the Socket is the only child of this EventBox, and the PyGame commands
+            will be writing to the Window ID of the socket.  The internal EventBox is 
+            centered via an Alignment instance within the PyGameCanvas instance.
+            
+        XXX Should refactor so that the internal setup can be controlled by the 
+        sub-class, e.g. to get size from the host window, or something similar.
+        """
+        # Build the main widget
+        super(PyGameCanvas,self).__init__()
+        self.set_flags(gtk.CAN_FOCUS)
+        
+        # Build the sub-widgets
+        self._align = gtk.Alignment(0.5, 0.5)
+        self._inner_evb = gtk.EventBox()
+        self._socket = gtk.Socket()
+
+        
+        # Add internal widgets
+        self._inner_evb.set_size_request(width, height)
+        self._inner_evb.add(self._socket)
+        
+        self._socket.show()
+        
+        self._align.add(self._inner_evb)
+        self._inner_evb.show()
+        
+        self._align.show()
+        
+        self.add(self._align)
+        
+        # Construct a gtkEvent.Translator
+        self._translator = gtkEvent.Translator(self, self._inner_evb)
+        # <Cue Thus Spract Zarathustra>
+        self.show()
+    def connect_game(self, app):
+        """Imports the given main-loop and starts processing in secondary thread 
+        
+        app -- fully-qualified Python path-name for the game's main-loop, with 
+            name within module as :functionname, if no : character is present then 
+            :main will be assumed.
+        
+        Side effects:
+        
+            Sets the SDL_WINDOWID variable to our socket's window ID 
+            Calls PyGame init
+            Causes the gtkEvent.Translator to "hook" PyGame
+            Creates and starts secondary thread for Game/PyGame event processing.
+        """
+        # Setup the embedding
+        os.environ['SDL_WINDOWID'] = str(self._socket.get_id())
+        #print 'Socket ID=%s'%os.environ['SDL_WINDOWID']
+        pygame.init()
+
+        self._translator.hook_pygame()
+        
+        # Load the modules
+        # NOTE: This is delayed because pygame.init() must come after the embedding is up
+        if ':' not in app:
+            app += ':main'
+        mod_name, fn_name = app.split(':')
+        mod = __import__(mod_name, globals(), locals(), [])
+        fn = getattr(mod, fn_name)
+        
+        # Start Pygame
+        self.__thread = threading.Thread(target=self._start, args=[fn])
+        self.__thread.start()
+
+    def _start(self, fn):
+        """The method that actually runs in the background thread"""
+        import olpcgames
+        olpcgames.widget = self
+        try:
+            import sugar.activity.activity,os
+        except ImportError, err:
+            log.info( """Running outside Sugar""" )
+        else:
+            os.chdir(sugar.activity.activity.get_bundle_path())
+        
+        try:
+            fn()
+        finally:
+            gtk.main_quit()
+        
diff --git a/olpcgames/canvas.pyc b/olpcgames/canvas.pyc
new file mode 100755
index 0000000..51658ae
--- /dev/null
+++ b/olpcgames/canvas.pyc
diff --git a/olpcgames/eventwrap.py b/olpcgames/eventwrap.py
new file mode 100755
index 0000000..000511c
--- /dev/null
+++ b/olpcgames/eventwrap.py
@@ -0,0 +1,160 @@
+"""Converts from GTK to Pygame events
+
+Provides methods which will be substituted into Pygame in order to 
+provide the synthetic events that we will feed into the Pygame queue.
+These methods are registered by the "install" method.
+"""
+import pygame
+import gtk
+import Queue
+import thread
+import logging
+
+log = logging.getLogger( 'eventwrap' )
+
+# This module reuses Pygame's Event, but
+# reimplements the event queue.
+from pygame.event import Event, event_name, pump as pygame_pump, get as pygame_get
+
+#print "Initializing own event.py"
+
+# Install myself on top of pygame.event
+def install():
+    """Installs this module (eventwrap) as an in-place replacement for the pygame.event module.
+   
+    Use install() when you need to interact with Pygame code written
+    without reference to the olpcgames wrapper mechanisms to have the 
+    code use this module's event queue.
+    
+    XXX Really, use it everywhere you want to use olpcgames, as olpcgames
+    registers the handler itself, so you will always wind up with it registered when 
+    you use olpcgames (the gtkEvent.Translator.hook_pygame method calls it).
+    """
+    import eventwrap,pygame
+    pygame.event = eventwrap
+    import sys
+    sys.modules["pygame.event"] = eventwrap
+    
+
+# Event queue:
+g_events = Queue.Queue()
+
+# Set of blocked events as set by set
+g_blocked = set()
+g_blockedlock = thread.allocate_lock()
+g_blockAll = False
+
+def pump():
+    """Handle any window manager and other external events that aren't passed to the user. Call this periodically (once a frame) if you don't call get(), poll() or wait()."""
+    pygame_pump()
+
+def get():
+    """Get a list of all pending events. (Unlike pygame, there's no option to filter by event type; you should use set_blocked() if you don't want to see certain events.)"""
+    pump()
+    eventlist = []
+    try:
+        while True:
+            eventlist.append(g_events.get(block=False))
+    except Queue.Empty:
+        pass
+    
+    pygameEvents = pygame_get()
+    if pygameEvents:
+        log.info( 'Raw Pygame events: %s', pygameEvents)
+        eventlist.extend( pygameEvents )
+
+    return eventlist
+
+def poll():
+    """Get the next pending event if exists. Otherwise, return pygame.NOEVENT."""
+    pump()
+    try:
+        return g_events.get(block=False)
+    except Queue.Empty:
+        return Event(pygame.NOEVENT)
+
+
+def wait():
+    """Get the next pending event, waiting if none."""
+    pump()
+    return g_events.get(block=True)
+
+def peek(types=None):
+    """True if there is any pending event. (Unlike pygame, there's no option to
+    filter by event type)"""
+    return not g_events.empty()
+    
+def clear():
+    """Dunno why you would do this, but throws every event out of the queue"""
+    try:
+        while True:
+            g_events.get(block=False)
+    except Queue.Empty:
+        pass
+
+def set_blocked(item):
+    g_blockedlock.acquire()
+    try:
+        # FIXME: we do not currently know how to block all event types when
+        # you set_blocked(none).
+        [g_blocked.add(x) for x in makeseq(item)]
+    finally:
+        g_blockedlock.release()
+    
+def set_allowed(item):
+    g_blockedlock.acquire()
+    try:
+        if item is None:
+            # Allow all events when you set_allowed(none). Strange, eh?
+            # Pygame is a wonderful API.
+            g_blocked.clear()
+        else:
+            [g_blocked.remove(x) for x in makeseq(item)]
+    finally:
+        g_blockedlock.release()
+
+def get_blocked(*args, **kwargs):
+    g_blockedlock.acquire()
+    try:
+        blocked = frozenset(g_blocked)
+        return blocked
+    finally:
+        g_blockedlock.release()
+
+def set_grab(grabbing):
+    # We don't do this.
+    pass
+
+def get_grab():
+    # We don't do this.
+    return False
+
+def post(event):
+    #print "posting on own"
+    g_blockedlock.acquire()
+    try:
+        if event.type not in g_blocked:
+            g_events.put(event, block=False)
+    finally:
+        g_blockedlock.release()
+
+def makeseq(obj):
+    """Accept either a scalar object or a sequence, and return a sequence
+    over which we can iterate. If we were passed a sequence, return it
+    unchanged. If we were passed a scalar, return a tuple containing only
+    that scalar. This allows the caller to easily support one-or-many.
+    """
+    # Strings are the exception because you can iterate over their chars
+    # -- yet, for all the purposes I've ever cared about, I want to treat
+    # a string as a scalar.
+    if isinstance(obj, basestring):
+        return (obj,)
+    try:
+        # Except as noted above, if you can get an iter() from an object,
+        # it's a collection.
+        iter(obj)
+        return obj
+    except TypeError:
+        # obj is a scalar. Wrap it in a tuple so we can iterate over the
+        # one item.
+        return (obj,)
diff --git a/olpcgames/eventwrap.pyc b/olpcgames/eventwrap.pyc
new file mode 100755
index 0000000..3511089
--- /dev/null
+++ b/olpcgames/eventwrap.pyc
diff --git a/olpcgames/gtkEvent.py b/olpcgames/gtkEvent.py
new file mode 100755
index 0000000..2dbe652
--- /dev/null
+++ b/olpcgames/gtkEvent.py
@@ -0,0 +1,264 @@
+"""gtkEvent.py: translate GTK events into Pygame events."""
+import pygtk
+pygtk.require('2.0')
+import gtk
+import gobject
+import pygame
+import pygame.event as Pevent
+#PCevent = Pevent
+from olpcgames import eventwrap as PCevent
+import logging 
+log = logging.getLogger( 'gtkevent' )
+log.setLevel( logging.DEBUG )
+
+class MockEvent(object):
+    """Used to inject key-repeat events."""
+    
+    def __init__(self, keyval):
+        self.keyval = keyval
+
+class Translator(object):
+    """Utility class to translate GTK events into Pygame events 
+    
+    The Translator object interprets incoming GTK events and generates
+    Pygame events in the eventwrap module's queue as a result.
+    It also handles generating Pygame style key-repeat events 
+    by synthesizing them via a GTK timer.
+    """
+    key_trans = {
+        'Alt_L': pygame.K_LALT,
+        'Alt_R': pygame.K_RALT,
+        'Control_L': pygame.K_LCTRL,
+        'Control_R': pygame.K_RCTRL,
+        'Shift_L': pygame.K_LSHIFT,
+        'Shift_R': pygame.K_RSHIFT,
+        'Super_L': pygame.K_LSUPER,
+        'Super_R': pygame.K_RSUPER,
+        'KP_Page_Up' : pygame.K_KP9, 
+        'KP_Page_Down' : pygame.K_KP3,
+        'KP_End' : pygame.K_KP1, 
+        'KP_Home' : pygame.K_KP7,
+        'KP_Up' : pygame.K_KP8,
+        'KP_Down' : pygame.K_KP2,
+        'KP_Left' : pygame.K_KP4,
+        'KP_Right' : pygame.K_KP6,
+
+    }
+    
+    mod_map = {
+        pygame.K_LALT: pygame.KMOD_LALT,
+        pygame.K_RALT: pygame.KMOD_RALT,
+        pygame.K_LCTRL: pygame.KMOD_LCTRL,
+        pygame.K_RCTRL: pygame.KMOD_RCTRL,
+        pygame.K_LSHIFT: pygame.KMOD_LSHIFT,
+        pygame.K_RSHIFT: pygame.KMOD_RSHIFT,
+    }
+    
+    def __init__(self, mainwindow, mouselistener=None):
+        """Initialise the Translator with the windows to which to listen"""
+        # _inner_evb is Mouselistener
+        self._mainwindow = mainwindow
+        if mouselistener is None:
+            mouselistener = mainwindow
+
+        self._inner_evb = mouselistener
+
+        # Need to set our X event masks so we see mouse motion and stuff --
+        mainwindow.set_events(
+            gtk.gdk.KEY_PRESS_MASK | \
+            gtk.gdk.KEY_RELEASE_MASK \
+        )
+        
+        self._inner_evb.set_events(
+            gtk.gdk.POINTER_MOTION_MASK | \
+            gtk.gdk.POINTER_MOTION_HINT_MASK | \
+            gtk.gdk.BUTTON_MOTION_MASK | \
+            gtk.gdk.BUTTON_PRESS_MASK | \
+            gtk.gdk.BUTTON_RELEASE_MASK 
+        )
+          
+        # Callback functions to link the event systems
+        mainwindow.connect('unrealize', self._quit)
+        mainwindow.connect('key_press_event', self._keydown)
+        mainwindow.connect('key_release_event', self._keyup)
+        self._inner_evb.connect('button_press_event', self._mousedown)
+        self._inner_evb.connect('button_release_event', self._mouseup)
+        self._inner_evb.connect('motion-notify-event', self._mousemove)
+
+        # You might need to do this
+        mainwindow.set_flags(gtk.CAN_FOCUS)
+        self._inner_evb.set_flags(gtk.CAN_FOCUS)
+        
+        # Internal data
+        self.__stopped = False
+        self.__keystate = [0] * 323
+        self.__button_state = [0,0,0]
+        self.__mouse_pos = (0,0)
+        self.__repeat = (None, None)
+        self.__held = set()
+        self.__held_time_left = {}
+        self.__held_last_time = {}
+        self.__tick_id = None
+
+        #print "translator  initialized"
+        
+    def hook_pygame(self):
+        """Hook the various Pygame features so that we implement the event APIs"""
+        # Pygame should be initialized. Hijack their key and mouse methods
+        pygame.key.get_pressed = self._get_pressed
+        pygame.key.set_repeat = self._set_repeat
+        pygame.mouse.get_pressed = self._get_mouse_pressed
+        pygame.mouse.get_pos = self._get_mouse_pos
+        import eventwrap
+        eventwrap.install()
+        
+    def _quit(self, data=None):
+        self.__stopped = True
+        PCevent.post(Pevent.Event(pygame.QUIT))
+
+    def _keydown(self, widget, event):
+        key = event.keyval
+        log.debug( 'key down: %s', key )
+        if key in self.__held:
+            return True
+        else:
+            if self.__repeat[0] is not None:
+                self.__held_last_time[key] = pygame.time.get_ticks()
+                self.__held_time_left[key] = self.__repeat[0]
+            self.__held.add(key)
+            
+        return self._keyevent(widget, event, pygame.KEYDOWN)
+        
+    def _keyup(self, widget, event):
+        key = event.keyval
+        if self.__repeat[0] is not None:
+            if key in self.__held:
+                # This is possibly false if set_repeat() is called with a key held
+                del self.__held_time_left[key]
+                del self.__held_last_time[key]
+        self.__held.discard(key)
+
+        return self._keyevent(widget, event, pygame.KEYUP)
+        
+    def _keymods(self):
+        """Extract the keymods as they stand currently."""
+        mod = 0
+        for key_val, mod_val in self.mod_map.iteritems():
+            mod |= self.__keystate[key_val] and mod_val
+        return mod
+        
+        
+    def _keyevent(self, widget, event, type):
+        key = gtk.gdk.keyval_name(event.keyval)
+        if key is None:
+            # No idea what this key is.
+            return False 
+        
+        keycode = None
+        if key in self.key_trans:
+            keycode = self.key_trans[key]
+        elif hasattr(pygame, 'K_'+key.upper()):
+            keycode = getattr(pygame, 'K_'+key.upper())
+        elif hasattr(pygame, 'K_'+key.lower()):
+            keycode = getattr(pygame, 'K_'+key.lower())
+        else:
+            print 'Key %s unrecognized'%key
+            
+        if keycode is not None:
+            if type == pygame.KEYDOWN:
+                mod = self._keymods()
+            self.__keystate[keycode] = type == pygame.KEYDOWN
+            if type == pygame.KEYUP:
+                mod = self._keymods()
+            ukey = gtk.gdk.keyval_to_unicode(event.keyval)
+            evt = Pevent.Event(type, key=keycode, unicode=ukey, mod=mod)
+            self._post(evt)
+        return True
+
+    def _get_pressed(self):
+        """Retrieve map/array of which keys are currently depressed (held down)"""
+        return self.__keystate
+
+    def _get_mouse_pressed(self):
+        """Return three-element array of which mouse-buttons are currently depressed (held down)"""
+        return self.__button_state
+
+    def _mousedown(self, widget, event):
+        self.__button_state[event.button-1] = 1
+        return self._mouseevent(widget, event, pygame.MOUSEBUTTONDOWN)
+
+    def _mouseup(self, widget, event):
+        self.__button_state[event.button-1] = 0
+        return self._mouseevent(widget, event, pygame.MOUSEBUTTONUP)
+        
+    def _mouseevent(self, widget, event, type):
+
+        evt = Pevent.Event(type, 
+                                             button=event.button, 
+                                             pos=(event.x, event.y))
+        self._post(evt)
+        return True
+        
+    def _mousemove(self, widget, event):
+        # From http://www.learningpython.com/2006/07/25/writing-a-custom-widget-using-pygtk/
+        # if this is a hint, then let's get all the necessary 
+        # information, if not it's all we need.
+        if event.is_hint:
+            x, y, state = event.window.get_pointer()
+        else:
+            x = event.x
+            y = event.y
+            state = event.state
+
+        rel = (x - self.__mouse_pos[0],
+                y - self.__mouse_pos[1])
+        self.__mouse_pos = (x, y)
+        
+        self.__button_state = [
+            state & gtk.gdk.BUTTON1_MASK and 1 or 0,
+            state & gtk.gdk.BUTTON2_MASK and 1 or 0,
+            state & gtk.gdk.BUTTON3_MASK and 1 or 0,
+        ]
+        
+        evt = Pevent.Event(pygame.MOUSEMOTION,
+                                             pos=self.__mouse_pos,
+                                             rel=rel,
+                                             buttons=self.__button_state)
+        self._post(evt)
+        return True
+        
+    def _tick(self):
+        """Generate synthetic events for held-down keys"""
+        cur_time = pygame.time.get_ticks()
+        for key in self.__held:
+            delta = cur_time - self.__held_last_time[key] 
+            self.__held_last_time[key] = cur_time
+            
+            self.__held_time_left[key] -= delta
+            if self.__held_time_left[key] <= 0:
+                self.__held_time_left[key] = self.__repeat[1]
+                self._keyevent(None, MockEvent(key), pygame.KEYDOWN)
+                
+        return True
+        
+    def _set_repeat(self, delay=None, interval=None):
+        """Set the key-repetition frequency for held-down keys"""
+        if delay is not None and self.__repeat[0] is None:
+            self.__tick_id = gobject.timeout_add(10, self._tick)
+        elif delay is None and self.__repeat[0] is not None:
+            gobject.source_remove(self.__tick_id)
+        self.__repeat = (delay, interval)
+        
+    def _get_mouse_pos(self):
+        """Retrieve the current mouse position as a two-tuple of integers"""
+        return self.__mouse_pos
+            
+    def _post(self, evt):
+        try:
+            PCevent.post(evt)
+        except pygame.error, e:
+            if str(e) == 'Event queue full':
+                print "Event queue full!"
+                pass
+            else:
+                raise e
diff --git a/olpcgames/gtkEvent.pyc b/olpcgames/gtkEvent.pyc
new file mode 100755
index 0000000..ccdab8e
--- /dev/null
+++ b/olpcgames/gtkEvent.pyc
diff --git a/olpcgames/mesh.py b/olpcgames/mesh.py
new file mode 100755
index 0000000..254089f
--- /dev/null
+++ b/olpcgames/mesh.py
@@ -0,0 +1,398 @@
+'''mesh.py: utilities for wrapping the mesh and making it accessible to Pygame'''
+import logging
+log = logging.getLogger( 'olpcgames.mesh' )
+#log.setLevel( logging.DEBUG )
+try:
+    from sugar.presence.tubeconn import TubeConnection
+except ImportError, err:
+    TubeConnection = object
+try:
+    from dbus.gobject_service import ExportedGObject
+except ImportError, err:
+    ExportedGObject = object
+from dbus.service import method, signal
+
+try:
+    import telepathy
+except ImportError, err:
+    telepathy = None
+
+class OfflineError( Exception ):
+    """Raised when we cannot complete an operation due to being offline"""
+
+DBUS_IFACE="org.laptop.games.pygame"
+DBUS_PATH="/org/laptop/games/pygame"
+DBUS_SERVICE = None
+
+
+### NEW PYGAME EVENTS ###
+
+'''The tube connection was started. (i.e., the user clicked Share or started
+the activity from the Neighborhood screen).
+Event properties:
+  id: a unique identifier for this connection. (shouldn't be needed for anything)'''
+CONNECT            = 9912
+
+'''A participant joined the activity. This will trigger for the local user
+as well as any arriving remote users.
+Event properties:
+  handle: the arriving user's handle.'''
+PARTICIPANT_ADD    = 9913
+
+'''A participant quit the activity.
+Event properties:
+  handle: the departing user's handle.'''
+PARTICIPANT_REMOVE = 9914
+
+'''A message was sent to you.
+Event properties:
+   content: the content of the message (a string)
+   handle: the handle of the sending user.'''
+MESSAGE_UNI        = 9915
+
+'''A message was sent to everyone.
+Event properties:
+   content: the content of the message (a string)
+   handle: the handle of the sending user.'''
+MESSAGE_MULTI      = 9916
+
+
+# Private objects for useful purposes!
+pygametubes = []
+text_chan, tubes_chan = (None, None)
+conn = None
+initiating = False
+joining = False
+
+connect_callback = None
+
+def is_initiating():
+    '''A version of is_initiator that's a bit less goofy, and can be used
+    before the Tube comes up.'''
+    global initiating
+    return initiating
+
+def is_joining():
+    '''Returns True if the activity was started up by means of the
+    Neighbourhood mesh view.'''
+    global joining
+    return joining
+
+def set_connect_callback(cb):
+    '''Just the same as the Pygame event loop can listen for CONNECT,
+    this is just an ugly callback that the glib side can use to be aware
+    of when the Tube is ready.'''
+    global connect_callback
+    connect_callback = cb
+
+def activity_shared(activity):
+    '''Called when the user clicks Share.'''
+
+    global initiating
+    initiating = True
+
+    _setup(activity)
+
+
+    log.debug('This is my activity: making a tube...')
+    channel = tubes_chan[telepathy.CHANNEL_TYPE_TUBES]
+    if hasattr( channel, 'OfferDBusTube' ):
+        id = channel.OfferDBusTube(
+            DBUS_SERVICE, {})
+    else:
+        id = channel.OfferTube(
+            telepathy.TUBE_TYPE_DBUS, DBUS_SERVICE, {})
+
+    global connect_callback
+    if connect_callback is not None:
+        connect_callback()
+
+def activity_joined(activity):
+    '''Called at the startup of our Activity, when the user started it via Neighborhood intending to join an existing activity.'''
+
+    # Find out who's already in the shared activity:
+    log.debug('Joined an existing shared activity')
+
+    for buddy in activity._shared_activity.get_joined_buddies():
+        log.debug('Buddy %s is already in the activity' % buddy.props.nick)
+
+
+    global initiating
+    global joining
+    initiating = False
+    joining = True
+
+
+    _setup(activity)
+
+    tubes_chan[telepathy.CHANNEL_TYPE_TUBES].ListTubes(
+        reply_handler=_list_tubes_reply_cb,
+        error_handler=_list_tubes_error_cb)
+
+    global connect_callback
+    if connect_callback is not None:
+        connect_callback()
+
+def _getConn():
+    log.info( '_getConn' )
+    pservice = _get_presence_service()
+    name, path = pservice.get_preferred_connection()
+    global conn
+    conn = telepathy.client.Connection(name, path)
+    return conn
+
+
+
+def _setup(activity):
+    '''Determines text and tube channels for the current Activity. If no tube
+channel present, creates one. Updates text_chan and tubes_chan.
+
+setup(sugar.activity.Activity, telepathy.client.Connection)'''
+    global text_chan, tubes_chan, DBUS_SERVICE
+    if not DBUS_SERVICE:
+        DBUS_SERVICE = activity.get_bundle_id()
+    if not activity.get_shared():
+        log.error('Failed to share or join activity')
+        raise "Failure"
+
+    bus_name, conn_path, channel_paths = activity._shared_activity.get_channels()
+    _getConn()
+
+    # Work out what our room is called and whether we have Tubes already
+    room = None
+    tubes_chan = None
+    text_chan = None
+    for channel_path in channel_paths:
+        channel = telepathy.client.Channel(bus_name, channel_path)
+        htype, handle = channel.GetHandle()
+        if htype == telepathy.HANDLE_TYPE_ROOM:
+            log.debug('Found our room: it has handle#%d "%s"',
+                handle, conn.InspectHandles(htype, [handle])[0])
+            room = handle
+            ctype = channel.GetChannelType()
+            if ctype == telepathy.CHANNEL_TYPE_TUBES:
+                log.debug('Found our Tubes channel at %s', channel_path)
+                tubes_chan = channel
+            elif ctype == telepathy.CHANNEL_TYPE_TEXT:
+                log.debug('Found our Text channel at %s', channel_path)
+                text_chan = channel
+
+    if room is None:
+        log.error("Presence service didn't create a room")
+        raise "Failure"
+    if text_chan is None:
+        log.error("Presence service didn't create a text channel")
+        raise "Failure"
+
+    # Make sure we have a Tubes channel - PS doesn't yet provide one
+    if tubes_chan is None:
+        log.debug("Didn't find our Tubes channel, requesting one...")
+        tubes_chan = conn.request_channel(telepathy.CHANNEL_TYPE_TUBES,
+            telepathy.HANDLE_TYPE_ROOM, room, True)
+
+    tubes_chan[telepathy.CHANNEL_TYPE_TUBES].connect_to_signal('NewTube',
+        new_tube_cb)
+
+    return (text_chan, tubes_chan)
+
+def new_tube_cb(id, initiator, type, service, params, state):
+    log.debug("New_tube_cb called: %s %s %s" % (id, initiator, type))
+    if (type == telepathy.TUBE_TYPE_DBUS and service == DBUS_SERVICE):
+        if state == telepathy.TUBE_STATE_LOCAL_PENDING:
+            channel = tubes_chan[telepathy.CHANNEL_TYPE_TUBES]
+            if hasattr( channel, 'AcceptDBusTube' ):
+                channel.AcceptDBusTube( id )
+            else:
+                channel.AcceptTube(id)
+
+        tube_conn = TubeConnection(conn,
+            tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
+            id, group_iface=text_chan[telepathy.CHANNEL_INTERFACE_GROUP])
+
+        global pygametubes, initiating
+        pygametubes.append(PygameTube(tube_conn, initiating, len(pygametubes)))
+
+
+def _list_tubes_reply_cb(tubes):
+    for tube_info in tubes:
+        new_tube_cb(*tube_info)
+
+def _list_tubes_error_cb(e):
+    log.error('ListTubes() failed: %s', e)
+
+
+
+def get_buddy(dbus_handle):
+    """Get a Buddy from a handle."""
+    log.debug('Trying to find owner of handle %s...', dbus_handle)
+    cs_handle = instance().tube.bus_name_to_handle[dbus_handle]
+    log.debug('Trying to find my handle in %s...', cs_handle)
+    group = text_chan[telepathy.CHANNEL_INTERFACE_GROUP]
+    log.debug( 'Calling GetSelfHandle' )
+    my_csh = group.GetSelfHandle()
+    log.debug('My handle in that group is %s', my_csh)
+    if my_csh == cs_handle:
+        handle = conn.GetSelfHandle()
+        log.debug('CS handle %s belongs to me, %s', cs_handle, handle)
+    elif group.GetGroupFlags() & telepathy.CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES:
+        handle = group.GetHandleOwners([cs_handle])[0]
+        log.debug('CS handle %s belongs to %s', cs_handle, handle)
+    else:
+        handle = cs_handle
+        log.debug('non-CS handle %s belongs to itself', handle)
+
+    # XXX: we're assuming that we have Buddy objects for all contacts -
+    # this might break when the server becomes scalable.
+    pservice = _get_presence_service()
+    name, path = pservice.get_preferred_connection()
+    return pservice.get_buddy_by_telepathy_handle(name, path, handle)
+
+def _get_presence_service( ):
+    """Attempt to retrieve the presence service (check for offline condition)
+
+    The presence service, when offline, has no preferred connection type,
+    so we check that before returning the object...
+    """
+    import sugar.presence.presenceservice
+    pservice = sugar.presence.presenceservice.get_instance()
+    try:
+        name, path = pservice.get_preferred_connection()
+    except (TypeError,ValueError), err:
+        log.warn('Working in offline mode, cannot retrieve buddy information for %s: %s', handle, err )
+        raise OfflineError( """Unable to retrieve buddy information, currently offline""" )
+    else:
+        return pservice
+
+def instance(idx=0):
+    return pygametubes[idx]
+
+import eventwrap,pygame.event as PEvent
+
+class PygameTube(ExportedGObject):
+    '''The object whose instance is shared across D-bus
+
+    Call instance() to get the instance of this object for your activity service.
+    Its 'tube' property contains the underlying D-bus Connection.
+    '''
+    def __init__(self, tube, is_initiator, tube_id):
+        super(PygameTube, self).__init__(tube, DBUS_PATH)
+        log.info( 'PygameTube init' )
+        self.tube = tube
+        self.is_initiator = is_initiator
+        self.entered = False
+        self.ordered_bus_names = []
+        eventwrap.post(PEvent.Event(CONNECT, id=tube_id))
+
+        if not self.is_initiator:
+            self.tube.add_signal_receiver(self.new_participant_cb, 'NewParticipants', DBUS_IFACE, path=DBUS_PATH)
+        self.tube.watch_participants(self.participant_change_cb)
+        self.tube.add_signal_receiver(self.broadcast_cb, 'Broadcast', DBUS_IFACE, path=DBUS_PATH, sender_keyword='sender')
+
+
+    def participant_change_cb(self, added, removed):
+        log.debug( 'participant_change_cb: %s %s', added, removed )
+        def nick(buddy):
+            if buddy is not None:
+                return buddy.props.nick
+            else:
+                return 'Unknown'
+
+        for handle, bus_name in added:
+            dbus_handle = self.tube.participants[handle]
+            self.ordered_bus_names.append(dbus_handle)
+            eventwrap.post(PEvent.Event(PARTICIPANT_ADD, handle=dbus_handle))
+
+        for handle in removed:
+            dbus_handle = self.tube.participants[handle]
+            self.ordered_bus_names.remove(dbus_handle)
+            eventwrap.post(PEvent.Event(PARTICIPANT_REMOVE, handle=dbus_handle))
+
+        if self.is_initiator:
+            if not self.entered:
+                # Initiator will broadcast a new ordered_bus_names each time
+                # a participant joins.
+                self.ordered_bus_names = [self.tube.get_unique_name()]
+            self.NewParticipants(self.ordered_bus_names)
+
+        self.entered = True
+
+    @signal(dbus_interface=DBUS_IFACE, signature='as')
+    def NewParticipants(self, ordered_bus_names):
+        '''This is the NewParticipants signal, sent when the authoritative list of ordered_bus_names changes.'''
+        log.debug("sending NewParticipants: %s" % ordered_bus_names)
+        pass
+
+    @signal(dbus_interface=DBUS_IFACE, signature='s')
+    def Broadcast(self, content):
+        '''This is the Broadcast signal; it sends a message to all other activity participants.'''
+        pass
+
+    @method(dbus_interface=DBUS_IFACE, in_signature='s', out_signature='', sender_keyword='sender')
+    def Tell(self, content, sender=None):
+        '''This is the targeted-message interface; called when a message is received that was sent directly to me.'''
+        eventwrap.post(PEvent.Event(MESSAGE_UNI, handle=sender, content=content))
+
+    def broadcast_cb(self, content, sender=None):
+        '''This is the Broadcast callback, fired when someone sends a Broadcast signal along the bus.'''
+        eventwrap.post(PEvent.Event(MESSAGE_MULTI, handle=sender, content=content))
+
+    def new_participant_cb(self, new_bus_names):
+        '''This is the NewParticipants callback, fired when someone joins or leaves.'''
+        log.debug("new participant. new bus names %s, old %s" % (new_bus_names, self.ordered_bus_names))
+        if self.ordered_bus_names != new_bus_names:
+            log.warn("ordered bus names out of sync with server, resyncing")
+            self.ordered_bus_names = new_bus_names
+
+def send_to(handle, content=""):
+    '''Sends the given message to the given buddy identified by handle.'''
+    log.debug( 'send_to: %s %s', handle, content )
+    remote_proxy = dbus_get_object(handle, DBUS_PATH)
+    remote_proxy.Tell(content, reply_handler=dbus_msg, error_handler=dbus_err)
+
+def dbus_msg():
+    log.debug("async reply to send_to")
+def dbus_err(e):
+    log.error("async error: %s" % e)
+
+def broadcast(content=""):
+    '''Sends the given message to all participants.'''
+    log.debug( 'Broadcast: %s', content )
+    instance().Broadcast(content)
+
+def my_handle():
+    '''Returns the handle of this user
+    
+    Note, you can get a DBusException from this if you have 
+    not yet got a unique ID assigned by the bus.  You may need 
+    to delay calling until you are sure you are connected.
+    '''
+    log.debug( 'my handle' )
+    return instance().tube.get_unique_name()
+
+def is_initiator():
+    '''Returns the handle of this user.'''
+    log.debug( 'is initiator' )
+    return instance().is_initiator
+
+def get_participants():
+    '''Returns the list of active participants, in order of arrival.
+    List is maintained by the activity creator; if that person leaves it may not stay in sync.'''
+    log.debug( 'get_participants' )
+    try:
+        return instance().ordered_bus_names[:]
+    except IndexError, err:
+        return [] # no participants yet, as we don't yet have a connection
+
+def dbus_get_object(handle, path):
+    '''Get a D-bus object from another participant.
+
+    This is how you can communicate with other participants using
+    arbitrary D-bus objects without having to manage the participants
+    yourself.
+
+    Simply define a D-bus class with an interface and path that you
+    choose; when you want a reference to the corresponding remote
+    object on a participant, call this method.
+    '''
+    log.debug( 'dbus_get_object: %s %s', handle, path )
+    return instance().tube.get_object(handle, path)
diff --git a/olpcgames/mesh.pyc b/olpcgames/mesh.pyc
new file mode 100755
index 0000000..4ef256a
--- /dev/null
+++ b/olpcgames/mesh.pyc
diff --git a/olpcgames/pangofont.py b/olpcgames/pangofont.py
new file mode 100755
index 0000000..ef2640a
--- /dev/null
+++ b/olpcgames/pangofont.py
@@ -0,0 +1,293 @@
+"""Implement Pygame's font interface using Pango for international support
+
+Depends on:
+
+    pygtk (to get the pango context)
+    pycairo (for the pango rendering context)
+    python-pango (obviously)
+    pygame (obviously)
+"""
+import pango
+import logging
+import cairo
+import pangocairo
+import pygame.rect, pygame.image
+import gtk
+import struct
+from pygame import surface
+
+log = logging.getLogger( 'pangofont' )
+#log.setLevel( logging.DEBUG )
+
+# Install myself on top of pygame.font
+def install():
+    """Replace Pygame's font module with this module"""
+    log.info( 'installing' )
+    from olpcgames import pangofont
+    import pygame
+    pygame.font = pangofont
+    import sys
+    sys.modules["pygame.font"] = pangofont
+
+class PangoFont(object):
+    """Base class for a pygame.font.Font-like object drawn by Pango."""
+    def __init__(self, family=None, size=None, bold=False, italic=False, fd=None):
+        """If you know what pango.FontDescription (fd) you want, pass it in as
+        'fd'.  Otherwise, specify any number of family, size, bold, or italic,
+        and we will try to match something up for you."""
+
+        # Always set the FontDescription (FIXME - only set it if the user wants
+        # to change something?)
+        if fd is None:
+            fd = pango.FontDescription()
+            if family is not None:
+                fd.set_family(family)
+            if size is not None:
+                fd.set_size(size*1000)
+
+            if bold:
+                fd.set_weight(pango.WEIGHT_BOLD)
+            if italic:
+                fd.set_style(pango.STYLE_OBLIQUE)
+
+        self.fd = fd
+
+    def render(self, text, antialias=True, color=(255,255,255), background=None ):
+        """Render the font onto a new Surface and return it.
+        We ignore 'antialias' and use system settings.
+        
+        text -- (unicode) string with the text to render
+        antialias -- attempt to antialias the text or not
+        color -- three or four-tuple of 0-255 values specifying rendering 
+            colour for the text 
+        background -- three or four-tuple of 0-255 values specifying rendering 
+            colour for the background, or None for trasparent background
+        
+        returns a pygame image instance
+        """
+        log.info( 'render: %r, antialias = %s, color=%s, background=%s', text, antialias, color, background )
+
+        # create layout
+        layout = pango.Layout(gtk.gdk.pango_context_get())
+        layout.set_font_description(self.fd)
+        layout.set_text(text)
+
+        # determine pixel size
+        (logical, ink) = layout.get_pixel_extents()
+        ink = pygame.rect.Rect(ink)
+
+        # Create a new Cairo ImageSurface
+        csrf = cairo.ImageSurface(cairo.FORMAT_ARGB32, ink.w, ink.h)
+        cctx = pangocairo.CairoContext(cairo.Context(csrf))
+
+        # Mangle the colors on little-endian machines. The reason for this 
+        # is that Cairo writes native-endian 32-bit ARGB values whereas
+        # Pygame expects endian-independent values in whatever format. So we
+        # tell our users not to expect transparency here (avoiding the A issue)
+        # and we swizzle all the colors around.
+        big_endian = struct.pack( '=i', 1 ) == struct.pack( '>i', 1 )
+        if hasattr(csrf,'get_data'):
+            swap = True
+        else:
+            swap = False
+        log.debug( 'big_endian: %s   swap: %s', big_endian, swap )
+        def mangle_color(color):
+            """Mange a colour depending on endian-ness, and swap-necessity
+            
+            This implementation has only been tested on an AMD64
+            machine with a get_data implementation (rather than 
+            a get_data_as_rgba implementation).
+            """
+            r,g,b = color[:3]
+            if len(color) > 3:
+                a = color[3]
+            else:
+                a = 255.0
+            if swap and not big_endian:
+                return map(_fixColorBase, (b,g,r,a) )
+            return map(_fixColorBase, (r,g,b,a) )
+
+        # render onto it
+        if background is not None:
+            background = mangle_color( background )
+            cctx.set_source_rgba(*background)
+            cctx.paint()
+        
+        log.debug( 'incoming color: %s', color )
+        color = mangle_color( color )
+        log.debug( '  translated color: %s', color )
+
+        cctx.new_path()
+        cctx.layout_path(layout)
+        cctx.set_source_rgba(*color)
+        cctx.fill()
+
+        # Create and return a new Pygame Image derived from the Cairo Surface
+        if big_endian:
+            # You see, in big-endian-world, we can just use the RGB values
+            format = "ARGB"
+        else:
+            # But with little endian, we've already swapped R and B in 
+            # mangle_color, so now just move the A
+            format = "RGBA"
+        if hasattr(csrf,'get_data'):
+            data = csrf.get_data()
+        else:
+            # XXX little-endian here, check on a big-endian machine 
+            data = csrf.get_data_as_rgba()
+            format = 'RGBA' # XXX wrong, what's with all the silly swapping!
+        try:
+            data = str(data)
+            return pygame.image.fromstring(data, (ink.w,ink.h), format)
+        except ValueError, err:
+            err.args += (len(data), ink.w*ink.h*4,format )
+            raise
+
+class SysFont(PangoFont):
+    """Construct a PangoFont from a font description (name), size in pixels,
+    bold, and italic designation. Similar to SysFont from Pygame."""
+    def __init__(self, name, size, bold=False, italic=False):
+        fd = pango.FontDescription(name)
+        fd.set_absolute_size(size*pango.SCALE)
+        if bold:
+            fd.set_weight(pango.WEIGHT_BOLD)
+        if italic:
+            fd.set_style(pango.STYLE_OBLIQUE)
+        super(SysFont, self).__init__(fd=fd)
+
+# originally defined a new class, no reason for that...
+NotImplemented = NotImplementedError
+
+class Font(PangoFont):
+    """Abstract class, do not use"""
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError("PangoFont doesn't support Font directly, use SysFont or .fontByDesc")
+
+def match_font(name,bold=False,italic=False):
+    """Stub, does not work, use fontByDesc instead"""
+    raise NotImplementedError("PangoFont doesn't support match_font directly, use SysFont or .fontByDesc")
+
+def fontByDesc(desc="",bold=False,italic=False):
+    """Constructs a FontDescription from the given string representation.
+The format of the string representation is:
+
+  "[FAMILY-LIST] [STYLE-OPTIONS] [SIZE]"
+
+where FAMILY-LIST is a comma separated list of families optionally terminated by a comma, STYLE_OPTIONS is a whitespace separated list of words where each WORD describes one of style, variant, weight, or stretch, and SIZE is an decimal number (size in points). For example the following are all valid string representations:
+
+  "sans bold 12"
+  "serif,monospace bold italic condensed 16"
+  "normal 10"
+
+The commonly available font families are: Normal, Sans, Serif and Monospace. The available styles are:
+Normal	the font is upright.
+Oblique	the font is slanted, but in a roman style.
+Italic	the font is slanted in an italic style.
+
+The available weights are:
+Ultra-Light	the ultralight weight (= 200)
+Light	the light weight (=300)
+Normal	the default weight (= 400)
+Bold	the bold weight (= 700)
+Ultra-Bold	the ultra-bold weight (= 800)
+Heavy	the heavy weight (= 900)
+
+The available variants are:
+Normal	
+Small-Caps	
+
+The available stretch styles are:
+Ultra-Condensed	the smallest width
+Extra-Condensed	
+Condensed	
+Semi-Condensed	
+Normal	the normal width
+Semi-Expanded	
+Expanded	
+Extra-Expanded	
+Ultra-Expanded	the widest width
+    """
+    fd = pango.FontDescription(name)
+    if bold:
+        fd.set_weight(pango.WEIGHT_BOLD)
+    if italic:
+        fd.set_style(pango.STYLE_OBLIQUE)
+    return PangoFont(fd=fd)
+
+def get_init():
+    """Return boolean indicating whether we are initialised
+    
+    Always returns True 
+    """
+    return True
+
+def init():
+    """Initialise the module (null operation)"""
+    pass
+
+def quit():
+    """De-initialise the module (null operation)"""
+    pass
+
+def get_default_font():
+    """Return default-font specification to be passed to e.g. fontByDesc"""
+    return "sans"
+
+def get_fonts():
+    """Return the set of all fonts available (currently just 3 generic types)"""
+    return ["sans","serif","monospace"]
+
+
+def stdcolor(color):
+    """Produce a 4-element 0.0-1.0 color value from input"""
+    def fixlen(color):
+        if len(color) == 3:
+            return tuple(color) + (255,)
+        elif len(color) == 4:
+            return color
+        else:
+            raise TypeError("What sort of color is this: %s" % (color,))
+    return [_fixColorBase(x) for x in fixlen(color)]
+def _fixColorBase( v ):
+    """Return a properly clamped colour in floating-point space"""
+    return max((0,min((v,255.0))))/255.0
+
+if __name__ == "__main__":
+    # Simple testing code...
+    logging.basicConfig()
+    from pygame import image,display, event, sprite
+    import pygame
+    import pygame.event
+    def main():
+        display.init()
+        maxX,maxY = display.list_modes()[0] 
+        screen = display.set_mode( (maxX/2, maxY/2 ) )
+        background = pygame.Surface(screen.get_size())
+        background = background.convert()
+        background.fill((255, 255,255))
+        
+        screen.blit(background, (0, 0))
+        display.flip()
+        
+        clock = pygame.time.Clock()
+        
+        font = PangoFont( size=30, family='monospace' )
+        text1 = font.render( 'red', color=(255,0,0) , background=(255,255,255,0) )
+        text2 = font.render( 'green', color=(0,255,0)  )
+        text3 = font.render( 'blue', color=(0,0,255)  )
+        text4 = font.render( 'blue-trans', color=(0,0,255,128)  )
+        text5 = font.render( 'cyan-trans', color=(0,255,255,128)  )
+        while 1:
+            clock.tick( 60 )
+            for event in pygame.event.get():
+                log.debug( 'event: %s', event )
+                if event.type == pygame.QUIT:
+                    return True
+            screen.blit( text1, (20,20 ))
+            screen.blit( text2, (20,80 ))
+            screen.blit( text3, (20,140 ))
+            screen.blit( text4, (200,20 ))
+            screen.blit( text5, (200,80 ))
+            display.flip()
+    main()
+    
diff --git a/olpcgames/pangofont.pyc b/olpcgames/pangofont.pyc
new file mode 100755
index 0000000..6c9f08c
--- /dev/null
+++ b/olpcgames/pangofont.pyc
diff --git a/olpcgames/tubeconn.py b/olpcgames/tubeconn.py
new file mode 100755
index 0000000..d1c1403
--- /dev/null
+++ b/olpcgames/tubeconn.py
@@ -0,0 +1,107 @@
+# This should eventually land in telepathy-python, so has the same license:
+
+# Copyright (C) 2007 Collabora Ltd. <http://www.collabora.co.uk/>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+__all__ = ('TubeConnection',)
+__docformat__ = 'reStructuredText'
+
+
+import logging
+
+from dbus.connection import Connection
+
+
+logger = logging.getLogger('telepathy.tubeconn')
+
+
+class TubeConnection(Connection):
+
+    def __new__(cls, conn, tubes_iface, tube_id, address=None,
+                group_iface=None, mainloop=None):
+        if address is None:
+            address = tubes_iface.GetDBusServerAddress(tube_id)
+        self = super(TubeConnection, cls).__new__(cls, address,
+                                                  mainloop=mainloop)
+
+        self._tubes_iface = tubes_iface
+        self.tube_id = tube_id
+        self.participants = {}
+        self.bus_name_to_handle = {}
+        self._mapping_watches = []
+
+        if group_iface is None:
+            method = conn.GetSelfHandle
+        else:
+            method = group_iface.GetSelfHandle
+        method(reply_handler=self._on_get_self_handle_reply,
+               error_handler=self._on_get_self_handle_error)
+
+        return self
+
+    def _on_get_self_handle_reply(self, handle):
+        self.self_handle = handle
+        match = self._tubes_iface.connect_to_signal('DBusNamesChanged',
+                self._on_dbus_names_changed)
+        self._tubes_iface.GetDBusNames(self.tube_id,
+                reply_handler=self._on_get_dbus_names_reply,
+                error_handler=self._on_get_dbus_names_error)
+        self._dbus_names_changed_match = match
+
+    def _on_get_self_handle_error(self, e):
+        logging.basicConfig()
+        logger.error('GetSelfHandle failed: %s', e)
+
+    def close(self):
+        self._dbus_names_changed_match.remove()
+        self._on_dbus_names_changed(self.tube_id, (), self.participants.keys())
+        super(TubeConnection, self).close()
+
+    def _on_get_dbus_names_reply(self, names):
+        self._on_dbus_names_changed(self.tube_id, names, ())
+
+    def _on_get_dbus_names_error(self, e):
+        logging.basicConfig()
+        logger.error('GetDBusNames failed: %s', e)
+
+    def _on_dbus_names_changed(self, tube_id, added, removed):
+        if tube_id == self.tube_id:
+            for handle, bus_name in added:
+                if handle == self.self_handle:
+                    # I've just joined - set my unique name
+                    self.set_unique_name(bus_name)
+                self.participants[handle] = bus_name
+                self.bus_name_to_handle[bus_name] = handle
+
+            # call the callback while the removed people are still in
+            # participants, so their bus names are available
+            for callback in self._mapping_watches:
+                callback(added, removed)
+
+            for handle in removed:
+                bus_name = self.participants.pop(handle, None)
+                self.bus_name_to_handle.pop(bus_name, None)
+
+    def watch_participants(self, callback):
+        self._mapping_watches.append(callback)
+        if self.participants:
+            # GetDBusNames already returned: fake a participant add event
+            # immediately
+            added = []
+            for k, v in self.participants.iteritems():
+                added.append((k, v))
+            callback(added, [])
diff --git a/olpcgames/util.py b/olpcgames/util.py
new file mode 100755
index 0000000..44d42b5
--- /dev/null
+++ b/olpcgames/util.py
@@ -0,0 +1,67 @@
+"""Abstraction layer for working outside the Sugar environment"""
+import traceback, cStringIO
+import logging
+log = logging.getLogger( 'olpcgames.util' )
+import os
+import os.path
+
+
+try:
+    from sugar.activity.activity import get_bundle_path as _get_bundle_path
+    def get_bundle_path( ):
+        """Retrieve bundle path from activity with fix for silly registration bug"""
+        path = _get_bundle_path()
+        if path.endswith( '.activity.activity' ):
+            log.warn( '''Found double .activity suffix in bundle path, truncating: %s''', path )
+            path = path[:-9]
+        return path
+except ImportError:
+    log.warn( '''Do not appear to be running under Sugar, stubbing-in get_bundle_path''' )
+    def get_bundle_path():
+        """Retrieve a substitute data-path for non OLPC systems"""
+        return os.getcwd()
+
+
+def get_activity_root( ):
+    """Return the activity root for data storage operations
+
+    If the activity is present, returns the activity's root,
+    otherwise returns NON_SUGAR_ROOT as the directory.
+    """
+    import olpcgames
+    if olpcgames.ACTIVITY:
+        return olpcgames.ACTIVITY.get_activity_root()
+    else:
+        return os.path.expanduser( NON_SUGAR_ROOT )
+
+def data_path(file_name):
+    """Return the full path to a file in the data sub-directory of the bundle"""
+    return os.path.join(get_bundle_path(), 'data', file_name)
+def tmp_path(file_name):
+    """Return the full path to a file in the temporary directory"""
+    return os.path.join(get_activity_root(), 'tmp', file_name)
+
+def get_traceback(error):
+    """Get formatted traceback from current exception
+    
+    error -- Exception instance raised
+    
+    Attempts to produce a 10-level traceback as a string
+    that you can log off.  Use like so:
+    
+    try:
+        doSomething()
+    except Exception, err:
+        log.error( 
+            '''Failure during doSomething with X,Y,Z parameters: %s''', 
+            util.get_traceback( err ),
+        )
+    """
+    exception = str(error)
+    file = cStringIO.StringIO()
+    try:
+        traceback.print_exc( limit=10, file = file )
+        exception = file.getvalue()
+    finally:
+        file.close()
+    return exception
diff --git a/olpcgames/util.pyc b/olpcgames/util.pyc
new file mode 100755
index 0000000..28a4636
--- /dev/null
+++ b/olpcgames/util.pyc
diff --git a/olpcgames/video.py b/olpcgames/video.py
new file mode 100755
index 0000000..2c3a842
--- /dev/null
+++ b/olpcgames/video.py
@@ -0,0 +1,71 @@
+"""Video widget for displaying a gstreamer pipe"""
+import logging
+log = logging.getLogger( 'olpcgames.video' )
+import os
+import signal
+
+import pygtk
+pygtk.require('2.0')
+import gtk
+import gst
+
+class VideoWidget(gtk.DrawingArea):
+    """A custom widget to render GStreamer video."""
+    
+    def __init__(self, x=160, y=120):
+        super(VideoWidget, self).__init__()
+        self._imagesink = None
+        self.unset_flags(gtk.DOUBLE_BUFFERED)
+        self.set_size_request(x,y)
+
+    def do_expose_event(self, event):
+        if self._imagesink:
+            self._imagesink.expose()
+            return False
+        else:
+            return True
+
+    def set_sink(self, sink):
+        assert self.window.xid
+        self._imagesink = sink
+        self._imagesink.set_xwindow_id(self.window.xid)
+        
+#pipe_desc = 'v4l2src ! video/x-raw-yuv,width=160,height=120 ! ffmpegcolorspace ! xvimagesink'
+pipe_desc = 'v4l2src ! ffmpegcolorspace ! video/x-raw-yuv ! xvimagesink'
+class Player(object):
+    def __init__(self, videowidget):
+        self._playing = False
+        self._videowidget = videowidget
+
+        self._pipeline = gst.parse_launch(pipe_desc)
+
+        bus = self._pipeline.get_bus()
+        bus.enable_sync_message_emission()
+        bus.add_signal_watch()
+        bus.connect('sync-message::element', self.on_sync_message)
+        bus.connect('message', self.on_message)
+
+    def play(self):
+        if self._playing == False:
+            self._pipeline.set_state(gst.STATE_PLAYING)
+            self._playing = True
+
+    def pause(self):
+        if self._playing == True:
+            self._pipeline.set_state(gst.STATE_PAUSED)
+            self._playing = False
+
+    def on_sync_message(self, bus, message):
+        if message.structure is None:
+            return
+        if message.structure.get_name() == 'prepare-xwindow-id':
+            self._videowidget.set_sink(message.src)
+
+    def on_message(self, bus, message):
+        t = message.type
+        if t == gst.MESSAGE_ERROR:
+            err, debug = message.parse_error()
+            log.debug("Video error: (%s) %s" ,err, debug)
+            self._playing = False
+            gtk.main_quit()
+    
diff --git a/olpcgames/video.pyc b/olpcgames/video.pyc
new file mode 100755
index 0000000..f0f8668
--- /dev/null
+++ b/olpcgames/video.pyc