adding support for OSK

6 files changed, 189 insertions, 224 deletions

diff --git a/NEWS b/NEWS
index 90b1227..dbb0389 100644
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,8 @@
+165
+
+Sync with gtk-2 version 164
+Begin migration to GST-1.0
+
 161
 
 Sync with gtk-2 version 160
diff --git a/TurtleArt/tablock.py b/TurtleArt/tablock.py
index e01c3dd..7a7f2f7 100644
--- a/TurtleArt/tablock.py
+++ b/TurtleArt/tablock.py
@@ -73,8 +73,8 @@ class Blocks:
 
     def set_scale(self, scale):
         for b in self.list:
-            for i in range(len(b._font_size)):
-                b._font_size[i] *= b.scale * scale / self.font_scale_factor
+            for i in range(len(b.font_size)):
+                b.font_size[i] *= b.scale * scale / self.font_scale_factor
         self.font_scale_factor = scale
 
     def spr_to_block(self, spr):
@@ -149,7 +149,7 @@ class Block:
         self.ey = 0
         self.ey2 = 0
         self._ei = 0
-        self._font_size = [6.0, 4.5]
+        self.font_size = [6.0, 4.5]
         self._image = None
         self._visible = True
         self.unknown = False  # Block is of unknown style
@@ -195,8 +195,8 @@ class Block:
         if self.name in OLD_NAMES:
             self.name = OLD_NAMES[self.name]
 
-        for i in range(len(self._font_size)):
-            self._font_size[i] *= self.scale * \
+        for i in range(len(self.font_size)):
+            self.font_size[i] *= self.scale * \
                 self.block_list.font_scale_factor
 
         for v in (values):
@@ -293,11 +293,11 @@ class Block:
         """ We may want to rescale blocks as well. """
         if self.spr is None:
             return
-        for i in range(len(self._font_size)):
-            self._font_size[i] /= self.scale
+        for i in range(len(self.font_size)):
+            self.font_size[i] /= self.scale
         self.scale = scale
-        for i in range(len(self._font_size)):
-            self._font_size[i] *= self.scale
+        for i in range(len(self.font_size)):
+            self.font_size[i] *= self.scale
         self.svg.set_scale(self.scale)
         self.refresh()
         self.spr.inval()
@@ -533,9 +533,9 @@ class Block:
                 n = 0
         for i in range(n):
             if i > 0:
-                size = int(self._font_size[1] + 0.5)
+                size = int(self.font_size[1] + 0.5)
             else:
-                size = int(self._font_size[0] + 0.5)
+                size = int(self.font_size[0] + 0.5)
             if self.name in block_styles['compare-porch-style']:
                 self.spr.set_label_attributes(size, True, 'center', 'bottom',
                                               i=i)
@@ -561,28 +561,28 @@ class Block:
         if self.name in block_styles['clamp-style'] or \
            self.name in block_styles['clamp-style-collapsible']:
             y = int((self.docks[0][3] + self.docks[1][3]) / 3)
-            self.spr.set_label_attributes(int(self._font_size[0] + 0.5),
+            self.spr.set_label_attributes(int(self.font_size[0] + 0.5),
                                           True, 'right', y_pos=y, i=0)
         elif self.name in block_styles['clamp-style-1arg']:
-            y = self.docks[1][3] - int(int(self._font_size[0] * 1.3))
-            self.spr.set_label_attributes(int(self._font_size[0] + 0.5),
+            y = self.docks[1][3] - int(int(self.font_size[0] * 1.3))
+            self.spr.set_label_attributes(int(self.font_size[0] + 0.5),
                                           True, 'right', y_pos=y, i=0)
         elif self.name in block_styles['clamp-style-boolean']:
-            y = self.docks[1][3] - int(int(self._font_size[0] * 1.3))
-            self.spr.set_label_attributes(int(self._font_size[0] + 0.5),
+            y = self.docks[1][3] - int(int(self.font_size[0] * 1.3))
+            self.spr.set_label_attributes(int(self.font_size[0] + 0.5),
                                           True, 'right', y_pos=y, i=0)
-            y = self.docks[2][3] - int(int(self._font_size[0] * 1.3))
-            self.spr.set_label_attributes(int(self._font_size[1] + 0.5),
+            y = self.docks[2][3] - int(int(self.font_size[0] * 1.3))
+            self.spr.set_label_attributes(int(self.font_size[1] + 0.5),
                                           True, 'right', y_pos=y, i=1)
         elif self.name in block_styles['clamp-style-else']:
-            y = self.docks[1][3] - int(int(self._font_size[0] * 1.3))
-            self.spr.set_label_attributes(int(self._font_size[0] + 0.5),
+            y = self.docks[1][3] - int(int(self.font_size[0] * 1.3))
+            self.spr.set_label_attributes(int(self.font_size[0] + 0.5),
                                           True, 'right', y_pos=y, i=0)
-            y = self.docks[2][3] - int(int(self._font_size[0] * 1.3))
-            self.spr.set_label_attributes(int(self._font_size[1] + 0.5),
+            y = self.docks[2][3] - int(int(self.font_size[0] * 1.3))
+            self.spr.set_label_attributes(int(self.font_size[1] + 0.5),
                                           True, 'right', y_pos=y, i=1)
-            y = self.docks[3][3] - int(int(self._font_size[0] * 1.3))
-            self.spr.set_label_attributes(int(self._font_size[1] + 0.5),
+            y = self.docks[3][3] - int(int(self.font_size[0] * 1.3))
+            self.spr.set_label_attributes(int(self.font_size[1] + 0.5),
                                           True, 'right', y_pos=y, i=2)
 
 
diff --git a/TurtleArt/tagplay.py b/TurtleArt/tagplay.py
index bc38b6e..defc360 100644
--- a/TurtleArt/tagplay.py
+++ b/TurtleArt/tagplay.py
@@ -30,6 +30,8 @@ import gi
 gi.require_version('Gtk', '3.0')
 
 from gi.repository import GObject
+
+gi.require_version('Gst', '1.0')
 from gi.repository import Gst, GstVideo
 
 GObject.threads_init()
diff --git a/TurtleArt/tawindow.py b/TurtleArt/tawindow.py
index 7d6db60..e65166c 100644
--- a/TurtleArt/tawindow.py
+++ b/TurtleArt/tawindow.py
@@ -31,6 +31,7 @@ from gi.repository import Gtk
 from gi.repository import Gdk
 from gi.repository import GObject
 from gi.repository import GdkPixbuf
+from gi.repository import Pango
 from gi.repository import PangoCairo
 from gettext import gettext as _
 
@@ -53,7 +54,7 @@ from taconstants import HORIZONTAL_PALETTE, VERTICAL_PALETTE, BLOCK_SCALE, \
     TOOLBAR_SHAPES, TAB_LAYER, RETURN, OVERLAY_LAYER, CATEGORY_LAYER, \
     BLOCKS_WITH_SKIN, ICON_SIZE, PALETTE_SCALE, PALETTE_WIDTH, SKIN_PATHS, \
     MACROS, TOP_LAYER, BLOCK_LAYER, OLD_NAMES, DEFAULT_TURTLE, TURTLE_LAYER, \
-    CURSOR, EXPANDABLE, DEAD_DICTS, DEAD_KEYS, NO_IMPORT, \
+    EXPANDABLE, NO_IMPORT, \
     TEMPLATES, PYTHON_SKIN, PALETTE_HEIGHT, STATUS_LAYER, OLD_DOCK, \
     EXPANDABLE_ARGS, XO1, XO15, XO175, XO30, TITLEXY, CONTENT_ARGS, \
     CONSTANTS, EXPAND_SKIN, PROTO_LAYER, EXPANDABLE_FLOW
@@ -74,7 +75,7 @@ from tautils import magnitude, get_load_name, get_save_name, data_from_file, \
     find_group, find_blk_below, data_to_string, find_start_stack, \
     get_hardware, debug_output, error_output, data_to_string, convert, \
     find_bot_block, restore_clamp, collapse_clamp, data_from_string, \
-    increment_name
+    increment_name, get_screen_dpi
 from tasprite_factory import SVG, svg_str_to_pixbuf, svg_from_file
 from sprites import Sprites, Sprite
 
@@ -136,10 +137,11 @@ class TurtleArtWindow():
 
         self.no_help = False
         self.last_label = None
-
+        self._autohide_shape = True
         self.keypress = ''
         self.keyvalue = 0
-        self.dead_key = ''
+        self._focus_out_id = None
+        self._text_to_check = False
         self.mouse_flag = 0
         self.mouse_x = 0
         self.mouse_y = 0
@@ -180,7 +182,7 @@ class TurtleArtWindow():
         self.palette = True
         self.coord_scale = 1
         self.buddies = []
-        self.saved_string = ''
+        self._saved_string = ''
         self._saved_action_name = ''
         self._saved_box_name = ''
         self.dx = 0
@@ -286,7 +288,7 @@ class TurtleArtWindow():
         self.window_init_complete = True
 
     def _set_screen_dpi(self):
-        dpi = _get_screen_dpi()
+        dpi = get_screen_dpi()
         font_map_default = PangoCairo.font_map_get_default()
         font_map_default.set_resolution(dpi)
 
@@ -414,12 +416,12 @@ class TurtleArtWindow():
                               self.paste_offset)
             self.paste_offset += 20
             context.finish(True, False, time)
-        elif data and \
+        elif data and data.format == 8 and \
              self.selected_blk is not None and \
              self.selected_blk.name == 'string':
-            for i in data.get_text():
-                self.process_alphanumeric_input(i, -1)
-            self.selected_blk.resize()
+            bounds = self._text_buffer.get_bounds()
+            text = self._text_buffer.get_text(bounds[0], bounds[1], True)
+            self._text_buffer.set_text(text + data.data)
             context.finish(True, False, time)
         else:
             context.finish(False, False, time)
@@ -456,6 +458,7 @@ class TurtleArtWindow():
                                  self.status_shapes['status'])
         self.status_spr.hide()
         self.status_spr.type = 'status'
+        self._autohide_shape = True
 
         for name in OVERLAY_SHAPES:
             self.overlay_shapes[name] = Sprite(self.sprite_list,
@@ -522,6 +525,7 @@ class TurtleArtWindow():
         ''' Eraser_button (hide status block when clearing the screen.) '''
         if self.status_spr is not None:
             self.status_spr.hide()
+        self._autohide_shape = True
         self.lc.find_value_blocks()  # Are there blocks to update?
         self.lc.prim_clear()
         self.display_coordinates()
@@ -756,6 +760,12 @@ class TurtleArtWindow():
             if blk.name in BLOCKS_WITH_SKIN:
                 self._resize_skin(blk)
 
+        # Resize text_entry widget
+        if hasattr(self, '_text_entry') and len(blocks) > 0:
+            font_desc = Pango.font_description_from_string(
+                str(int(blocks[0].font_size[0])))
+            self._text_entry.modify_font(font_desc)
+
     def _shift_toolbar_palette(self, n):
         ''' Shift blocks on specified palette '''
         x, y = self.palette_sprs[n][self.orientation].get_xy()
@@ -1200,7 +1210,8 @@ class TurtleArtWindow():
         self.mouse_flag = 1
         self.mouse_x = x
         self.mouse_y = y
-        self.button_press(event.get_state() & Gdk.ModifierType.CONTROL_MASK, x, y)
+        self.button_press(
+            event.get_state() & Gdk.ModifierType.CONTROL_MASK, x, y)
         return True
 
     def button_press(self, mask, x, y):
@@ -1213,8 +1224,9 @@ class TurtleArtWindow():
         if self.selected_blk is not None:
             if self.selected_blk.name == 'number' and \
                spr in self.triangle_sprs:
-                # increment or decrement a number block
-                nf = float(self.selected_blk.spr.labels[0].replace(CURSOR, ''))
+                bounds = self._text_buffer.get_bounds()
+                text = self._text_buffer.get_text(bounds[0], bounds[1], True)
+                nf = float(text)
                 ni = int(nf)
                 if ni == nf:
                     n = ni
@@ -1224,7 +1236,7 @@ class TurtleArtWindow():
                     n += 1
                 else:
                     n -= 1
-                self.selected_blk.spr.set_label(str(n) + CURSOR)
+                self._text_buffer.set_text(str(n))
                 return True
             elif self._action_name(self.selected_blk, hat=True):
                 if self.selected_blk.values[0] == _('action'):
@@ -1248,9 +1260,12 @@ class TurtleArtWindow():
                     _('Select blocks to share'))
         self.selected_turtle = None
 
-        # Always hide the status layer on a click
-        if self.status_spr is not None:
+        # Almost always hide the status layer on a click
+        if self._autohide_shape and self.status_spr is not None:
+            self.status_spr.hide()
+        elif spr == self.status_spr:
             self.status_spr.hide()
+            self._autohide_shape = True
 
         self.dx = 0
         self.dy = 0
@@ -1418,15 +1433,10 @@ class TurtleArtWindow():
         ''' change the label on action blocks of the same name '''
         if type(name) in [float, int]:
             return
-        if CURSOR in name:
-            name = name.replace(CURSOR, '')
         if type(name) == 'unicode':
             name = name.encode('ascii', 'replace')
         for blk in self.just_blocks():
             if self._action_name(blk, hat=False):
-                if CURSOR in blk.spr.labels[0]:
-                    blk.spr.labels[0] = \
-                        blk.spr.labels[0].replace(CURSOR, '')
                 if blk.spr.labels[0] == self._saved_action_name:
                     blk.spr.labels[0] = name
                     blk.values[0] = name
@@ -1438,15 +1448,10 @@ class TurtleArtWindow():
         ''' change the label on box blocks of the same name '''
         if type(name) in [float, int]:
             return
-        if CURSOR in name:
-            name = name.replace(CURSOR, '')
         if type(name) == 'unicode':
             name = name.encode('ascii', 'replace')
         for blk in self.just_blocks():
             if self._box_name(blk, storein=False):
-                if CURSOR in blk.spr.labels[0]:
-                    blk.spr.labels[0] = \
-                        blk.spr.labels[0].replace(CURSOR, '')
                 if blk.spr.labels[0] == self._saved_box_name:
                     blk.spr.labels[0] = name
                     blk.values[0] = name
@@ -1458,15 +1463,10 @@ class TurtleArtWindow():
         ''' change the label on storin blocks of the same name '''
         if type(name) in [float, int]:
             return
-        if CURSOR in name:
-            name = name.replace(CURSOR, '')
         if type(name) == 'unicode':
             name = name.encode('ascii', 'replace')
         for blk in self.just_blocks():
             if self._box_name(blk, storein=True):
-                if CURSOR in blk.spr.labels[0]:
-                    blk.spr.labels[0] = \
-                        blk.spr.labels[0].replace(CURSOR, '')
                 if blk.spr.labels[0] == self._saved_box_name:
                     blk.spr.labels[0] = name
                     blk.values[0] = name
@@ -1752,21 +1752,24 @@ class TurtleArtWindow():
                 self.activity.share_button.set_tooltip(
                     _('Share selected blocks'))
             if len(blk.spr.labels) > 0:
-                self.saved_string = blk.spr.labels[0]
-                self._saved_action_name = self.saved_string
-                self._saved_box_name = self.saved_string
+                self._saved_string = blk.spr.labels[0]
+                self._saved_action_name = self._saved_string
+                self._saved_box_name = self._saved_string
             else:
-                self.saved_string = ''
+               self._saved_string = ''
 
     def _unselect_block(self):
         ''' Unselect block '''
         # After unselecting a 'number' block, we need to check its value
         if self.selected_blk.name == 'number':
-            self._number_check()
+            if self._text_to_check:
+                self._test_number()
             for spr in self.triangle_sprs:
                 spr.hide()
         elif self.selected_blk.name == 'string':
-            self._string_check()
+            if self._text_to_check:
+                self._test_string()
+        self._text_to_check = False
         self.selected_blk.unhighlight()
         self.selected_blk = None
 
@@ -2333,8 +2336,8 @@ class TurtleArtWindow():
         self.selected_blk = blk
 
         if  blk.name == 'number' or blk.name == 'string':
-            self.saved_string = blk.spr.labels[0]
-            blk.spr.labels[0] += CURSOR
+            self._saved_string = blk.spr.labels[0]
+            blk.spr.labels[0] = ''
             if blk.name == 'number':
                 bx, by = blk.spr.get_xy()
                 bw, bh = blk.spr.get_dimensions()
@@ -2343,6 +2346,32 @@ class TurtleArtWindow():
                     spr.set_layer(TOP_LAYER)
                 self.triangle_sprs[0].move((int(bx + (bw - tw) / 2), by - th))
                 self.triangle_sprs[1].move((int(bx + (bw - tw) / 2), by + bh))
+            if not hasattr(self, '_text_entry'):
+                self._text_entry = Gtk.TextView()
+                self._text_entry.set_justification(Gtk.Justification.CENTER)
+                self._text_entry.override_background_color(
+                    Gtk.StateType.NORMAL, Gdk.RGBA(0, 0, 0, 0))
+                self._text_buffer = self._text_entry.get_buffer()
+                font_desc = Pango.font_description_from_string(
+                    str(int(blk.font_size[0])))
+                self._text_entry.modify_font(font_desc)
+                self.activity.fixed.put(self._text_entry, 0, 0)
+            self._text_entry.show()
+            self._text_buffer.set_text(
+                self._saved_string.replace(RETURN, '\12'))
+            w = blk.spr.label_safe_width()
+            h = blk.spr.label_safe_height()
+            self._text_entry.set_size_request(w, h)
+            bx, by = blk.spr.get_xy()
+            if not self.running_sugar:
+                by += self.activity.menu_height + 4  # FIXME: padding
+            mx, my = blk.spr.label_left_top()
+            self._text_entry.set_pixels_above_lines(my * 2)
+            self.activity.fixed.move(self._text_entry, bx + mx, by + my * 2)
+            self.activity.fixed.show()
+            self._focus_out_id = self._text_entry.connect(
+                'focus-out-event', self._text_focus_out_cb)
+            self._text_entry.grab_focus()
 
         elif blk.name in block_styles['box-style-media'] and \
              blk.name not in NO_IMPORT:
@@ -2558,6 +2587,9 @@ class TurtleArtWindow():
 
     def _run_stack(self, blk):
         ''' Run a stack of blocks. '''
+        if self.status_spr is not None:
+            self.status_spr.hide()
+        self._autohide_shape = True
         if blk is None:
             return
         self.lc.find_value_blocks()  # Are there blocks to update?
@@ -2972,13 +3004,7 @@ class TurtleArtWindow():
                 self._align_to_grid()
 
         elif self.selected_blk is not None:
-            if self.selected_blk.name == 'number':
-                self._process_numeric_input(keyname)
-            elif self.selected_blk.name == 'string':
-                self.process_alphanumeric_input(keyname, keyunicode)
-                # if self.selected_blk is not None:
-                self.selected_blk.resize()
-            elif self.selected_blk.name != 'proto':
+            if self.selected_blk.name != 'proto':
                 self._process_keyboard_commands(keyname, block_flag=True)
 
         elif self.turtles.spr_to_turtle(self.selected_spr) is not None:
@@ -2986,131 +3012,6 @@ class TurtleArtWindow():
 
         return True
 
-    def _process_numeric_input(self, keyname):
-        ''' Make sure numeric input is valid. '''
-        oldnum = self.selected_blk.spr.labels[0].replace(CURSOR, '')
-        if len(oldnum) == 0:
-            oldnum = '0'
-        if keyname == 'minus':
-            if oldnum == '0':
-                newnum = '-'
-            elif oldnum[0] != '-':
-                newnum = '-' + oldnum
-            else:
-                newnum = oldnum
-        elif keyname == 'comma' and self.decimal_point == ',' and \
-                ',' not in oldnum:
-            newnum = oldnum + ','
-        elif keyname == 'period' and self.decimal_point == '.' and \
-                '.' not in oldnum:
-            newnum = oldnum + '.'
-        elif keyname == 'BackSpace':
-            if len(oldnum) > 0:
-                newnum = oldnum[:len(oldnum) - 1]
-            else:
-                newnum = ''
-        elif keyname in ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']:
-            if oldnum == '0':
-                newnum = keyname
-            else:
-                newnum = oldnum + keyname
-        elif keyname == 'Return':
-            self._unselect_block()
-            return
-        else:
-            newnum = oldnum
-        if newnum == '.':
-            newnum = '0.'
-        if newnum == ',':
-            newnum = '0,'
-        if len(newnum) > 0 and newnum != '-':
-            try:
-                float(newnum.replace(self.decimal_point, '.'))
-            except ValueError, e:
-                newnum = oldnum
-        self.selected_blk.spr.set_label(newnum + CURSOR)
-
-    def process_alphanumeric_input(self, keyname, keyunicode):
-        ''' Make sure alphanumeric input is properly parsed. '''
-        if len(self.selected_blk.spr.labels[0]) > 0:
-            c = self.selected_blk.spr.labels[0].count(CURSOR)
-            if c == 0:
-                oldleft = self.selected_blk.spr.labels[0]
-                oldright = ''
-            elif len(self.selected_blk.spr.labels[0]) == 1:
-                oldleft = ''
-                oldright = ''
-            elif CURSOR in self.selected_blk.spr.labels[0]:
-                oldleft, oldright = \
-                    self.selected_blk.spr.labels[0].split(CURSOR)
-            else:  # Where did our cursor go?
-                oldleft = self.selected_blk.spr.labels[0]
-                oldright = ''
-        else:
-            oldleft = ''
-            oldright = ''
-        newleft = oldleft
-        if keyname in ['Shift_L', 'Shift_R', 'Control_L', 'Caps_Lock', \
-                       'Alt_L', 'Alt_R', 'KP_Enter', 'ISO_Level3_Shift']:
-            keyname = ''
-            keyunicode = 0
-        # Hack until I sort out input and unicode and dead keys,
-        if keyname[0:5] == 'dead_':
-            self.dead_key = keyname
-            keyname = ''
-            keyunicode = 0
-        if keyname == 'space':
-            keyunicode = 32
-        elif keyname == 'Tab':
-            keyunicode = 9
-        if keyname == 'BackSpace':
-            if len(oldleft) > 1:
-                newleft = oldleft[:len(oldleft) - 1]
-            else:
-                newleft = ''
-        if keyname == 'Delete':
-            if len(oldright) > 0:
-                oldright = oldright[1:]
-        elif keyname == 'Home':
-            oldright = oldleft + oldright
-            newleft = ''
-        elif keyname == 'Left':
-            if len(oldleft) > 0:
-                oldright = oldleft[len(oldleft) - 1:] + oldright
-                newleft = oldleft[:len(oldleft) - 1]
-        elif keyname == 'Right':
-            if len(oldright) > 0:
-                newleft = oldleft + oldright[0]
-                oldright = oldright[1:]
-        elif keyname == 'End':
-            newleft = oldleft + oldright
-            oldright = ''
-        elif keyname == 'Return':
-            newleft = oldleft + RETURN
-        elif keyname == 'Down':
-            self._unselect_block()
-            return
-        elif keyname == 'Up' or keyname == 'Escape':  # Restore previous state
-            self.selected_blk.spr.set_label(self.saved_string)
-            self._unselect_block()
-            return
-        else:
-            if self.dead_key is not '':
-                keyunicode = \
-                    DEAD_DICTS[DEAD_KEYS.index(self.dead_key[5:])][keyname]
-                self.dead_key = ''
-            if keyunicode > 0:
-                if unichr(keyunicode) != '\x00':
-                    newleft = oldleft + unichr(keyunicode)
-                else:
-                    newleft = oldleft
-            elif keyunicode == -1:  # clipboard text
-                if keyname == '\n':
-                    newleft = oldleft + RETURN
-                else:
-                    newleft = oldleft + keyname
-        self.selected_blk.spr.set_label("%s%s%s" % (newleft, CURSOR, oldright))
-
     def _process_keyboard_commands(self, keyname, block_flag=True):
         ''' Use the keyboard to move blocks and turtle '''
         mov_dict = {'KP_Up': [0, 20], 'j': [0, 20], 'Up': [0, 20],
@@ -3210,39 +3111,78 @@ class TurtleArtWindow():
         self._snap_to_dock()
         self.drag_group = None
 
-    def _number_check(self):
+    def _test_number(self):
         ''' Make sure a 'number' block contains a number. '''
-        n = self.selected_blk.spr.labels[0].replace(CURSOR, '')
-        if n in ['-', '.', '-.', ',', '-,']:
-            n = 0
-        elif n is not None:
+        if hasattr(self, '_text_entry'):
+            if self._focus_out_id is not None:
+                self._text_entry.disconnect(self._focus_out_id)
+            self._focus_out_id = None
+            bounds = self._text_buffer.get_bounds()
+            text = self._text_buffer.get_text(bounds[0], bounds[1], True)
+            self._text_buffer.set_text('')
+            self._text_entry.hide()
+        else:
+            text = self.selected_blk.spr.labels[0]
+        self._number_check(text)
+
+    def _number_check(self, text):
+        text = text.strip()  # Ignore any whitespace
+        if text == '':
+            text = '0'
+        if text in ['-', '.', '-.', ',', '-,']:
+            num = 0
+        elif text is not None:
             try:
-                f = float(n.replace(self.decimal_point, '.'))
-                if f > 1000000:
-                    n = 1
+                num = float(text.replace(self.decimal_point, '.'))
+                if num > 1000000:
+                    num = 1
                     self.showlabel("#overflowerror")
-                elif f < -1000000:
-                    n = -1
+                elif num < -1000000:
+                    num = -1
                     self.showlabel("#overflowerror")
+                if int(num) == num:
+                    num = int(num)
             except ValueError:
-                n = 0
+                num = 0
                 self.showlabel("#notanumber")
         else:
-            n = 0
-        self.selected_blk.spr.set_label(str(n))
+            num = 0
+        self.selected_blk.spr.set_label(str(num))
         try:
             self.selected_blk.values[0] = \
-                float(str(n).replace(self.decimal_point, '.'))
+                float(str(num).replace(self.decimal_point, '.'))
         except ValueError:
-            self.selected_blk.values[0] = float(str(n))
+            self.selected_blk.values[0] = float(str(num))
         except IndexError:
-            self.selected_blk.values[0] = float(str(n))
+            self.selected_blk.values[0] = float(str(num))
+
+    def _text_focus_out_cb(self, widget=None, event=None):
+        bounds = self._text_buffer.get_bounds()
+        text = self._text_buffer.get_text(bounds[0], bounds[1], True)
+        self._text_to_check = True
+        if self.selected_blk.type == 'number':
+            self._number_check(text)
+        else:
+            self._string_check(text)
+
+    def _test_string(self):
+        if hasattr(self, '_text_entry'):
+            if self._focus_out_id is not None:
+                self._text_entry.disconnect(self._focus_out_id)
+            self._focus_out_id = None
+            bounds = self._text_buffer.get_bounds()
+            text = self._text_buffer.get_text(bounds[0], bounds[1], True)
+            self._text_buffer.set_text('')
+            self._text_entry.hide()
+        else:
+            text = self.selected_blk.spr.labels[0]
+        self._string_check(text)
 
-    def _string_check(self):
-        s = self.selected_blk.spr.labels[0].replace(CURSOR, '')
-        self.selected_blk.spr.set_label(s)
-        self.selected_blk.values[0] = s.replace(RETURN, "\12")
-        self.saved_string = self.selected_blk.values[0]
+    def _string_check(self, text):
+        self.selected_blk.spr.set_label(text.replace('\12', RETURN))
+        self.selected_blk.resize()
+        self.selected_blk.values[0] = text.replace(RETURN, '\12')
+        self._saved_string = self.selected_blk.values[0]
 
     def load_python_code_from_file(self, fname=None, add_new_block=True):
         ''' Load Python code from a file '''
@@ -3784,6 +3724,13 @@ class TurtleArtWindow():
         if not self.interactive_mode:
             debug_output(label, self.running_sugar)
             return
+        # Don't overwrite an error message
+        if not self._autohide_shape:
+            return
+        if shp in ['print', 'info', 'help']:
+            self._autohide_shape = True
+        else:
+            self._autohide_shape = False
         if shp == 'syntaxerror' and str(label) != '':
             if str(label)[1:] in self.status_shapes:
                 shp = str(label)[1:]
@@ -4013,8 +3960,6 @@ class TurtleArtWindow():
         ''' Add a stack block to the 'blocks' palette '''
         if type(name) in [float, int]:
             return
-        if CURSOR in name:
-            name = name.replace(CURSOR, '')
         if type(name) == unicode:
             name = name.encode('ascii', 'replace')
         if name == _('action'):
@@ -4042,8 +3987,6 @@ class TurtleArtWindow():
         ''' Add a box block to the 'blocks' palette '''
         if type(name) in [float, int]:
             return
-        if CURSOR in name:
-            name = name.replace(CURSOR, '')
         if type(name) == unicode:
             name = name.encode('ascii', 'replace')
         if name == _('my box'):
@@ -4072,8 +4015,6 @@ class TurtleArtWindow():
         ''' Add a storin block to the 'blocks' palette '''
         if type(name) in [float, int]:
             return
-        if CURSOR in name:
-            name = name.replace(CURSOR, '')
         if type(name) == unicode:
             name = name.encode('ascii', 'replace')
         if name == _('my box'):
diff --git a/TurtleArtActivity.py b/TurtleArtActivity.py
index 1bc456e..b5c3b2a 100644
--- a/TurtleArtActivity.py
+++ b/TurtleArtActivity.py
@@ -783,10 +783,27 @@ class TurtleArtActivity(activity.Activity):
 
         return new_version
 
+    def _fixed_resize_cb(self, widget=None, rect=None):
+        ''' If a toolbar opens or closes, we need to resize the vbox
+        holding out scrolling window. '''
+        self.vbox.set_size_request(rect.width, rect.height)
+
     def _setup_scrolled_window(self):
         ''' Create a scrolled window to contain the turtle canvas. '''
+        self.fixed = Gtk.Fixed()
+        self.fixed.connect('size-allocate', self._fixed_resize_cb)
+        self.fixed.show()
+        self.set_canvas(self.fixed)
+
+        self.vbox = Gtk.VBox(False, 0)
+        self.vbox.set_size_request(Gdk.Screen.width(),
+                                   Gdk.Screen.height() - \
+                                       2 * style.GRID_CELL_SIZE)
+        self.fixed.put(self.vbox, 0, 0)
+        self.vbox.show()
+
         self.sw = Gtk.ScrolledWindow()
-        self.set_canvas(self.sw)
+        self.vbox.pack_end(self.sw, True, True, 0)
         self.sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
         self.sw.show()
 
diff --git a/activity/activity.info b/activity/activity.info
index c16d224..3996d4b 100644
--- a/activity/activity.info
+++ b/activity/activity.info
@@ -1,6 +1,6 @@
 [Activity]
 name = Turtle Art
-activity_version = 161
+activity_version = 165
 license = MIT
 bundle_id = org.laptop.TurtleArtActivity
 exec = sugar-activity TurtleArtActivity.TurtleArtActivity