Web   ·   Wiki   ·   Activities   ·   Blog   ·   Lists   ·   Chat   ·   Meeting   ·   Bugs   ·   Git   ·   Translate   ·   Archive   ·   People   ·   Donate
summaryrefslogtreecommitdiffstats
path: root/TurtleArt
diff options
context:
space:
mode:
authorWalter Bender <walter@sugarlabs.org>2010-10-25 19:19:37 (GMT)
committer Walter Bender <walter@sugarlabs.org>2010-10-25 19:19:37 (GMT)
commitc996f3959214da574cbca46eeb5b1cfa79f48da5 (patch)
tree2181a350bcb53f579da8887e3971994b159e5f73 /TurtleArt
parent9798fd2389daff90e5765f3fc61b1d1e14593356 (diff)
cleaned up method names: internal method name begin with _
Diffstat (limited to 'TurtleArt')
-rw-r--r--TurtleArt/talogo.py555
1 files changed, 275 insertions, 280 deletions
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)