added selection mask

6 files changed, 124 insertions, 604 deletions

diff --git a/block.py b/block.py
index 02fcaf4..74b995c 100644
--- a/block.py
+++ b/block.py
@@ -75,6 +75,8 @@ class Block:
                  colors=["#00FF00","#00A000"], scale=2.0):
         self.blocks = blocks
         self.spr = None
+        self.shape = None
+        self.selected_shape = None
         self._new_block_from_prototype(proto_name, labels, colors, scale, x, y)
         self.blocks.append_to_list(self)
         #
@@ -102,66 +104,66 @@ class Block:
             svg.set_colors(NUMBER_COLORS)
         elif name in BLOCKS_PALETTE:
             svg.set_colors(BLOCKS_COLORS)
+        elif name in MISC_PALETTE:
+            svg.set_colors(MISC_COLORS)
+        elif name in FLOW_PALETTE:
+            svg.set_colors(FLOW_COLORS)
+        elif name in PORTFOLIO_PALETTE:
+            svg.set_colors(PORTFOLIO_COLORS)
         svg.set_scale(scale)
         svg.set_gradiant(True)
+        svg.set_innie([False])
+        svg.set_outie(False)
+        svg.set_tab(True)
+        svg.set_slot(True)
         if name in BASIC_STYLE:
             svg.expand(40,0)
-            svg.set_innie([False])
-            svg.set_outie(False)
-            svg.set_tab(True)
-            svg.set_slot(True)
-            self.spr = sprites.Sprite(self.blocks.sprites, x, y,
-                                      svg_str_to_pixbuf(svg.basic_block()))
+            self._make_basic_block(svg, x, y)
+            self.docks = (('flow',True,37,5),('flow',False,37,44))
             print "created new basic block: %s" % (str(self.spr))
         elif name in BASIC_STYLE_HEAD:
             svg.expand(40,0)
-            svg.set_innie([False])
-            svg.set_outie(False)
-            svg.set_tab(True)
             svg.set_slot(False)
-            self.spr = sprites.Sprite(self.blocks.sprites, x, y,
-                                      svg_str_to_pixbuf(svg.basic_block()))
+            self._make_basic_block(svg, x, y)
+            self.docks = (('start',True,50,0), ('flow',False,49,55))
+            print "created new basic block head: %s" % (str(self.spr))
+        elif name in BASIC_STYLE_HEAD_1ARG:
+            svg.expand(40,0)
+            svg.set_slot(False)
+            self._make_basic_block(svg, x, y)
+            self.docks = (('start',True,50,0), ('string',False,21,38),
+                          ('flow',False,75,75))
             print "created new basic block head: %s" % (str(self.spr))
         elif name in BASIC_STYLE_TAIL:
             svg.expand(40,0)
-            svg.set_innie([False])
-            svg.set_outie(False)
             svg.set_tab(False)
-            svg.set_slot(True)
-            self.spr = sprites.Sprite(self.blocks.sprites, x, y,
-                                      svg_str_to_pixbuf(svg.basic_block()))
+            self._make_basic_block(svg, x, y)
+            self.docks = (('flow',True,37,5),('unavailable',False,0,0))
             print "created new basic block tail: %s" % (str(self.spr))
         elif name in BASIC_STYLE_1ARG:
             svg.expand(20,0)
             svg.set_innie([True])
-            svg.set_outie(False)
-            svg.set_tab(True)
-            svg.set_slot(True)
-            self.spr = sprites.Sprite(self.blocks.sprites, x, y,
-                                      svg_str_to_pixbuf(svg.basic_block()))
+            self._make_basic_block(svg, x, y)
+            self.docks = (('flow',True,37,5), ('num',False,74,21),
+                          ('flow',False,37,44))
             print "created new basic block 1 arg: %s" % (str(self.spr))
         elif name in BASIC_STYLE_2ARG:
             svg.expand(20,0)
             svg.set_innie([True,True])
-            svg.set_outie(False)
-            svg.set_tab(True)
-            svg.set_slot(True)
-            self.spr = sprites.Sprite(self.blocks.sprites, x, y,
-                                      svg_str_to_pixbuf(svg.basic_block()))
+            self._make_basic_block(svg, x, y)
+            self.docks = (('flow',True,37,5), ('num',False,74,21),
+                          ('num',False,74,58), ('flow',False,37,81))
             print "created new basic block 2 args: %s" % (str(self.spr))
         elif name in BOX_STYLE:
             svg.expand(50,0)
-            self.spr = sprites.Sprite(self.blocks.sprites, x, y,
-                                      svg_str_to_pixbuf(svg.basic_box()))
+            self._make_basic_box(svg, x, y)
+            self.docks = (('num',True,0,12),('numend',False,105,12))
             print "created new box block: %s" % (str(self.spr))
         else:
-            svg.expand(50,0)
-            self.spr = sprites.Sprite(self.blocks.sprites, x, y,
-                                      svg_str_to_pixbuf(svg.basic_box()))
+            svg.expand(40,0)
+            self._make_basic_block(svg, x, y)
             print "don't know how to create a block for %s" % (name)
 
-            return
-
         if len(labels) > 0:
             self.spr.set_label(labels[0])
             for label in labels:
@@ -169,6 +171,20 @@ class Block:
 
         self.type = 'block'
 
+    def _make_basic_block(self, svg, x, y):
+        self.shape = svg_str_to_pixbuf(svg.basic_block())
+        svg.set_stroke_width(SELECTED_STROKE_WIDTH)
+        svg.set_stroke_color(SELECTED_COLOR)
+        self.selected_shape = svg_str_to_pixbuf(svg.basic_block())
+        self.spr = sprites.Sprite(self.blocks.sprites, x, y, self.shape)
+
+    def _make_basic_box(self, svg, x, y):
+        self.shape = svg_str_to_pixbuf(svg.basic_box())
+        svg.set_stroke_width(SELECTED_STROKE_WIDTH)
+        svg.set_stroke_color(SELECTED_COLOR)
+        self.selected_shape = svg_str_to_pixbuf(svg.basic_box())
+        self.spr = sprites.Sprite(self.blocks.sprites, x, y, self.shape)
+
 class Turtle:
     def __init__(self, blocks, orientation=0, scale=1.0):
         self.blocks = blocks
diff --git a/block_factory.py b/block_factory.py
deleted file mode 100755
index 061d624..0000000
--- a/block_factory.py
+++ /dev/null
@@ -1,542 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#Copyright (c) 2009,10 Walter Bender
-
-#Permission is hereby granted, free of charge, to any person obtaining a copy
-#of this software and associated documentation files (the "Software"), to deal
-#in the Software without restriction, including without limitation the rights
-#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-#copies of the Software, and to permit persons to whom the Software is
-#furnished to do so, subject to the following conditions:
-
-#The above copyright notice and this permission notice shall be included in
-#all copies or substantial portions of the Software.
-
-#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-#THE SOFTWARE.
-
-import os
-from gettext import gettext as _
-
-class SVG:
-    def __init__(self):
-        self._x = 0
-        self._y = 0
-        self._min_x = 0
-        self._min_y = 0
-        self._max_x = 0
-        self._max_y = 0
-        self._width = 0
-        self._height = 0
-        self._scale = 1
-        self._radius = 8
-        self._stroke_width = 1
-        self._innie = [False]
-        self._outie = False
-        self._innie_x1 = 4
-        self._innie_y1 = 3
-        self._innie_x2 = 4
-        self._innie_y2 = 4
-        self._innie_spacer = 9
-        self._slot = True
-        self._tab = True
-        self._bool = False
-        self._slot_x = 12
-        self._slot_y = 2
-        self._porch = False
-        self._porch_x = self._innie_x1+self._innie_x2+4*self._stroke_width
-        self._porch_y = self._innie_y1+self._innie_y2+4*self._stroke_width
-        self._expand_x = 0
-        self._expand_y = 0
-        self._fill = "#00FF00"
-        self._stroke = "#00A000"
-        self._gradiant = False
-
-    def basic_block(self):
-        (x, y) = self._calculate_x_y()
-        svg = self._new_path(x, y)
-        svg += self._rarc_to(1, -1)
-        svg += self._do_slot()
-        svg += self._rline_to(self._expand_x, 0)
-        xx = self._x
-        svg += self._rarc_to(1, 1)
-        for i in range(len(self._innie)):
-            if self._innie[i] is True:
-                svg += self._do_innie()
-            if i==0 and self._porch is True:
-                svg += self._do_porch()
-            elif len(self._innie)-1 > i:
-                svg += self._rline_to(0, 2*self._innie_y2+self._innie_spacer)
-        svg += self._rline_to(0, self._expand_y)
-        svg += self._rarc_to(-1, 1)
-        svg += self._line_to(xx, self._y)
-        svg += self._rline_to(-self._expand_x, 0)
-        svg += self._do_tab()
-        svg += self._rarc_to(-1, -1)
-        svg += self._rline_to(0, -self._expand_y)
-        if True in self._innie:
-            svg += self._line_to(x,
-                                 self._radius+self._innie_y2+self._stroke_width)
-            svg += self._do_outie()
-        svg += self._close_path()
-        self._calculate_w_h()
-        svg += self._style()
-        svg += self._footer()
-        return self._header() + svg
-
-    def basic_flow(self):
-        (x, y) = self._calculate_x_y()
-        svg = self._new_path(x, y)
-        svg += self._rarc_to(1, -1)
-        svg += self._do_slot()
-        svg += self._rline_to(self._expand_x, 0)
-        xx = self._x
-        svg += self._rarc_to(1, 1)
-        for i in range(len(self._innie)):
-            if self._innie[i] is True:
-                svg += self._do_innie()
-                svg += self._rline_to(0, 2*self._innie_y2+self._innie_spacer)
-        if self._bool is True:
-            svg += self._rline_to(0,self._radius/2.0)
-            svg += self._do_boolean()
-            svg += self._rline_to(0,self._radius/2.0)
-        svg += self._rline_to(self._radius+self._slot_x, 0)
-        svg += self._rarc_to(1,1)
-        svg += self._rline_to(-self._radius,0)
-        svg += self._do_tab()
-        svg += self._rline_to(-self._radius, 0)
-        svg += self._rline_to(0, self._expand_y)
-        svg += self._rarc_to(-1, 1)
-        svg += self._line_to(xx, self._y)
-        svg += self._rline_to(-self._expand_x, 0)
-        svg += self._do_tab()
-        svg += self._rarc_to(-1, -1)
-        svg += self._rline_to(0, -self._expand_y)
-        if True in self._innie:
-            svg += self._line_to(x,
-                                 self._radius+self._innie_y2+self._stroke_width)
-            svg += self._do_outie()
-        svg += self._close_path()
-        self._calculate_w_h()
-        svg += self._style()
-        svg += self._footer()
-        return self._header() + svg
-
-    def basic_box(self):
-        self.set_outie(True)
-        x = self._stroke_width/2.0+self._innie_x1+self._innie_x2
-        svg = self._new_path(x, self._stroke_width/2.0)
-        svg += self._rline_to(self._expand_x, 0)
-        svg += self._rline_to(0, 2*self._radius+self._innie_y2+self._expand_y)
-        svg += self._rline_to(-self._expand_x, 0)
-        svg += self._line_to(x, self._radius+self._innie_y2+\
-                                self._stroke_width/2.0)
-        svg += self._do_outie()
-        svg += self._close_path()
-        self._calculate_w_h()
-        svg += self._style()
-        svg += self._footer()
-        return self._header() + svg
-
-    def boolean_and_or(self):
-        svg = self._start_boolean(self._stroke_width/2.0,
-                                  self._radius*5.5+self._stroke_width/2.0+\
-                                  self._innie_y2+self._innie_spacer)
-        svg += self._rline_to(0,-self._radius*3.5-self._innie_y2-\
-                             self._innie_spacer-self._stroke_width)
-        svg += self._rarc_to(1, -1)
-        svg += self._rline_to(self._radius/2.0+self._expand_x, 0)
-        svg += self._rline_to(0,self._radius/2.0)
-        svg += self._do_boolean()
-        svg += self._rline_to(0,self._radius*1.5+self._innie_y2+\
-                                self._innie_spacer)
-        svg += self._do_boolean()
-        svg += self._rline_to(0,self._radius/2.0)
-        svg += self._end_boolean()
-        return self._header() + svg
-
-    def boolean_not(self):
-        svg = self._start_boolean(self._stroke_width/2.0,
-                                  self._radius*2.0+self._stroke_width/2.0)
-        svg += self._rline_to(0,-self._stroke_width)
-        svg += self._rarc_to(1, -1)
-        svg += self._rline_to(self._radius/2.0+self._expand_x, 0)
-        svg += self._rline_to(0,self._radius/2.0)
-        svg += self._do_boolean()
-        svg += self._rline_to(0,self._radius/2.0)
-        svg += self._end_boolean()
-        return self._header() + svg
-
-    def boolean_compare(self):
-        yoffset = self._radius*2+2*self._innie_y2+\
-                  self._innie_spacer+self._stroke_width/2.0
-        if self._porch is True:
-            yoffset += self._porch_y
-        svg = self._start_boolean(self._stroke_width/2.0, yoffset)
-        yoffset = -2*self._innie_y2-self._innie_spacer-self._stroke_width
-        if self._porch is True:
-            yoffset -= self._porch_y
-        svg += self._rline_to(0, yoffset)
-        svg += self._rarc_to(1, -1)
-        svg += self._rline_to(self._radius/2.0+self._expand_x, 0)
-        svg += self._rline_to(0,self._radius)
-        xx = self._x
-        svg += self._do_innie()
-        if self._porch is True:
-           svg += self._do_porch()
-        else:
-           svg += self._rline_to(0, 2*self._innie_y2+self._innie_spacer)
-        svg += self._do_innie()
-        svg += self._rline_to(0, self._radius)
-        svg += self._line_to(xx, self._y)
-        svg += self._end_boolean()
-        return self._header() + svg
-
-    #
-    # Utility methods
-    #
-
-    def set_scale(self, scale=1):
-        self._scale = scale
-
-    def expand(self, w=0, h=0):
-        self._expand_x = w
-        self._expand_y = h
-
-    def set_stroke_width(self, stroke_width=1.5):
-        self._stroke_width = stroke_width
-        self._calc_porch_params()
-
-    def set_colors(self, colors=["#00FF00","#00A000"]):
-        self._fill = colors[0]
-        self._stroke = colors[1]
-
-    def set_gradiant(self, flag=False):
-        self._gradiant = flag
-
-    def set_innie(self, innie_array=[False]):
-        self._innie = innie_array
-
-    def set_outie(self, flag=False):
-        self._outie = flag
-
-    def set_slot(self, flag=True):
-        self._slot = flag
-
-    def set_tab(self, flag=True):
-        self._tab = flag
-
-    def set_porch(self, flag=False):
-        self._porch = flag
-
-    def set_boolean(self, flag=False):
-        self._bool = flag
-
-    #
-    # Exotic methods
-    #
-
-    def set_radius(self, radius=8):
-        self._radius = radius
-
-    def set_innie_params(self, x1=4, y1=3, x2=4, y2=4):
-        self._innie_x1 = x1
-        self._innie_y1 = y1
-        self._innie_x2 = x2
-        self._innie_y2 = y2
-        self._calc_porch_params()
-
-    def set_innie_spacer(self, innie_spacer = 0):
-        self._innie_spacer = innie_spacer
-
-    def set_slot_params(self, x=12, y=4):
-        self._slot_x = x
-        self._slot_y = y
-
-    def _calc_porch_params(self):
-        self._porch_x = self._innie_x1+self._innie_x2+4*self._stroke_width
-        self._porch_y = self._innie_y1+self._innie_y2+4*self._stroke_width
-
-    #
-    # SVG helper methods
-    #
-
-    def _header(self):
-        return "%s%s%s%s%s%s%s%s%.1f%s%s%.1f%s%s%s" % (
-            "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
-            "<!-- Created with Python -->\n",
-            "<svg\n",
-            "   xmlns:svg=\"http://www.w3.org/2000/svg\"\n",
-            "   xmlns=\"http://www.w3.org/2000/svg\"\n",
-            "   xmlns:xlink=\"http://www.w3.org/1999/xlink\"",
-            "   version=\"1.1\"\n",
-            "   width=\"", self._width, "\"\n",
-            "   height=\"", self._height, "\">\n",
-            self._defs(),
-            self._transform())
-
-    def _defs(self):
-        if self._gradiant is True:
-            return "%s%s%s%s%s%s%s%s%s%s%s%s%.1f%s%s%.1f%s%s%.1f%s%s" % (
-        "  <defs>\n    <linearGradient\n       id=\"linearGradient1234\">\n",
-        "      <stop\n         style=\"stop-color:#ffffff;stop-opacity:1;\"\n",
-        "         offset=\"0\" />\n",
-        "      <stop\n         style=\"stop-color:", self._fill,
-        ";stop-opacity:1;\"\n",
-        "         offset=\"1\" />\n",
-        "    </linearGradient>\n",
-        "    <linearGradient\n       xlink:href=\"#linearGradient1234\"\n",
-        "       id=\"linearGradient5678\"\n",
-        "       x1=\"0\"\n",
-        "       y1=\"", self._height/2.0, "\"\n",
-        "       x2=\"", self._width, "\"\n",
-        "       y2=\"", self._height/2.0, "\"\n",
-        "       gradientUnits=\"userSpaceOnUse\" />\n  </defs>\n")
-        else:
-            return ""
-
-    def _transform(self):
-        return "%s%.1f%s%.1f%s" % (
-        "<g\n       transform=\"scale(",self._scale,",",self._scale,")\">\n")
-
-    def _footer(self):
-        return "   </g>\n</svg>\n"
-
-    def _style(self):
-        if self._gradiant is True:
-            fill = "url(#linearGradient5678)"
-        else:
-            fill = self._fill
-        return "%s%s;%s%s;%s%.1f;%s%s" % (
-               "       style=\"fill:",fill,
-               "fill-opacity:1;stroke:",self._stroke,
-               "stroke-width:",self._stroke_width,
-               "stroke-linecap:square;",
-               "stroke-opacity:1;\" />\n")
-
-    def _check_min_max(self):
-        if self._x < self._min_x:
-            self._min_x = self._x
-        if self._y < self._min_y:
-            self._min_y = self._y
-        if self._x > self._max_x:
-            self._max_x = self._x
-        if self._y > self._max_y:
-            self._max_y = self._y
-
-    def _line_to(self, x, y):
-        if self._x == x and self._y == y:
-            return ""
-        else:
-            self._x = x
-            self._y = y
-            self._check_min_max()
-            return "L %.1f %.1f " % (x, y) 
-
-    def _rline_to(self, dx, dy):
-        if dx == 0 and dy == 0:
-            return ""
-        else:
-            return self._line_to(self._x+dx, self._y+dy)
-
-    def _arc_to(self, x, y, a=90, l=0, s=1):
-        if self._radius == 0:
-            return self._line_to(x, y)
-        else:
-            self._x = x
-            self._y = y
-            self._check_min_max()
-            return "A %.1f %.1f %.1f %d %d %.1f %.1f " % (
-                self._radius, self._radius, a, l, s, x, y)
-
-    def _rarc_to(self, sign_x, sign_y, a=90, l=0, s=1):
-        if self._radius == 0:
-            return ""
-        else:
-            x = self._x + sign_x*self._radius
-            y = self._y + sign_y*self._radius
-            return self._arc_to(x, y, a, l, s)
-
-    def _new_path(self, x, y):
-        self._min_x = x
-        self._min_y = y
-        self._max_x = x
-        self._max_y = y
-        self._x = x
-        self._y = y
-        return "      <path d=\"m%.1f %.1f " % (x, y)
-
-    def _close_path(self):
-        return "z\"\n"
-
-    def _do_slot(self):
-        if self._slot is True:
-            return "%s%s%s" % (
-                self._rline_to(0, self._slot_y),
-                self._rline_to(self._slot_x, 0),
-                self._rline_to(0, -self._slot_y))
-        else:
-            return self._rline_to(self._slot_x, 0)
-
-    def _do_tab(self):
-        if self._tab is True:
-            return "%s%s%s%s%s" % (
-                self._rline_to(-self._stroke_width, 0),
-                self._rline_to(0, self._slot_y),
-                self._rline_to(-self._slot_x+2*self._stroke_width, 0),
-                self._rline_to(0, -self._slot_y),
-                self._rline_to(-self._stroke_width, 0))
-        else:
-            return self._rline_to(-self._slot_x, 0)
-
-    def _do_innie(self):
-        return "%s%s%s%s%s%s%s" % (
-            self._rline_to(-self._innie_x1, 0),
-            self._rline_to(0, -self._innie_y1),
-            self._rline_to(-self._innie_x2, 0),
-            self._rline_to(0, self._innie_y2+2*self._innie_y1),
-            self._rline_to(self._innie_x2, 0),
-            self._rline_to(0, -self._innie_y1),          
-            self._rline_to(self._innie_x1, 0))
-
-    def _do_outie(self):
-        if self._outie is not True:
-            return self._rline_to(0, -self._innie_y2)
-        return "%s%s%s%s%s%s%s%s%s" % (
-            self._rline_to(0, -self._stroke_width),
-            self._rline_to(-self._innie_x1-2*self._stroke_width, 0),
-            self._rline_to(0, self._innie_y1),
-            self._rline_to(-self._innie_x2+2*self._stroke_width, 0),
-            self._rline_to(0,
-                -self._innie_y2-2*self._innie_y1+2*self._stroke_width),
-            self._rline_to(self._innie_x2-2*self._stroke_width, 0),
-            self._rline_to(0, self._innie_y1),
-            self._rline_to(self._innie_x1+2*self._stroke_width, 0),
-            self._rline_to(0, -self._stroke_width))
-
-    def _do_porch(self):
-         return "%s%s%s" % (
-            self._rline_to(0, self._porch_y),
-            self._rline_to(self._porch_x-self._radius, 0),
-            self._rarc_to(1, 1))
-
-    def _start_boolean(self, xoffset, yoffset):
-        svg = self._new_path(xoffset, yoffset)
-        self._radius -= self._stroke_width
-        svg += self._rarc_to(1, -1)
-        self._radius += self._stroke_width
-        return svg + self._rline_to(self._stroke_width, 0)
-
-    def _do_boolean(self):
-        return self._rarc_to(-1, 1, 90, 0, 0) + self._rarc_to(1, 1, 90, 0, 0)
-
-    def _end_boolean(self):
-        svg = self._rline_to(-self._radius*1.5,0)
-        svg += self._rline_to(0, -self._stroke_width)
-        svg += self._rline_to(-self._stroke_width, 0)
-        self._radius -= self._stroke_width
-        svg += self._rarc_to(-1, -1)
-        self._radius += self._stroke_width
-        svg += self._close_path()
-        self._calculate_w_h()
-        svg += self._style()
-        return svg + self._footer()
-
-    def _calculate_w_h(self):
-        self._width = (self._max_x-self._min_x+self._stroke_width)*\
-                      self._scale
-        self._height = (self._max_y-self._min_y+self._stroke_width)*\
-                      self._scale
-
-    def _calculate_x_y(self):
-        if self._outie is True:
-            return(self._stroke_width/2.0+self._innie_x1+self._innie_x2,
-                   self._radius+self._stroke_width/2.0)
-        else:
-            return(self._stroke_width/2.0, self._radius+self._stroke_width/2.0)
-
-#
-# Command-line tools for testing
-#
-
-def open_file(datapath, filename):
-    return file(os.path.join(datapath, filename), "w")
-
-def close_file(f):
-    f.close()
-
-def generator(datapath):
-    svg0 = SVG()
-    f = open_file(datapath, "flow-test.svg")
-    svg0.set_scale(1)
-    svg0.expand(20,0)
-    # svg0.set_innie([True])
-    svg0.set_boolean(True)
-    svg0.set_tab(True)
-    svg0.set_gradiant(True)
-    svg_str = svg0.basic_flow()
-    f.write(svg_str)
-    close_file(f)
-
-    svg1 = SVG()
-    f = open_file(datapath, "blob-test.svg")
-    svg1.set_scale(1)
-    svg1.expand(20,0)
-    svg1.set_innie([True,True])
-    svg1.set_tab(False)
-    svg1.set_gradiant(True)
-    svg_str = svg1.basic_block()
-    f.write(svg_str)
-    close_file(f)
-
-    svg2 = SVG()
-    f = open_file(datapath, "box-test.svg")
-    svg2.set_scale(1)
-    svg2.expand(40,0)
-    svg2.set_colors(["#FFA000","#A08000"])
-    svg2.set_gradiant(True)
-    svg_str = svg2.basic_box()
-    f.write(svg_str)
-    close_file(f)
-
-    svg3 = SVG()
-    f = open_file(datapath, "compare-text.svg")
-    svg3.set_scale(1)
-    svg3.set_colors(["#0000FF","#0000A0"])
-    svg3.set_gradiant(True)
-    # svg3.set_porch(True)
-    svg_str = svg3.boolean_compare()
-    f.write(svg_str)
-    close_file(f)
-
-    svg4 = SVG()
-    f = open_file(datapath, "and-or-test.svg")
-    svg4.set_scale(1)
-    svg4.set_colors(["#00FFFF","#00A0A0"])
-    svg4.set_gradiant(True)
-    svg_str = svg4.boolean_and_or()
-    f.write(svg_str)
-    close_file(f)
-
-    svg5 = SVG()
-    f = open_file(datapath, "nor-test.svg")
-    svg5.set_scale(1)
-    svg5.set_colors(["#FF00FF","#A000A0"])
-    svg5.set_gradiant(True)
-    svg_str = svg5.boolean_not()
-    f.write(svg_str)
-    close_file(f)
-
-def main():
-    return 0
-
-if __name__ == "__main__":
-    generator(os.path.abspath('.'))
-    main()
-
-
diff --git a/constants.py b/constants.py
index 41e11dd..8877a78 100644
--- a/constants.py
+++ b/constants.py
@@ -13,26 +13,33 @@
 
 from gettext import gettext as _
 
+#
 # sprite layers
-CANVAS_LAYER = 600
-TURTLE_LAYER = 630
+#
+
+CANVAS_LAYER = 500
+TURTLE_LAYER = 550
 HIDE_LAYER = 100
-OVERLAY_LAYER = 615
-STATUS_LAYER = 710
-TOP_LAYER = 2000
-BLOCK_LAYER = 650
-CATEGORY_LAYER = 660
-TAB_LAYER = 670
+OVERLAY_LAYER = 525
+STATUS_LAYER = 900
+TOP_LAYER = 1000
+BLOCK_LAYER = 600
+CATEGORY_LAYER = 700
+TAB_LAYER = 710
+
+#
+# block definitions
+#
 
-# block to proto tables
 BASIC_STYLE_HEAD = ['start', 'action 1', 'action 2']
+BASIC_STYLE_HEAD_1ARG = []
 BASIC_STYLE_TAIL = ['stop action']
 BASIC_STYLE = ['clean', 'pen up', 'pen down', 'action 1', 'action 2', 'nop' ]
 BASIC_STYLE_1ARG = ['forward', 'back', 'left', 'right', 'seth', 'show',\
     'set scale', 'set pen size', 'set color', 'set shade'\
     'set text size', 'set text color', 'print', 'wait', 'store in box 1',\
     'store in box 2']
-BASIC_STYLE_2ARG = ['arc', 'setxy', 'fill screen']
+BASIC_STYLE_2ARG = ['arc', 'set xy', 'fill screen']
 BOX_STYLE = ['number', 'xcor', 'ycor', 'heading', 'pen size', 'color', 'shade'\
     'text color', 'text size', 'box 1', 'box 2', 'string']
 
@@ -41,13 +48,34 @@ TURTLE_PALETTE = ['clean', 'forward', 'back', 'left', 'right', 'seth', 'show',\
 PEN_PALETTE = ['pen up','pen down']
 NUMBER_PALETTE = ['number']
 BLOCKS_PALETTE = ['start', 'string']
+FLOW_PALETTE = []
+MISC_PALETTE = []
+PORTFOLIO_PALETTE = []
 
 TURTLE_COLORS = ["#00FF00","#00A000"]
 PEN_COLORS = ["#00FFFF","#00A0A0"]
 NUMBER_COLORS = ["#FF00FF","#A000A0"]
 BLOCKS_COLORS = ["#FFFF00","#A0A000"]
+FLOW_COLORS = ["#FFC000","#A08000"]
+MISC_COLORS = ["#FF0000","#A0000"]
+PORTFOLIO_COLORS = ["#0000FF","#0000FF"]
+
+SELECTED_COLOR = "#0000FF"
+SELECTED_STROKE_WIDTH = 2.0
 
+#
+# default values
+#
+
+DEFAULTS = {'forward':100, 'back':100, 'left':90, 'set xy':(0,0), 
+            'arc':(90,100), 'seth':0, 'set scale':33, 'show':_('text'),
+            'set pen size':5, 'set text size':32, 'set color':0,
+            'set shade':50, 'fill screen':(60,80), 'number':100,
+            'random':(0,100), 'wait':1, 'repeat':4, 'store in':(_('box'),100)}
+#
 # 'dead key' Unicode dictionaries
+#
+
 DEAD_KEYS = ['grave','acute','circumflex','tilde','diaeresis','abovering']
 DEAD_DICTS = [{'A':192,'E':200,'I':204,'O':210,'U':217,'a':224,'e':232,'i':236,\
                'o':242,'u':249},
diff --git a/sprite_factory.py b/sprite_factory.py
index e56ff09..8f58d92 100755
--- a/sprite_factory.py
+++ b/sprite_factory.py
@@ -257,6 +257,12 @@ class SVG:
         self._fill = colors[0]
         self._stroke = colors[1]
 
+    def set_fill_color(self, color="#00FF00"):
+        self._fill = color
+
+    def set_stroke_color(self, color="#00A000"):
+        self._stroke = color
+
     def set_gradiant(self, flag=False):
         self._gradiant = flag
 
diff --git a/tasetup.py b/tasetup.py
index 7fd22cd..920abe3 100644
--- a/tasetup.py
+++ b/tasetup.py
@@ -55,7 +55,7 @@ selectors = (
      ('left','left','onearg',90),
      ('right','right','onearg',90),
      ('arc','arc','twoargs',90,100),
-     ('setxy','setxy','twoargs',0,0),
+     ('set xy','setxy','twoargs',0,0),
      ('seth','seth','onearg',0),
      ('show','show','onesarg',_('text')),
      ('set scale','setscale','onearg',33),
@@ -77,7 +77,7 @@ selectors = (
      ('set shade','setshade','1arg',50),
      ('fill screen','fillscreen','twoargs',60,80),
      ('pen size','pensize','num'),
-     ('text_size','textsize','num'),
+     ('text size','textsize','num'),
      ('color','color','num'),
      ('shade','shade','num'),
      ('red','red','num'),
@@ -119,7 +119,7 @@ selectors = (
      ('forever','forever','forever'),
      ('repeat','repeat','repeat',4),
      ('if','if','if'),
-     ('stop_stack','stopstack','stop'),
+     ('stop stack','stopstack','stop'),
      ('if else','ifelse','ifelse'),
      ('hspace','nop','hspace'),
      ('vspace','nop','vspace'),
@@ -133,9 +133,9 @@ selectors = (
      ('stack2','stack2','noarg'),
      ('hat','nop3','starts',_('action')),
      ('stack','stack','sarg',_('action')),
-     ('storeinbox1','storeinbox1','1arg'),
+     ('store in box 1','storeinbox1','1arg'),
      ('box 1','box1','num'),
-     ('storeinbox2','storeinbox2','1arg'),
+     ('store in box 2','storeinbox2','1arg'),
      ('box 2','box2','num'),
      ('store in','storeinbox','1varg',_('box'),100),
      ('box','box','nfuncs',_('box')),
@@ -146,20 +146,20 @@ selectors = (
     (('kbinput','kbinput','noarg2'),
      ('keyboard','keyboard','num'),
      ('nop','userdefined','onearg',100),
-     ('myfunc','myfunc','myfunc',_('x'),100),
+     ('my func','myfunc','myfunc',_('x'),100),
      ('push','push','onearg'),
      ('pop','pop','num'),
-     ('printheap','heap','noarg2'),
-     ('clearheap','emptyheap','noarg2'),
-     ('leftpos','leftpos','num'),
-     ('toppos','toppos','num'),
-     ('rightpos','rightpos','num'),
-     ('bottompos','bottompos','num'),
+     ('print heap','heap','noarg2'),
+     ('clear heap','emptyheap','noarg2'),
+     ('left pos','leftpos','num'),
+     ('top pos','toppos','num'),
+     ('right pos','rightpos','num'),
+     ('bottom pos','bottompos','num'),
      ('hres','hres','num'),
      ('vres','vres','num'))),
   ('templates',55,
     (('journal','','media','','',''),
-     ('audiooff','','audio','','',''),
+     ('audio off','','audio','','',''),
      ('descriptionoff','','text','','',''),
      ('template1','tp1','tp1',_('title'),'None'),
      ('template6','tp6','tp6',_('title'),'None','None'),
@@ -167,7 +167,7 @@ selectors = (
      ('template7','tp7','tp7',_('title'),'None','None','None','None'),
      ('template3','tp3','tp3',_('title'),'','','','','','',''),
      ('template4','tp8','tp1',_('title'),'None'),
-     ('hideblocks','hideblocks','noarg2'),
+     ('hide blocks','hideblocks','noarg2'),
      # not selectable, but here for backward compatability
      ('sound','sound','sound','None'))))
 
diff --git a/tawindow.py b/tawindow.py
index 53aa435..4d47560 100644
--- a/tawindow.py
+++ b/tawindow.py
@@ -292,6 +292,8 @@ class TurtleArtWindow():
 
         self.select_mask.hide()
         self.select_mask_string.hide()
+        self.selected_block.set_shape(
+                      self.blocks.spr_to_block(self.selected_block).shape)
         self.selected_block = None
 
     """
@@ -712,21 +714,31 @@ class TurtleArtWindow():
         if self.block_operation=='click':
             if self.spr.proto.name=='number':
                 self.selected_block = spr
-                self.select_mask.move((spr.x-5,spr.y-5))
-                self.select_mask.set_layer(MASK_LAYER)
+                self.selected_block.set_shape(
+                    self.blocks.spr_to_block(
+                        self.selected_block).selected_shape)
+                # self.select_mask.move((spr.x-5,spr.y-5))
+                # self.select_mask.set_layer(MASK_LAYER)
                 self.firstkey = True
             elif self.defdict.has_key(spr.proto.name):
                 self.selected_block = spr
                 if self.spr.proto.name=='string':
-                    self.select_mask_string.move((spr.x-5,spr.y-5))
-                    self.select_mask_string.set_layer(MASK_LAYER)
+                    self.selected_block.set_shape(
+                        self.blocks.spr_to_block(
+                            self.selected_block).selected_shape)
+                    # self.select_mask_string.move((spr.x-5,spr.y-5))
+                    # self.select_mask_string.set_layer(MASK_LAYER)
                     self.firstkey = True
                 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:
-                # TODO: mark block as selected
+                # mark block as selected
+                self.selected_block = spr
+                self.selected_block.set_shape(
+                        self.blocks.spr_to_block(
+                            self.selected_block).selected_shape)
                 spr.set_selected(True)
                 self._run_stack(spr)