new file: Making_Activities_Using_PyGame_gtk3/DemoiselleActivity.py

new file:   Making_Activities_Using_PyGame_gtk3/MANIFEST
new file:   Making_Activities_Using_PyGame_gtk3/activity/activity.info
new file:   Making_Activities_Using_PyGame_gtk3/activity/activity.info~
new file:   Making_Activities_Using_PyGame_gtk3/activity/read-etexts.svg
new file:   Making_Activities_Using_PyGame_gtk3/demoiselle.png
new file:   Making_Activities_Using_PyGame_gtk3/demoiselle.py
new file:   Making_Activities_Using_PyGame_gtk3/demoiselle2.py
new file:   Making_Activities_Using_PyGame_gtk3/glider_hit.png
new file:   Making_Activities_Using_PyGame_gtk3/glider_normal.png
new file:   Making_Activities_Using_PyGame_gtk3/po/Demoiselle.pot
new file:   Making_Activities_Using_PyGame_gtk3/setup.py
new file:   Making_Activities_Using_PyGame_gtk3/sky.jpg
new file:   Making_Activities_Using_PyGame_gtk3/sugargame/__init__.py
new file:   Making_Activities_Using_PyGame_gtk3/sugargame/canvas.py
new file:   Making_Activities_Using_PyGame_gtk3/sugargame/event.py
modified:   Making_Shared_Activities_gtk3/ReadEtextsActivity3.py
Convert Activity to have new style toolbar.

17 files changed, 895 insertions, 33 deletions

diff --git a/Making_Activities_Using_PyGame_gtk3/DemoiselleActivity.py b/Making_Activities_Using_PyGame_gtk3/DemoiselleActivity.py
new file mode 100644
index 0000000..2c6c99f
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/DemoiselleActivity.py
@@ -0,0 +1,103 @@
+# DemoiselleActivity.py 
+
+# Copyright (C) 2010  James D. Simmons
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+from gettext import gettext as _
+
+import gtk
+import pygame
+from sugar.activity import activity
+from sugar.graphics.toolbutton import ToolButton
+import gobject
+import sugargame.canvas
+import demoiselle2
+
+class DemoiselleActivity(activity.Activity):
+    def __init__(self, handle):
+        super(DemoiselleActivity, self).__init__(handle)
+        
+        # Build the activity toolbar.
+        self.build_toolbar()
+
+        # Create the game instance.
+        self.game = demoiselle2.Demoiselle()
+
+        # Build the Pygame canvas.
+        self._pygamecanvas = sugargame.canvas.PygameCanvas(self)
+        # Note that set_canvas implicitly calls read_file when resuming from the Journal.
+        self.set_canvas(self._pygamecanvas)
+        self.score = ''
+        
+        # Start the game running.
+        self._pygamecanvas.run_pygame(self.game.run)
+        
+    def build_toolbar(self):
+        toolbox = activity.ActivityToolbox(self)
+        activity_toolbar = toolbox.get_activity_toolbar()
+        activity_toolbar.keep.props.visible = False
+        activity_toolbar.share.props.visible = False
+        
+        self.view_toolbar = ViewToolbar()
+        toolbox.add_toolbar(_('View'), self.view_toolbar)
+        self.view_toolbar.connect('go-fullscreen',
+                self.view_toolbar_go_fullscreen_cb)
+        self.view_toolbar.show()
+
+        toolbox.show()
+        self.set_toolbox(toolbox)
+
+    def view_toolbar_go_fullscreen_cb(self, view_toolbar):
+        self.fullscreen()
+
+    def read_file(self, file_path):
+        score_file = open(file_path, "r")
+        while score_file:
+            self.score = score_file.readline()
+            self.game.set_score(int(self.score))
+        score_file.close()
+        
+    def write_file(self, file_path):
+        score = self.game.get_score()
+        f = open(file_path, 'wb')
+        try:
+            f.write(str(score))
+        finally:
+            f.close
+
+class ViewToolbar(gtk.Toolbar):
+    __gtype_name__ = 'ViewToolbar'
+
+    __gsignals__ = {
+        'needs-update-size': (gobject.SIGNAL_RUN_FIRST,
+                              gobject.TYPE_NONE,
+                              ([])),
+        'go-fullscreen': (gobject.SIGNAL_RUN_FIRST,
+                          gobject.TYPE_NONE,
+                          ([]))
+    }
+
+    def __init__(self):
+        gtk.Toolbar.__init__(self)
+        self.fullscreen = ToolButton('view-fullscreen')
+        self.fullscreen.set_tooltip(_('Fullscreen'))
+        self.fullscreen.connect('clicked', self.fullscreen_cb)
+        self.insert(self.fullscreen, -1)
+        self.fullscreen.show()
+
+    def fullscreen_cb(self, button):
+        self.emit('go-fullscreen')
diff --git a/Making_Activities_Using_PyGame_gtk3/MANIFEST b/Making_Activities_Using_PyGame_gtk3/MANIFEST
new file mode 100644
index 0000000..42b54df
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/MANIFEST
@@ -0,0 +1,17 @@
+
+setup.py
+
+
+activity/read-etexts.svg
+activity/activity.info
+demoiselle2.py
+glider_hit.png
+demoiselle.py
+demoiselle.png
+DemoiselleActivity.py
+sky.jpg
+glider_normal.png
+po/Demoiselle.pot
+sugargame/event.py
+sugargame/__init__.py
+sugargame/canvas.py
diff --git a/Making_Activities_Using_PyGame_gtk3/activity/activity.info b/Making_Activities_Using_PyGame_gtk3/activity/activity.info
new file mode 100644
index 0000000..2767e12
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/activity/activity.info
@@ -0,0 +1,9 @@
+[Activity]
+name = Demoiselle
+service_name = net.flossmanuals.Demoiselle
+icon = read-etexts
+exec = sugar-activity DemoiselleActivity.DemoiselleActivity
+show_launcher = yes
+activity_version = 1
+license = GPLv2+
+
diff --git a/Making_Activities_Using_PyGame_gtk3/activity/activity.info~ b/Making_Activities_Using_PyGame_gtk3/activity/activity.info~
new file mode 100644
index 0000000..137333f
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/activity/activity.info~
@@ -0,0 +1,9 @@
+[Activity]
+name = ReadEtexts II
+service_name = net.flossmanuals.ReadETexts
+icon = read-etexts
+exec = sugar-activity ReadEtextsActivity4.ReadEtextsActivity
+show_launcher = no
+mime_types = text/plain;application/zip
+activity_version = 1
+license = GPLv2+
diff --git a/Making_Activities_Using_PyGame_gtk3/activity/read-etexts.svg b/Making_Activities_Using_PyGame_gtk3/activity/read-etexts.svg
new file mode 100644
index 0000000..5682ec8
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/activity/read-etexts.svg
@@ -0,0 +1,71 @@
+<?xml version="1.0" ?><!DOCTYPE svg  PUBLIC '-//W3C//DTD SVG 1.1//EN'  'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd' [
+	<!ENTITY stroke_color "#000000">
+	<!ENTITY fill_color "#FFFFFF">
+]><svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="48px"
+   height="48px"
+   id="svg116"
+   sodipodi:version="0.32"
+   inkscape:version="0.46+devel"
+   sodipodi:docname="New document 4"
+   inkscape:output_extension="org.inkscape.output.svg.inkscape">
+  <defs
+     id="defs118">
+    <inkscape:perspective
+       sodipodi:type="inkscape:persp3d"
+       inkscape:vp_x="0 : 24 : 1"
+       inkscape:vp_y="0 : 1000 : 0"
+       inkscape:vp_z="48 : 24 : 1"
+       inkscape:persp3d-origin="24 : 16 : 1"
+       id="perspective124" />
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="7"
+     inkscape:cx="24"
+     inkscape:cy="24"
+     inkscape:current-layer="layer1"
+     showgrid="true"
+     inkscape:grid-bbox="true"
+     inkscape:document-units="px"
+     inkscape:window-width="1024"
+     inkscape:window-height="698"
+     inkscape:window-x="0"
+     inkscape:window-y="25" />
+  <metadata
+     id="metadata121">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     id="layer1"
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer">
+    <rect
+       style="fill:&fill_color;;stroke:&stroke_color;;stroke-opacity:1"
+       id="rect904"
+       width="36.142857"
+       height="32.142857"
+       x="4.1428571"
+       y="7.1428571" />
+  </g>
+</svg>
diff --git a/Making_Activities_Using_PyGame_gtk3/demoiselle.png b/Making_Activities_Using_PyGame_gtk3/demoiselle.png
new file mode 100644
index 0000000..37db411
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/demoiselle.png
diff --git a/Making_Activities_Using_PyGame_gtk3/demoiselle.py b/Making_Activities_Using_PyGame_gtk3/demoiselle.py
new file mode 100755
index 0000000..93817e1
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/demoiselle.py
@@ -0,0 +1,166 @@
+#! /usr/bin/env python
+#
+# demoiselle.py Standalone version of DemoiselleActivity.py
+# Copyright (C) 2010  James D. Simmons
+# Adapted from code in the article "Rapid Game Development In
+# Python" by Richard Jones.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+import pygame
+import math
+import sys
+
+class Demoiselle:
+    "This is a simple demonstration of using PyGame \
+    sprites and collision detection."
+    def __init__(self):
+        self.background = pygame.image.load('sky.jpg')
+        self.screen = pygame.display.get_surface()
+        self.screen.blit(self.background, (0, 0))
+        self.clock = pygame.time.Clock()
+        self.running = True
+
+        gliders = [
+            GliderSprite((200, 200)),
+            GliderSprite((800, 200)),
+            GliderSprite((200, 600)),
+            GliderSprite((800, 600)),
+        ]
+        self. glider_group = pygame.sprite.RenderPlain(gliders)
+        
+    def run(self):
+        "This method processes PyGame messages"
+        rect = self.screen.get_rect()
+        airplane = AirplaneSprite('demoiselle.png', rect.center)
+        airplane_sprite = pygame.sprite.RenderPlain(airplane)
+        
+        while self.running:
+            self.clock.tick(30)
+
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT: 
+                    self.running = False
+                    return
+                elif event.type == pygame.VIDEORESIZE:
+                    pygame.display.set_mode(event.size,  pygame.RESIZABLE)
+                    self.screen.blit(self.background, (0, 0))
+                
+                if not hasattr(event, 'key'): 
+                    continue
+                down = event.type == pygame.KEYDOWN
+                if event.key == pygame.K_DOWN or \
+                    event.key == pygame.K_KP2: 
+                    airplane.joystick_back = down * 5
+                elif event.key == pygame.K_UP or \
+                    event.key == pygame.K_KP8: 
+                    airplane.joystick_forward = down * -5
+                elif event.key == pygame.K_EQUALS or \
+                    event.key == pygame.K_KP_PLUS or \
+                    event.key == pygame.K_KP9:
+                    airplane.throttle_up = down * 2
+                elif event.key == pygame.K_MINUS or \
+                    event.key == pygame.K_KP_MINUS or \
+                    event.key == pygame.K_KP3: 
+                    airplane.throttle_down = down * -2
+
+            self.glider_group.clear(self.screen, self.background)
+            airplane_sprite.clear(self.screen, self.background)
+            collisions = pygame.sprite.spritecollide(airplane, \
+                                                     self.glider_group,  False)
+            self.glider_group.update(collisions)
+            self.glider_group.draw(self.screen)
+            airplane_sprite.update()
+            airplane_sprite.draw(self.screen)
+            pygame.display.flip()
+
+class AirplaneSprite(pygame.sprite.Sprite):
+    "This class represents an airplane, the Demoiselle \
+    created by Alberto Santos-Dumont"
+    MAX_FORWARD_SPEED = 10
+    MIN_FORWARD_SPEED = 1
+    ACCELERATION = 2
+    TURN_SPEED = 5
+    def __init__(self, image, position):
+        pygame.sprite.Sprite.__init__(self)
+        self.src_image = pygame.image.load(image)
+        self.rect = pygame.Rect(self.src_image.get_rect())
+        self.position = position
+        self.rect.center = self.position
+        self.speed = 1
+        self.direction = 0
+        self.joystick_back = self.joystick_forward = \
+            self.throttle_down = self.throttle_up = 0
+        
+    def update(self):
+        "This method redraws the airplane in response\
+        to events."
+        self.speed += (self.throttle_up + self.throttle_down)
+        if self.speed > self.MAX_FORWARD_SPEED:
+            self.speed = self.MAX_FORWARD_SPEED
+        if self.speed < self.MIN_FORWARD_SPEED:
+            self.speed = self.MIN_FORWARD_SPEED
+        self.direction += (self.joystick_forward + self.joystick_back)
+        x_coord, y_coord = self.position
+        rad = self.direction * math.pi / 180
+        x_coord += -self.speed * math.cos(rad)
+        y_coord += -self.speed * math.sin(rad)
+        screen = pygame.display.get_surface()
+        if y_coord < 0:
+            y_coord = screen.get_height()
+            
+        if x_coord < 0:
+            x_coord = screen.get_width()
+            
+        if x_coord > screen.get_width():
+            x_coord = 0
+            
+        if y_coord > screen.get_height():
+            y_coord = 0
+        self.position = (x_coord, y_coord)
+        self.image = pygame.transform.rotate(self.src_image, -self.direction)
+        self.rect = self.image.get_rect()
+        self.rect.center = self.position
+
+class GliderSprite(pygame.sprite.Sprite):
+    "This class represents an individual hang glider as developed\
+    by Otto Lilienthal."
+    def __init__(self, position):
+        pygame.sprite.Sprite.__init__(self)
+        self.normal = pygame.image.load('glider_normal.png')
+        self.rect = pygame.Rect(self.normal.get_rect())
+        self.rect.center = position
+        self.image = self.normal
+        self.hit = pygame.image.load('glider_hit.png')
+    def update(self, hit_list):
+        "This method redraws the glider when it collides\
+        with the airplane and when it is no longer \
+        colliding with the airplane."
+        if self in hit_list: 
+            self.image = self.hit
+        else: 
+            self.image = self.normal
+
+def main():
+    "This function is called when the game is run from the command line"
+    pygame.init()
+    pygame.display.set_mode((0, 0), pygame.RESIZABLE)
+    game = Demoiselle() 
+    game.run()
+    sys.exit(0)
+
+if __name__ == '__main__':
+    main()
diff --git a/Making_Activities_Using_PyGame_gtk3/demoiselle2.py b/Making_Activities_Using_PyGame_gtk3/demoiselle2.py
new file mode 100755
index 0000000..46656ca
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/demoiselle2.py
@@ -0,0 +1,185 @@
+#! /usr/bin/env python
+#
+# demoiselle2.py 
+
+# This is a modified version of demoiselle.py that will be run
+# by DemoiselleActivity.py using SugarGame.
+
+# Copyright (C) 2010  James D. Simmons
+# Adapted from code in the article "Rapid Game Development In
+# Python" by Richard Jones.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+import pygame
+import gtk
+import math
+import sys
+
+class Demoiselle:
+    "This is a simple demonstration of using PyGame \
+    sprites and collision detection."
+    def __init__(self):
+        self.clock = pygame.time.Clock()
+        self.running = True
+        self.background = pygame.image.load('sky.jpg')
+        self.score = 99
+        
+    def get_score(self):
+        return self.score
+    
+    def set_score(self,  score):
+        self.score = score
+
+    def run(self):
+        "This method processes PyGame messages"
+
+        screen = pygame.display.get_surface()
+        screen.blit(self.background, (0, 0))
+
+        gliders = [
+            GliderSprite((200, 200)),
+            GliderSprite((800, 200)),
+            GliderSprite((200, 600)),
+            GliderSprite((800, 600)),
+        ]
+        glider_group = pygame.sprite.RenderPlain(gliders)
+
+        rect = screen.get_rect()
+        airplane = AirplaneSprite('demoiselle.png', rect.center)
+        airplane_sprite = pygame.sprite.RenderPlain(airplane)
+        
+        while self.running:
+            self.clock.tick(30)
+
+            # Pump GTK messages.
+            while gtk.events_pending():
+                gtk.main_iteration()
+ 
+            # Pump PyGame messages.
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT: 
+                    self.running = False
+                    return
+                elif event.type == pygame.VIDEORESIZE:
+                    pygame.display.set_mode(event.size,  pygame.RESIZABLE)
+                    screen.blit(self.background, (0, 0))
+                
+                if not hasattr(event, 'key'): 
+                    continue
+                down = event.type == pygame.KEYDOWN
+                if event.key == pygame.K_DOWN or \
+                    event.key == pygame.K_KP2: 
+                    airplane.joystick_back = down * 5
+                elif event.key == pygame.K_UP or \
+                    event.key == pygame.K_KP8: 
+                    airplane.joystick_forward = down * -5
+                elif event.key == pygame.K_EQUALS or \
+                    event.key == pygame.K_KP_PLUS or \
+                    event.key == pygame.K_KP9:
+                    airplane.throttle_up = down * 2
+                elif event.key == pygame.K_MINUS or \
+                    event.key == pygame.K_KP_MINUS or \
+                    event.key == pygame.K_KP3: 
+                    airplane.throttle_down = down * -2
+
+            glider_group.clear(screen, self.background)
+            airplane_sprite.clear(screen, self.background)
+            collisions = pygame.sprite.spritecollide(airplane, \
+                                                     glider_group,  False)
+            glider_group.update(collisions)
+            glider_group.draw(screen)
+            airplane_sprite.update()
+            airplane_sprite.draw(screen)
+            pygame.display.flip()
+
+class AirplaneSprite(pygame.sprite.Sprite):
+    "This class represents an airplane, the Demoiselle \
+    created by Alberto Santos-Dumont"
+    MAX_FORWARD_SPEED = 10
+    MIN_FORWARD_SPEED = 1
+    ACCELERATION = 2
+    TURN_SPEED = 5
+    def __init__(self, image, position):
+        pygame.sprite.Sprite.__init__(self)
+        self.src_image = pygame.image.load(image)
+        self.rect = pygame.Rect(self.src_image.get_rect())
+        self.position = position
+        self.rect.center = self.position
+        self.speed = 1
+        self.direction = 0
+        self.joystick_back = self.joystick_forward = \
+            self.throttle_down = self.throttle_up = 0
+        
+    def update(self):
+        "This method redraws the airplane in response\
+        to events."
+        self.speed += (self.throttle_up + self.throttle_down)
+        if self.speed > self.MAX_FORWARD_SPEED:
+            self.speed = self.MAX_FORWARD_SPEED
+        if self.speed < self.MIN_FORWARD_SPEED:
+            self.speed = self.MIN_FORWARD_SPEED
+        self.direction += (self.joystick_forward + self.joystick_back)
+        x_coord, y_coord = self.position
+        rad = self.direction * math.pi / 180
+        x_coord += -self.speed * math.cos(rad)
+        y_coord += -self.speed * math.sin(rad)
+        screen = pygame.display.get_surface()
+        if y_coord < 0:
+            y_coord = screen.get_height()
+            
+        if x_coord < 0:
+            x_coord = screen.get_width()
+            
+        if x_coord > screen.get_width():
+            x_coord = 0
+            
+        if y_coord > screen.get_height():
+            y_coord = 0
+        self.position = (x_coord, y_coord)
+        self.image = pygame.transform.rotate(self.src_image, -self.direction)
+        self.rect = self.image.get_rect()
+        self.rect.center = self.position
+
+class GliderSprite(pygame.sprite.Sprite):
+    "This class represents an individual hang glider as developed\
+    by Otto Lilienthal."
+    def __init__(self, position):
+        pygame.sprite.Sprite.__init__(self)
+        self.normal = pygame.image.load('glider_normal.png')
+        self.rect = pygame.Rect(self.normal.get_rect())
+        self.rect.center = position
+        self.image = self.normal
+        self.hit = pygame.image.load('glider_hit.png')
+    def update(self, hit_list):
+        "This method redraws the glider when it collides\
+        with the airplane and when it is no longer \
+        colliding with the airplane."
+        if self in hit_list: 
+            self.image = self.hit
+        else: 
+            self.image = self.normal
+
+def main():
+    "This function is called when the game is run from the command line"
+    pygame.init()
+    pygame.display.set_mode((0, 0), pygame.RESIZABLE)
+    game = Demoiselle() 
+    game.run()
+    sys.exit(0)
+
+if __name__ == '__main__':
+    main()
diff --git a/Making_Activities_Using_PyGame_gtk3/glider_hit.png b/Making_Activities_Using_PyGame_gtk3/glider_hit.png
new file mode 100644
index 0000000..49f0a8c
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/glider_hit.png
diff --git a/Making_Activities_Using_PyGame_gtk3/glider_normal.png b/Making_Activities_Using_PyGame_gtk3/glider_normal.png
new file mode 100644
index 0000000..8fa812b
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/glider_normal.png
diff --git a/Making_Activities_Using_PyGame_gtk3/po/Demoiselle.pot b/Making_Activities_Using_PyGame_gtk3/po/Demoiselle.pot
new file mode 100644
index 0000000..e50ab51
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/po/Demoiselle.pot
@@ -0,0 +1,3 @@
+#: activity/activity.info:2
+msgid "Demoiselle"
+msgstr ""
diff --git a/Making_Activities_Using_PyGame_gtk3/setup.py b/Making_Activities_Using_PyGame_gtk3/setup.py
new file mode 100755
index 0000000..ebc201d
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/setup.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+
+# setup.py
+
+# Copyright (C) 2006, Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+from sugar.activity import bundlebuilder
+
+bundlebuilder.start()
diff --git a/Making_Activities_Using_PyGame_gtk3/sky.jpg b/Making_Activities_Using_PyGame_gtk3/sky.jpg
new file mode 100644
index 0000000..a92cf6c
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/sky.jpg
diff --git a/Making_Activities_Using_PyGame_gtk3/sugargame/__init__.py b/Making_Activities_Using_PyGame_gtk3/sugargame/__init__.py
new file mode 100644
index 0000000..7e49527
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/sugargame/__init__.py
@@ -0,0 +1 @@
+__version__ = '1.0'
diff --git a/Making_Activities_Using_PyGame_gtk3/sugargame/canvas.py b/Making_Activities_Using_PyGame_gtk3/sugargame/canvas.py
new file mode 100644
index 0000000..cf99a13
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/sugargame/canvas.py
@@ -0,0 +1,56 @@
+import os
+import gtk
+import gobject
+import pygame
+import event
+
+CANVAS = None
+
+class PygameCanvas(gtk.EventBox):
+    def __init__(self, mainwindow):
+        gtk.EventBox.__init__(self)
+
+        global CANVAS
+        assert CANVAS == None, "Only one PygameCanvas can be created, ever."
+        CANVAS = self
+
+        self._mainwindow = mainwindow
+
+        self.set_flags(gtk.CAN_FOCUS)
+        
+        self._socket = gtk.Socket()
+        self.add(self._socket)
+        self.show_all()
+
+    def run_pygame(self, main_fn):
+        # Run the main loop after a short delay.  The reason for the delay is that the
+        # Sugar activity is not properly created until after its constructor returns.
+        # If the Pygame main loop is called from the activity constructor, the 
+        # constructor never returns and the activity freezes.
+        gobject.idle_add(self._run_pygame_cb, main_fn)
+
+    def _run_pygame_cb(self, main_fn):
+        assert pygame.display.get_surface() is None, "PygameCanvas.run_pygame can only be called once."
+        
+        # Preinitialize Pygame with the X window ID.
+        assert pygame.display.get_init() == False, "Pygame must not be initialized before calling PygameCanvas.run_pygame."
+        os.environ['SDL_WINDOWID'] = str(self._socket.get_id())
+        pygame.init()
+        
+        # Restore the default cursor.
+        self._socket.get_window().set_cursor(None)
+
+        # Initialize the Pygame window.
+        r = self.get_allocation()
+        pygame.display.set_mode((r.width, r.height), pygame.RESIZABLE)
+
+        # Hook certain Pygame functions with GTK equivalents.
+        translator = event.Translator(self._mainwindow, self)
+        translator.hook_pygame()
+
+        # Run the Pygame main loop.
+        main_fn()
+        return False
+
+    def get_pygame_widget(self):
+        return self._socket
diff --git a/Making_Activities_Using_PyGame_gtk3/sugargame/event.py b/Making_Activities_Using_PyGame_gtk3/sugargame/event.py
new file mode 100644
index 0000000..52ca4ab
--- /dev/null
+++ b/Making_Activities_Using_PyGame_gtk3/sugargame/event.py
@@ -0,0 +1,241 @@
+import gtk
+import gobject
+import pygame
+import pygame.event
+import logging 
+
+class _MockEvent(object):
+    def __init__(self, keyval):
+        self.keyval = keyval
+
+class Translator(object):
+    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, inner_evb):
+        """Initialise the Translator with the windows to which to listen"""
+        self._mainwindow = mainwindow
+        self._inner_evb = inner_evb
+
+        # Enable events
+        self._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 
+        )
+
+        self._mainwindow.set_flags(gtk.CAN_FOCUS)
+        self._inner_evb.set_flags(gtk.CAN_FOCUS)
+        
+        # Callback functions to link the event systems
+        self._mainwindow.connect('unrealize', self._quit_cb)
+        self._inner_evb.connect('key_press_event', self._keydown_cb)
+        self._inner_evb.connect('key_release_event', self._keyup_cb)
+        self._inner_evb.connect('button_press_event', self._mousedown_cb)
+        self._inner_evb.connect('button_release_event', self._mouseup_cb)
+        self._inner_evb.connect('motion-notify-event', self._mousemove_cb)
+        self._inner_evb.connect('expose-event', self._expose_cb)
+        self._inner_evb.connect('configure-event', self._resize_cb)
+        
+        # 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
+
+    def hook_pygame(self):
+        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
+        
+    def _expose_cb(self, event, widget):
+        pygame.event.post(pygame.event.Event(pygame.VIDEOEXPOSE))
+        return True
+
+    def _resize_cb(self, widget, event):
+        evt = pygame.event.Event(pygame.VIDEORESIZE, 
+                                 size=(event.width,event.height), width=event.width, height=event.height)
+        pygame.event.post(evt)
+        return False # continue processing
+
+    def _quit_cb(self, data=None):
+        self.__stopped = True
+        pygame.event.post(pygame.event.Event(pygame.QUIT))
+
+    def _keydown_cb(self, widget, event):
+        key = event.keyval
+        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_cb(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):
+        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())
+        elif key == 'XF86Start':
+            # view source request, specially handled...
+            self._mainwindow.view_source()
+        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 = unichr(gtk.gdk.keyval_to_unicode(event.keyval))
+            if ukey == '\000':
+                ukey = ''
+            evt = pygame.event.Event(type, key=keycode, unicode=ukey, mod=mod)
+            self._post(evt)
+            
+        return True
+
+    def _get_pressed(self):
+        return self.__keystate
+
+    def _get_mouse_pressed(self):
+        return self.__button_state
+
+    def _mousedown_cb(self, widget, event):
+        self.__button_state[event.button-1] = 1
+        return self._mouseevent(widget, event, pygame.MOUSEBUTTONDOWN)
+
+    def _mouseup_cb(self, widget, event):
+        self.__button_state[event.button-1] = 0
+        return self._mouseevent(widget, event, pygame.MOUSEBUTTONUP)
+        
+    def _mouseevent(self, widget, event, type):
+        evt = pygame.event.Event(type, button=event.button, pos=(event.x, event.y))
+        self._post(evt)
+        return True
+        
+    def _mousemove_cb(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 = pygame.event.Event(pygame.MOUSEMOTION,
+                                 pos=self.__mouse_pos, rel=rel, buttons=self.__button_state)
+        self._post(evt)
+        return True
+        
+    def _tick_cb(self):
+        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):
+        if delay is not None and self.__repeat[0] is None:
+            self.__tick_id = gobject.timeout_add(10, self._tick_cb)
+        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):
+        return self.__mouse_pos
+
+    def _post(self, evt):
+        try:
+            pygame.event.post(evt)
+        except pygame.error, e:
+            if str(e) == 'Event queue full':
+                print "Event queue full!"
+                pass
+            else:
+                raise e
diff --git a/Making_Shared_Activities_gtk3/ReadEtextsActivity3.py b/Making_Shared_Activities_gtk3/ReadEtextsActivity3.py
index 16062f0..5e93d43 100644
--- a/Making_Shared_Activities_gtk3/ReadEtextsActivity3.py
+++ b/Making_Shared_Activities_gtk3/ReadEtextsActivity3.py
@@ -19,10 +19,9 @@
 # 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #
 
-import sys
 import os
+import re
 import logging
-import tempfile
 import time
 import zipfile
 from gi.repository import Gtk
@@ -157,9 +156,9 @@ class ReadEtextsActivity(activity.Activity):
         self.num_page_entry.set_text('0')
         self.num_page_entry.set_alignment(1)
         self.num_page_entry.connect('insert-text',
-                               self.__new_num_page_entry_insert_text_cb)
+                               self.num_page_entry_insert_text_cb)
         self.num_page_entry.connect('activate',
-                               self.__new_num_page_entry_activate_cb)
+                               self.num_page_entry_activate_cb)
         self.num_page_entry.set_width_chars(4)
         num_page_item.add(self.num_page_entry)
         self.num_page_entry.show()
@@ -215,7 +214,7 @@ class ReadEtextsActivity(activity.Activity):
         vbox.show()
         
         page = 0
-        self.clipboard = Gtk.Clipboard()
+        self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
         self.textview.grab_focus()
         self.font_desc = Pango.FontDescription("sans %d" % style.zoom(10))
         self.textview.modify_font(self.font_desc)
@@ -241,13 +240,13 @@ class ReadEtextsActivity(activity.Activity):
                 # Wait for a successful join before trying to get the document
                 self.connect("joined", self.joined_cb)
 
-    def __new_num_page_entry_insert_text_cb(self, entry, text, length, position):
+    def num_page_entry_insert_text_cb(self, entry, text, length, position):
         if not re.match('[0-9]', text):
             entry.emit_stop_by_name('insert-text')
             return True
         return False
 
-    def __new_num_page_entry_activate_cb(self, entry):
+    def num_page_entry_activate_cb(self, entry):
         global page
         if entry.props.text:
             new_page = int(entry.props.text) - 1
@@ -309,25 +308,6 @@ class ReadEtextsActivity(activity.Activity):
             return True
         return False
 
-    def num_page_entry_activate_cb(self, entry):
-        global page
-        if entry.props.text:
-            new_page = int(entry.props.text) - 1
-        else:
-            new_page = 0
-
-        if new_page >= self.read_toolbar.total_pages:
-            new_page = self.read_toolbar.total_pages - 1
-        elif new_page < 0:
-            new_page = 0
-
-        self.read_toolbar.current_page = new_page
-        self.read_toolbar.set_current_page(new_page)
-        self.show_page(new_page)
-        entry.props.text = str(new_page + 1)
-        self.read_toolbar.update_nav_buttons()
-        page = new_page
-        
     def go_back_cb(self, button):
         self.page_previous()
     
@@ -338,7 +318,7 @@ class ReadEtextsActivity(activity.Activity):
         global page
         page=page-1
         if page < 0: page=0
-        self.read_toolbar.set_current_page(page)
+        self.set_current_page(page)
         self.show_page(page)
         v_adjustment = self.scrolled_window.get_vadjustment()
         v_adjustment.set_value(v_adjustment.get_upper() - \
@@ -348,7 +328,7 @@ class ReadEtextsActivity(activity.Activity):
         global page
         page=page+1
         if page >= len(self.page_index): page=0
-        self.read_toolbar.set_current_page(page)
+        self.set_current_page(page)
         self.show_page(page)
         v_adjustment = self.scrolled_window.get_vadjustment()
         v_adjustment.set_value(v_adjustment.get_lower())
@@ -383,9 +363,7 @@ class ReadEtextsActivity(activity.Activity):
 
     def edit_toolbar_copy_cb(self, button):
         textbuffer = self.textview.get_buffer()
-        begin, end = textbuffer.get_selection_bounds()
-        copy_text = textbuffer.get_text(begin, end)
-        self.clipboard.set_text(copy_text)
+        textbuffer.copy_clipboard(self.clipboard)
 
     def view_toolbar_go_fullscreen_cb(self, view_toolbar):
         self.fullscreen()
@@ -510,8 +488,8 @@ class ReadEtextsActivity(activity.Activity):
             os.remove(currentFileName)
         self.get_saved_page_number()
         self.show_page(page)
-        self.read_toolbar.set_total_pages(pagecount + 1)
-        self.read_toolbar.set_current_page(page)
+        self.set_total_pages(pagecount + 1)
+        self.set_current_page(page)
  
         # We've got the document, so if we're a shared activity, offer it
         if self.get_shared():