toolbar palettes mostly complete

4 files changed, 105 insertions, 41 deletions

diff --git a/block.py b/block.py
index a6737bd..9b0feb4 100644
--- a/block.py
+++ b/block.py
@@ -294,8 +294,7 @@ class Block:
         self.svg.set_slot(False)
         self._make_basic_block(svg)
         """
-        NOTE:
-        The "outie" is added last, so the dock order in the NUMBER_STYLE
+        NOTE: The "outie" is added last, so the dock order in the NUMBER_STYLE
         needs to be modified.
         """
         self.docks = (('number', True, self.svg.docks[2][0],
@@ -304,7 +303,8 @@ class Block:
                                         self.svg.docks[0][1]),
                       ('number', False, self.svg.docks[1][0],
                                         self.svg.docks[1][1])) 
-        self._left, self._right = self.svg.docks[2][0], 0
+        self._left = self.svg.docks[2][0]
+        self._right = self.svg.get_innie_width()*1.5
 
     def _make_number_style_1arg(self, e, svg):
         self.svg.expand(e, 0)
diff --git a/constants.py b/constants.py
index d71a441..1f6e114 100644
--- a/constants.py
+++ b/constants.py
@@ -36,9 +36,12 @@ PEN = 1
 NUMBER = 2
 FLOW = 3
 BLOCKS = 4
-MISC = 5
+EXTRAS = 5
 PORTFOLIO = 6
 
+PALETTE_NAMES = ['turtle', 'pen', 'number', 'flow', 'blocks', 'extras',
+                 'portfolio']
+
 PALETTES = [['clean', 'forward', 'back', 'left', 'right', 'arc', 'set xy',
      'show', 'set scale', 'set heading', 'scale', 'xcor', 'ycor', 'heading'],
     ['pen up','pen down', 'set pen size', 'set text size',
@@ -46,13 +49,13 @@ PALETTES = [['clean', 'forward', 'back', 'left', 'right', 'arc', 'set xy',
      'shade'],
     ['number', 'plus', 'minus', 'multiply',
      'divide', 'mod', 'square root', 'random', 'greater than', 'less than',
-     'equal to', 'and', 'or', 'not', 'print'],
+     'equal to', 'and', 'or', 'not'],
     ['wait', 'forever', 'repeat', 'if then', 'stop action', 'hspace',
      'vspace'],
     ['start', 'def action 1', 'action 1', 'def action 2', 
      'action 2', 'def action', 'action', 'store in box 1', 'box 1',
      'store in box 2', 'box 2', 'store in', 'box', 'string'],
-    ['left pos', 'top pos', 'right pos', 'bottom pos', 'width', 
+    ['print', 'left pos', 'top pos', 'right pos', 'bottom pos', 'width', 
      'height'],
     ['hide blocks']]
 
@@ -64,6 +67,9 @@ COLORS = [["#00FF00","#00A000"], ["#00FFFF","#00A0A0"], ["#FF00FF","#A000A0"],
           ["#FFC000","#A08000"], ["#FFFF00","#A0A000"], ["#FF0000","#A0000"],
           ["#0000FF","#0000FF"]]
 
+
+PALETTE_HEIGHT = 175
+ICON_SIZE = 55
 SELECTED_COLOR = "#0000FF"
 SELECTED_STROKE_WIDTH = 1.5
 STANDARD_STROKE_WIDTH = 1.0
@@ -118,7 +124,8 @@ BLOCK_NAMES = {'clean':[_('clean')], 'forward':[_('forward')],
     'color':[_('color')],
     'plus':['+'], 'minus':['–'], 'multiply':['×'], 'divide':['/'],
     'mod':[_('mod')], 
-    'random':[_('random')], 'square root':['√'], 'less than':['<'],
+    'random':[_('random'),_('min'),_('max')], 'square root':['√'],
+    'less than':['<'],
     'greater than':[">"], 'equal to':['='], 'and':[_('and')], 'or':[_('or')],
     'not':[_('not')], 'print':[_('print')], 'wait':[_('wait')],
     'forever':[_('forever')], 'repeat':[_('repeat')], 'if then':[_('if then')],
diff --git a/tawindow.py b/tawindow.py
index 9fcbe52..7c623ae 100644
--- a/tawindow.py
+++ b/tawindow.py
@@ -73,11 +73,17 @@ class TurtleArtWindow():
 
     def __init__(self, win, path, lang, parent=None):
         self._setup_initial_values(win, path, lang, parent)
+        # TODO: most of this goes away
         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])
+        # self._select_category(self.selbuttons[0])
+
+        # the new palette
+        self.show_toolbar_palette(0, False)
+        # hide the old palette
+        self._hide_palette()
 
     def _setup_initial_values(self, win, path, lang, parent):
         self.window = win
@@ -146,6 +152,9 @@ class TurtleArtWindow():
         self.palette_spr = None
         self.palettes = []
         self.selected_palette = None
+        self.selectors = []
+        self.selected_selector = None
+        self.selector_shapes = []
 
     #
     # Public methods are called from the activity class
@@ -155,7 +164,7 @@ class TurtleArtWindow():
     eraser_button: hide status block
     """
     def eraser_button(self):
-        self.status_spr.set_layer(400)
+        self.status_spr.set_layer(HIDE_LAYER)
         clear(self.lc)
         display_coordinates(self)
 
@@ -238,48 +247,78 @@ class TurtleArtWindow():
         return
 
     """
-    Show turtle palette
-    The new tasetup
-    Experiment with toolbar palette for block creation
+    Show/hide turtle palettes
     """
-    def show_toolbar_palette(self, n):
+    def hide_toolbar_palette(self, hide_palette_spr=True):
+        for i in range(len(PALETTES[self.selected_palette])):        
+            self.palettes[self.selected_palette][i].spr.set_layer(HIDE_LAYER)
+        if hide_palette_spr is True:
+            self.palette_spr.set_layer(HIDE_LAYER)
+            self.selected_palette = None
+
+    def show_toolbar_palette(self, n, init_only=False):
+        # TODO: make graphical selector buttons
+        if self.selectors == []:
+            svg = sprite_factory.SVG()
+            svg.set_scale(2.0)
+            svg.set_gradiant(True)
+            svg.set_innie([False])
+            svg.set_outie(False)
+            svg.set_tab(False)
+            svg.set_slot(False)
+            svg.expand(25)
+            x, y = 5, 5
+            for i, name in enumerate(PALETTE_NAMES):
+                svg.set_stroke_width(STANDARD_STROKE_WIDTH)
+                svg.set_colors(COLORS[i])
+                a = sprite_factory.svg_str_to_pixbuf(svg.basic_block())
+                svg.set_stroke_width(SELECTED_STROKE_WIDTH)
+                svg.set_stroke_color(SELECTED_COLOR)
+                b = sprite_factory.svg_str_to_pixbuf(svg.basic_block())
+                self.selector_shapes.append([a,b])
+                self.selectors.append(sprites.Sprite(self.sprite_list, x, y, a))
+                self.selectors[i].set_label(name)
+                self.selectors[i].type = 'selector'
+                self.selectors[i].set_layer(TAB_LAYER)
+                w, h = self.selectors[i].get_dimensions()
+                x += (w+5) 
         if self.palette_spr is None:
             svg = sprite_factory.SVG()
             self.palette_spr = sprites.Sprite(self.sprite_list, 0, 0,
-                sprite_factory.svg_str_to_pixbuf(svg.palette(self.width, 150)))
-            self.palette_spr.set_layer(CATEGORY_LAYER)
+                sprite_factory.svg_str_to_pixbuf(svg.palette(self.width,
+                                                             PALETTE_HEIGHT)))
             self.palette_spr.type = 'category'
+        self.palette_spr.set_layer(CATEGORY_LAYER)
         if len(self.palettes) == 0:
             for i in range(len(PALETTES)):
                 self.palettes.append([])
         
-        if n < 0 or n > len(PALETTES)-1:
+        if init_only is True:
             return
 
         if self.selected_palette is not None:
-            print "out with the old %d" % (self.selected_palette)
-            for i in range(len(PALETTES[self.selected_palette])):        
-                self.palettes[self.selected_palette][i].spr.set_layer(
-                                                                    HIDE_LAYER)
-            self.selected_palette = n
+            self.hide_toolbar_palette(False)
+        self.selected_palette = n
+        self.selectors[n].set_shape(self.selector_shapes[n][1])
+        self.selected_selector = self.selectors[n]
 
         if self.palettes[n] == []:
             for i, name in enumerate(PALETTES[n]):
                 self.palettes[n].append(block.Block(self.block_list,
                                                     self.sprite_list, name,
-                                                    0, 0, 'selector', [], 1.5))
+                                                    0, 0, 'proto', [], 1.5))
                 self.palettes[n][i].spr.set_layer(TAB_LAYER)
                 self.palettes[n][i].spr.set_shape(self.palettes[n][i].shapes[0])
             # simple packing algorithm
-            x, y, max_width = 10, 75, 0
+            x, y, max_width = 5, ICON_SIZE+5, 0
             for i in range(len(PALETTES[n])):
                 w, h = self.palettes[n][i].spr.get_dimensions()
-                if y+h > 150:
-                    y = 75
-                    x += (max_width+10)
+                if y+h > PALETTE_HEIGHT:
+                    y = ICON_SIZE+5
+                    x += (max_width+5)
                     max_width = 0
                 self.palettes[n][i].spr.move((int(x), int(y)))
-                y += h
+                y += (h+5)
                 if w > max_width:
                     max_width = w
         else:
@@ -331,11 +370,20 @@ class TurtleArtWindow():
     TODO: move to toolbar
     """
     def _select_category(self, spr):
+        i = self.selectors.index(spr)
+        spr.set_shape(self.selector_shapes[i][1])
+        if self.selected_selector is not None:
+            j = self.selectors.index(self.selected_selector)
+            self.selected_selector.set_shape(self.selector_shapes[j][0])
+        self.selected_selector = spr
+        self.show_toolbar_palette(i)
+        """
         if hasattr(self, 'current_category'):
             self.current_category.set_shape(self.current_category.offshape)
         spr.set_shape(spr.onshape)
         self.current_category = spr
         self.category_spr.set_shape(spr.group)
+        """
 
     """
     Hide the palette.
@@ -461,6 +509,8 @@ class TurtleArtWindow():
     TODO: move to toolbar
     """
     def _get_proto_from_category(self, x, y):
+        return
+
         (sx,sy) = self.category_spr.get_xy()
         pixel = self.current_category.get_pixel(self.current_category.mask,
                                                 x-sx, y-sy)
@@ -490,6 +540,8 @@ class TurtleArtWindow():
                     except:
                         self.timeout_tag[0] = 0
         elif spr and hasattr(spr,'type') and spr.type == 'category':
+            # TODO: reassign to new palettes
+            return
             proto = self._get_proto_from_category(x, y)
             if proto and proto!='hide':
                 if self.timeout_tag[0] == 0:
@@ -689,6 +741,7 @@ class TurtleArtWindow():
                                          mov_dict[keyname][1])
             elif tur is not None:
                 self._jog_turtle(mov_dict[keyname][0], mov_dict[keyname][1])
+            """
             elif self.selected_spr.type == 'selbutton':
                 if keyname == 'Return' or keyname == 'KP_Page_Up':
                     self._select_category(self.selected_spr)
@@ -700,6 +753,7 @@ class TurtleArtWindow():
                        (bx, by) = b.spr.get_xy()
                        b.spr.move((bx+200, by))
                     self.drag_group = None
+            """
         return True
 
     """
@@ -732,9 +786,9 @@ class TurtleArtWindow():
             if blk.type == 'block':
                 self.selected_blk = blk
                 self._block_pressed(mask, x, y, blk)
-            elif blk.type == 'selector':
+            elif blk.type == 'proto':
                 blk.spr.set_shape(blk.shapes[1])
-                self._new_block_from_category(blk.name, x, y+100)
+                self._new_block_from_category(blk.name, x, y+PALETTE_HEIGHT)
                 blk.spr.set_shape(blk.shapes[0])
             return True
 
@@ -753,10 +807,14 @@ class TurtleArtWindow():
             if spr.type == "canvas":
                 spr.set_layer(CANVAS_LAYER)
                 return True
+            elif spr.type == 'selector':
+                self._select_category(spr)
+            """
             elif spr.type == 'selbutton':
                 self._select_category(spr)
             elif spr.type == 'category':
                 self._block_selector_pressed(x,y)
+            """
 
     """
     Block pressed
@@ -839,11 +897,13 @@ class TurtleArtWindow():
 
         blk = self.drag_group[0]
         # Remove blocks by dragging them onto the category palette
-        # TODO: rethink when palette moves to toolbar
+        # TODO: rethink when palette moves to toolbar -- Trash can??
+        """
         if self.block_operation=='move' and self.category_spr.hit((x,y)):
             for b in self.drag_group: b.spr.hide()
             self.drag_group = None
             return
+        """
 
         # Pull a stack of new blocks off of the category palette.
         if self.block_operation=='new':
diff --git a/turtleart.py b/turtleart.py
index 9b35f4b..b90eecf 100755
--- a/turtleart.py
+++ b/turtleart.py
@@ -91,14 +91,14 @@ class TurtleMain():
 
         menu = gtk.Menu()
 
-        menu_items = gtk.MenuItem(_("Turtle"))
-        menu.append(menu_items)
-        menu_items.connect("activate", self._do_turtle_cb)
-        menu_items.show()
         menu_items = gtk.MenuItem(_("Palette"))
         menu.append(menu_items)
         menu_items.connect("activate", self._do_palette_cb)
         menu_items.show()
+        menu_items = gtk.MenuItem(_("Hide Palette"))
+        menu.append(menu_items)
+        menu_items.connect("activate", self._do_hide_palette_cb)
+        menu_items.show()
         menu_items = gtk.MenuItem(_("Blocks"))
         menu.append(menu_items)
         menu_items.connect("activate", self._do_hideshow_cb)
@@ -149,17 +149,14 @@ class TurtleMain():
     def _do_save_cb(self, widget):
         save_file(self.tw)
 
-    def _do_turtle_cb(self, widget):
+    def _do_palette_cb(self, widget):
         self.tw.show_toolbar_palette(self.i)
         self.i += 1
-        if self.i > 6:
+        if self.i == len(self.tw.palettes):
             self.i = 0
 
-    def _do_palette_cb(self, widget):
-        if self.tw.palette == True:
-            self.tw.hideshow_palette(False)
-        else:
-            self.tw.hideshow_palette(True)
+    def _do_hide_palette_cb(self, widget):
+        self.tw.hide_toolbar_palette()
 
     def _do_hideshow_cb(self, widget):
         self.tw.hideshow_button()