From c996f3959214da574cbca46eeb5b1cfa79f48da5 Mon Sep 17 00:00:00 2001
From: Walter Bender <walter@sugarlabs.org>
Date: Mon, 25 Oct 2010 19:19:37 +0000
Subject: cleaned up method names: internal method name begin with _

---
(limited to 'TurtleArt')

diff --git a/TurtleArt/talogo.py b/TurtleArt/talogo.py
index 36a59f6..e35c265 100644
--- a/TurtleArt/talogo.py
+++ b/TurtleArt/talogo.py
@@ -79,7 +79,7 @@ class logoerror(Exception):
 # Utility functions
 
 
-def numtype(x):
+def _num_type(x):
     """ Is x a number type? """
     if type(x) == int:
         return True
@@ -90,7 +90,7 @@ def numtype(x):
     return False
 
 
-def str_to_num(x):
+def _string_to_num(x):
     """ Try to comvert a string to a number """
     xx = convert(x.replace(self.tw.decimal_point, '.'), float)
     if type(xx) is float:
@@ -103,17 +103,17 @@ def str_to_num(x):
             raise logoerror("#syntaxerror")
 
 
-def taand(x, y):
+def _and(x, y):
     """ Logical and """
     return x & y
 
 
-def taor(x, y):
+def _or(x, y):
     """ Logical or """
     return x | y
 
 
-def careful_divide(x, y):
+def _careful_divide(x, y):
     """ Raise error on divide by zero """
     try:
         return x / y
@@ -121,7 +121,7 @@ def careful_divide(x, y):
         raise logoerror("#zerodivide")
     except TypeError:
         try:
-            return str_to_num(x) / str_to_num(y)
+            return _string_to_num(x) / _string_to_num(y)
         except ZeroDivisionError:
             raise logoerror("#zerodivide")
         except ValueError:
@@ -130,7 +130,7 @@ def careful_divide(x, y):
             raise logoerror("#notanumber")
 
 
-def taequal(x, y):
+def _equal(x, y):
     """ Numeric and logical equal """
     try:
         return float(x) == float(y)
@@ -143,12 +143,12 @@ def taequal(x, y):
         if typex and typey:
             return x == y
         try:
-            return str_to_num(x) == str_to_num(y)
+            return _string_to_num(x) == _string_to_num(y)
         except ValueError:
             raise logoerror("#syntaxerror")
 
 
-def taless(x, y):
+def _less(x, y):
     """ Compare numbers and strings """
     try:
         return float(x) < float(y)
@@ -161,97 +161,97 @@ def taless(x, y):
         if typex and typey:
             return x < y
         try:
-            return str_to_num(x) < str_to_num(y)
+            return _string_to_num(x) < _string_to_num(y)
         except TypeError:
             raise logoerror("#notanumber")
 
 
-def tamore(x, y):
+def _more(x, y):
     """ Compare numbers and strings """
-    return taless(y, x)
+    return _less(y, x)
 
 
-def taplus(x, y):
+def _plus(x, y):
     """ Add numbers, concat strings """
-    if numtype(x) and numtype(y):
+    if _num_type(x) and _num_type(y):
         return(x + y)
     else:
-        if numtype(x):
+        if _num_type(x):
             xx = str(round_int(x))
         else:
             xx = str(x)
-        if numtype(y):
+        if _num_type(y):
             yy = str(round_int(y))
         else:
             yy = str(y)
         return(xx + yy)
 
 
-def taminus(x, y):
+def _minus(x, y):
     """ Numerical subtraction """
-    if numtype(x) and numtype(y):
+    if _num_type(x) and _num_type(y):
         return(x - y)
     try:
-        return str_to_num(x) - str_to_num(y)
+        return _string_to_num(x) - _string_to_num(y)
     except TypeError:
         raise logoerror("#notanumber")
 
 
-def taproduct(x, y):
+def _product(x, y):
     """ Numerical multiplication """
-    if numtype(x) and numtype(y):
+    if _num_type(x) and _num_type(y):
         return(x * y)
     try:
-        return str_to_num(x) * str_to_num(y)
+        return _string_to_num(x) * _string_to_num(y)
     except TypeError:
         raise logoerror("#notanumber")
 
 
-def tamod(x, y):
+def _mod(x, y):
     """ Numerical mod """
-    if numtype(x) and numtype(y):
+    if _num_type(x) and _num_type(y):
         return(x % y)
     try:
-        return str_to_num(x) % str_to_num(y)
+        return _string_to_num(x) % _string_to_num(y)
     except TypeError:
         raise logoerror("#notanumber")
     except ValueError:
         raise logoerror("#syntaxerror")
 
 
-def tasqrt(x):
+def _sqrt(x):
     """ Square root """
-    if numtype(x):
+    if _num_type(x):
         if x < 0:
             raise logoerror("#negroot")
         return sqrt(x)
     try:
-        return sqrt(str_to_num(x))
+        return sqrt(_string_to_num(x))
     except ValueError:
         raise logoerror("#negroot")
     except TypeError:
         raise logoerror("#notanumber")
 
 
-def tarandom(x, y):
+def _random(x, y):
     """ Random integer """
-    if numtype(x) and numtype(y):
+    if _num_type(x) and _num_type(y):
         return(int(round(uniform(x, y), 0)))
     xx, xflag = chr_to_ord(x)
     yy, yflag = chr_to_ord(y)
     if xflag and yflag:
         return chr(int(round(uniform(xx, yy), 0)))
     if not xflag:
-        xx = str_to_num(x)
+        xx = _string_to_num(x)
     if not yflag:
-        yy = str_to_num(y)
+        yy = _string_to_num(y)
     try:
         return(int(round(uniform(xx, yy), 0)))
     except TypeError:
         raise logoerror("#notanumber")
 
 
-def identity(x):
+def _identity(x):
     """ Identity function """
     return(x)
 
@@ -259,16 +259,16 @@ def identity(x):
 def stop_logo(tw):
     """ Stop logo is called from the Stop button on the toolbar """
     tw.step_time = 0
-    tw.lc.step = just_stop()
+    tw.lc.step = _just_stop()
     tw.active_turtle.show()
 
 
-def just_stop():
+def _just_stop():
     """ yield False to stop stack """
     yield False
 
 
-def millis():
+def _millisecond():
     """ Current time in milliseconds """
     return int(clock() * 1000)
 
@@ -282,56 +282,57 @@ class LogoCode:
         self.oblist = {}
 
         DEFPRIM = {
-        '(': [1, lambda self, x: self.prim_opar(x)],
-        'and': [2, lambda self, x, y: taand(x, y)],
-        'arc': [2, lambda self, x, y: self.prim_move(self.tw.canvas.arc, x, y,
+        '(': [1, lambda self, x: self._prim_opar(x)],
+        'and': [2, lambda self, x, y: _and(x, y)],
+        'arc': [2, lambda self, x, y: self._prim_move(self.tw.canvas.arc, x, y,
                                                      update_heading=True)],
-        'back': [1, lambda self, x: self.prim_move(self.tw.canvas.forward, -x)],
+        'back': [1, lambda self, x: self._prim_move(self.tw.canvas.forward,
+                                                    -x)],
         'black': [0, lambda self: BLACK],
         'blue': [0, lambda self: CONSTANTS['blue']],
         'bpos': [0, lambda self: CONSTANTS['bottompos']],
         'boty': [0, lambda self: CONSTANTS['bottomy']],
         'box1': [0, lambda self: self.boxes['box1']],
-        'box': [1, lambda self, x: self.box(x)],
+        'box': [1, lambda self, x: self._box(x)],
         'box2': [0, lambda self: self.boxes['box2']],
-        'bullet': [1, self.prim_bullet, True],
-        'bulletlist': [1, self.prim_list, True],
+        'bullet': [1, self._prim_bullet, True],
+        'bulletlist': [1, self._prim_list, True],
         'cartesian': [0, lambda self: self.tw.set_cartesian(True)],
-        'clean': [0, lambda self: self.prim_clear()],
-        'clearheap': [0, lambda self: self.empty_heap()],
+        'clean': [0, lambda self: self._prim_clear()],
+        'clearheap': [0, lambda self: self._empty_heap()],
         'color': [0, lambda self: self.tw.canvas.color],
         'gray': [0, lambda self: self.tw.canvas.gray],
-        'comment': [1, lambda self, x: self.prim_print(x, True)],
+        'comment': [1, lambda self, x: self._prim_print(x, True)],
         'container': [1, lambda self, x: x],
         'cyan': [0, lambda self: CONSTANTS['cyan']],
-        'define': [2, self.prim_define],
-        'division': [2, lambda self, x, y: careful_divide(x, y)],
-        'equal?': [2, lambda self,x, y: taequal(x, y)],
+        'define': [2, self._prim_define],
+        'division': [2, lambda self, x, y: _careful_divide(x, y)],
+        'equal?': [2, lambda self,x, y: _equal(x, y)],
         'fillscreen': [2, lambda self, x, y: self.tw.canvas.fillscreen(x, y)],
-        'forever': [1, self.prim_forever, True],
-        'forward': [1, lambda self, x: self.prim_move(self.tw.canvas.forward,
+        'forever': [1, self._prim_forever, True],
+        'forward': [1, lambda self, x: self._prim_move(self.tw.canvas.forward,
                                                       x)],
         'fullscreen': [0, lambda self: self.tw.set_fullscreen()],
-        'greater?': [2, lambda self, x, y: tamore(x, y)],
+        'greater?': [2, lambda self, x, y: _more(x, y)],
         'green': [0, lambda self: CONSTANTS['green']],
         'heading': [0, lambda self: self.tw.canvas.heading],
         'hideblocks': [0, lambda self: self.tw.hideblocks()],
         'hres': [0, lambda self: CONSTANTS['width']],
-        'id': [1, lambda self, x: identity(x)],
-        'if': [2, self.prim_if, True],
-        'ifelse': [3, self.prim_ifelse, True],
-        'insertimage': [1, lambda self, x: self.insert_image(x, False)],
-        'kbinput': [0, lambda self: self.prim_kbinput()],
+        'id': [1, lambda self, x: _identity(x)],
+        'if': [2, self._prim_if, True],
+        'ifelse': [3, self._prim_ifelse, True],
+        'insertimage': [1, lambda self, x: self._insert_image(x, False)],
+        'kbinput': [0, lambda self: self._prim_kbinput()],
         'keyboard': [0, lambda self: self.keyboard],
-        'left': [1, lambda self, x: self.prim_right(-x)],
+        'left': [1, lambda self, x: self._prim_right(-x)],
         'leftx': [0, lambda self: CONSTANTS['leftx']],
         'lpos': [0, lambda self: CONSTANTS['leftpos']],
-        'less?': [2, lambda self, x, y: taless(x, y)],
-        'minus': [2, lambda self, x, y: taminus(x, y)],
-        'mod': [2, lambda self, x, y: tamod(x, y)],
-        'myfunction': [2, lambda self, f, x: self.myfunction(f, [x])],
-        'myfunction2': [3, lambda self, f, x, y: self.myfunction(f, [x, y])],
-        'myfunction3': [4, lambda self, f, x, y, z: self.myfunction(
+        'less?': [2, lambda self, x, y: _less(x, y)],
+        'minus': [2, lambda self, x, y: _minus(x, y)],
+        'mod': [2, lambda self, x, y: _mod(x, y)],
+        'myfunction': [2, lambda self, f, x: self._myfunction(f, [x])],
+        'myfunction2': [3, lambda self, f, x, y: self._myfunction(f, [x, y])],
+        'myfunction3': [4, lambda self, f, x, y, z: self._myfunction(
                     f, [x, y, z])],
         'nop': [0, lambda self: None],
         'nop1': [0, lambda self: None],
@@ -339,70 +340,70 @@ class LogoCode:
         'nop3': [1, lambda self, x: None],
         'not': [1, lambda self, x: not x],
         'orange': [0, lambda self: CONSTANTS['orange']],
-        'or': [2, lambda self, x, y: taor(x, y)],
+        'or': [2, lambda self, x, y: _or(x, y)],
         'pendown': [0, lambda self: self.tw.canvas.setpen(True)],
         'pensize': [0, lambda self: self.tw.canvas.pensize],
         'penup': [0, lambda self: self.tw.canvas.setpen(False)],
-        'plus': [2, lambda self, x, y: taplus(x, y)],
+        'plus': [2, lambda self, x, y: _plus(x, y)],
         'polar': [0, lambda self: self.tw.set_polar(True)],
-        'pop': [0, lambda self: self.prim_pop()],
-        'print': [1, lambda self, x: self.prim_print(x, False)],
-        'printheap': [0, lambda self: self.prim_print_heap()],
-        'product': [2, lambda self, x, y: taproduct(x, y)],
+        'pop': [0, lambda self: self._prim_pop()],
+        'print': [1, lambda self, x: self._prim_print(x, False)],
+        'printheap': [0, lambda self: self._prim_print_heap()],
+        'product': [2, lambda self, x, y: _product(x, y)],
         'purple': [0, lambda self: CONSTANTS['purple']],
-        'push': [1, lambda self, x: self.prim_push(x)],
-        'random': [2, lambda self, x, y: tarandom(x, y)],
-        'readpixel': [0, lambda self: self.read_pixel()],
+        'push': [1, lambda self, x: self._prim_push(x)],
+        'random': [2, lambda self, x, y: _random(x, y)],
+        'readpixel': [0, lambda self: self._read_pixel()],
         'red': [0, lambda self: CONSTANTS['red']],
-        'repeat': [2, self.prim_repeat, True],
-        'right': [1, lambda self, x: self.prim_right(x)],
+        'repeat': [2, self._prim_repeat, True],
+        'right': [1, lambda self, x: self._prim_right(x)],
         'rightx': [0, lambda self: CONSTANTS['rightx']],
         'rpos': [0, lambda self: CONSTANTS['rightpos']],
-        'savepix': [1, lambda self, x: self.save_picture(x)],
-        'savesvg': [1, lambda self, x: self.save_svg(x)],
+        'savepix': [1, lambda self, x: self._save_picture(x)],
+        'savesvg': [1, lambda self, x: self._save_svg(x)],
         'scale': [0, lambda self: self.scale],
-        'see': [0, lambda self: self.see()],
-        'setcolor': [1, lambda self, x: self.prim_set('color',
+        'see': [0, lambda self: self._see()],
+        'setcolor': [1, lambda self, x: self._prim_set('color',
             self.tw.canvas.setcolor, x)],
-        'setgray': [1, lambda self, x: self.prim_set('gray',
+        'setgray': [1, lambda self, x: self._prim_set('gray',
             self.tw.canvas.setgray, x)],
-        'seth': [1, lambda self, x: self.prim_set('heading',
+        'seth': [1, lambda self, x: self._prim_set('heading',
             self.tw.canvas.seth, x)],
-        'setpensize': [1, lambda self, x: self.prim_set('pensize',
+        'setpensize': [1, lambda self, x: self._prim_set('pensize',
             self.tw.canvas.setpensize, x)],
-        'setscale': [1, lambda self, x: self.prim_set('scale',
-            self.set_scale, x)],
-        'setshade': [1, lambda self, x: self.prim_set('shade',
+        'setscale': [1, lambda self, x: self._prim_set('scale',
+            self._set_scale, x)],
+        'setshade': [1, lambda self, x: self._prim_set('shade',
             self.tw.canvas.setshade, x)],
         'settextcolor': [1, lambda self, x: self.tw.canvas.settextcolor(x)],
         'settextsize': [1, lambda self, x: self.tw.canvas.settextsize(x)],
-        'setxy2': [2, lambda self, x, y: self.prim_move(self.tw.canvas.setxy,
+        'setxy2': [2, lambda self, x, y: self._prim_move(self.tw.canvas.setxy,
                                                         x, y)],
-        'setxy': [2, lambda self, x, y: self.prim_move(self.tw.canvas.setxy, x,
+        'setxy': [2, lambda self, x, y: self._prim_move(self.tw.canvas.setxy, x,
                                                        y, pendown=False)],
         'shade': [0, lambda self: self.tw.canvas.shade],
-        'show': [1, lambda self, x: self.show(x, True)],
-        'showaligned': [1,lambda self, x: self.show(x, False)],
+        'show': [1, lambda self, x: self._show(x, True)],
+        'showaligned': [1,lambda self, x: self._show(x, False)],
         'showblocks': [0, lambda self: self.tw.showblocks()],
-        'skin': [1, lambda self, x: self.reskin(x)],
-        'sound': [1, lambda self, x: self.play_sound(x)],
-        'sqrt': [1, lambda self, x: tasqrt(x)],
-        'stack1': [0, self.prim_stack1, True],
-        'stack': [1, self.prim_stack, True],
-        'stack2': [0, self.prim_stack2, True],
-        'start': [0, lambda self: self.prim_start()],
+        'skin': [1, lambda self, x: self._reskin(x)],
+        'sound': [1, lambda self, x: self._play_sound(x)],
+        'sqrt': [1, lambda self, x: _sqrt(x)],
+        'stack1': [0, self._prim_stack1, True],
+        'stack': [1, self._prim_stack, True],
+        'stack2': [0, self._prim_stack2, True],
+        'start': [0, lambda self: self._prim_start()],
         'startfill': [0, lambda self: self.tw.canvas.start_fill()],
         'stopfill': [0, lambda self: self.tw.canvas.stop_fill()],
-        'stopstack': [0, lambda self: self.prim_stopstack()],
-        'storeinbox1': [1, lambda self, x: self.prim_setbox('box1', None, x)],
-        'storeinbox2': [1, lambda self, x: self.prim_setbox('box2', None, x)],
-        'storeinbox': [2, lambda self, x, y: self.prim_setbox('box3', x, y)],
-        't1x1': [2, lambda self, x, y: self.show_template1x1(x, y)],
-        't1x1a': [2, lambda self, x, y: self.show_template1x1a(x, y)],
-        't1x2': [3, lambda self, x, y, z: self.show_template1x2(x, y, z)],
-        't2x1': [3, lambda self, x, y, z: self.show_template2x1(x, y, z)],
-        't2x2': [5, lambda self, x, y, z, a, b: self.show_template2x2(
-                                                   x, y, z, a, b)],
+        'stopstack': [0, lambda self: self._prim_stopstack()],
+        'storeinbox1': [1, lambda self, x: self._prim_setbox('box1', None, x)],
+        'storeinbox2': [1, lambda self, x: self._prim_setbox('box2', None, x)],
+        'storeinbox': [2, lambda self, x, y: self._prim_setbox('box3', x, y)],
+        't1x1': [2, lambda self, x, y: self._show_template1x1(x, y)],
+        't1x1a': [2, lambda self, x, y: self._show_template1x1a(x, y)],
+        't1x2': [3, lambda self, x, y, z: self._show_template1x2(x, y, z)],
+        't2x1': [3, lambda self, x, y, z: self._show_template2x1(x, y, z)],
+        't2x2': [5, lambda self, x, y, z, a, b: self._show_template2x2(
+                    x, y, z, a, b)],
         'textcolor': [0, lambda self: self.tw.canvas.textcolor],
         'textsize': [0, lambda self: self.tw.textsize],
         'titlex': [0, lambda self: self.tw.titlex],
@@ -410,30 +411,30 @@ class LogoCode:
         'topy': [0, lambda self: CONSTANTS['topy']],
         'tpos': [0, lambda self: CONSTANTS['toppos']],
         'turtle': [1, lambda self, x: self.tw.canvas.set_turtle(x)],
-        'userdefined': [1, lambda self, x: self.prim_myblock([x])],
-        'userdefined2': [2, lambda self, x, y: self.prim_myblock([x, y])],
+        'userdefined': [1, lambda self, x: self._prim_myblock([x])],
+        'userdefined2': [2, lambda self, x, y: self._prim_myblock([x, y])],
         'userdefined3': [3, lambda self, x, y,
-                         z: self.prim_myblock([x, y, z])],
-        'video': [1, lambda self, x: self.play_movie(x)],
+                         z: self._prim_myblock([x, y, z])],
+        'video': [1, lambda self, x: self._play_movie(x)],
         'vres': [0, lambda self: CONSTANTS['height']],
-        'wait': [1, self.prim_wait, True],
-        # 'while': [2, self.prim_while, True],
+        'wait': [1, self._prim_wait, True],
+        # 'while': [2, self._prim_while, True],
         'white': [0, lambda self: WHITE],
-        'write': [2, lambda self, x, y: self.write(self, x, y)],
+        'write': [2, lambda self, x, y: self._write(self, x, y)],
         'xcor': [0, lambda self: self.tw.canvas.xcor / self.tw.coord_scale],
         'ycor': [0, lambda self: self.tw.canvas.ycor / self.tw.coord_scale],
         'yellow': [0, lambda self: CONSTANTS['yellow']]}
 
         for p in iter(DEFPRIM):
             if len(DEFPRIM[p]) == 2:
-                self.defprim(p, DEFPRIM[p][0], DEFPRIM[p][1])
+                self._def_prim(p, DEFPRIM[p][0], DEFPRIM[p][1])
             else:
-                self.defprim(p, DEFPRIM[p][0], DEFPRIM[p][1], DEFPRIM[p][2])
+                self._def_prim(p, DEFPRIM[p][0], DEFPRIM[p][1], DEFPRIM[p][2])
 
-        self.symtype = type(self.intern('print'))
+        self.symtype = type(self._intern('print'))
         self.listtype = type([])
-        self.symnothing = self.intern('%nothing%')
-        self.symopar = self.intern('(')
+        self.symnothing = self._intern('%nothing%')
+        self.symopar = self._intern('(')
         self.iline = None
         self.cfun = None
         self.arglist = None
@@ -463,13 +464,13 @@ class LogoCode:
 
         self.scale = DEFAULT_SCALE
 
-    def defprim(self, name, args, fcn, rprim=False):
+    def _def_prim(self, name, args, fcn, rprim=False):
         """ Define the primitives associated with the blocks """
-        sym = self.intern(name)
+        sym = self._intern(name)
         sym.nargs, sym.fcn = args, fcn
         sym.rprim = rprim
 
-    def intern(self, string):
+    def _intern(self, string):
         """ Add any new objects to the symbol list. """
         if string in self.oblist:
             return self.oblist[string]
@@ -494,30 +495,30 @@ class LogoCode:
         for b in blocks:
             b.unhighlight()
             if b.name == 'hat1':
-                code = self.blocks_to_code(b)
-                self.stacks['stack1'] = self.readline(code)
+                code = self._blocks_to_code(b)
+                self.stacks['stack1'] = self._readline(code)
             if b.name == 'hat2':
-                code = self.blocks_to_code(b)
-                self.stacks['stack2'] = self.readline(code)
+                code = self._blocks_to_code(b)
+                self.stacks['stack2'] = self._readline(code)
             if b.name == 'hat':
                 if b.connections[1] is not None:
-                    code = self.blocks_to_code(b)
+                    code = self._blocks_to_code(b)
                     x = b.connections[1].values[0]
                     if type(convert(x, float, False)) == float:
                         if int(float(x)) == x:
                             x = int(x)
-                    self.stacks['stack3' + str(x)] = self.readline(code)
+                    self.stacks['stack3' + str(x)] = self._readline(code)
 
-        code = self.blocks_to_code(blk)
+        code = self._blocks_to_code(blk)
         if run_flag:
             print "running code: %s" % (code)
-            self.setup_cmd(code)
+            self._setup_cmd(code)
             if not self.tw.hide:
                 self.tw.display_coordinates()
         else:
             return code
 
-    def blocks_to_code(self, blk):
+    def _blocks_to_code(self, blk):
         """ Convert a stack of blocks to pseudocode. """
         if blk is None:
             return ['%nothing%', '%nothing%']
@@ -569,20 +570,20 @@ class LogoCode:
                     for c in dock[4]:
                         code.append(c)
                 if b is not None:
-                    code.extend(self.blocks_to_code(b))
+                    code.extend(self._blocks_to_code(b))
                 elif blk.docks[i][0] not in ['flow', 'unavailable']:
                     code.append('%nothing%')
         return code
 
-    def setup_cmd(self, string):
+    def _setup_cmd(self, string):
         """ Execute the psuedocode. """
         self.hidden_turtle = self.tw.active_turtle
         self.hidden_turtle.hide() # Hide the turtle while we are running.
         self.procstop = False
-        blklist = self.readline(string)
-        self.step = self.start_eval(blklist)
+        blklist = self._readline(string)
+        self.step = self._start_eval(blklist)
 
-    def readline(self, line):
+    def _readline(self, line):
         """
         Convert the pseudocode into a list of commands.
         The block associated with the command is stored as the second element
@@ -605,23 +606,23 @@ class LogoCode:
             elif token[0:2] == "#s":
                 res.append(token[2:])
             elif token == '[':
-                res.append(self.readline(line))
+                res.append(self._readline(line))
             elif token == ']':
                 return res
             elif bindex is None or type(bindex) is not int:
-                res.append(self.intern(token))
+                res.append(self._intern(token))
             else:
-                res.append((self.intern(token), bindex))
+                res.append((self._intern(token), bindex))
         return res
 
-    def start_eval(self, blklist):
+    def _start_eval(self, blklist):
         """ Step through the list. """
         if self.tw.running_sugar:
             self.tw.activity.stop_turtle_button.set_icon("stopiton")
         elif self.tw.interactive_mode:
             self.tw.toolbar_shapes['stopiton'].set_layer(TAB_LAYER)
         self.running = True
-        self.icall(self.evline, blklist)
+        self._icall(self._evline, blklist)
         yield True
         if self.tw.running_sugar:
             self.tw.activity.stop_turtle_button.set_icon("stopitoff")
@@ -630,12 +631,12 @@ class LogoCode:
         yield False
         self.running = False
 
-    def icall(self, fcn, *args):
+    def _icall(self, fcn, *args):
         """ Add a function and its arguments to the program stack. """
         self.istack.append(self.step)
         self.step = fcn(*(args))
 
-    def evline(self, blklist):
+    def _evline(self, blklist):
         """ Evaluate a line of code from the list. """
         oldiline = self.iline
         self.iline = blklist[:]
@@ -653,8 +654,8 @@ class LogoCode:
             # In debugging modes, we pause between steps and show the turtle.
             if self.tw.step_time > 0:
                 self.tw.active_turtle.show()
-                endtime = millis() + self.an_int(self.tw.step_time) * 100
-                while millis() < endtime:
+                endtime = _millisecond() + self._int(self.tw.step_time) * 100
+                while _millisecond() < endtime:
                     yield True
                 self.tw.active_turtle.hide()
 
@@ -665,7 +666,7 @@ class LogoCode:
                     (token, bindex) = self.iline[1]
 
             # Process the token and any arguments.
-            self.icall(self.eval)
+            self._icall(self._eval)
             yield True
 
             # Time to unhighlight the current block.
@@ -681,12 +682,12 @@ class LogoCode:
                 self.tw.block_list.list[bindex].highlight()
             raise logoerror(str(self.iresult))
         self.iline = oldiline
-        self.ireturn()
+        self._ireturn()
         if not self.tw.hide and self.tw.step_time > 0:
             self.tw.display_coordinates()
         yield True
 
-    def eval(self):
+    def _eval(self):
         """ Evaluate the next token on the line of code we are processing. """
         token = self.iline.pop(0)
         bindex = None
@@ -699,7 +700,7 @@ class LogoCode:
             # print "> ", token
             if not self.tw.hide and bindex is not None:
                 self.tw.block_list.list[bindex].highlight()
-            self.icall(self.evalsym, token)
+            self._icall(self._evalsym, token)
             yield True
             # and unhighlight if everything was OK.
             if not self.tw.hide and bindex is not None:
@@ -709,30 +710,30 @@ class LogoCode:
             # print ": ", token
             res = token
 
-        self.ireturn(res)
+        self._ireturn(res)
         yield True
 
-    def evalsym(self, token):
+    def _evalsym(self, token):
         """ Process primitive associated with symbol token """
-        self.undefined_check(token)
+        self._undefined_check(token)
         oldcfun, oldarglist = self.cfun, self.arglist
         self.cfun, self.arglist = token, []
 
         if token.nargs == None:
             raise logoerror("#noinput")
         for i in range(token.nargs):
-            self.no_args_check()
-            self.icall(self.eval)
+            self._no_args_check()
+            self._icall(self._eval)
             yield True
             self.arglist.append(self.iresult)
         if self.cfun.rprim:
             if type(self.cfun.fcn) == self.listtype:
                 print "evalsym rprim list: ", token
-                self.icall(self.ufuncall, self.cfun.fcn)
+                self._icall(self._ufuncall, self.cfun.fcn)
                 yield True
             else:
                 # print "evalsym rprim: ", token
-                self.icall(self.cfun.fcn, *self.arglist)
+                self._icall(self.cfun.fcn, *self.arglist)
                 yield True
             result = None
         else:
@@ -742,19 +743,19 @@ class LogoCode:
         if self.arglist is not None and result == None:
             raise logoerror("%s %s %s" % \
                 (oldcfun.name, _("did not output to"), self.cfun.name))
-        self.ireturn(result)
+        self._ireturn(result)
         yield True
 
-    def ufuncall(self, body):
+    def _ufuncall(self, body):
         """ ufuncall """
-        self.ijmp(self.evline, body)
+        self._ijmp(self._evline, body)
         yield True
 
     def doevalstep(self):
         """ evaluate one step """
-        starttime = millis()
+        starttime = _millisecond()
         try:
-            while (millis() - starttime)<120:
+            while (_millisecond() - starttime)<120:
                 try:
                     if self.step is not None:
                         self.step.next()
@@ -774,16 +775,16 @@ class LogoCode:
             return False
         return True
 
-    def ireturn(self, res=None):
+    def _ireturn(self, res=None):
         """ return value """
         self.step = self.istack.pop()
         self.iresult = res
 
-    def ijmp(self, fcn, *args):
+    def _ijmp(self, fcn, *args):
         """ ijmp """
         self.step = fcn(*(args))
 
-    def undefined_check(self, token):
+    def _undefined_check(self, token):
         """ Make sure token has a definition """
         if token.fcn is not None:
             return False
@@ -793,7 +794,7 @@ class LogoCode:
             errormsg = "%s %s" % (_("I don't know how to"), _(token.name))
         raise logoerror(errormsg)
 
-    def no_args_check(self):
+    def _no_args_check(self):
         """ Missing argument ? """
         if self.iline and self.iline[0] is not self.symnothing:
             return
@@ -803,7 +804,7 @@ class LogoCode:
     # Primitives
     #
 
-    def prim_clear(self):
+    def _prim_clear(self):
         """ Clear screen """
         stop_media(self)
         self.tw.canvas.clearscreen()
@@ -814,45 +815,45 @@ class LogoCode:
         for name in VALUE_BLOCKS:
             self.update_label_value(name)
 
-    def prim_start(self):
+    def _prim_start(self):
         """ Start block: recenter """
         if self.tw.running_sugar:
             self.tw.activity.recenter()
 
-    def prim_wait(self, time):
+    def _prim_wait(self, time):
         """ Show the turtle while we wait """
         self.tw.active_turtle.show()
-        endtime = millis() + self.an_int(time * 1000)
-        while millis()<endtime:
+        endtime = _millisecond() + self._int(time * 1000)
+        while _millisecond()<endtime:
             yield True
         self.tw.active_turtle.hide()
-        self.ireturn()
+        self._ireturn()
         yield True
 
-    def prim_repeat(self, num, blklist):
+    def _prim_repeat(self, num, blklist):
         """ Repeat list num times. """
-        num = self.an_int(num)
+        num = self._int(num)
         for i in range(num):
-            self.icall(self.evline, blklist[:])
+            self._icall(self._evline, blklist[:])
             yield True
             if self.procstop:
                 break
-        self.ireturn()
+        self._ireturn()
         yield True
 
-    def prim_bullet(self, blklist):
+    def _prim_bullet(self, blklist):
         """ Depreciated bullet-list block style """
-        self.show_bullets(blklist)
-        self.ireturn()
+        self._show_bullets(blklist)
+        self._ireturn()
         yield True
 
-    def prim_list(self, blklist):
+    def _prim_list(self, blklist):
         """ Expandable list block """
-        self.show_list(blklist)
-        self.ireturn()
+        self._show_list(blklist)
+        self._ireturn()
         yield True
 
-    def myfunction(self, f, x):
+    def _myfunction(self, f, x):
         """ Programmable block """
         try:
             y = myfunc(f, x)
@@ -881,57 +882,57 @@ class LogoCode:
             stop_logo(self.tw)
             raise logoerror("#notanumber")
 
-    def prim_forever(self, blklist):
+    def _prim_forever(self, blklist):
         """ Do list forever """
         while True:
-            self.icall(self.evline, blklist[:])
+            self._icall(self._evline, blklist[:])
             yield True
             if self.procstop:
                 break
-        self.ireturn()
+        self._ireturn()
         yield True
 
     '''
-    def prim_while(self, list1, list2):
-        list = [self.intern('if')]
+    def _prim_while(self, list1, list2):
+        list = [self._intern('if')]
         for i in list1:
             list.append(i)
         list.append(list2)
-        while self.icall(self.evline, list[:]):
+        while self._icall(self._evline, list[:]):
             yield True
-        self.ireturn()
+        self._ireturn()
         yield True
     '''
 
-    def prim_if(self, boolean, blklist):
+    def _prim_if(self, boolean, blklist):
         """ If bool, do list """
         if boolean:
-            self.icall(self.evline, blklist[:])
+            self._icall(self._evline, blklist[:])
             yield True
-        self.ireturn()
+        self._ireturn()
         yield True
 
-    def prim_ifelse(self, boolean, list1, list2):
+    def _prim_ifelse(self, boolean, list1, list2):
         """ If bool, do list1, else do list2 """
         if boolean:
-            self.ijmp(self.evline, list1[:])
+            self.ijmp(self._evline, list1[:])
             yield True
         else:
-            self.ijmp(self.evline, list2[:])
+            self.ijmp(self._evline, list2[:])
             yield True
 
-    def prim_opar(self, val):
+    def _prim_opar(self, val):
         self.iline.pop(0)
         return val
 
-    def prim_define(self, name, body):
+    def _prim_define(self, name, body):
         """ Define a primitive """
         if type(name) is not self.symtype:
-            name = self.intern(name)
+            name = self._intern(name)
         name.nargs, name.fcn = 0, body
         name.rprim = True
 
-    def prim_stack(self, x):
+    def _prim_stack(self, x):
         """ Process a named stack """
         if type(convert(x, float, False)) == float:
             if int(float(x)) == x:
@@ -939,41 +940,41 @@ class LogoCode:
         if 'stack3' + str(x) not in self.stacks or\
            self.stacks['stack3' + str(x)] is None:
             raise logoerror("#nostack")
-        self.icall(self.evline, self.stacks['stack3' + str(x)][:])
+        self._icall(self._evline, self.stacks['stack3' + str(x)][:])
         yield True
         self.procstop = False
-        self.ireturn()
+        self._ireturn()
         yield True
 
-    def prim_stack1(self):
+    def _prim_stack1(self):
         """ Process Stack 1 """
         if self.stacks['stack1'] is None:
             raise logoerror("#nostack")
-        self.icall(self.evline, self.stacks['stack1'][:])
+        self._icall(self._evline, self.stacks['stack1'][:])
         yield True
         self.procstop = False
-        self.ireturn()
+        self._ireturn()
         yield True
 
-    def prim_stack2(self):
+    def _prim_stack2(self):
         """ Process Stack 2 """
         if self.stacks['stack2'] is None:
             raise logoerror("#nostack")
-        self.icall(self.evline, self.stacks['stack2'][:])
+        self._icall(self._evline, self.stacks['stack2'][:])
         yield True
         self.procstop = False
-        self.ireturn()
+        self._ireturn()
         yield True
 
-    def prim_stopstack(self):
+    def _prim_stopstack(self):
         """ Stop execution of a stack """
         self.procstop = True
 
-    def prim_print_heap(self):
+    def _prim_print_heap(self):
         """ Display contents of heap """
         self.tw.showlabel('status', self.heap)
 
-    def an_int(self, n):
+    def _int(self, n):
         """ Raise an error if n doesn't convert to int. """
         if type(n) == int:
             return n
@@ -985,7 +986,7 @@ class LogoCode:
             raise logoerror("%s %s %s %s" \
                 % (self.cfun.name, _("doesn't like"), str(n), _("as input")))
 
-    def box(self, x):
+    def _box(self, x):
         """ Retrieve value from named box """
         if type(convert(x, float, False)) == float:
             if int(float(x)) == x:
@@ -995,7 +996,7 @@ class LogoCode:
         except:
             raise logoerror("#emptybox")
 
-    def prim_myblock(self, x):
+    def _prim_myblock(self, x):
         """ Run Python code imported from Journal """
         if self.tw.myblock is not None:
             try:
@@ -1009,7 +1010,7 @@ class LogoCode:
             raise logoerror("#nocode")
         return
 
-    def prim_print(self, n, flag):
+    def _prim_print(self, n, flag):
         """ Print n """
         if flag and (self.tw.hide or self.tw.step_time == 0):
             return
@@ -1032,7 +1033,7 @@ class LogoCode:
             self.tw.showlabel('status',
                 str(round_int(n)).replace('.', self.tw.decimal_point))
 
-    def prim_kbinput(self):
+    def _prim_kbinput(self):
         """ Query keyboard """
         if len(self.tw.keypress) == 1:
             self.keyboard = ord(self.tw.keypress[0])
@@ -1073,17 +1074,17 @@ class LogoCode:
                 block.spr.set_label(BLOCK_NAMES[name][0] + ' = ' + valstring)
                 block.resize()
 
-    def prim_set(self, name, cmd, value=None):
+    def _prim_set(self, name, cmd, value=None):
         """ Set a value and update the associated value blocks """
         if value is not None:
             cmd(value)
             self.update_label_value(name, value)
 
-    def prim_right(self, value):
+    def _prim_right(self, value):
         self.tw.canvas.right(value)
         self.update_label_value('heading', self.tw.canvas.heading)
 
-    def prim_move(self, cmd, value1, value2=None, update_heading=False):
+    def _prim_move(self, cmd, value1, value2=None, update_heading=False):
         if value2 is None:
             cmd(value1)
         else:
@@ -1095,9 +1096,9 @@ class LogoCode:
         if update_heading:
             self.update_label_value('heading', self.tw.canvas.heading)
         if len(self.value_blocks['see']) > 0:
-            self.see()
+            self._see()
 
-    def prim_setbox(self, name, x, val):
+    def _prim_setbox(self, name, x, val):
         """ Define value of named box """
         if x is not None:
             if type(convert(x, float, False)) == float:
@@ -1109,12 +1110,12 @@ class LogoCode:
         self.boxes[name] = val
         self.update_label_value(name, val)
 
-    def prim_push(self, val):
+    def _prim_push(self, val):
         """ Push value onto FILO """
         self.heap.append(val)
         self.update_label_value('pop', val)
 
-    def prim_pop(self):
+    def _prim_pop(self):
         """ Pop value off of FILO """
         if len(self.heap) == 0:
             raise logoerror("#emptyheap")
@@ -1125,36 +1126,36 @@ class LogoCode:
                 self.update_label_value('pop', self.heap[-2])
             return self.heap.pop(-1)
 
-    def empty_heap(self):
+    def _empty_heap(self):
         """ Empty FILO """
         self.heap = []
 
-    def save_picture(self, name):
+    def _save_picture(self, name):
         """ Save canvas to file as PNG """
         self.tw.save_as_image(name)
 
-    def save_svg(self, name):
+    def _save_svg(self, name):
         """ Save SVG to file """
         self.tw.canvas.svg_close()
         self.tw.save_as_image(name, True)
 
-    def show_list(self, sarray):
+    def _show_list(self, sarray):
         """ Display list of media objects """
         x = self.tw.canvas.xcor / self.tw.coord_scale
         y = self.tw.canvas.ycor / self.tw.coord_scale
         for s in sarray:
             self.tw.canvas.setxy(x, y, pendown=False)
-            self.show(s)
+            self._show(s)
             y -= int(self.tw.canvas.textsize * self.tw.lead)
 
-    def set_scale(self, x):
+    def _set_scale(self, x):
         """ Set scale used by media object display """
         self.scale = x
 
-    def reskin(self, media):
+    def _reskin(self, media):
         """ Reskin the turtle with an image from a file """
         scale = int(ICON_SIZE * float(self.scale) / DEFAULT_SCALE)
-        pixbuf = self.show_picture(media, 0, 0, scale, scale, False)
+        pixbuf = self._show_picture(media, 0, 0, scale, scale, False)
         if pixbuf is not None:
             self.tw.active_turtle.set_shapes([pixbuf])
             pen_state = self.tw.active_turtle.get_pen_state()
@@ -1164,7 +1165,7 @@ class LogoCode:
             if pen_state:
                 self.tw.canvas.setpen(True)
 
-    def show(self, string, center=False):
+    def _show(self, string, center=False):
         """ Show is the general-purpose media-rendering block. """
         # convert from Turtle coordinates to screen coordinates
         x = int(self.tw.canvas.width / 2) + int(self.tw.canvas.xcor)
@@ -1173,11 +1174,11 @@ class LogoCode:
             if string == "media_None":
                 pass
             elif string[0:6] == 'media_':
-                self.insert_image(string, center)
+                self._insert_image(string, center)
             elif string[0:6] == 'descr_':
-                self.insert_desc(string)
+                self._insert_desc(string)
             elif string[0:6] == 'audio_':
-                self.play_sound(string)
+                self._play_sound(string)
             else:
                 if center:
                     y -= self.tw.canvas.textsize
@@ -1194,7 +1195,7 @@ class LogoCode:
                                          self.scale / 100.),
                                      self.tw.canvas.width - x)
 
-    def insert_image(self, media, center):
+    def _insert_image(self, media, center):
         """ Image only (at current x, y) """
         w = int((self.tw.canvas.width * self.scale) / 100.)
         h = int((self.tw.canvas.height * self.scale) / 100.)
@@ -1205,9 +1206,9 @@ class LogoCode:
             x -= int(w / 2.)
             y -= int(h / 2.)
         if media[0:5] == 'media':
-            self.show_picture(media, x, y, w, h)
+            self._show_picture(media, x, y, w, h)
 
-    def insert_desc(self, media):
+    def _insert_desc(self, media):
         """ Description text only (at current x, y) """
         w = int((self.tw.canvas.width * self.scale) / 100.)
         h = int((self.tw.canvas.height * self.scale) / 100.)
@@ -1217,7 +1218,7 @@ class LogoCode:
         if media[0:5] == 'descr':
             self.show_description(media, x, y, w, h)
 
-    def play_sound(self, audio):
+    def _play_sound(self, audio):
         """ Sound file from Journal """
         if audio == "" or audio[6:] == "":
             raise logoerror("#nomedia")
@@ -1231,7 +1232,7 @@ class LogoCode:
         else:
             play_audio(self, audio[6:])
 
-    def show_picture(self, media, x, y, w, h, show=True):
+    def _show_picture(self, media, x, y, w, h, show=True):
         """ Image file from Journal """
         if w < 1 or h < 1:
             return None
@@ -1283,7 +1284,7 @@ class LogoCode:
             else:
                 return pixbuf
 
-    def show_description(self, media, x, y, w, h):
+    def _show_description(self, media, x, y, w, h):
         """ Description field from Journal """
         if media == "" or media[6:] == "":
             return
@@ -1313,7 +1314,7 @@ class LogoCode:
                 self.tw.canvas.draw_text(text, int(x), int(y),
                                          self.body_height, int(w))
 
-    def see(self):
+    def _see(self):
         """ Read r, g, b from the canvas and return a corresponding palette
         color """
         r, g, b, a = self.tw.canvas.get_pixel()
@@ -1321,7 +1322,7 @@ class LogoCode:
         self.update_label_value('see', color_index)
         return color_index
 
-    def read_pixel(self):
+    def _read_pixel(self):
         """ Read r, g, b, a from the canvas and push b, g, r to the stack """
         r, g, b, a = self.tw.canvas.get_pixel()
         self.heap.append(b)
@@ -1330,13 +1331,7 @@ class LogoCode:
 
     # Depreciated block methods
 
-    def draw_title(self, title, x, y):
-        """ slide title """
-        self.tw.canvas.draw_text(title, int(x), int(y),
-                                 self.title_height,
-                                 self.tw.canvas.width - x)
-
-    def show_template1x1(self, title, media):
+    def _show_template1x1(self, title, media):
         """ title, one image, and description """
         xo = self.tw.calc_position('t1x1')[2]
         x = -(self.tw.canvas.width / 2) + xo
@@ -1346,26 +1341,26 @@ class LogoCode:
         save_text_size = self.tw.canvas.textsize
         # set title text
         self.tw.canvas.settextsize(self.title_height)
-        self.show(title)
+        self._show(title)
         # calculate and set scale for media blocks
         myscale = 45 * (self.tw.canvas.height - self.title_height * 2) \
                       / self.tw.canvas.height
-        self.set_scale(myscale)
+        self._set_scale(myscale)
         # set body text size
         self.tw.canvas.settextsize(self.body_height)
         # render media object
         # leave some space below the title
         y -= int(self.title_height * 2 * self.tw.lead)
         self.tw.canvas.setxy(x, y, pendown=False)
-        self.show(media)
+        self._show(media)
         if self.tw.running_sugar:
             x = 0
             self.tw.canvas.setxy(x, y, pendown=False)
-            self.show(media.replace('media_', 'descr_'))
+            self._show(media.replace('media_', 'descr_'))
         # restore text size
         self.tw.canvas.settextsize(save_text_size)
 
-    def show_template2x1(self, title, media1, media2):
+    def _show_template2x1(self, title, media1, media2):
         """ title, two images (horizontal), two descriptions """
         xo = self.tw.calc_position('t2x1')[2]
         x = -(self.tw.canvas.width / 2) + xo
@@ -1375,32 +1370,32 @@ class LogoCode:
         save_text_size = self.tw.canvas.textsize
         # set title text
         self.tw.canvas.settextsize(self.title_height)
-        self.show(title)
+        self._show(title)
         # calculate and set scale for media blocks
         myscale = 45 * (self.tw.canvas.height - self.title_height * 2) / \
                   self.tw.canvas.height
-        self.set_scale(myscale)
+        self._set_scale(myscale)
         # set body text size
         self.tw.canvas.settextsize(self.body_height)
         # render four quadrents
         # leave some space below the title
         y -= int(self.title_height * 2 * self.tw.lead)
         self.tw.canvas.setxy(x, y, pendown=False)
-        self.show(media1)
+        self._show(media1)
         x = 0
         self.tw.canvas.setxy(x, y, pendown=False)
-        self.show(media2)
+        self._show(media2)
         y = -self.title_height
         if self.tw.running_sugar:
             self.tw.canvas.setxy(x, y, pendown=False)
-            self.show(media2.replace('media_', 'descr_'))
+            self._show(media2.replace('media_', 'descr_'))
             x = -(self.tw.canvas.width / 2) + xo
             self.tw.canvas.setxy(x, y, pendown=False)
-            self.show(media1.replace('media_', 'descr_'))
+            self._show(media1.replace('media_', 'descr_'))
         # restore text size
         self.tw.canvas.settextsize(save_text_size)
 
-    def show_bullets(self, sarray):
+    def _show_bullets(self, sarray):
         """ title and varible number of  bullets """
         xo = self.tw.calc_position('bullet')[2]
         x = -(self.tw.canvas.width / 2) + xo
@@ -1410,19 +1405,19 @@ class LogoCode:
         save_text_size = self.tw.canvas.textsize
         # set title text
         self.tw.canvas.settextsize(self.title_height)
-        self.show(sarray[0])
+        self._show(sarray[0])
         # set body text size
         self.tw.canvas.settextsize(self.bullet_height)
         # leave some space below the title
         y -= int(self.title_height * 2 * self.tw.lead)
         for s in sarray[1:]:
             self.tw.canvas.setxy(x, y, pendown=False)
-            self.show(s)
+            self._show(s)
             y -= int(self.bullet_height * 2 * self.tw.lead)
         # restore text size
         self.tw.canvas.settextsize(save_text_size)
 
-    def show_template1x2(self, title, media1, media2):
+    def _show_template1x2(self, title, media1, media2):
         """ title, two images (vertical), two desciptions """
         xo = self.tw.calc_position('t1x2')[2]
         x = -(self.tw.canvas.width / 2) + xo
@@ -1432,32 +1427,32 @@ class LogoCode:
         save_text_size = self.tw.canvas.textsize
         # set title text
         self.tw.canvas.settextsize(self.title_height)
-        self.show(title)
+        self._show(title)
         # calculate and set scale for media blocks
         myscale = 45 * (self.tw.canvas.height - self.title_height * 2) / \
                  self.tw.canvas.height
-        self.set_scale(myscale)
+        self._set_scale(myscale)
         # set body text size
         self.tw.canvas.settextsize(self.body_height)
         # render four quadrents
         # leave some space below the title
         y -= int(self.title_height * 2 * self.tw.lead)
         self.tw.canvas.setxy(x, y, pendown=False)
-        self.show(media1)
+        self._show(media1)
         if self.tw.running_sugar:
             x = 0
             self.tw.canvas.setxy(x, y, pendown=False)
-            self.show(media1.replace('media_', 'descr_'))
+            self._show(media1.replace('media_', 'descr_'))
             y = -self.title_height
             self.tw.canvas.setxy(x, y, pendown=False)
-            self.show(media2.replace('media_', 'descr_'))
+            self._show(media2.replace('media_', 'descr_'))
             x = -(self.tw.canvas.width / 2) + xo
             self.tw.canvas.setxy(x, y, pendown=False)
-            self.show(media2)
+            self._show(media2)
         # restore text size
         self.tw.canvas.settextsize(save_text_size)
 
-    def show_template2x2(self, title, media1, media2, media3, media4):
+    def _show_template2x2(self, title, media1, media2, media3, media4):
         """ title and four images """
         xo = self.tw.calc_position('t2x2')[2]
         x = -(self.tw.canvas.width / 2) + xo
@@ -1467,31 +1462,31 @@ class LogoCode:
         save_text_size = self.tw.canvas.textsize
         # set title text
         self.tw.canvas.settextsize(self.title_height)
-        self.show(title)
+        self._show(title)
         # calculate and set scale for media blocks
         myscale = 45 * (self.tw.canvas.height - self.title_height * 2) / \
                   self.tw.canvas.height
-        self.set_scale(myscale)
+        self._set_scale(myscale)
         # set body text size
         self.tw.canvas.settextsize(self.body_height)
         # render four quadrents
         # leave some space below the title
         y -= int(self.title_height * 2 * self.tw.lead)
         self.tw.canvas.setxy(x, y, pendown=False)
-        self.show(media1)
+        self._show(media1)
         x = 0
         self.tw.canvas.setxy(x, y, pendown=False)
-        self.show(media2)
+        self._show(media2)
         y = -self.title_height
         self.tw.canvas.setxy(x, y, pendown=False)
-        self.show(media4)
+        self._show(media4)
         x = -(self.tw.canvas.width / 2) + xo
         self.tw.canvas.setxy(x, y, pendown=False)
-        self.show(media3)
+        self._show(media3)
         # restore text size
         self.tw.canvas.settextsize(save_text_size)
 
-    def show_template1x1a(self, title, media1):
+    def _show_template1x1a(self, title, media1):
         """ title, one media object """
         xo = self.tw.calc_position('t1x1a')[2]
         x = -(self.tw.canvas.width / 2) + xo
@@ -1501,22 +1496,22 @@ class LogoCode:
         save_text_size = self.tw.canvas.textsize
         # set title text
         self.tw.canvas.settextsize(self.title_height)
-        self.show(title)
+        self._show(title)
         # calculate and set scale for media blocks
         myscale = 90 * (self.tw.canvas.height - self.title_height * 2) / \
                        self.tw.canvas.height
-        self.set_scale(myscale)
+        self._set_scale(myscale)
         # set body text size
         self.tw.canvas.settextsize(self.body_height)
         # render media object
         # leave some space below the title
         y -= int(self.title_height * 2 * self.tw.lead)
         self.tw.canvas.setxy(x, y, pendown=False)
-        self.show(media1)
+        self._show(media1)
         # restore text size
         self.tw.canvas.settextsize(save_text_size)
 
-    def write(self, string, fsize):
+    def _write(self, string, fsize):
         """ Write string at size """
         x = self.tw.canvas.width / 2 + int(self.tw.canvas.xcor)
         y = self.tw.canvas.height / 2 - int(self.tw.canvas.ycor)
--
cgit v0.9.1