More cleanup. Now we have the Sprite class where all the selected, copied, paste, etc. logic should go. Cleaned the corresponding client code as well, not thoroughfully tested , though

6 files changed, 296 insertions, 289 deletions

diff --git a/talogo.py b/talogo.py
index 16002d7..849e1e7 100644
--- a/talogo.py
+++ b/talogo.py
@@ -158,7 +158,7 @@ def readline(lc, line):
     return res
 
 def setup_cmd(lc, str):
-    setlayer(lc.tw.turtle.spr,100) 
+    lc.tw.turtle.spr.setlayer(100) 
     lc.procstop=False
     list = readline(lc, str)
     lc.step = start_eval(lc, list)
@@ -176,11 +176,11 @@ def evline(lc, list):
     lc.arglist = None
     while lc.iline:
         if lc.tw.step_time > 0:
-            setlayer(lc.tw.turtle.spr,630)
+            lc.tw.turtle.spr.setlayer(630)
             endtime = millis()+an_int(lc,lc.tw.step_time)*100
             while millis()<endtime:
                 yield True
-            setlayer(lc.tw.turtle.spr,100)
+            lc.tw.turtle.spr.setlayer(100)
         token = lc.iline[0]
         if token==lc.symopar: token=lc.iline[1]
         icall(lc, eval); yield True
@@ -274,7 +274,7 @@ def debug_trace(lc, token):
         shp = 'info'
         setshape(lc.tw.status_spr, lc.tw.status_shapes[shp])
         setlabel(lc.tw.status_spr, _(my_string))
-        setlayer(lc.tw.status_spr, 710)
+        lc.tw.status_spr.setlayer(710)
     return
 
 def undefined_check(lc, token):
@@ -286,11 +286,11 @@ def no_args_check(lc):
     raise logoerror("#noinput")
 
 def prim_wait(lc,time):
-    setlayer(lc.tw.turtle.spr,630)
+    lc.tw.turtle.spr.setlayer(630)
     endtime = millis()+an_int(lc,time*1000)
     while millis()<endtime:
         yield True
-    setlayer(lc.tw.turtle.spr,100)
+    lc.tw.turtle.spr.setlayer(100)
     ireturn(lc); yield True
 
 def prim_repeat(lc, num, list):
@@ -989,11 +989,11 @@ def doevalstep(lc):
             try:
                 lc.step.next()
             except StopIteration:
-                setlayer(lc.tw.turtle.spr,630)
+                lc.tw.turtle.spr.setlayer(630)
                 return False
     except logoerror, e:
         showlabel(lc, str(e)[1:-1])
-        setlayer(lc.tw.turtle.spr,630)
+        lc.tw.turtle.spr.setlayer(630)
         return False
     return True
 
@@ -1069,7 +1069,7 @@ def showlabel(lc,label):
         shp = 'status'
     setshape(lc.tw.status_spr, lc.tw.status_shapes[shp])
     setlabel(lc.tw.status_spr, label)
-    setlayer(lc.tw.status_spr, 710)
+    lc.tw.status_spr.setlayer(710)
 
 def stop_logo(tw):
     tw.step_time = 0
diff --git a/taproject.py b/taproject.py
index 28b885e..8fde7c7 100644
--- a/taproject.py
+++ b/taproject.py
@@ -59,7 +59,7 @@ shape_dict = {'journal':'texton', \
 def new_project(tw):
     stop_logo(tw)
     for b in blocks(tw): hide(b)
-    setlayer(tw.turtle.canvas, 600)
+    tw.turtle.canvas.setlayer(600)
     clearscreen(tw.turtle)
     tw.save_file_name = None
 
@@ -162,7 +162,7 @@ def load_spr(tw,b):
         media = label
         label = None
     proto = tw.protodict[btype]
-    spr = sprNew(tw,b[2]+tw.turtle.canvas.x,b[3]+tw.turtle.canvas.y, \
+    spr = Sprite(tw,b[2]+tw.turtle.canvas.x,b[3]+tw.turtle.canvas.y, \
                  proto.image)
     spr.type = 'block'
     spr.proto = proto
@@ -181,7 +181,7 @@ def load_spr(tw,b):
             dsobject.destroy()
         except:
             print "couldn't open dsobject (" + str(spr.ds_id) + ")"
-    setlayer(spr,650)
+    spr.setlayer(650)
     return spr
 
 def load_turtle(tw,b):
diff --git a/tasetup.py b/tasetup.py
index 174c897..767ac7a 100644
--- a/tasetup.py
+++ b/tasetup.py
@@ -262,14 +262,14 @@ def setup_selectors(tw,s):
     tw.selbuttons.append(cat)
 
 def setup_misc(tw):
-    tw.category_spr = sprNew(tw,0, 0, tw.selbuttons[0].group)
+    tw.category_spr = Sprite(tw,0, 0, tw.selbuttons[0].group)
     tw.category_spr.type = 'category'
-    setlayer(tw.category_spr,660)
+    tw.category_spr.setlayer(660)
     # masks get positioned on top of other blocks
-    tw.select_mask = sprNew(tw,100,100,\
+    tw.select_mask = Sprite(tw,100,100,\
         load_image(tw, tw.path, '', 'masknumber'))
     tw.select_mask.type = 'selectmask'
-    tw.select_mask_string = sprNew(tw,100,100,load_image(tw, tw.path, '', \
+    tw.select_mask_string = Sprite(tw,100,100,load_image(tw, tw.path, '', \
         'maskstring'))
     tw.select_mask_string.type = 'selectmask'
     # used to hide the palette
@@ -284,16 +284,16 @@ def setup_misc(tw):
     tw.media_shapes['pythonloaded'] = \
         load_image(tw, tw.path_lang, 'sensors', 'nop-loaded')
     # coordinare systems
-    tw.cartesian_coordinates_spr = sprNew(tw, tw.width/2-600, tw.height/2-450, \
+    tw.cartesian_coordinates_spr = Sprite(tw, tw.width/2-600, tw.height/2-450, \
                                       load_image(tw, tw.path, '', "Cartesian"))
     tw.cartesian_coordinates_spr.type = 'coordinates'
-    setlayer(tw.cartesian_coordinates_spr, 610)
-    hide(tw.cartesian_coordinates_spr)
-    tw.polar_coordinates_spr = sprNew(tw, tw.width/2-600, tw.height/2-450, \
+    tw.cartesian_coordinates_spr.setlayer(610)
+    tw.cartesian_coordinates_spr.hide()
+    tw.polar_coordinates_spr = Sprite(tw, tw.width/2-600, tw.height/2-450, \
                                       load_image(tw, tw.path, '', "polar"))
     tw.polar_coordinates_spr.type = 'coordinates'
-    setlayer(tw.polar_coordinates_spr, 610)
-    hide(tw.polar_coordinates_spr)
+    tw.polar_coordinates_spr.setlayer(610)
+    tw.polar_coordinates_spr.hide()
     # status shapes get positioned at the bottom of the screen
     tw.status_shapes = {}
     tw.status_shapes['status'] = load_image(tw, tw.path, '', 'status')
@@ -307,11 +307,11 @@ def setup_misc(tw):
     tw.status_shapes['overflowerror'] = \
         load_image(tw, tw.path, '', 'overflowerror')
     tw.status_shapes['syntaxerror'] = load_image(tw, tw.path, '', 'syntaxerror')
-    tw.status_spr = sprNew(tw,0,(tw.height-175), \
+    tw.status_spr = Sprite(tw,0,(tw.height-175), \
             tw.status_shapes['status'],True)
     tw.status_spr.type = 'status'
-    setlayer(tw.status_spr,900)
-    hide(tw.status_spr)
+    tw.status_spr.setlayer(900)
+    tw.status_spr.hide()
     # everything should be loaded at this point
     # print tw.status_shapes
     tw.loaded = True
@@ -320,8 +320,8 @@ def setup_selector(tw,name,y,blockdescriptions):
     # selector tabs
     offshape = load_image(tw, tw.path, 'palette', name+'off')
     onshape = load_image(tw, tw.path, 'palette', name+'on')
-    spr = sprNew(tw,143,y,offshape)
-    setlayer(spr,800)
+    spr = Sprite(tw,143,y,offshape)
+    spr.setlayer(800)
     spr.offshape = offshape
     spr.onshape = onshape
     # print 'setting up selector ' + name
diff --git a/tasprites.py b/tasprites.py
index 7310655..6a7a44f 100644
--- a/tasprites.py
+++ b/tasprites.py
@@ -26,7 +26,7 @@ pygtk.require('2.0')
 import gtk
 import gobject
 import pango
-class taSprite: pass
+import tasetup
 
 # Don't display the label for these blocks 
 nolabel = ['audiooff', 'descriptionoff','journal']
@@ -35,140 +35,152 @@ def findsprite(tw,pos):
     list = tw.sprites[:]
     list.reverse()
     for s in list:
-        if hit(s,pos): return s
+        if s.hit(pos): return s
     return None
 
 def redrawsprites(tw):
-    for s in tw.sprites: draw(s)
-
-def sprNew(tw,x,y,image,altlabel=False):
-    spr = taSprite()
-    spr.tw, spr.x, spr.y = tw,x,y
-    setimage(spr,image)
-    spr.label = None
-    spr.ds_id = None
-    if altlabel:
-        spr.draw_label = draw_label2
-    else: spr.draw_label = draw_label1
-    return spr
-
-def setimage(spr,image):
-    spr.image = image
-    if isinstance(image,gtk.gdk.Pixbuf):
-        spr.width = image.get_width()
-        spr.height = image.get_height()
-    else: spr.width,spr.height=image.get_size()
-
-def move(spr,pos):
-    inval(spr)
-    spr.x,spr.y = pos
-    inval(spr)
-
-def setshape(spr,image):
-    inval(spr)
-    setimage(spr,image)
-    inval(spr)
-
-def setshapex(spr):
-    inval(spr)
-
-def setlayer(spr, layer):
-    sprites = spr.tw.sprites
-    if spr in sprites: sprites.remove(spr)
-    spr.layer = layer
-    for i in range(len(sprites)):
-        if layer < sprites[i].layer:
-            sprites.insert(i, spr)
-            inval(spr)
-            return
-    sprites.append(spr)
-    inval(spr)
-
-def hide(spr):
-    if spr not in spr.tw.sprites: return
-    inval(spr)
-    spr.tw.sprites.remove(spr)
-
-def setlabel(spr,label):
-    spr.label = label
-    inval(spr)
-
-def inval(spr):
-    spr.tw.area.invalidate_rect(gtk.gdk.Rectangle(spr.x,spr.y,spr.width, \
-                                                      spr.height), False)
-
-def draw(spr):
-    if isinstance(spr.image,gtk.gdk.Pixbuf):
-        spr.tw.area.draw_pixbuf(spr.tw.gc, spr.image, 0, 0, spr.x, spr.y)
-    else:
-        spr.tw.area.draw_drawable(spr.tw.gc,spr.image,0,0,spr.x,spr.y,-1,-1)
-    if spr.label!=None:
-        if hasattr(spr, 'proto') and hasattr(spr.proto, 'name'):
-            name = spr.proto.name
+    for s in tw.sprites: s.draw()
+
+
+class Sprite():
+
+    def __init__(self, tw, x, y, image, altlabel=False):
+        self.tw, self.x, self.y = tw,x,y
+        self.setimage(image)
+        self.label = None
+        self.ds_id = None
+        if altlabel:
+            self.draw_label = self.draw_label2
+        else: self.draw_label = self.draw_label1
+
+    '''
+    mark block as selected or un-selected 
+    FIXME: how we'll we create the images for selected blocks
+    '''
+    def set_selected(self, selected):
+        if selected:
+            img = tasetup.load_image(self.tw, self.tw.path, '', 'audioon')
         else:
-            name = ""
-        if name not in nolabel:
-            spr.draw_label(spr,str(spr.label))
-
-def hit(spr,pos):
-    x, y = pos
-    if x<spr.x: return False
-    if x>spr.x+spr.width-1: return False
-    if y<spr.y: return False
-    if y>spr.y+spr.height-1: return False
-    if isinstance(spr.image,gtk.gdk.Pixmap): return True
-    if hasattr(spr, 'proto') and hasattr(spr.proto, 'name') and \
-        spr.proto.name == 'journal':
-            return True
-    dx, dy = x-spr.x, y-spr.y
-    try:
-        return ord(spr.image.get_pixels()[(dy*spr.width+dx)*4+3]) == 255
-    except IndexError:
-        if hasattr(spr, 'proto') and hasattr(spr.proto, 'name'):
-            print spr.proto.name
-        print "IndexError: string index out of range: " + str(dx) + " " \
-            + str(dy) + " " + str(spr.width) + " " + str(spr.height)
-        return True
-
-def draw_label(spr, label, myscale, center_flag, truncate_flag):
-    fd = pango.FontDescription('Sans')
-    fd.set_size(int(myscale*spr.tw.scale*pango.SCALE))
-    if type(label) == str or type(label) == unicode:
-        mylabel = label.replace("\0"," ")
-        l = len(mylabel)
-        if truncate_flag and l > 8:
-            pl = spr.tw.window.create_pango_layout("..."+mylabel[l-8:])
+            img = tasetup.load_image(self.tw, self.tw.path, '', 'audioon')
+        self.setimage(img)
+
+    def setimage(self, image):
+        self.image = image
+        if isinstance(image,gtk.gdk.Pixbuf):
+            self.width = image.get_width()
+            self.height = image.get_height()
+        else: self.width,self.height=image.get_size()
+
+    def move(self, pos):
+        self.inval()
+        self.x,self.y = pos
+        self.inval()
+
+    def inval(self):
+        rect = gtk.gdk.Rectangle(self.x, self.y, self.width, self.height)
+        self.tw.area.invalidate_rect(rect, False)
+
+    def setshape(self, image):
+        self.inval()
+        self.setimage(image)
+        self.inval()
+
+    def setshapex(self):
+        self.inval()
+
+    def setlayer(self, layer):
+        sprites = self.tw.sprites
+        if self in sprites: sprites.remove(self)
+        self.layer = layer
+        for i in range(len(sprites)):
+            if layer < sprites[i].layer:
+                sprites.insert(i, self)
+                self.inval()
+                return
+        sprites.append(self)
+        self.inval()
+
+    def hide(self):
+        if self not in self.tw.sprites: return
+        self.inval()
+        self.tw.sprites.remove(self)
+
+    def setlabel(self, label):
+        self.label = label
+        self.inval()
+
+    def draw(self):
+        if isinstance(self.image,gtk.gdk.Pixbuf):
+            self.tw.area.draw_pixbuf(self.tw.gc, self.image, 0, 0, self.x, self.y)
         else:
-            pl = spr.tw.window.create_pango_layout(mylabel)
-        pl.set_font_description(fd)
-        if center_flag:
-            swidth = pl.get_size()[0]/pango.SCALE
-            centerx = spr.x+spr.width/2
-            x = int(centerx-swidth/2)
+            self.tw.area.draw_drawable(self.tw.gc,self.image,0,0,self.x,self.y,-1,-1)
+        if self.label!=None:
+            if hasattr(self, 'proto') and hasattr(self.proto, 'name'):
+                name = self.proto.name
+            else:
+                name = ""
+            if name not in nolabel:
+                self.draw_label1(str(self.label))
+
+    def hit(self, pos):
+        x, y = pos
+        if x<self.x: return False
+        if x>self.x+self.width-1: return False
+        if y<self.y: return False
+        if y>self.y+self.height-1: return False
+        if isinstance(self.image,gtk.gdk.Pixmap): return True
+        if hasattr(self, 'proto') and hasattr(self.proto, 'name') and \
+            self.proto.name == 'journal':
+                return True
+        dx, dy = x-self.x, y-self.y
+        try:
+            return ord(self.image.get_pixels()[(dy*self.width+dx)*4+3]) == 255
+        except IndexError:
+            if hasattr(spr, 'proto') and hasattr(self.proto, 'name'):
+                print self.proto.name
+            print "IndexError: string index out of range: " + str(dx) + " " \
+                + str(dy) + " " + str(self.width) + " " + str(self.height)
+            return True
+
+    def real_draw_label(self, label, myscale, center_flag, truncate_flag):
+        fd = pango.FontDescription('Sans')
+        fd.set_size(int(myscale*self.tw.scale*pango.SCALE))
+        if type(label) == str or type(label) == unicode:
+            mylabel = label.replace("\0"," ")
+            l = len(mylabel)
+            if truncate_flag and l > 8:
+                pl = self.tw.window.create_pango_layout("..."+mylabel[l-8:])
+            else:
+                pl = self.tw.window.create_pango_layout(mylabel)
+            pl.set_font_description(fd)
+            if center_flag:
+                swidth = pl.get_size()[0]/pango.SCALE
+                centerx = self.x+self.width/2
+                x = int(centerx-swidth/2)
+            else:
+                x = self.x+70
+            sheight = pl.get_size()[1]/pango.SCALE
+            centery = self.y+self.height/2
+            y = int(centery-sheight/2)
+            self.tw.gc.set_foreground(self.tw.msgcolor)
+            self.tw.area.draw_layout(self.tw.gc, x, y, pl)
         else:
-            x = spr.x+70
-        sheight = pl.get_size()[1]/pango.SCALE
-        centery = spr.y+spr.height/2
-        y = int(centery-sheight/2)
-        spr.tw.gc.set_foreground(spr.tw.msgcolor)
-        spr.tw.area.draw_layout(spr.tw.gc, x, y, pl)
-    else:
-        print type(label)
-
-# used for most things
-def draw_label1(spr, label):
-    draw_label(spr, label, 7, True, True)
-
-# used for status blocks
-def draw_label2(spr, label):
-    draw_label(spr, str(label), 9, False, False)
-
-# used to get pixel value from mask for category selector
-def getpixel(image,x,y):
-    array = image.get_pixels()
-    offset = (y*image.get_width()+x)*4
-    r,g,b,a = ord(array[offset]),ord(array[offset+1]),ord(array[offset+2]), \
-        ord(array[offset+3])
-    return (a<<24)+(b<<16)+(g<<8)+r
+            print type(label)
+
+    # used for most things
+    def draw_label1(self, label):
+        self.real_draw_label(label, 7, True, True)
+        
+    # used for status blocks
+    def draw_label2(self, label):
+        self.real_draw_label(str(label), 9, False, False)
+
+    # used to get pixel value from mask for category selector
+    def getpixel(self, image,x,y):
+        array = image.get_pixels()
+        offset = (y*image.get_width()+x)*4
+        r,g,b,a = ord(array[offset]),ord(array[offset+1]),ord(array[offset+2]), \
+            ord(array[offset+3])
+        return (a<<24)+(b<<16)+(g<<8)+r
 
 
diff --git a/taturtle.py b/taturtle.py
index 42447c3..524a35f 100644
--- a/taturtle.py
+++ b/taturtle.py
@@ -54,14 +54,14 @@ color_table = (
 def tNew(tw,w,h):
     t = taTurtle()
     t.tw, t.width, t.height = tw, w, h
-    t.canvas = sprNew(tw,0,0,gtk.gdk.Pixmap(tw.area,w,h,-1))
+    t.canvas = Sprite(tw,0,0,gtk.gdk.Pixmap(tw.area,w,h,-1))
     t.canvas.type = 'canvas'
-    setlayer(t.canvas,600)
+    t.canvas.setlayer(600)
     t.shapelist = \
         [load_image(tw, tw.path, 'shapes','t'+str(i)) for i in range(36)]
-    t.spr = sprNew(tw,100,100,t.shapelist[0])
+    t.spr = Sprite(tw,100,100,t.shapelist[0])
     t.spr.type = 'turtle'
-    setlayer(t.spr, 630)
+    t.spr.setlayer(630)
     t.gc = t.canvas.image.new_gc()
     t.shade = 0
     clearscreen(t)
@@ -292,11 +292,11 @@ def draw_line(t,x1,y1,x2,y2):
            h+t.pensize*t.tw.coord_scale+6)
 
 def turn_turtle(t):
-    setshape(t.spr, t.shapelist[(int(t.heading+5)%360)/10])
+    t.spr.setshape(t.shapelist[(int(t.heading+5)%360)/10])
 
 def move_turtle(t):
     x,y = t.width/2+int(t.xcor), t.height/2-int(t.ycor)
-    move(t.spr, (t.canvas.x+x-30,t.canvas.y+y-30))
+    t.spr.move((t.canvas.x+x-30,t.canvas.y+y-30))
     invalt(t,x-30,y-30,60,60)
 
 def invalt(t,x,y,w,h):
diff --git a/tawindow.py b/tawindow.py
index 5af0600..4b8f485 100644
--- a/tawindow.py
+++ b/tawindow.py
@@ -23,11 +23,10 @@
 
 
 # TODO:
+# - better comments! 
+# - many methods could have their logic simplified! 
 # - we need a method to know if we are running inside Sugar (vs. stand-alone)
-# - we need helper methods to discriminate what XO version we are using (if any)
 # - verbose flag should be in the scope of the object instance
-# - better comments! 
-#
 
 
 import pygtk
@@ -39,10 +38,6 @@ import os
 import os.path
 import time
 
-# Import from Journal for these blocks 
-importblocks = ['audiooff', 'descriptionoff','journal']
-
-
 from math import atan2, pi
 DEGTOR = 2*pi/360
 
@@ -59,29 +54,41 @@ except:
 from tahoverhelp import *
 from gettext import gettext as _
 
-# dead key dictionaries
-dead_grave = {'A':192,'E':200,'I':204,'O':210,'U':217,'a':224,'e':232,'i':236,\
-              'o':242,'u':249}
-dead_acute = {'A':193,'E':201,'I':205,'O':211,'U':218,'a':225,'e':233,'i':237,\
-              'o':243,'u':250}
-dead_circumflex = {'A':194,'E':202,'I':206,'O':212,'U':219,'a':226,'e':234,\
-                   'i':238,'o':244,'u':251}
-dead_tilde = {'A':195,'O':211,'N':209,'U':360,'a':227,'o':245,'n':241,'u':361}
-dead_diaeresis = {'A':196,'E':203,'I':207,'O':211,'U':218,'a':228,'e':235,\
-                  'i':239,'o':245,'u':252}
-dead_abovering = {'A':197,'a':229}
-
-# Time out for triggering help
-timeout_tag = [0]
-
-
 
 """
 TurtleArt Window class abstraction 
 """
 class TurtleArtWindow():
 
+    # Import from Journal for these blocks 
+    importblocks = ['audiooff', 'descriptionoff','journal']
+
+    # dead key dictionaries
+    dead_grave = {'A':192,'E':200,'I':204,'O':210,'U':217,'a':224,'e':232,'i':236,\
+                  'o':242,'u':249}
+    dead_acute = {'A':193,'E':201,'I':205,'O':211,'U':218,'a':225,'e':233,'i':237,\
+                  'o':243,'u':250}
+    dead_circumflex = {'A':194,'E':202,'I':206,'O':212,'U':219,'a':226,'e':234,\
+                       'i':238,'o':244,'u':251}
+    dead_tilde = {'A':195,'O':211,'N':209,'U':360,'a':227,'o':245,'n':241,'u':361}
+    dead_diaeresis = {'A':196,'E':203,'I':207,'O':211,'U':218,'a':228,'e':235,\
+                      'i':239,'o':245,'u':252}
+    dead_abovering = {'A':197,'a':229}
+
+    # Time out for triggering help
+    timeout_tag = [0]
+
+
     def __init__(self, win, path, lang, parent=None):
+        self._setup_initial_values(win, path, lang, parent)
+        prep_selectors(self) # i wonder where this method belongs
+        for s in selectors:
+            setup_selectors(self,s)
+        setup_misc(self)
+        self._select_category(self.selbuttons[0])
+
+
+    def _setup_initial_values(self, win, path, lang, parent):
         self.window = win
         self.path = os.path.join(path,'images')
         self.path_lang = os.path.join(path,'images',lang)
@@ -89,13 +96,13 @@ class TurtleArtWindow():
         self.load_save_folder = os.path.join(path,'samples')
         self.save_folder = None
         self.save_file_name = None
-        win.set_flags(gtk.CAN_FOCUS)
+        self.window.set_flags(gtk.CAN_FOCUS)
         self.width = gtk.gdk.screen_width()
         self.height = gtk.gdk.screen_height() 
 
         # starting from command line
         if parent is None:
-            win.show_all()
+            self.window.show_all()
         # starting from Sugar
         else:
             parent.show_all()
@@ -108,8 +115,7 @@ class TurtleArtWindow():
         self.area = self.window.window
         self.gc = self.area.new_gc()
         # on an OLPC-XO-1, there is a scaling factor
-        if os.path.exists('/etc/olpc-release') or \
-           os.path.exists('/sys/power/olpc-pm'):
+        if self._is_XO_1():
             self.lead = 1.6
             self.scale = 1.0
         else:
@@ -125,17 +131,12 @@ class TurtleArtWindow():
         self.sprites = []
         self.selected_block = None
         self.draggroup = None
-        prep_selectors(self)
         self.myblock = None
         self.nop = 'nop'
         self.loaded = 0
-        for s in selectors:
-            setup_selectors(self,s)
-        setup_misc(self)
         self.step_time = 0
         self.hide = False
         self.palette = True
-        self._select_category(self.selbuttons[0])
         self.coord_scale = 1
         self.turtle = tNew(self,self.width,self.height)
         self.lc = lcNew(self)
@@ -146,7 +147,6 @@ class TurtleArtWindow():
         self.polar = False
         self.spr = None # "currently selected spr"
 
-
     """
     DEPRECATED
     """
@@ -157,7 +157,7 @@ class TurtleArtWindow():
     eraser_button: hide status block
     """
     def eraser_button(self):
-        setlayer(self.status_spr,400)
+        self.status_spr.setlayer(400)
         clear(self.lc)
         display_coordinates(self)
 
@@ -167,7 +167,6 @@ class TurtleArtWindow():
     def stop_button(self):
         stop_logo(self)
 
-
     """
     change the icon for user-defined blocks after Python code is loaded
     """
@@ -178,19 +177,18 @@ class TurtleArtWindow():
                 setimage(spr,self.media_shapes['pythonloaded'])
         self.nop = 'pythonloaded'
 
-
     """
     hideshow button
     """
     def hideshow_button(self):
         if self.hide is False: 
-            for b in self._blocks(): setlayer(b,100)
+            for b in self._blocks(): b.setlayer(100)
             self._hide_palette() 
-            hide(self.select_mask)
-            hide(self.select_mask_string)
+            self.select_mask.hide()
+            self.select_mask_string.hide()
             self.hide = True
         else:
-            for b in self._blocks(): setlayer(b,650)
+            for b in self._blocks(): b.setlayer(650)
             self.show_palette()
             self.hide = False
         inval(self.turtle.canvas)
@@ -227,7 +225,7 @@ class TurtleArtWindow():
         if self.selected_block != None:
             self._unselect()
         else:
-            setlayer(self.status_spr,400)
+            self.status_spr.setlayer(400)
         spr = findsprite(self,(x,y))
         self.x, self.y = x,y
         self.dx = 0
@@ -246,7 +244,6 @@ class TurtleArtWindow():
             self._turtle_pressed(x,y)
         self.spr = spr
 
-
     """
     hideshow_palette 
     """
@@ -268,10 +265,12 @@ class TurtleArtWindow():
     show palette 
     """
     def show_palette(self):
-        for i in self.selbuttons: setlayer(i,800)
+        for i in self.selbuttons: i.setlayer(800)
         self._select_category(self.selbuttons[0])
         self.palette = True
 
+    def xy(self, event):
+        return map(int, event.get_coords())
 
     """
     unselect
@@ -294,30 +293,28 @@ class TurtleArtWindow():
             except ValueError:
                 pass
 
-        hide(self.select_mask)
-        hide(self.select_mask_string)
+        self.select_mask.hide()
+        self.select_mask_string.hide()
         self.selected_block = None
 
-
     """
     select category 
     """
     def _select_category(self, spr):
         if hasattr(self, 'current_category'):
-            setshape(self.current_category, self.current_category.offshape)
-        setshape(spr, spr.onshape)
+            self.current_category.setshape(self.current_category.offshape)
+        spr.setshape(spr.onshape)
         self.current_category = spr
-        setshape(self.category_spr,spr.group)
+        self.category_spr.setshape(spr.group)
 
     """
     hide palette 
     """
     def _hide_palette(self):
-        for i in self.selbuttons: hide(i)
-        setshape(self.category_spr, self.hidden_palette_icon)
+        for i in self.selbuttons: i.hide()
+        self.category_spr.setshape(self.hidden_palette_icon)
         self.palette = False
 
-
     """
     register the events we listen to 
     """
@@ -332,9 +329,11 @@ class TurtleArtWindow():
         self.window.connect("motion-notify-event", self._move_cb)
         self.window.connect("key_press_event", self._keypress_cb)
 
-    def xy(self, event):
-        return map(int, event.get_coords())
-
+    """
+    XO-1 ?
+    """
+    def _is_XO_1(self):
+        return os.path.exists('/etc/olpc-release') or os.path.exists('/sys/power/olpc-pm')
 
     """
     find a stack to run (any stack without a hat)
@@ -375,7 +374,6 @@ class TurtleArtWindow():
                 ret = True
         return ret
 
-
     """
     Mouse move
     """
@@ -414,7 +412,7 @@ class TurtleArtWindow():
                     dx += -(b.x+dx)
             # move the stack
             for b in self.draggroup:
-                move(b,(b.x+dx, b.y+dy))
+                b.move((b.x+dx, b.y+dy))
         elif spr.type=='turtle':
             type,dragx,dragy = self.dragpos
             if type == 'move':
@@ -422,7 +420,7 @@ class TurtleArtWindow():
                     dx,dy = mdx,mdy
                 else:
                     dx,dy = x-dragx-spr.x,y-dragy-spr.y
-                move(spr, (spr.x+dx, spr.y+dy))
+                spr.move((spr.x+dx, spr.y+dy))
             else:
                 if mdx != 0 or mdy != 0:
                     dx,dy = mdx,mdy
@@ -440,7 +438,7 @@ class TurtleArtWindow():
     """
     def _get_proto_from_category(self, x, y):
         dx, dy = x-self.category_spr.x, y-self.category_spr.y,
-        pixel = getpixel(self.current_category.mask,dx,dy)
+        pixel = self.current_category.getpixel(self.current_category.mask,dx,dy)
         index = ((pixel%256)>>3)-1
         if index==0:
             return 'hide'
@@ -457,46 +455,46 @@ class TurtleArtWindow():
         if spr and spr.type == 'category':
             proto = self._get_proto_from_category(x, y)
             if proto and proto!='hide':
-                if timeout_tag[0] == 0:
-                    timeout_tag[0] = self._do_show_popup(proto.name)
+                if self.timeout_tag[0] == 0:
+                    self.timeout_tag[0] = self._do_show_popup(proto.name)
                     self.spr = spr
                     return
             else:
-                if timeout_tag[0] > 0:
+                if self.timeout_tag[0] > 0:
                     try:
-                        gobject.source_remove(timeout_tag[0])
-                        timeout_tag[0] = 0
+                        gobject.source_remove(self.timeout_tag[0])
+                        self.timeout_tag[0] = 0
                     except:
-                        timeout_tag[0] = 0
+                        self.timeout_tag[0] = 0
         elif spr and spr.type == 'selbutton':
-            if timeout_tag[0] == 0:
-                timeout_tag[0] = self._do_show_popup(spr.name)
+            if self.timeout_tag[0] == 0:
+                self.timeout_tag[0] = self._do_show_popup(spr.name)
                 self.spr = spr
             else:
-                if timeout_tag[0] > 0:
+                if self.timeout_tag[0] > 0:
                     try:
-                        gobject.source_remove(timeout_tag[0])
-                        timeout_tag[0] = 0
+                        gobject.source_remove(self.timeout_tag[0])
+                        self.timeout_tag[0] = 0
                     except:
-                        timeout_tag[0] = 0
+                        self.timeout_tag[0] = 0
         elif spr and spr.type == 'block':
-            if timeout_tag[0] == 0:
-                timeout_tag[0] = self._do_show_popup(spr.proto.name)
+            if self.timeout_tag[0] == 0:
+                self.timeout_tag[0] = self._do_show_popup(spr.proto.name)
                 self.spr = spr
             else:
-                if timeout_tag[0] > 0:
+                if self.timeout_tag[0] > 0:
                     try:
-                        gobject.source_remove(timeout_tag[0])
-                        timeout_tag[0] = 0
+                        gobject.source_remove(self.timeout_tag[0])
+                        self.timeout_tag[0] = 0
                     except:
-                        timeout_tag[0] = 0
+                        self.timeout_tag[0] = 0
         else:
-            if timeout_tag[0] > 0:
+            if self.timeout_tag[0] > 0:
                 try:
-                    gobject.source_remove(timeout_tag[0])
-                    timeout_tag[0] = 0
+                    gobject.source_remove(self.timeout_tag[0])
+                    self.timeout_tag[0] = 0
                 except:
-                    timeout_tag[0] = 0
+                    self.timeout_tag[0] = 0
 
     """
     fetch the help text and display it 
@@ -517,7 +515,6 @@ class TurtleArtWindow():
             self.win.set_title(_("Turtle Art") + " — " + label)
         return 0
 
-
     """
     Keyboard
     """
@@ -613,7 +610,7 @@ class TurtleArtWindow():
                         elif keyname == 'KP_Page_Down':
                             if self.draggroup == None:
                                 self.draggroup = findgroup(self.spr)
-                            for b in self.draggroup: hide(b)
+                            for b in self.draggroup: b.hide()
                             self.draggroup = None
                     elif self.spr.type == 'selbutton':
                         if keyname == 'Return' or keyname == 'KP_Page_Up':
@@ -623,7 +620,7 @@ class TurtleArtWindow():
                             (x,y) = self.window.get_pointer()
                             self._block_selector_pressed(x, y)
                             for b in self.draggroup:
-                               move(b, (b.x+200, b.y))
+                               b.move((b.x+200, b.y))
                             self.draggroup = None
                 return True
         if self.selected_block is None:
@@ -654,17 +651,17 @@ class TurtleArtWindow():
         elif keyname is not '':
             # Hack until I sort out input and unicode + dead keys
             if self.dead_key == 'dead_grave':
-                keyunicode = dead_grave[keyname]
+                keyunicode = self.dead_grave[keyname]
             elif self.dead_key == 'dead_acute':
-                keyunicode = dead_acute[keyname]
+                keyunicode = self.dead_acute[keyname]
             elif self.dead_key == 'dead_circumflex':
-                keyunicode = dead_circumflex[keyname]
+                keyunicode = self.dead_circumflex[keyname]
             elif self.dead_key == 'dead_tilde':
-                keyunicode = dead_tilde[keyname]
+                keyunicode = self.dead_tilde[keyname]
             elif self.dead_key == 'dead_diaeresis':
-                keyunicode = dead_diaeresis[keyname]
+                keyunicode = self.dead_diaeresis[keyname]
             elif self.dead_key == 'dead_abovering':
-                keyunicode = dead_abovering[keyname]
+                keyunicode = self.dead_abovering[keyname]
             self.dead_key = ""
             if self.firstkey:
                 newnum = selblock.check(unichr(keyunicode), \
@@ -680,9 +677,6 @@ class TurtleArtWindow():
             self.firstkey = False
         return True
 
-
-
-
     """
     Button release
     """
@@ -717,33 +711,36 @@ class TurtleArtWindow():
             display_coordinates(self)
             self.draggroup = None
             return
-        if self.block_operation=='move' and hit(self.category_spr, (x,y)):
-            for b in self.draggroup: hide(b)
+        if self.block_operation=='move' and self.category_spr.hit((x,y)):
+            for b in self.draggroup: b.hide()
             self.draggroup = None
             return
         if self.block_operation=='new':
             for b in self.draggroup:
-                move(b, (b.x+200, b.y))
+                b.move((b.x+200, b.y))
         self._snap_to_dock()
-        for b in self.draggroup: setlayer(b,650)
+        for b in self.draggroup: b.setlayer(650)
         self.draggroup = None
         if self.block_operation=='click':
             if self.spr.proto.name=='number':
                 self.selected_block = spr
-                move(self.select_mask, (spr.x-5,spr.y-5))
-                setlayer(self.select_mask, 660)
+                self.select_mask.move((spr.x-5,spr.y-5))
+                self.select_mask.setlayer(660)
                 self.firstkey = True
             elif self.defdict.has_key(spr.proto.name):
                 self.selected_block = spr
                 if self.spr.proto.name=='string':
-                    move(self.select_mask_string, (spr.x-5,spr.y-5))
-                    setlayer(self.select_mask_string, 660)
+                    self.select_mask_string.move((spr.x-5,spr.y-5))
+                    self.select_mask_string.setlayer(660)
                     self.firstkey = True
-                elif self.spr.proto.name in importblocks:
+                elif self.spr.proto.name in self.importblocks:
                     self._import_from_journal(spr)
             elif self.spr.proto.name=='nop' and self.myblock==None:
                 self.activity.import_py()
-            else: self._run_stack(spr)
+            else:
+                # TODO: mark block as selected
+                spr.set_selected(True)
+                self._run_stack(spr)
 
     """
     click block
@@ -751,16 +748,16 @@ class TurtleArtWindow():
     def _click_block(self):
         if self.spr.proto.name=='number':
             self.selected_block = self.spr
-            move(self.select_mask, (self.spr.x-5,self.spr.y-5))
-            setlayer(self.select_mask, 660)
+            self.select_mask.move((self.spr.x-5,self.spr.y-5))
+            self.select_mask.setlayer(660)
             self.firstkey = True
         elif self.defdict.has_key(self.spr.proto.name):
             self.selected_block = self.spr
             if self.spr.proto.name=='string':
-                move(self.select_mask_string, (self.spr.x-5,self.spr.y-5))
-                setlayer(self.select_mask_string, 660)
+                self.select_mask_string.move((self.spr.x-5,self.spr.y-5))
+                self.select_mask_string.setlayer(660)
                 self.firstkey = True
-            elif self.spr.proto.name in importblocks:
+            elif self.spr.proto.name in self.importblocks:
                 self._import_from_journal(self.spr)
         elif self.spr.proto.name=='nop' and self.myblock==None:
             self.activity.import_py()
@@ -770,7 +767,6 @@ class TurtleArtWindow():
     Repaint
     """
     def _expose_cb(self, win, event):
-        # FIXME
         redrawsprites(self)
         return True
 
@@ -791,7 +787,6 @@ class TurtleArtWindow():
                 self.activity._send_event("p:"+str(x)+":"+str(y)+":"+'F')
         return True
 
-
     """
     snap_to_dock
     """
@@ -813,11 +808,11 @@ class TurtleArtWindow():
                     bestmydockn=mydockn
         if d<200:
             for b in self.draggroup:
-                move(b,(b.x+bestxy[0],b.y+bestxy[1]))
+                b.move((b.x+bestxy[0],b.y+bestxy[1]))
             blockindock=bestyou.connections[bestyourdockn]
             if blockindock!=None:
                 for b in findgroup(blockindock):
-                    hide(b)
+                    b.hide()
             bestyou.connections[bestyourdockn]=me
             me.connections[bestmydockn]=bestyou
 
@@ -875,19 +870,23 @@ class TurtleArtWindow():
         else:
             self.hideshow_palette(False)
 
-
     """
     new block from category
     """
     def _new_block_from_category(self, proto, x, y):
         if proto is None:
             return True
+
+        #
+        # Create new instance of the block
+        # 
+
         # load alternative image of nop block if python code is loaded
         if proto.name == 'nop' and self.nop == 'pythonloaded':
-            newspr = sprNew(self,x-20,y-20,self.media_shapes['pythonloaded'])
+            newspr = Sprite(self,x-20,y-20,self.media_shapes['pythonloaded'])
         else:
-            newspr = sprNew(self,x-20,y-20,proto.image)
-        setlayer(newspr,2000)
+            newspr = Sprite(self,x-20,y-20,proto.image)
+        newspr.setlayer(2000)
         self.dragpos = 20,20
         newspr.type = 'block'
         newspr.proto = proto
@@ -899,24 +898,25 @@ class TurtleArtWindow():
             argproto = self.protodict[self.valdict[dock[0]]]
             argdock = argproto.docks[0]
             nx,ny = newspr.x+dock[2]-argdock[2],newspr.y+dock[3]-argdock[3]
-            argspr = sprNew(self,nx,ny,argproto.image)
+            argspr = Sprite(self,nx,ny,argproto.image)
             argspr.type = 'block'
             argspr.proto = argproto
             argspr.label = str(proto.defaults[i])
-            setlayer(argspr,2000)
+            argspr.setlayer(2000)
             argspr.connections = [newspr,None]
             newspr.connections[i+1] = argspr
         self.draggroup = findgroup(newspr)
-        self.block_operation = 'new'
+        self.block_operation = 'new' 
 
 
     """
     block pressed
+    TODO: mark block as selected
     """
     def _block_pressed(self, mask, x, y, spr):
         if spr is not None:
             self.draggroup = findgroup(spr)
-            for b in self.draggroup: setlayer(b,2000)
+            for b in self.draggroup: b.setlayer(2000)
             if spr.connections[0] != None and spr.proto.name == 'lock':
                 b = self._find_top_block(spr)
                 self.dragpos = x-b.x,y-b.y
@@ -924,7 +924,6 @@ class TurtleArtWindow():
                 self.dragpos = x-spr.x,y-spr.y
                 self._disconnect(spr)
 
-
     """
     disconnect block
     """
@@ -959,7 +958,6 @@ class TurtleArtWindow():
         else:
             setimage(spr, self.media_shapes['texton'])
 
-
     """
     dock_dx_dy 
     """
@@ -1037,13 +1035,10 @@ class TurtleArtWindow():
                 dx += -(b.x+dx)
         # move the stack
         for b in self.draggroup:
-            move(b,(b.x+dx, b.y-dy))
+            b.move((b.x+dx, b.y-dy))
         self._snap_to_dock()
         self.draggroup = None
 
 
 
 
-
-
-