Port Gtk 3HEADmaster

13 files changed, 954 insertions, 943 deletions

diff --git a/FollowMe.py b/FollowMe.py
index bc1c02f..d8b9fe4 100755
--- a/FollowMe.py
+++ b/FollowMe.py
@@ -1,218 +1,225 @@
-#!/usr/bin/python

-# FollowMe.py

-"""

-    Copyright (C) 2010  Peter Hewitt

-

-    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 3 of the License, or

-    (at your option) any later version.

-

-"""

-import g,utils,pygame,simon,buttons,sys,slider,load_save,rc_skip_last

-try:

-    import gtk

-except:

-    pass

-

-class FollowMe:

-    

-    def __init__(self):

-        self.journal=True # set to False if we come in via main()

-        self.canvas=None # set to the pygame canvas if we come in via activity.py

-

-    def display(self):

-        g.screen.fill((0,255,0))

-        if self.aim.running or self.aim.glow_active:

-            pass

-        else:

-            x=g.imgs[g.green].x; y=g.imgs[g.green].y

-            w=g.imgs[g.green].w; h=g.imgs[g.green].h

-            pygame.draw.rect(g.screen,utils.WHITE,(x,y,w,h),g.sy(.2))

-        for img in g.imgs: # img from ImgClick (centred)

-            img.draw(g.screen)

-        if g.wrong:

-            img=g.imgs[g.wrong_ind]

-            utils.centre_blit(g.screen,g.wrong_img,(img.cx,img.cy))

-            img=g.imgs[g.right_ind]

-            utils.centre_blit(g.screen,g.glowy[g.right_ind],(img.cx,img.cy))

-        buttons.draw()

-        self.slider.draw()

-        self.ladder()

-        self.aim.glow()

-        self.player.glow(True)

-

-    def do_click(self):

-        self.glow_off()

-        if self.click(): return

-        bu=buttons.check()

-        if bu<>'':self.do_button(bu); return

-        if self.slider.mouse(): self.set_delay()

-

-    def do_button(self,bu):

-        if bu=='green': # start

-            self.aim.new1(); g.player_n=0; g.wrong=False; g.score=0

-            buttons.off("green"); buttons.on("back")

-        elif bu=='back': self.aim.start() # show again

-

-    def do_key(self,key):

-        if key in g.TICK:

-            self.change_level(); self.set_delay(); return

-        if key==pygame.K_v: g.version_display=not g.version_display; return

-        if self.aim.running or self.aim.glow_active: return

-        if key in g.CROSS: self.do_click(); return

-        if key in g.SQUARE:

-            if buttons.active('green'): self.do_button('green'); return

-            if buttons.active('back'): self.do_button('back'); return

-        if key in g.RIGHT:

-            g.green=self.rc.inc_c(g.green); g.imgs[g.green].mouse_set()

-        if key in g.LEFT:

-            g.green=self.rc.dec_c(g.green); g.imgs[g.green].mouse_set()

-        if key in g.UP:

-            g.green=self.rc.dec_r(g.green); g.imgs[g.green].mouse_set()

-        if key in g.DOWN:

-            g.green=self.rc.inc_r(g.green); g.imgs[g.green].mouse_set()

-

-    def mouse_set(self):

-        ind=0

-        for imgc in g.imgs:

-            if imgc.mouse_on(): g.green=ind; return

-            ind+=1

-

-    def change_level(self):

-        g.level+=1

-        if g.level>self.slider.steps: g.level=1

-

-    def ladder(self):

-        if g.score>g.best: g.best=g.score

-        if g.best>11:

-            cx=g.sx(30.55); cy=g.sy(13.25)

-            utils.centre_blit(g.screen,g.star,(cx,cy))

-            utils.display_number(g.best,(cx,cy),g.font2)

-        if g.score>0:

-            n=g.score-1

-            if n>11: n=11

-            g.screen.blit(g.ladder,(g.sx(26.95),g.sy(13.7)))

-            x=g.man_x0+n*g.man_dx; y=g.man_y0+n*g.man_dy

-            g.screen.blit(g.man,(x,y))

-            cx=x+g.man_sc_dx; cy=y+g.man_sc_dy

-            if g.score<g.best or g.best<12:

-                utils.centre_blit(g.screen,g.star,(cx,cy))

-                utils.display_number(g.score,(cx,cy),g.font2)

-        

-    def which(self):

-        ind=0

-        for img in g.imgs:

-            if img.mouse_on(): return ind

-            ind+=1

-        return -1 # none clicked

-

-    def click(self):

-        if self.aim.running: return False

-        if g.wrong: return False

-        ind=self.which()

-        if ind==-1: return False

-        if len(self.aim.list1)==0: return False

-        self.player.glow_start(ind)

-        buttons.off("back")

-        if ind==self.aim.list1[g.player_n]:

-            g.player_n+=1

-            if g.player_n>g.score: g.score=g.player_n

-            if g.player_n==len(self.aim.list1): # all correct - add another

-                self.aim.inc(); g.player_n=0

-        else:

-            g.wrong=True; g.wrong_ind=ind

-            g.right_ind=self.aim.list1[g.player_n]

-            buttons.on("green")

-        return True # click processed

-        

-    def glow_off(self):

-        self.aim.glow_off(); self.player.glow_off()

-

-    def set_delay(self):

-        self.aim.glow_time=(4-g.level)*500-300

-        self.aim.delay=(4-g.level)*330

-

-    def flush_queue(self):

-        flushing=True

-        while flushing:

-            flushing=False

-            if self.journal:

-                while gtk.events_pending(): gtk.main_iteration()

-            for event in pygame.event.get(): flushing=True

-

-    def run(self):

-        g.init()

-        if not self.journal: utils.load()

-        load_save.retrieve()

-        self.aim=simon.Simon(1200) # arg is glow time

-        self.set_delay()

-        self.player=simon.Simon(200)

-        bx=g.sx(22.42); by=g.sy(20.8)

-        buttons.Button("green",(bx,by),True)

-        buttons.Button("back",(bx,by),True); buttons.off("back")

-        self.slider=slider.Slider(g.sx(9),g.sy(20.8),3,utils.BLUE)

-        self.rc=rc_skip_last.RC(3,5)

-        if self.canvas<>None: self.canvas.grab_focus()

-        ctrl=False

-        pygame.key.set_repeat(600,120); key_ms=pygame.time.get_ticks()

-        going=True

-        while going:

-            if self.journal:

-                # Pump GTK messages.

-                while gtk.events_pending(): gtk.main_iteration()

-

-            # Pump PyGame messages.

-            for event in pygame.event.get():

-                if event.type==pygame.QUIT:

-                    if not self.journal: utils.save()

-                    going=False

-                elif event.type == pygame.MOUSEMOTION:

-                    g.pos=event.pos

-                    g.redraw=True

-                    if self.canvas<>None: self.canvas.grab_focus()

-                    self.mouse_set()

-                elif event.type == pygame.MOUSEBUTTONDOWN:

-                    g.redraw=True

-                    if event.button==1: self.do_click(); self.flush_queue()

-                elif event.type == pygame.KEYDOWN:

-                    # throttle keyboard repeat

-                    if pygame.time.get_ticks()-key_ms>110:

-                        key_ms=pygame.time.get_ticks()

-                        if ctrl:

-                            if event.key==pygame.K_q:

-                                if not self.journal: utils.save()

-                                going=False; break

-                            else:

-                                ctrl=False

-                        if event.key in (pygame.K_LCTRL,pygame.K_RCTRL):

-                            ctrl=True; break

-                        self.do_key(event.key); g.redraw=True

-                        self.flush_queue()

-                elif event.type == pygame.KEYUP:

-                    ctrl=False

-            if not going: break

-            if g.player_n==0 and not buttons.active('green'):

-                buttons.on("back")

-            self.player.do()

-            self.aim.do()

-            if g.redraw:

-                self.display()

-                if g.version_display: utils.version_display()

-                if self.aim.running or self.aim.glow_active:

-                    pass

-                else:

-                    g.screen.blit(g.pointer,g.pos)

-                pygame.display.flip()

-                g.redraw=False

-            g.clock.tick(40)

-

-if __name__=="__main__":

-    pygame.init()

-    pygame.display.set_mode((1024,768),pygame.FULLSCREEN)

-    game=FollowMe()

-    game.journal=False

-    game.run()

-    pygame.display.quit()

-    pygame.quit()

-    sys.exit(0)

+#!/usr/bin/python
+# FollowMe.py
+"""
+    Copyright (C) 2010  Peter Hewitt
+
+    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 3 of the License, or
+    (at your option) any later version.
+
+"""
+import g
+import utils
+import pygame
+import simon
+import buttons
+import sys
+import slider
+import load_save
+import rc_skip_last
+
+import gi
+from gi.repository import Gtk
+
+class FollowMe:
+    
+    def __init__(self):
+        self.journal=True # set to False if we come in via main()
+        self.canvas=None # set to the pygame canvas if we come in via activity.py
+
+    def display(self):
+        g.screen.fill((0,255,0))
+        if self.aim.running or self.aim.glow_active:
+            pass
+        else:
+            x=g.imgs[g.green].x; y=g.imgs[g.green].y
+            w=g.imgs[g.green].w; h=g.imgs[g.green].h
+            pygame.draw.rect(g.screen,utils.WHITE,(x,y,w,h),g.sy(.2))
+        for img in g.imgs: # img from ImgClick (centred)
+            img.draw(g.screen)
+        if g.wrong:
+            img=g.imgs[g.wrong_ind]
+            utils.centre_blit(g.screen,g.wrong_img,(img.cx,img.cy))
+            img=g.imgs[g.right_ind]
+            utils.centre_blit(g.screen,g.glowy[g.right_ind],(img.cx,img.cy))
+        buttons.draw()
+        self.slider.draw()
+        self.ladder()
+        self.aim.glow()
+        self.player.glow(True)
+
+    def do_click(self):
+        self.glow_off()
+        if self.click(): return
+        bu=buttons.check()
+        if bu<>'':self.do_button(bu); return
+        if self.slider.mouse(): self.set_delay()
+
+    def do_button(self,bu):
+        if bu=='green': # start
+            self.aim.new1(); g.player_n=0; g.wrong=False; g.score=0
+            buttons.off("green"); buttons.on("back")
+        elif bu=='back': self.aim.start() # show again
+
+    def do_key(self,key):
+        if key in g.TICK:
+            self.change_level(); self.set_delay(); return
+        if key==pygame.K_v: g.version_display=not g.version_display; return
+        if self.aim.running or self.aim.glow_active: return
+        if key in g.CROSS: self.do_click(); return
+        if key in g.SQUARE:
+            if buttons.active('green'): self.do_button('green'); return
+            if buttons.active('back'): self.do_button('back'); return
+        if key in g.RIGHT:
+            g.green=self.rc.inc_c(g.green); g.imgs[g.green].mouse_set()
+        if key in g.LEFT:
+            g.green=self.rc.dec_c(g.green); g.imgs[g.green].mouse_set()
+        if key in g.UP:
+            g.green=self.rc.dec_r(g.green); g.imgs[g.green].mouse_set()
+        if key in g.DOWN:
+            g.green=self.rc.inc_r(g.green); g.imgs[g.green].mouse_set()
+
+    def mouse_set(self):
+        ind=0
+        for imgc in g.imgs:
+            if imgc.mouse_on(): g.green=ind; return
+            ind+=1
+
+    def change_level(self):
+        g.level+=1
+        if g.level>self.slider.steps: g.level=1
+
+    def ladder(self):
+        if g.score>g.best: g.best=g.score
+        if g.best>11:
+            cx=g.sx(30.55); cy=g.sy(13.25)
+            utils.centre_blit(g.screen,g.star,(cx,cy))
+            utils.display_number(g.best,(cx,cy),g.font2)
+        if g.score>0:
+            n=g.score-1
+            if n>11: n=11
+            g.screen.blit(g.ladder,(g.sx(26.95),g.sy(13.7)))
+            x=g.man_x0+n*g.man_dx; y=g.man_y0+n*g.man_dy
+            g.screen.blit(g.man,(x,y))
+            cx=x+g.man_sc_dx; cy=y+g.man_sc_dy
+            if g.score<g.best or g.best<12:
+                utils.centre_blit(g.screen,g.star,(cx,cy))
+                utils.display_number(g.score,(cx,cy),g.font2)
+        
+    def which(self):
+        ind=0
+        for img in g.imgs:
+            if img.mouse_on(): return ind
+            ind+=1
+        return -1 # none clicked
+
+    def click(self):
+        if self.aim.running: return False
+        if g.wrong: return False
+        ind=self.which()
+        if ind==-1: return False
+        if len(self.aim.list1)==0: return False
+        self.player.glow_start(ind)
+        buttons.off("back")
+        if ind==self.aim.list1[g.player_n]:
+            g.player_n+=1
+            if g.player_n>g.score: g.score=g.player_n
+            if g.player_n==len(self.aim.list1): # all correct - add another
+                self.aim.inc(); g.player_n=0
+        else:
+            g.wrong=True; g.wrong_ind=ind
+            g.right_ind=self.aim.list1[g.player_n]
+            buttons.on("green")
+        return True # click processed
+        
+    def glow_off(self):
+        self.aim.glow_off(); self.player.glow_off()
+
+    def set_delay(self):
+        self.aim.glow_time=(4-g.level)*500-300
+        self.aim.delay=(4-g.level)*330
+
+    def flush_queue(self):
+        flushing=True
+        while flushing:
+            flushing=False
+            if self.journal:
+                while Gtk.events_pending(): Gtk.main_iteration()
+            for event in pygame.event.get(): flushing=True
+
+    def run(self):
+        g.init()
+        if not self.journal: utils.load()
+        load_save.retrieve()
+        self.aim=simon.Simon(1200) # arg is glow time
+        self.set_delay()
+        self.player=simon.Simon(200)
+        bx=g.sx(22.42); by=g.sy(20.8)
+        buttons.Button("green",(bx,by),True)
+        buttons.Button("back",(bx,by),True); buttons.off("back")
+        self.slider=slider.Slider(g.sx(9),g.sy(20.8),3,utils.BLUE)
+        self.rc=rc_skip_last.RC(3,5)
+        if self.canvas<>None: self.canvas.grab_focus()
+        ctrl=False
+        pygame.key.set_repeat(600,120); key_ms=pygame.time.get_ticks()
+        going=True
+        while going:
+            if self.journal:
+                # Pump GTK messages.
+                while Gtk.events_pending(): Gtk.main_iteration()
+
+            # Pump PyGame messages.
+            for event in pygame.event.get():
+                if event.type==pygame.QUIT:
+                    if not self.journal: utils.save()
+                    going=False
+                elif event.type == pygame.MOUSEMOTION:
+                    g.pos=event.pos
+                    g.redraw=True
+                    if self.canvas<>None: self.canvas.grab_focus()
+                    self.mouse_set()
+                elif event.type == pygame.MOUSEBUTTONDOWN:
+                    g.redraw=True
+                    if event.button==1: self.do_click(); self.flush_queue()
+                elif event.type == pygame.KEYDOWN:
+                    # throttle keyboard repeat
+                    if pygame.time.get_ticks()-key_ms>110:
+                        key_ms=pygame.time.get_ticks()
+                        if ctrl:
+                            if event.key==pygame.K_q:
+                                if not self.journal: utils.save()
+                                going=False; break
+                            else:
+                                ctrl=False
+                        if event.key in (pygame.K_LCTRL,pygame.K_RCTRL):
+                            ctrl=True; break
+                        self.do_key(event.key); g.redraw=True
+                        self.flush_queue()
+                elif event.type == pygame.KEYUP:
+                    ctrl=False
+            if not going: break
+            if g.player_n==0 and not buttons.active('green'):
+                buttons.on("back")
+            self.player.do()
+            self.aim.do()
+            if g.redraw:
+                self.display()
+                if g.version_display: utils.version_display()
+                if self.aim.running or self.aim.glow_active:
+                    pass
+                else:
+                    g.screen.blit(g.pointer,g.pos)
+                pygame.display.flip()
+                g.redraw=False
+            g.clock.tick(40)
+
+if __name__=="__main__":
+    pygame.init()
+    pygame.display.set_mode((1024,768),pygame.FULLSCREEN)
+    game=FollowMe()
+    game.journal=False
+    game.run()
+    pygame.display.quit()
+    pygame.quit()
+    sys.exit(0)
diff --git a/activity.py b/activity.py
index fdaa0f9..50c17a1 100755
--- a/activity.py
+++ b/activity.py
@@ -1,53 +1,68 @@
-# activity.py

-# my standard link between sugar and my activity

-

-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 load_save

-import FollowMe

-

-class PeterActivity(activity.Activity):

-    def __init__(self, handle):

-        super(PeterActivity, self).__init__(handle)

-

-        # Build the activity toolbar.

-        toolbox = activity.ActivityToolbox(self)

-        activity_toolbar = toolbox.get_activity_toolbar()

-        activity_toolbar.keep.props.visible = False

-        activity_toolbar.share.props.visible = False

-

-        toolbox.show()

-        self.set_toolbox(toolbox)

-

-        # Create the game instance.

-        self.game = FollowMe.FollowMe()

-

-        # 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.game.canvas=self._pygamecanvas

-

-        # Start the game running.

-        self._pygamecanvas.run_pygame(self.game.run)

-

-    def read_file(self, file_path):

-        try:

-            f = open(file_path, 'r')

-        except:

-            return #****

-        load_save.load(f)

-        f.close()

-

-    def write_file(self, file_path):

-        f = open(file_path, 'w')

-        load_save.save(f)

-        f.close()

+# activity.py
+# my standard link between sugar and my activity
+
+from gettext import gettext as _
+import pygame
+
+import gi
+from gi.repository import Gtk
+
+from sugar3.activity import activity
+from sugar3.graphics.toolbarbox import ToolbarBox
+
+from sugar3.activity.widgets import StopButton
+from sugar3.activity.widgets import ActivityToolbarButton
+
+
+import sugargame.canvas
+import load_save
+import FollowMe
+
+class PeterActivity(activity.Activity):
+    def __init__(self, handle):
+        super(PeterActivity, self).__init__(handle)
+
+        toolbar_box = ToolbarBox()
+        
+        activity_button = ActivityToolbarButton(self)
+        toolbar_box.toolbar.insert(activity_button, 0)
+
+        separator = Gtk.SeparatorToolItem()
+        separator.props.draw = False
+        separator.set_expand(True)
+        toolbar_box.toolbar.insert(separator, -1)
+
+        stop_button = StopButton(self)
+        stop_button.props.accelerator = '<Ctrl><Shift>Q'
+        toolbar_box.toolbar.insert(stop_button, -1)
+
+        self.set_toolbar_box(toolbar_box)
+        
+        # Create the game instance.
+        self.game = FollowMe.FollowMe()
+
+        # 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.game.canvas=self._pygamecanvas
+        
+        self.show_all()
+        
+        # Start the game running.
+        self._pygamecanvas.run_pygame(self.game.run)
+    
+    def read_file(self, file_path):
+        try:
+            f = open(file_path, 'r')
+        except:
+            return #****
+        load_save.load(f)
+        f.close()
+
+    def write_file(self, file_path):
+        f = open(file_path, 'w')
+        load_save.save(f)
+        f.close()
diff --git a/buttons.py b/buttons.py
index 9542796..f924f25 100755
--- a/buttons.py
+++ b/buttons.py
@@ -1,106 +1,106 @@
-# buttons.py

-import g,utils,pygame

-

-class Button:

-    _instances=[]

-    

-    def __init__(self,name,(x1,y1),centre=True): # eg ('plus',(30,40))

-        self._instances.append(self)

-        up=utils.load_image(name+"_up.png",True)

-        down=utils.load_image(name+"_down.png",True)

-        w=up.get_width();h=up.get_height();x=x1;y=y1

-        if centre:

-            self.cx=x; self.cy=y

-            x=x-w/2; y=y-h/2

-        else:

-            self.cx=x+w/2; self.cy=y+h/2

-        self.rect=pygame.Rect(x,y,w,h)

-        self.name=name; self.x=x; self.y=y; self.active=True

-        self.up=up; self.down=down; self.stay_down=False

-

-    def mouse_on(self):

-        mx,my=g.pos

-        return self.rect.collidepoint(mx,my)

-

-    def draw_up(self):

-        g.screen.blit(self.up,(self.x,self.y))

-

-    def draw_down(self):

-        g.screen.blit(self.down,(self.x,self.y))

-

-    def on(self):

-        self.active=True

-

-    def off(self):

-        self.active=False

-

-def draw():

-    for b in Button._instances:

-        if b.active:

-            if b.stay_down:

-                b.draw_down()

-            else:

-                b.draw_up()

-

-def check():

-    clear()

-    for b in Button._instances:

-        if b.active:

-            if b.mouse_on():

-                if b.name in ('xyz1','xyz2'):

-                    b.stay_down=True

-                else:

-                    b.draw_down()

-                    g.screen.blit(g.pointer,g.pos)

-                    pygame.display.flip()

-                    pygame.time.wait(300)

-                return b.name #****

-    return '' # no button pressed

-

-def clear():

-    for b in Button._instances: b.stay_down=False

-    

-def active(name):

-    for b in Button._instances:

-        if b.name==name: return b.active #****

-    return False # not found

-

-def stay_down(name):

-    for b in Button._instances:

-        if b.name==name: b.stay_down=True; return #****

-    return

-

-def mouse_on(name):

-    mx,my=g.pos

-    for b in Button._instances:

-        if b.name==name:

-            return b.rect.collidepoint(mx,my)

-    return False

-

-def set_mouse(name):

-    p2=g.pointer.get_height()/2

-    for b in Button._instances:

-        if b.name==name:

-            x=b.cx; y=b.cy+p2

-            pygame.mouse.set_pos(x,y); g.pos=(x,y)

-

-# eg1 buttons.on('plus')

-# eg2 buttons.on(['plus','times'])

-def on(name):

-    if type(name)==type('a'):

-        list1=[]; list1.append(name)

-    else:

-        list1=name

-    for b in Button._instances:

-        if b.name in list1: b.active=True

-

-# eg1 buttons.off('plus')

-# eg2 buttons.off(['plus','times'])

-def off(name):

-    if type(name)==type('a'):

-        list1=[]; list1.append(name)

-    else:

-        list1=name

-    for b in Button._instances:

-        if b.name in list1: b.active=False

-

+# buttons.py
+import g,utils,pygame
+
+class Button:
+    _instances=[]
+    
+    def __init__(self,name,(x1,y1),centre=True): # eg ('plus',(30,40))
+        self._instances.append(self)
+        up=utils.load_image(name+"_up.png",True)
+        down=utils.load_image(name+"_down.png",True)
+        w=up.get_width();h=up.get_height();x=x1;y=y1
+        if centre:
+            self.cx=x; self.cy=y
+            x=x-w/2; y=y-h/2
+        else:
+            self.cx=x+w/2; self.cy=y+h/2
+        self.rect=pygame.Rect(x,y,w,h)
+        self.name=name; self.x=x; self.y=y; self.active=True
+        self.up=up; self.down=down; self.stay_down=False
+
+    def mouse_on(self):
+        mx,my=g.pos
+        return self.rect.collidepoint(mx,my)
+
+    def draw_up(self):
+        g.screen.blit(self.up,(self.x,self.y))
+
+    def draw_down(self):
+        g.screen.blit(self.down,(self.x,self.y))
+
+    def on(self):
+        self.active=True
+
+    def off(self):
+        self.active=False
+
+def draw():
+    for b in Button._instances:
+        if b.active:
+            if b.stay_down:
+                b.draw_down()
+            else:
+                b.draw_up()
+
+def check():
+    clear()
+    for b in Button._instances:
+        if b.active:
+            if b.mouse_on():
+                if b.name in ('xyz1','xyz2'):
+                    b.stay_down=True
+                else:
+                    b.draw_down()
+                    g.screen.blit(g.pointer,g.pos)
+                    pygame.display.flip()
+                    pygame.time.wait(300)
+                return b.name #****
+    return '' # no button pressed
+
+def clear():
+    for b in Button._instances: b.stay_down=False
+    
+def active(name):
+    for b in Button._instances:
+        if b.name==name: return b.active #****
+    return False # not found
+
+def stay_down(name):
+    for b in Button._instances:
+        if b.name==name: b.stay_down=True; return #****
+    return
+
+def mouse_on(name):
+    mx,my=g.pos
+    for b in Button._instances:
+        if b.name==name:
+            return b.rect.collidepoint(mx,my)
+    return False
+
+def set_mouse(name):
+    p2=g.pointer.get_height()/2
+    for b in Button._instances:
+        if b.name==name:
+            x=b.cx; y=b.cy+p2
+            pygame.mouse.set_pos(x,y); g.pos=(x,y)
+
+# eg1 buttons.on('plus')
+# eg2 buttons.on(['plus','times'])
+def on(name):
+    if type(name)==type('a'):
+        list1=[]; list1.append(name)
+    else:
+        list1=name
+    for b in Button._instances:
+        if b.name in list1: b.active=True
+
+# eg1 buttons.off('plus')
+# eg2 buttons.off(['plus','times'])
+def off(name):
+    if type(name)==type('a'):
+        list1=[]; list1.append(name)
+    else:
+        list1=name
+    for b in Button._instances:
+        if b.name in list1: b.active=False
+        
\ No newline at end of file
diff --git a/g.py b/g.py
index 4233b0b..1bca057 100755
--- a/g.py
+++ b/g.py
@@ -1,127 +1,126 @@
-# g.py - globals

-import pygame,utils,random,imgClick

-

-app='Follow Me'; ver='1.0'

-ver='1.1'

-# new bgd

-# ladder

-ver='1.2'

-# scaled font @ imgf

-# man on ladder

-# green bgd -> new buttons

-ver='1.3'

-# star separate & left @ top

-ver='1.4' #<<<< Release 3

-# added magician pic

-ver='1.5'

-# magician -> object

-# speed slider

-# change green button colour

-ver='1.5'

-# rationalised g.py

-# no Esc on XO

-# simon.py - delay also controlled by slider

-# save level

-ver='2.0'

-# sugar coated

-# got this to work ok BUT cursor flickers

-ver='2.1'

-# added journal switch

-# swapped me & grapes

-# added version display for right click

-ver='2.2'

-# cf Boxes

-ver='2.3'

-# app title

-ver='2.4'

-# yellow glow for player & longer

-# increased glow size

-# random seed

-ver='3.0'

-# redraw implemented

-ver='4.0'

-# new sugar cursor etc

-ver='21'

-# bigger white glow

-# no pointer or rectangle while leading

-ver='22'

-# flush_queue() doesn't use gtk on non-XO

-

-UP=(264,273)

-DOWN=(258,274)

-LEFT=(260,276)

-RIGHT=(262,275)

-CROSS=(259,120)

-CIRCLE=(265,111)

-SQUARE=(263,32)

-TICK=(257,13)

-

-def init(): # called by main()

-    random.seed()

-    global redraw

-    global screen,w,h,font1,font2,clock,click_snd

-    global factor,offset,imgf,message,version_display

-    global pos,pointer

-    redraw=True

-    version_display=False

-    screen = pygame.display.get_surface()

-    pygame.display.set_caption(app)

-    screen.fill((70,0,70))

-    pygame.display.flip()

-    w,h=screen.get_size()

-    if float(w)/float(h)>1.5: #widescreen

-        offset=(w-4*h/3)/2 # we assume 4:3 - centre on widescreen

-    else:

-        h=int(.75*w) # allow for toolbar - works to 4:3

-        offset=0

-    clock=pygame.time.Clock()

-    factor=float(h)/24 # measurement scaling factor (32x24 = design units)

-    offset=(w-4*h/3)/2 # we assume 4:3 - centre on widescreen

-    imgf=float(h)/900 # image scaling factor - all images built for 1200x900

-    if pygame.font:

-        t=int(54*imgf); font1=pygame.font.Font(None,t)

-        t=int(48*imgf); font2=pygame.font.Font(None,t)

-    message=''

-    pos=pygame.mouse.get_pos()

-    pointer=utils.load_image('pointer.png',True)

-    pygame.mouse.set_visible(False)

-    

-    # this activity only

-    global imgs,glow,glowy,wrong_img,man,ladder,star,score

-    global man_x0,man_y0,man_dx,man_dy,man_sc_dx,man_sc_dy

-    global wrong,player_n,best,level

-    global max_w,max_h,green

-    wrong_img=utils.load_image('wrong.png',True); wrong_ind=0; right_ind=0

-    man=utils.load_image('man.png',True)

-    man_x0=sx(25.5); man_y0=sy(18.31)

-    man_dx=(sx(27.87)-man_x0)/11.0; man_dy=(sy(12.15)-man_y0)/11.0

-    man_sc_dx=sx(25.38)-man_x0; man_sc_dy=sy(18.61)-man_y0

-    ladder=utils.load_image('ladder.png',True)

-    star=utils.load_image('star.png',True)

-    cy=sy(3.2); dx=sy(6.4); dy=sy(6.2); i=1

-    score=0; best=0; level=1

-    imgs=[]; glow=[]; glowy=[]; max_w=0; max_h=0

-    for r in range(1,4):

-        cx=sx(3.2)

-        for c in range(1,6):

-            img=utils.load_image(str(i)+'.png',True)

-            imgC=imgClick.ImgClick(img,(cx,cy),True)

-            if imgC.w>max_w: max_w=imgC.w

-            if imgC.h>max_h: max_h=imgC.h

-            imgs.append(imgC)

-            glow.append(utils.load_image(str(i)+'.png',True,'glow'))

-            glowy.append(utils.load_image(str(i)+'.png',True,'glowy'))

-            cx+=dx; i+=1

-            if i==15: break

-        cy+=dy

-    player_n=0 # player click counter

-    wrong=False

-    green=0

-    imgs[green].mouse_set()

-

-def sx(f): # scale x function

-    return int(f*factor+offset+.5)

-

-def sy(f): # scale y function

-    return int(f*factor+.5)

-

+# g.py - globals
+import pygame,utils,random,imgClick
+
+app='Follow Me'; ver='1.0'
+ver='1.1'
+# new bgd
+# ladder
+ver='1.2'
+# scaled font @ imgf
+# man on ladder
+# green bgd -> new buttons
+ver='1.3'
+# star separate & left @ top
+ver='1.4' #<<<< Release 3
+# added magician pic
+ver='1.5'
+# magician -> object
+# speed slider
+# change green button colour
+ver='1.5'
+# rationalised g.py
+# no Esc on XO
+# simon.py - delay also controlled by slider
+# save level
+ver='2.0'
+# sugar coated
+# got this to work ok BUT cursor flickers
+ver='2.1'
+# added journal switch
+# swapped me & grapes
+# added version display for right click
+ver='2.2'
+# cf Boxes
+ver='2.3'
+# app title
+ver='2.4'
+# yellow glow for player & longer
+# increased glow size
+# random seed
+ver='3.0'
+# redraw implemented
+ver='4.0'
+# new sugar cursor etc
+ver='21'
+# bigger white glow
+# no pointer or rectangle while leading
+ver='22'
+# flush_queue() doesn't use gtk on non-XO
+
+UP=(264,273)
+DOWN=(258,274)
+LEFT=(260,276)
+RIGHT=(262,275)
+CROSS=(259,120)
+CIRCLE=(265,111)
+SQUARE=(263,32)
+TICK=(257,13)
+
+def init(): # called by main()
+    random.seed()
+    global redraw
+    global screen,w,h,font1,font2,clock,click_snd
+    global factor,offset,imgf,message,version_display
+    global pos,pointer
+    redraw=True
+    version_display=False
+    screen = pygame.display.get_surface()
+    pygame.display.set_caption(app)
+    screen.fill((70,0,70))
+    pygame.display.flip()
+    w,h=screen.get_size()
+    if float(w)/float(h)>1.5: #widescreen
+        offset=(w-4*h/3)/2 # we assume 4:3 - centre on widescreen
+    else:
+        h=int(.75*w) # allow for toolbar - works to 4:3
+        offset=0
+    clock=pygame.time.Clock()
+    factor=float(h)/24 # measurement scaling factor (32x24 = design units)
+    offset=(w-4*h/3)/2 # we assume 4:3 - centre on widescreen
+    imgf=float(h)/900 # image scaling factor - all images built for 1200x900
+    if pygame.font:
+        t=int(54*imgf); font1=pygame.font.Font(None,t)
+        t=int(48*imgf); font2=pygame.font.Font(None,t)
+    message=''
+    pos=pygame.mouse.get_pos()
+    pointer=utils.load_image('pointer.png',True)
+    pygame.mouse.set_visible(False)
+    
+    # this activity only
+    global imgs,glow,glowy,wrong_img,man,ladder,star,score
+    global man_x0,man_y0,man_dx,man_dy,man_sc_dx,man_sc_dy
+    global wrong,player_n,best,level
+    global max_w,max_h,green
+    wrong_img=utils.load_image('wrong.png',True); wrong_ind=0; right_ind=0
+    man=utils.load_image('man.png',True)
+    man_x0=sx(25.5); man_y0=sy(18.31)
+    man_dx=(sx(27.87)-man_x0)/11.0; man_dy=(sy(12.15)-man_y0)/11.0
+    man_sc_dx=sx(25.38)-man_x0; man_sc_dy=sy(18.61)-man_y0
+    ladder=utils.load_image('ladder.png',True)
+    star=utils.load_image('star.png',True)
+    cy=sy(3.2); dx=sy(6.4); dy=sy(6.2); i=1
+    score=0; best=0; level=1
+    imgs=[]; glow=[]; glowy=[]; max_w=0; max_h=0
+    for r in range(1,4):
+        cx=sx(3.2)
+        for c in range(1,6):
+            img=utils.load_image(str(i)+'.png',True)
+            imgC=imgClick.ImgClick(img,(cx,cy),True)
+            if imgC.w>max_w: max_w=imgC.w
+            if imgC.h>max_h: max_h=imgC.h
+            imgs.append(imgC)
+            glow.append(utils.load_image(str(i)+'.png',True,'glow'))
+            glowy.append(utils.load_image(str(i)+'.png',True,'glowy'))
+            cx+=dx; i+=1
+            if i==15: break
+        cy+=dy
+    player_n=0 # player click counter
+    wrong=False
+    green=0
+    imgs[green].mouse_set()
+
+def sx(f): # scale x function
+    return int(f*factor+offset+.5)
+
+def sy(f): # scale y function
+    return int(f*factor+.5)
diff --git a/imgClick.py b/imgClick.py
index 707ab86..d9a9aaa 100755
--- a/imgClick.py
+++ b/imgClick.py
@@ -1,27 +1,27 @@
-#imgClick.py

-# eg click_img=ImgClickClass(img,(x,y)) (x,y)=top left

-#   if click_img.mouse_on():

-#   click_img.draw(gscreen)

-

-import g,pygame

-

-class ImgClick: # for clickable images

-    def __init__(self,img,(x1,y1),centre=False):

-        w=img.get_width();h=img.get_height();x=x1;y=y1

-        if centre: x=x-w/2; y=y-h/2; self.cx=x1; self.cy=y1

-        else: self.cx=x+w/2; self.cy=y+h/2

-        self.rect=pygame.Rect(x,y,w,h)

-        self.x=x; self.y=y; self.img=img

-        self.w=w; self.h=h

-

-

-    def mouse_on(self):

-        return self.rect.collidepoint(g.pos)

-

-    def draw(self,screen):

-        screen.blit(self.img,(self.x,self.y))

-

-    def mouse_set(self):

-        pygame.mouse.set_pos((self.cx,self.cy))

-        g.pos=(self.cx,self.cy)

-        

+#imgClick.py
+# eg click_img=ImgClickClass(img,(x,y)) (x,y)=top left
+#   if click_img.mouse_on():
+#   click_img.draw(gscreen)
+
+import g,pygame
+
+class ImgClick: # for clickable images
+    def __init__(self,img,(x1,y1),centre=False):
+        w=img.get_width();h=img.get_height();x=x1;y=y1
+        if centre: x=x-w/2; y=y-h/2; self.cx=x1; self.cy=y1
+        else: self.cx=x+w/2; self.cy=y+h/2
+        self.rect=pygame.Rect(x,y,w,h)
+        self.x=x; self.y=y; self.img=img
+        self.w=w; self.h=h
+
+
+    def mouse_on(self):
+        return self.rect.collidepoint(g.pos)
+
+    def draw(self,screen):
+        screen.blit(self.img,(self.x,self.y))
+
+    def mouse_set(self):
+        pygame.mouse.set_pos((self.cx,self.cy))
+        g.pos=(self.cx,self.cy)
+        
\ No newline at end of file
diff --git a/load_save.py b/load_save.py
index 33d1265..8bbb3f6 100755
--- a/load_save.py
+++ b/load_save.py
@@ -1,26 +1,24 @@
-#load_save.py

-import g

-

-loaded=[] # list of strings

-

-def load(f):

-    global loaded

-    try:

-        for line in f.readlines():

-            loaded.append(line)

-    except:

-        pass

-

-def save(f):

-    f.write(str(g.best)+'\n')

-    f.write(str(g.level)+'\n')

-

-# note need for rstrip() on strings

-def retrieve():

-    global loaded

-    if len(loaded)>1:

-        g.best=int(loaded[0])

-        g.level=int(loaded[1])

-

-

-    

+#load_save.py
+import g
+
+loaded=[] # list of strings
+
+def load(f):
+    global loaded
+    try:
+        for line in f.readlines():
+            loaded.append(line)
+    except:
+        pass
+
+def save(f):
+    f.write(str(g.best)+'\n')
+    f.write(str(g.level)+'\n')
+
+# note need for rstrip() on strings
+def retrieve():
+    global loaded
+    if len(loaded)>1:
+        g.best=int(loaded[0])
+        g.level=int(loaded[1])
+        
\ No newline at end of file
diff --git a/rc_skip_last.py b/rc_skip_last.py
index 6557039..e58fa90 100755
--- a/rc_skip_last.py
+++ b/rc_skip_last.py
@@ -1,46 +1,44 @@
-# rc.py

-

-class RC():

-    def __init__(self,nr,nc):

-        self.nr=nr; self.nc=nc

-

-    def inc_r(self,ind):

-        r,c=self.row_col(ind)

-        r+=1

-        if r==self.nr: r=0

-        if r==(self.nr-1) and c==(self.nc-1): r=0

-        return self.indx(r,c)

-

-    def dec_r(self,ind):

-        r,c=self.row_col(ind)

-        r-=1

-        if r<0: r=self.nr-1

-        if r==(self.nr-1) and c==(self.nc-1): r=self.nr-2

-        return self.indx(r,c)

-

-    def inc_c(self,ind):

-        r,c=self.row_col(ind)

-        c+=1

-        if c==self.nc: c=0

-        if r==(self.nr-1) and c==(self.nc-1): c=0

-        return self.indx(r,c)

-

-    def dec_c(self,ind):

-        r,c=self.row_col(ind)

-        c-=1

-        if c<0: c=self.nc-1

-        if r==(self.nr-1) and c==(self.nc-1): c=self.nc-2

-        return self.indx(r,c)

-

-    def row_col(self,ind):

-        i=0

-        for r in range(self.nr):

-            for c in range(self.nc):

-                if i==ind: return r,c

-                i+=1

-

-    def indx(self,r,c):

-        return r*self.nc+c

-

-

-

+# rc.py
+
+class RC():
+    def __init__(self,nr,nc):
+        self.nr=nr; self.nc=nc
+
+    def inc_r(self,ind):
+        r,c=self.row_col(ind)
+        r+=1
+        if r==self.nr: r=0
+        if r==(self.nr-1) and c==(self.nc-1): r=0
+        return self.indx(r,c)
+
+    def dec_r(self,ind):
+        r,c=self.row_col(ind)
+        r-=1
+        if r<0: r=self.nr-1
+        if r==(self.nr-1) and c==(self.nc-1): r=self.nr-2
+        return self.indx(r,c)
+
+    def inc_c(self,ind):
+        r,c=self.row_col(ind)
+        c+=1
+        if c==self.nc: c=0
+        if r==(self.nr-1) and c==(self.nc-1): c=0
+        return self.indx(r,c)
+
+    def dec_c(self,ind):
+        r,c=self.row_col(ind)
+        c-=1
+        if c<0: c=self.nc-1
+        if r==(self.nr-1) and c==(self.nc-1): c=self.nc-2
+        return self.indx(r,c)
+
+    def row_col(self,ind):
+        i=0
+        for r in range(self.nr):
+            for c in range(self.nc):
+                if i==ind: return r,c
+                i+=1
+
+    def indx(self,r,c):
+        return r*self.nc+c
+    
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 77fda74..c17ead5 100755
--- a/setup.py
+++ b/setup.py
@@ -1,4 +1,4 @@
 #!/usr/bin/env python
-from sugar.activity import bundlebuilder
+from sugar3.activity import bundlebuilder
 if __name__ == "__main__":
     bundlebuilder.start()
diff --git a/simon.py b/simon.py
index 4633ab4..99d694b 100755
--- a/simon.py
+++ b/simon.py
@@ -1,65 +1,61 @@
-# simon.py

-import g,pygame,random,utils

-

-class Simon: # most methods only used by aim instance

-

-    def __init__(self,glow_time):

-        self.glow_time=glow_time; self.list1=[]

-        self.running=False; self.ind=0; self.started=False

-        self.glow_active=False

-        self.delay=1000 # between item displays - only used by aim instance

-    

-    def new1(self):

-        self.list1=[]; self.inc(); self.started=False

-

-    def do(self):

-        if self.glow_active:

-            d=pygame.time.get_ticks()-self.glow_ms

-            if d<0 or d>=self.glow_time:

-                self.glow_active=False; g.redraw=True

-        if self.running and not self.glow_active:

-            d=pygame.time.get_ticks()-self.ms

-            if d<0 or d>=self.delay: # time to display

-                g.redraw=True

-                self.glow_start(self.list1[self.ind]); self.ind+=1

-                self.ms=pygame.time.get_ticks()+self.glow_time

-                if self.ind==len(self.list1): self.running=False

-

-    def inc(self):

-        while True: # don't allow double at the start

-            r=random.randint(0,len(g.imgs)-1)

-            if self.list1==[]: break

-            if len(self.list1)>1: break

-            if r<>self.list1[0]: break

-        #if len(self.list1)>1: r=self.list1[0]+1 ###

-        self.list1.append(r)

-        self.play(); self.started=True

-        

-    def play(self): # delayed start

-        self.running=True; self.ind=0

-        self.ms=pygame.time.get_ticks()

-        

-    def start(self): # immediate start

-        self.running=True; self.ind=0

-        self.ms=pygame.time.get_ticks()-self.delay

-        

-    def glow(self,y=False):

-        if self.glow_active:

-            ind=self.glow_ind

-            cx=g.imgs[ind].cx; cy=g.imgs[ind].cy

-            img=g.glow[ind]

-            if y: img=g.glowy[ind]

-            utils.centre_blit(g.screen,img,(cx,cy))

-

-    def glow_start(self,ind):

-        self.glow_ms=pygame.time.get_ticks()

-        self.glow_active=True

-        self.glow_ind=ind

-

-    def glow_off(self):

-        self.glow_active=False

-

-

-

-    

-

+# simon.py
+import g,pygame,random,utils
+
+class Simon: # most methods only used by aim instance
+
+    def __init__(self,glow_time):
+        self.glow_time=glow_time; self.list1=[]
+        self.running=False; self.ind=0; self.started=False
+        self.glow_active=False
+        self.delay=1000 # between item displays - only used by aim instance
+    
+    def new1(self):
+        self.list1=[]; self.inc(); self.started=False
+
+    def do(self):
+        if self.glow_active:
+            d=pygame.time.get_ticks()-self.glow_ms
+            if d<0 or d>=self.glow_time:
+                self.glow_active=False; g.redraw=True
+        if self.running and not self.glow_active:
+            d=pygame.time.get_ticks()-self.ms
+            if d<0 or d>=self.delay: # time to display
+                g.redraw=True
+                self.glow_start(self.list1[self.ind]); self.ind+=1
+                self.ms=pygame.time.get_ticks()+self.glow_time
+                if self.ind==len(self.list1): self.running=False
+
+    def inc(self):
+        while True: # don't allow double at the start
+            r=random.randint(0,len(g.imgs)-1)
+            if self.list1==[]: break
+            if len(self.list1)>1: break
+            if r<>self.list1[0]: break
+        #if len(self.list1)>1: r=self.list1[0]+1 ###
+        self.list1.append(r)
+        self.play(); self.started=True
+        
+    def play(self): # delayed start
+        self.running=True; self.ind=0
+        self.ms=pygame.time.get_ticks()
+        
+    def start(self): # immediate start
+        self.running=True; self.ind=0
+        self.ms=pygame.time.get_ticks()-self.delay
+        
+    def glow(self,y=False):
+        if self.glow_active:
+            ind=self.glow_ind
+            cx=g.imgs[ind].cx; cy=g.imgs[ind].cy
+            img=g.glow[ind]
+            if y: img=g.glowy[ind]
+            utils.centre_blit(g.screen,img,(cx,cy))
+
+    def glow_start(self,ind):
+        self.glow_ms=pygame.time.get_ticks()
+        self.glow_active=True
+        self.glow_ind=ind
+
+    def glow_off(self):
+        self.glow_active=False
+        
\ No newline at end of file
diff --git a/slider.py b/slider.py
index 8968e6f..e7731e9 100755
--- a/slider.py
+++ b/slider.py
@@ -1,55 +1,55 @@
-# slider.py

-import utils,pygame,g,copy

-

-# sets g.level 1..steps

-class Slider:

-    def __init__(self,cx,cy,steps,colour=utils.BLACK):

-        self.easy=utils.load_image('slow.png',True)

-        self.hard=utils.load_image('fast.png',True)

-        self.xo=utils.load_image('xo.png',True)

-        iw=self.hard.get_width(); ih=self.hard.get_height()

-        w=g.sy(16); w2=w/2; h2=ih/2

-        self.x1=cx-w2; self.y=cy-h2; self.x2=cx+w2-iw

-        x=cx-w2+iw*1.2; w=w-2*iw*1.2; h=g.sy(.12);y=cy+g.sy(.34)

-        self.rect=pygame.Rect(x,y,w,h)

-        mh=g.sy(1);self.mark=pygame.Rect(x,y-mh/2+h/2,h,mh)

-        self.steps=steps; self.dx=w/(steps-1);self.colour=colour

-        self.cx=cx; self.cy=cy

-        marks=[]; x=self.rect.left; click_rects=[]; dx=self.dx

-        for i in range(self.steps):

-            rect=copy.copy(self.mark); rect.left=x-5; rect.width=10; marks.append(rect)

-            click_rect=pygame.Rect(x-dx/2,self.mark.top,dx,self.mark.h)

-            click_rects.append(click_rect)

-            x+=dx

-        self.marks=marks; self.click_rects=click_rects

-

-    def draw(self):

-        g.screen.blit(self.easy,(self.x1,self.y));

-        g.screen.blit(self.hard,(self.x2,self.y))

-        pygame.draw.rect(g.screen,self.colour,self.rect) # horizontal line

-        x=self.rect.left # now draw marks

-        for i in range(self.steps):

-            self.mark.left=x; pygame.draw.rect(g.screen,self.colour,self.mark)

-            if i==(g.level-1):

-                dx=self.xo.get_width()/2; dy=self.xo.get_height()/2

-                g.screen.blit(self.xo,(x-dx+self.mark.w/2,self.cy-dy))

-            x+=self.dx

-

-    def mouse(self):

-        mx,my=g.pos

-        rect=self.easy.get_rect(topleft=(self.x1,self.y))

-        if rect.collidepoint(mx,my):

-            if g.level>1: g.level-=1; return True#****

-        rect=self.hard.get_rect(topleft=(self.x2,self.y))

-        if rect.collidepoint(mx,my):

-            if g.level<self.steps: g.level+=1; return True#****

-        n=1

-        for rect in self.click_rects:

-            if rect.collidepoint(mx,my):

-                if g.level==n:

-                    return False#****

-                else:

-                    g.level=n; return True#****

-            n+=1

-        return False

-    

+# slider.py
+import utils,pygame,g,copy
+
+# sets g.level 1..steps
+class Slider:
+    def __init__(self,cx,cy,steps,colour=utils.BLACK):
+        self.easy=utils.load_image('slow.png',True)
+        self.hard=utils.load_image('fast.png',True)
+        self.xo=utils.load_image('xo.png',True)
+        iw=self.hard.get_width(); ih=self.hard.get_height()
+        w=g.sy(16); w2=w/2; h2=ih/2
+        self.x1=cx-w2; self.y=cy-h2; self.x2=cx+w2-iw
+        x=cx-w2+iw*1.2; w=w-2*iw*1.2; h=g.sy(.12);y=cy+g.sy(.34)
+        self.rect=pygame.Rect(x,y,w,h)
+        mh=g.sy(1);self.mark=pygame.Rect(x,y-mh/2+h/2,h,mh)
+        self.steps=steps; self.dx=w/(steps-1);self.colour=colour
+        self.cx=cx; self.cy=cy
+        marks=[]; x=self.rect.left; click_rects=[]; dx=self.dx
+        for i in range(self.steps):
+            rect=copy.copy(self.mark); rect.left=x-5; rect.width=10; marks.append(rect)
+            click_rect=pygame.Rect(x-dx/2,self.mark.top,dx,self.mark.h)
+            click_rects.append(click_rect)
+            x+=dx
+        self.marks=marks; self.click_rects=click_rects
+
+    def draw(self):
+        g.screen.blit(self.easy,(self.x1,self.y));
+        g.screen.blit(self.hard,(self.x2,self.y))
+        pygame.draw.rect(g.screen,self.colour,self.rect) # horizontal line
+        x=self.rect.left # now draw marks
+        for i in range(self.steps):
+            self.mark.left=x; pygame.draw.rect(g.screen,self.colour,self.mark)
+            if i==(g.level-1):
+                dx=self.xo.get_width()/2; dy=self.xo.get_height()/2
+                g.screen.blit(self.xo,(x-dx+self.mark.w/2,self.cy-dy))
+            x+=self.dx
+
+    def mouse(self):
+        mx,my=g.pos
+        rect=self.easy.get_rect(topleft=(self.x1,self.y))
+        if rect.collidepoint(mx,my):
+            if g.level>1: g.level-=1; return True#****
+        rect=self.hard.get_rect(topleft=(self.x2,self.y))
+        if rect.collidepoint(mx,my):
+            if g.level<self.steps: g.level+=1; return True#****
+        n=1
+        for rect in self.click_rects:
+            if rect.collidepoint(mx,my):
+                if g.level==n:
+                    return False#****
+                else:
+                    g.level=n; return True#****
+            n+=1
+        return False
+    
\ No newline at end of file
diff --git a/sugargame/canvas.py b/sugargame/canvas.py
index 9cbef63..1ce0250 100644
--- a/sugargame/canvas.py
+++ b/sugargame/canvas.py
@@ -1,18 +1,18 @@
 import os
-import gtk
-import gobject
+from gi.repository import Gtk
+from gi.repository import GObject
 import pygame
 import event
 
 CANVAS = None
 
-class PygameCanvas(gtk.EventBox):
+class PygameCanvas(Gtk.EventBox):
     
     """
     mainwindow is the activity intself.
     """
     def __init__(self, mainwindow, pointer_hint = True):
-        gtk.EventBox.__init__(self)
+        GObject.GObject.__init__(self)
 
         global CANVAS
         assert CANVAS == None, "Only one PygameCanvas can be created, ever."
@@ -23,9 +23,9 @@ class PygameCanvas(gtk.EventBox):
         
         self._mainwindow = mainwindow
 
-        self.set_flags(gtk.CAN_FOCUS)
+        self.set_can_focus(True)
         
-        self._socket = gtk.Socket()
+        self._socket = Gtk.Socket()
         self.add(self._socket)
         self.show_all()
 
@@ -34,7 +34,7 @@ class PygameCanvas(gtk.EventBox):
         # 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)
+        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."
@@ -45,7 +45,7 @@ class PygameCanvas(gtk.EventBox):
         pygame.init()
         
         # Restore the default cursor.
-        #self._socket.window.set_cursor(None) = no "phantom" cursor
+        self._socket.props.window.set_cursor(None)
 
         # Initialize the Pygame window.
         r = self.get_allocation()
diff --git a/sugargame/event.py b/sugargame/event.py
index 4cc3be8..431a600 100644
--- a/sugargame/event.py
+++ b/sugargame/event.py
@@ -1,5 +1,6 @@
-import gtk
-import gobject
+from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import GObject
 import pygame
 import pygame.event
 import logging 
@@ -46,20 +47,20 @@ class Translator(object):
         # Enable events
         # (add instead of set here because the main window is already realized)
         self._mainwindow.add_events(
-            gtk.gdk.KEY_PRESS_MASK | \
-            gtk.gdk.KEY_RELEASE_MASK \
+            Gdk.EventMask.KEY_PRESS_MASK | \
+            Gdk.EventMask.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 
+            Gdk.EventMask.POINTER_MOTION_MASK | \
+            Gdk.EventMask.POINTER_MOTION_HINT_MASK | \
+            Gdk.EventMask.BUTTON_MOTION_MASK | \
+            Gdk.EventMask.BUTTON_PRESS_MASK | \
+            Gdk.EventMask.BUTTON_RELEASE_MASK 
         )
 
-        self._mainwindow.set_flags(gtk.CAN_FOCUS)
-        self._inner_evb.set_flags(gtk.CAN_FOCUS)
+        self._mainwindow.set_can_focus(True)
+        self._inner_evb.set_can_focus(True)
         
         # Callback functions to link the event systems
         self._mainwindow.connect('unrealize', self._quit_cb)
@@ -68,7 +69,7 @@ class Translator(object):
         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('draw', self._draw_cb)
         self._inner_evb.connect('configure-event', self._resize_cb)
         
         # Internal data
@@ -88,7 +89,7 @@ class Translator(object):
         pygame.mouse.get_pressed = self._get_mouse_pressed
         pygame.mouse.get_pos = self._get_mouse_pos
         
-    def _expose_cb(self, event, widget):
+    def _draw_cb(self, widget, event):
         if pygame.display.get_init():
             pygame.event.post(pygame.event.Event(pygame.VIDEOEXPOSE))
         return True
@@ -133,7 +134,7 @@ class Translator(object):
         return mod
         
     def _keyevent(self, widget, event, type):
-        key = gtk.gdk.keyval_name(event.keyval)
+        key = Gdk.keyval_name(event.keyval)
         if key is None:
             # No idea what this key is.
             return False 
@@ -157,7 +158,7 @@ class Translator(object):
             self.__keystate[keycode] = type == pygame.KEYDOWN
             if type == pygame.KEYUP:
                 mod = self._keymods()
-            ukey = unichr(gtk.gdk.keyval_to_unicode(event.keyval))
+            ukey = unichr(Gdk.keyval_to_unicode(event.keyval))
             if ukey == '\000':
                 ukey = ''
             evt = pygame.event.Event(type, key=keycode, unicode=ukey, mod=mod)
@@ -189,19 +190,19 @@ class Translator(object):
         # 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()
+            win, x, y, state = event.window.get_device_position(event.device)
         else:
             x = event.x
             y = event.y
-            state = event.state
+            state = event.get_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,
+            state & Gdk.ModifierType.BUTTON1_MASK and 1 or 0,
+            state & Gdk.ModifierType.BUTTON2_MASK and 1 or 0,
+            state & Gdk.ModifierType.BUTTON3_MASK and 1 or 0,
         ]
         
         evt = pygame.event.Event(pygame.MOUSEMOTION,
@@ -224,9 +225,9 @@ class Translator(object):
         
     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)
+            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)
+            GObject.source_remove(self.__tick_id)
         self.__repeat = (delay, interval)
         
     def _get_mouse_pos(self):
diff --git a/utils.py b/utils.py
index 969d66d..0fff150 100755
--- a/utils.py
+++ b/utils.py
@@ -1,189 +1,186 @@
-# utils.py

-import g,pygame,sys,os,random,copy,load_save

-

-#constants

-RED,BLUE,GREEN,BLACK,WHITE=(255,0,0),(0,0,255),(0,255,0),(0,0,0),(255,255,255)

-CYAN,ORANGE,CREAM,YELLOW=(0,255,255),(255,165,0),(255,255,192),(255,255,0)

-

-def exit():

-    save()

-    pygame.display.quit()

-    pygame.quit()

-    sys.exit()

-

-def save():

-    dir=''

-    dir=os.environ.get('SUGAR_ACTIVITY_ROOT')

-    if dir==None: dir=''

-    fname=os.path.join(dir,'data','follow.dat')

-    f=open(fname, 'w')

-    load_save.save(f)

-    f.close

-    

-def load():

-    dir=''

-    dir=os.environ.get('SUGAR_ACTIVITY_ROOT')

-    if dir==None: dir=''

-    fname=os.path.join(dir,'data','follow.dat')

-    try:

-        f=open(fname, 'r')

-    except:

-        return None #****

-    try:

-        load_save.load(f)

-    except:

-        pass

-    f.close

-    

-def version_display():

-    g.message=g.app+' '+g.ver

-    g.message+='  '+str(g.screen.get_width())+' x '+str(g.screen.get_height())

-    message(g.screen,g.font1,g.message)

-    

-# loads an image (eg pic.png) from the data subdirectory

-# converts it for optimum display

-# resizes it using the image scaling factor, g.imgf

-#   so it is the right size for the current screen resolution

-#   all images are designed for 1200x900

-def load_image(file1,alpha=False,subdir=''): # eg subdir='glow'

-    data='data'

-    if subdir!='': data=os.path.join('data',subdir)

-    fname=os.path.join(data,file1)

-    try:

-        img=pygame.image.load(fname)

-    except:

-        print "Peter says: Can't find "+fname; exit()

-    if alpha:

-        img=img.convert_alpha()

-    else:

-        img=img.convert()

-    if abs(g.imgf-1.0)>.1: # only scale if factor <> 1

-        w=img.get_width(); h=img.get_height()

-        try:

-            img=pygame.transform.smoothscale(img,(int(g.imgf*w),int(g.imgf*h)))

-        except:

-            img=pygame.transform.scale(img,(int(g.imgf*w),int(g.imgf*h)))

-    return img

-               

-# eg new_list=copy_list(old_list)

-def copy_list(l):

-    new_list=[];new_list.extend(l)

-    return new_list

-

-def shuffle(lst):        

-    l1=lst; lt=[]

-    for i in range(len(lst)):

-        ln=len(l1); r=random.randint(0,ln-1);

-        lt.append(lst[r]); l1.remove(lst[r])

-    return lt

-

-def centre_blit(screen,img,(cx,cy),angle=0): # rotation is clockwise

-    img1=img

-    if angle!=0: img1=pygame.transform.rotate(img,-angle)

-    rect=img1.get_rect()

-    screen.blit(img1,(cx-rect.width/2,cy-rect.height/2))

-

-def text_blit(screen,s,font,(cx,cy),(r,g,b)):

-    text=font.render(s,True,(0,0,0))

-    rect=text.get_rect(); rect.centerx=cx+2; rect.centery=cy+2

-    screen.blit(text,rect)

-    text=font.render(s,True,(r,g,b))

-    rect=text.get_rect(); rect.centerx=cx; rect.centery=cy

-    screen.blit(text,rect)

-    return rect

-

-def text_blit1(screen,s,font,(x,y),(r,g,b)):

-    text=font.render(s,True,(r,g,b))

-    rect=text.get_rect(); rect.x=x; rect.y=y

-    screen.blit(text,rect)

-

-# m is the message

-# d is the # of pixels in the border around the text

-# (cx,cy) = co-ords centre - (0,0) means use screen centre

-def message(screen,font,m,(cx,cy)=(0,0),d=20):

-    if m!='':

-        if pygame.font:

-            text=font.render(m,True,(255,255,255))

-            shadow=font.render(m,True,(0,0,0))

-            rect=text.get_rect()

-            if cx==0: cx=screen.get_width()/2

-            if cy==0: cy=screen.get_height()/2

-            rect.centerx=cx;rect.centery=cy

-            bgd=pygame.Surface((rect.width+2*d,rect.height+2*d))

-            bgd.fill((0,255,255))

-            bgd.set_alpha(128)

-            screen.blit(bgd,(rect.left-d,rect.top-d))

-            screen.blit(shadow,(rect.x+2,rect.y+2,rect.width,rect.height))

-            screen.blit(text,rect)

-

-def mouse_on_img(img,(x,y)): # x,y=top left

-    w=img.get_width()

-    h=img.get_height()

-    mx,my=g.pos

-    if mx<x: return False

-    if mx>(x+w): return False

-    if my<y: return False

-    if my>(y+h): return False

-    try: # in case out of range

-        col=img.get_at((int(mx-x),int(my-y)))

-    except:

-        return False

-    if col[3]<10: return False

-    return True

-

-def mouse_on_img1(img,(cx,cy)):

-    xy=centre_to_top_left(img,(cx,cy))

-    return mouse_on_img(img,xy)

-            

-def mouse_on_img_rect(img,(cx,cy)):

-    w2=img.get_width()/2; h2=img.get_height()/2

-    x1=cx-w2; y1=cy-h2; x2=cx+w2; y2=cy+h2

-    return mouse_in(x1,y1,x2,y2)

-            

-def mouse_in(x1,y1,x2,y2):

-    mx,my=g.pos

-    if x1>mx: return False

-    if x2<mx: return False

-    if y1>my: return False

-    if y2<my: return False

-    return True

-

-def mouse_in_rect(rect): # x,y,w,h

-    return mouse_in(rect[0],rect[1],rect[0]+rect[2],rect[1]+rect[3])

-

-def display_score():

-    if pygame.font:

-        text=g.font2.render(str(g.score),True,ORANGE,BLUE)

-        w=text.get_width(); h=text.get_height()

-        x=g.sx(5.7); y=g.sy(18.8); d=g.sy(.3)

-        pygame.draw.rect(g.screen,BLUE,(x-d-g.sy(.05),y-d,w+2*d,h+2*d))

-        g.screen.blit(text,(x,y))

-        centre_blit(g.screen,g.sparkle,(x-d+g.sy(.05),y+h/2-g.sy(.2)))

-

-def display_number(n,(cx,cy),font,colour=BLACK,bgd=None,outline_font=None):

-    if pygame.font:

-        if bgd==None:

-            text=font.render(str(n),True,colour)

-        else:

-            text=font.render(str(n),True,colour,bgd)

-        if outline_font<>None:

-            outline=outline_font.render(str(n),True,BLACK)

-            centre_blit(g.screen,outline,(cx,cy))

-        centre_blit(g.screen,text,(cx,cy))

-

-def display_number1(n,(x,cy),font,colour=BLACK):

-    if pygame.font:

-        text=font.render(str(n),True,colour)

-        y=cy-text.get_height()/2

-        g.screen.blit(text,(x,y))

-

-def top_left_to_centre(img,(x,y)):

-    cx=x+img.get_width()/2; cy=y+img.get_height()/2

-    return (cx,cy)

-

-def centre_to_top_left(img,(cx,cy)):

-    x=cx-img.get_width()/2; y=cy-img.get_height()/2

-    return (x,y)

-

-       

-    

+# utils.py
+import g,pygame,sys,os,random,copy,load_save
+
+#constants
+RED,BLUE,GREEN,BLACK,WHITE=(255,0,0),(0,0,255),(0,255,0),(0,0,0),(255,255,255)
+CYAN,ORANGE,CREAM,YELLOW=(0,255,255),(255,165,0),(255,255,192),(255,255,0)
+
+def exit():
+    save()
+    pygame.display.quit()
+    pygame.quit()
+    sys.exit()
+
+def save():
+    dir=''
+    dir=os.environ.get('SUGAR_ACTIVITY_ROOT')
+    if dir==None: dir=''
+    fname=os.path.join(dir,'data','follow.dat')
+    f=open(fname, 'w')
+    load_save.save(f)
+    f.close
+    
+def load():
+    dir=''
+    dir=os.environ.get('SUGAR_ACTIVITY_ROOT')
+    if dir==None: dir=''
+    fname=os.path.join(dir,'data','follow.dat')
+    try:
+        f=open(fname, 'r')
+    except:
+        return None #****
+    try:
+        load_save.load(f)
+    except:
+        pass
+    f.close
+    
+def version_display():
+    g.message=g.app+' '+g.ver
+    g.message+='  '+str(g.screen.get_width())+' x '+str(g.screen.get_height())
+    message(g.screen,g.font1,g.message)
+    
+# loads an image (eg pic.png) from the data subdirectory
+# converts it for optimum display
+# resizes it using the image scaling factor, g.imgf
+#   so it is the right size for the current screen resolution
+#   all images are designed for 1200x900
+def load_image(file1,alpha=False,subdir=''): # eg subdir='glow'
+    data='data'
+    if subdir!='': data=os.path.join('data',subdir)
+    fname=os.path.join(data,file1)
+    try:
+        img=pygame.image.load(fname)
+    except:
+        print "Peter says: Can't find "+fname; exit()
+    if alpha:
+        img=img.convert_alpha()
+    else:
+        img=img.convert()
+    if abs(g.imgf-1.0)>.1: # only scale if factor <> 1
+        w=img.get_width(); h=img.get_height()
+        try:
+            img=pygame.transform.smoothscale(img,(int(g.imgf*w),int(g.imgf*h)))
+        except:
+            img=pygame.transform.scale(img,(int(g.imgf*w),int(g.imgf*h)))
+    return img
+               
+# eg new_list=copy_list(old_list)
+def copy_list(l):
+    new_list=[];new_list.extend(l)
+    return new_list
+
+def shuffle(lst):
+    l1=lst; lt=[]
+    for i in range(len(lst)):
+        ln=len(l1); r=random.randint(0,ln-1);
+        lt.append(lst[r]); l1.remove(lst[r])
+    return lt
+
+def centre_blit(screen,img,(cx,cy),angle=0): # rotation is clockwise
+    img1=img
+    if angle!=0: img1=pygame.transform.rotate(img,-angle)
+    rect=img1.get_rect()
+    screen.blit(img1,(cx-rect.width/2,cy-rect.height/2))
+
+def text_blit(screen,s,font,(cx,cy),(r,g,b)):
+    text=font.render(s,True,(0,0,0))
+    rect=text.get_rect(); rect.centerx=cx+2; rect.centery=cy+2
+    screen.blit(text,rect)
+    text=font.render(s,True,(r,g,b))
+    rect=text.get_rect(); rect.centerx=cx; rect.centery=cy
+    screen.blit(text,rect)
+    return rect
+
+def text_blit1(screen,s,font,(x,y),(r,g,b)):
+    text=font.render(s,True,(r,g,b))
+    rect=text.get_rect(); rect.x=x; rect.y=y
+    screen.blit(text,rect)
+
+# m is the message
+# d is the # of pixels in the border around the text
+# (cx,cy) = co-ords centre - (0,0) means use screen centre
+def message(screen,font,m,(cx,cy)=(0,0),d=20):
+    if m!='':
+        if pygame.font:
+            text=font.render(m,True,(255,255,255))
+            shadow=font.render(m,True,(0,0,0))
+            rect=text.get_rect()
+            if cx==0: cx=screen.get_width()/2
+            if cy==0: cy=screen.get_height()/2
+            rect.centerx=cx;rect.centery=cy
+            bgd=pygame.Surface((rect.width+2*d,rect.height+2*d))
+            bgd.fill((0,255,255))
+            bgd.set_alpha(128)
+            screen.blit(bgd,(rect.left-d,rect.top-d))
+            screen.blit(shadow,(rect.x+2,rect.y+2,rect.width,rect.height))
+            screen.blit(text,rect)
+
+def mouse_on_img(img,(x,y)): # x,y=top left
+    w=img.get_width()
+    h=img.get_height()
+    mx,my=g.pos
+    if mx<x: return False
+    if mx>(x+w): return False
+    if my<y: return False
+    if my>(y+h): return False
+    try: # in case out of range
+        col=img.get_at((int(mx-x),int(my-y)))
+    except:
+        return False
+    if col[3]<10: return False
+    return True
+
+def mouse_on_img1(img,(cx,cy)):
+    xy=centre_to_top_left(img,(cx,cy))
+    return mouse_on_img(img,xy)
+            
+def mouse_on_img_rect(img,(cx,cy)):
+    w2=img.get_width()/2; h2=img.get_height()/2
+    x1=cx-w2; y1=cy-h2; x2=cx+w2; y2=cy+h2
+    return mouse_in(x1,y1,x2,y2)
+            
+def mouse_in(x1,y1,x2,y2):
+    mx,my=g.pos
+    if x1>mx: return False
+    if x2<mx: return False
+    if y1>my: return False
+    if y2<my: return False
+    return True
+
+def mouse_in_rect(rect): # x,y,w,h
+    return mouse_in(rect[0],rect[1],rect[0]+rect[2],rect[1]+rect[3])
+
+def display_score():
+    if pygame.font:
+        text=g.font2.render(str(g.score),True,ORANGE,BLUE)
+        w=text.get_width(); h=text.get_height()
+        x=g.sx(5.7); y=g.sy(18.8); d=g.sy(.3)
+        pygame.draw.rect(g.screen,BLUE,(x-d-g.sy(.05),y-d,w+2*d,h+2*d))
+        g.screen.blit(text,(x,y))
+        centre_blit(g.screen,g.sparkle,(x-d+g.sy(.05),y+h/2-g.sy(.2)))
+
+def display_number(n,(cx,cy),font,colour=BLACK,bgd=None,outline_font=None):
+    if pygame.font:
+        if bgd==None:
+            text=font.render(str(n),True,colour)
+        else:
+            text=font.render(str(n),True,colour,bgd)
+        if outline_font<>None:
+            outline=outline_font.render(str(n),True,BLACK)
+            centre_blit(g.screen,outline,(cx,cy))
+        centre_blit(g.screen,text,(cx,cy))
+
+def display_number1(n,(x,cy),font,colour=BLACK):
+    if pygame.font:
+        text=font.render(str(n),True,colour)
+        y=cy-text.get_height()/2
+        g.screen.blit(text,(x,y))
+
+def top_left_to_centre(img,(x,y)):
+    cx=x+img.get_width()/2; cy=y+img.get_height()/2
+    return (cx,cy)
+
+def centre_to_top_left(img,(cx,cy)):
+    x=cx-img.get_width()/2; y=cy-img.get_height()/2
+    return (x,y)