Hi Gregor,
Thanks much for the tests - I've been thinking we needed something like
that.
As you note, turtlenew should really be called
turtle-with-a-few-minor-fxes-and-enhancements, but that was too long to
type. ;)
Your suggestions make sense. Based on everyone's suggestions I'm just
about done with an updated version, which I should have ready by the
weekend. I've had a bit of flu so haven't been able to think clearly
enough to pull it all together.
As to the circle and fill problem, we may not find a fix for this first
submission.
Cheers,
Vern
Gregor Lingl wrote:
> Hi Vern, hi everybody!
>
> I've had a look to turtlenew - which in fact has not very much new stuff ...
>
> I provide a set of sample programs, sort of test, which I use to use as
> test cases with my (X)turtle module - work inprogress .. I've modified
> them, so they work with turtlenew.
>
> Just save them together with turtlenew2.py in a directory and run them
> from within IDLE (or uncomment the mainloop - call). All of them except
> demo.py will also run with turtlenew.py
>
> I've - as a proposition - added one function to turtlenew:
> towards(*args), which returns the angle between the line from the turtle
> to the arg and the positive x-axis-direction. As a demo it's used
> in demo.py. (The idea is of course taken from Logo, where it is also
> present) This method uses atan2. So it's not elementary and young
> students won't be able to program it on their own. So I consider it
> rather essential. (In fact I incorporated it also into my book-specific
> turtle.py three years ago - which was also a moderate extension of the
> original one.)
>
> I've also changed one line in the speed-method just for aesthetic
> reasons. (Line 317 intutlenew2.py)
>
> If hope you appreciate these changes, and I'd like to see them
> integrated into turtle.py
>
> Imho there is one serious problem with circle and fill - they don't fit
> together. You can observe this with the yinyang - program and with
> demo.py . They simply do not work as everybody would naturally expect.
>
> I fear this could only be solved by abandoning the use of the arc items
> of the canvas widget.
>
> Regards,
> Gregor
>
>
>
>
>
> ------------------------------------------------------------------------
>
> # Xturtle ==> turtle example
> # yinyang
>
> # NOTE: In the first import statement
> # replace Xturtle by turtle to see, how
> # the original turtle acts here.
>
> from turtlenew2 import *
> from Tkinter import mainloop
>
> def yin(radius, farbe1, farbe2):
> width(3)
> color("black")
> fill(1)
> circle(radius/2., 180)
> circle(radius, 180)
> left(180)
> circle(-radius/2., 180)
> color(farbe1)
> fill(1)
> left(90)
> up()
> forward(radius*0.375)
> right(90)
> down()
> circle(radius*0.125)
> left(90)
> color(farbe2)
> fill(1)
> up()
> backward(radius*0.375)
> down()
> left(90)
>
> reset()
> yin(100, "white", "black")
> yin(100, "black", "white")
>
> #mainloop()
>
>
> ------------------------------------------------------------------------
>
> from turtlenew2 import *
> from Tkinter import mainloop
> from time import sleep
>
> def demo1():
> # demo des alten turtle-Moduls
> reset()
> tracer(1)
> up()
> backward(100)
> down()
> # draw 3 squares; the last filled
> width(3)
> for i in range(3):
> if i == 2:
> fill(1)
> for j in range(4):
> forward(20)
> left(90)
> if i == 2:
> color("maroon")
> fill(0)
> up()
> forward(30)
> down()
> width(1)
> color("black")
> # move out of the way
> tracer(0)
> up()
> right(90)
> forward(100)
> right(90)
> forward(100)
> right(180)
> down()
> # some text
> write("startstart", 1)
> write("start", 1)
> color("red")
> # staircase
> for i in range(5):
> forward(20)
> left(90)
> forward(20)
> right(90)
> # filled staircase
> fill(1)
> for i in range(5):
> forward(20)
> left(90)
> forward(20)
> right(90)
> fill(0)
> # more text
> write("wait a moment...")
> tracer(1)
>
> def demo2():
> # einige weitere und einige neue features
> speed(1)
> ## st()
> width(3)
> setheading(towards(0,0))
> x,y = position()
> r = (x**2+y**2)**.5/2.0
> right(90)
> pendown = True
> for i in range(18):
> if pendown:
> up()
> pendown = False
> else:
> down()
> pendown = True
> circle(r,10)
> sleep(2)
>
> reset()
> left(90)
>
> l = 10
> color("green")
> width(3)
> left(180)
> sp = 1
> for i in range(-2,16):
> if i > 0:
> color(1.0-0.05*i,0,0.05*i)
> fill(1)
> color("green")
> for j in range(3):
> forward(l)
> left(120)
> l += 10
> left(15)
> if sp < 4:
> sp = sp+1
> speed(sp)
> color(0.25,0,0.75)
> fill(0)
> color("green")
>
> left(120)
> up()
> forward(70)
> right(30)
> down()
> color("red")
> speed(0)
> fill(1)
> for i in range(4):
> circle(50,90)
> right(90)
> forward(30)
> right(90)
> color("yellow")
> fill(0)
> color("red")
> left(90)
> up(); forward(30); down(); # setshape(1)
>
> ## tri = turtles()[0]
> turtle=Pen()
> ## turtle.setshape(1)
> #### turtle.mode("logo")
> turtle.reset()
> turtle.left(90)
> turtle.speed(2)
> turtle.up()
> turtle.goto(280,40)
> turtle.left(24)
> turtle.down()
> turtle.speed(2)
> turtle.color("blue")
> turtle.width(2)
> speed(4)
> ## setheading(towards(*turtle.position())) ## for simple towards
> setheading(towards(turtle))
> while ( abs(position()[0]-turtle.position()[0])>4 or
> abs(position()[1]-turtle.position()[1])>4):
> turtle.forward(3.5)
> turtle.left(0.6)
> ## setheading(towards(*turtle.position()))
> setheading(towards(turtle))
> forward(4)
> write("CAUGHT! ", move=True)
>
>
> demo1()
> demo2()
>
> #mainloop()
>
>
> ------------------------------------------------------------------------
>
> ## NT - Die neue Turtle-Grafik
> ##
> #######################################
> ## Nfilltest.py ---
> ## urspruenglich ein Testprogramm in NT.py
> #######################################
> ##
> ## Autor: Gregor Lingl
> ## Datum: 16. 3. 2006
>
>
> from turtlenew2 import Pen
> from Tkinter import mainloop
>
> t = Pen()
> t.left(90)
> t.speed(1)
>
> l = 210
> t.up()
> t.backward(20)
> t.down()
>
> ## 1. triangle
>
> t.right(30)
> t.width(3)
>
> t.fill(True)
> for i in 1,2,3:
> t.color("red")
> t.forward(l/3.)
> t.color("green")
> t.forward(l/3.)
> t.color("blue")
> t.forward(l/3.)
> t.left(120)
> t.color(.8,.8,1)
> t.fill(False)
>
> t.left(30)
>
> ## 2. triangle
>
> t.left(60)
>
> t.color("blue")
> t.fill(True)
> t.width(10)
>
> for i in 1,2,3:
> t.forward(l)
> t.left(120)
> t.color("red")
> t.fill(False)
>
> t.left(30)
>
> ## 3. triangle
>
> t.left(60)
> t.up()
> t.fill(True)
> for i in 1,2,3:
> t.forward(l)
> t.left(120)
> t.color(0.7,0,0.7)
> t.fill(False)
> t.down()
> t.left(30)
>
> ## Change screencolor
>
> # t.screen.screencolor("yellow")
>
> ## 4. triangle
>
> t.left(60)
>
> t.speed(1)
> t.color("green")
> t.fill(True)
> for i in 1,2,3:
> #if i==2: t.hideturtle()
> t.width(2+3*i)
> t.forward(l/3.0)
> t.up()
> t.left(60)
> t.forward(l/6.0)
> t.right(120)
> t.forward(l/3.0)
> t.left(120)
> t.forward(l/6.0)
> t.right(60)
> t.down()
> t.forward(l/3.0)
> # if i==2: t.showturtle()
> t.left(120)
> t.color("red")
> t.fill(True)
>
> t.left(30)
>
> ## original heading
>
> t.left(90)
> t.speed(2)
> t.up()
> t.forward(l/3**0.5)
> #mainloop()
>
>
> ------------------------------------------------------------------------
>
> # Autor: Rudolf Zeidler
> # Datum: 01.12.2004
> # radioaktiv.py: Zeichnet ein radioaktiv-Gefahrensymbol
>
> # doesn't use the color-capabilities of Xturtle in order
> # to work also with turtle.py
>
>
> # NOTE: In the first import statement
> # replace Xturtle by turtle to see, how
> # (buggy) the turtle acts here, when trying to
> # fill sectors
>
> from turtlenew import *
> from Tkinter import mainloop
>
> def quadrat(laenge):
> for i in range(4):
> forward(laenge)
> left(90)
>
> def kreisSektor(radius, winkel):
> forward(radius)
> left(90)
> circle(radius, winkel)
> left(90)
> forward(radius)
> left(120)
>
> def move(x, y):
> up()
> forward(x)
> left(90)
> forward(y)
> left(-90)
> down()
>
> def radioaktiv(radius1, radius2, seite, winkel = 60, randFarbe = "black",
> fuellFarbe = "yellow"):
> color(randFarbe)
> move(-(seite / 2) , -(seite / 2))
>
> fill(1)
> quadrat(seite)
> color(fuellFarbe)
> fill(0)
> move((seite / 2), (seite / 2))
> color(randFarbe)
> right(90 + winkel / 2)
>
> for i in range(3):
> fill(1)
> kreisSektor(radius1,winkel)
> left((360 - 3 * winkel)/3 + 60)
> color(randFarbe)
> fill(0)
>
> up()
> forward(radius2)
> left(90)
> down()
>
> color(fuellFarbe)
> fill(1)
> circle(radius2)
> color(randFarbe)
> fill(0)
>
> up()
> left(90)
> forward(radius2)
> width(1)
>
> reset()
> width(5)
> radioaktiv(80, 15, 200)
> #mainloop()
>
>
>
>
>
>
> ------------------------------------------------------------------------
>
> #Gregor Lingl
> #14.12.2005
> #sierpinski_dreieck.py
>
> from turtlenew2 import *
> from Tkinter import mainloop
>
> class Vec3(tuple):
>
> def __new__(cls, x, y, z):
> return tuple.__new__(cls, (x, y, z))
> def __add__(self, other):
> return Vec3(self[0]+other[0], self[1]+other[1], self[2]+other[2])
> def __mul__(self, other):
> return Vec3(self[0]*other, self[1]*other, self[2]*other)
> def __rmul__(self, other):
> return Vec3(self[0]*other, self[1]*other, self[2]*other)
> def __sub__(self, other):
> return Vec3(self[0]-other[0], self[1]-other[1], self[2]-other[2])
> def __div__(self, other):
> other = float(other)
> return Vec3(self[0]/other, self[1]/other, self[2]/other)
> def __neg__(self):
> return Vec3(-self[0], -self[1], -self[2])
> def __repr__(self):
> return "(%.2f,%.2f,%.2f)" % self
>
>
>
> def dreieck(laenge, stufe, f1, f2, f3): # f1, f2, f3 Farben der Ecken
> if stufe == 0:
> color((f1+f2+f3)/3)
> down()
> fill(1)
> for i in range(3):
> forward(laenge)
> left(120)
> fill(0)
> up()
> else:
> c12 = (f1+f2)/2
> c13 = (f1+f3)/2
> c23 = (f2+f3)/2
> dreieck(laenge / 2, stufe - 1, f1, c12, c13)
> forward(laenge)
> left(120)
> dreieck(laenge / 2, stufe - 1, f2, c23, c12)
> forward(laenge)
> left(120)
> dreieck(laenge / 2, stufe - 1, f3, c13, c23)
> forward(laenge)
> left(120)
>
> reset()
> speed(0)
> up()
> backward(240)
> left(90)
> backward(200)
> right(90)
> down()
> tracer(1)
> speed(4)
> dreieck(480, 5, Vec3(1.0,0,0), Vec3(0,1.0,0), Vec3(0,0,1.0))
> #mainloop()
>
>
> ------------------------------------------------------------------------
>
> # LogoMation-like turtle graphics
>
> from math import * # Also for export
> import Tkinter
>
> class Error(Exception):
> pass
>
> _delay = 10 # default delay for drawing
>
> class RawPen:
>
> def __init__(self, canvas):
> self._canvas = canvas
> self._items = []
> self._tracing = 1
> self._arrow = 0
> self._delay = _delay
> self.degrees()
> self.reset()
>
> def degrees(self, fullcircle=360.0):
> self._fullcircle = fullcircle
> self._invradian = pi / (fullcircle * 0.5)
>
> def radians(self):
> self.degrees(2.0*pi)
>
> def reset(self):
> canvas = self._canvas
> self._canvas.update()
> width = canvas.winfo_width()
> height = canvas.winfo_height()
> if width <= 1:
> width = canvas['width']
> if height <= 1:
> height = canvas['height']
> self._origin = float(width)/2.0, float(height)/2.0
> self._position = self._origin
> self._angle = 0.0
> self._drawing = 1
> self._width = 1
> self._color = "black"
> self._filling = 0
> self._path = []
> self._tofill = []
> self.clear()
> canvas._root().tkraise()
>
> def clear(self):
> self.fill(0)
> canvas = self._canvas
> items = self._items
> self._items = []
> for item in items:
> canvas.delete(item)
> self._delete_turtle()
> self._draw_turtle()
>
> def tracer(self, flag):
> self._tracing = flag
> if not self._tracing:
> self._delete_turtle()
> self._draw_turtle()
>
> def forward(self, distance):
> x0, y0 = start = self._position
> x1 = x0 + distance * cos(self._angle*self._invradian)
> y1 = y0 - distance * sin(self._angle*self._invradian)
> self._goto(x1, y1)
>
> def backward(self, distance):
> self.forward(-distance)
>
> def left(self, angle):
> self._angle = (self._angle + angle) % self._fullcircle
> self._draw_turtle()
>
> def right(self, angle):
> self.left(-angle)
>
> def up(self):
> self._drawing = 0
>
> def down(self):
> self._drawing = 1
>
> def width(self, width):
> self._width = float(width)
>
> def color(self, *args):
> if not args:
> raise Error, "no color arguments"
> if len(args) == 1:
> color = args[0]
> if type(color) == type(""):
> # Test the color first
> try:
> id = self._canvas.create_line(0, 0, 0, 0, fill=color)
> except Tkinter.TclError:
> raise Error, "bad color string: %r" % (color,)
> self._set_color(color)
> return
> try:
> r, g, b = color
> except:
> raise Error, "bad color sequence: %r" % (color,)
> else:
> try:
> r, g, b = args
> except:
> raise Error, "bad color arguments: %r" % (args,)
> assert 0 <= r <= 1
> assert 0 <= g <= 1
> assert 0 <= b <= 1
> x = 255.0
> y = 0.5
> self._set_color("#%02x%02x%02x" % (int(r*x+y), int(g*x+y),
> int(b*x+y)))
>
> def _set_color(self,color):
> self._color = color
> self._draw_turtle()
>
> def write(self, arg, move=0):
> x, y = start = self._position
> x = x-1 # correction -- calibrated for Windows
> item = self._canvas.create_text(x, y,
> text=str(arg), anchor="sw",
> fill=self._color)
> self._items.append(item)
> if move:
> x0, y0, x1, y1 = self._canvas.bbox(item)
> self._goto(x1, y1)
> self._draw_turtle()
>
> def fill(self, flag):
> if self._filling:
> path = tuple(self._path)
> smooth = self._filling < 0
> if len(path) > 2:
> item = self._canvas._create('polygon', path,
> {'fill': self._color,
> 'smooth': smooth})
> self._items.append(item)
> if self._tofill:
> for item in self._tofill:
> self._canvas.itemconfigure(item, fill=self._color)
> self._items.append(item)
> self._path = []
> self._tofill = []
> self._filling = flag
> if flag:
> self._path.append(self._position)
> self.forward(0)
>
> def circle(self, radius, extent=None):
> if extent is None:
> extent = self._fullcircle
> x0, y0 = self._position
> xc = x0 - radius * sin(self._angle * self._invradian)
> yc = y0 - radius * cos(self._angle * self._invradian)
> if radius >= 0.0:
> start = self._angle - 90.0
> else:
> start = self._angle + 90.0
> extent = -extent
> if self._filling:
> if abs(extent) >= self._fullcircle:
> item = self._canvas.create_oval(xc-radius, yc-radius,
> xc+radius, yc+radius,
> width=self._width,
> outline="")
> self._tofill.append(item)
> item = self._canvas.create_arc(xc-radius, yc-radius,
> xc+radius, yc+radius,
> style="chord",
> start=start,
> extent=extent,
> width=self._width,
> outline="")
> self._tofill.append(item)
> if self._drawing:
> if abs(extent) >= self._fullcircle:
> item = self._canvas.create_oval(xc-radius, yc-radius,
> xc+radius, yc+radius,
> width=self._width,
> outline=self._color)
> self._items.append(item)
> item = self._canvas.create_arc(xc-radius, yc-radius,
> xc+radius, yc+radius,
> style="arc",
> start=start,
> extent=extent,
> width=self._width,
> outline=self._color)
> self._items.append(item)
> angle = start + extent
> x1 = xc + abs(radius) * cos(angle * self._invradian)
> y1 = yc - abs(radius) * sin(angle * self._invradian)
> self._angle = (self._angle + extent) % self._fullcircle
> self._position = x1, y1
> if self._filling:
> self._path.append(self._position)
> self._draw_turtle()
>
> def heading(self):
> return self._angle
>
> def setheading(self, angle):
> self._angle = angle
> self._draw_turtle()
>
> def window_width(self):
> width = self._canvas.winfo_width()
> if width <= 1: # the window isn't managed by a geometry manager
> width = self._canvas['width']
> return width
>
> def window_height(self):
> height = self._canvas.winfo_height()
> if height <= 1: # the window isn't managed by a geometry manager
> height = self._canvas['height']
> return height
>
> def position(self):
> x0, y0 = self._origin
> x1, y1 = self._position
> return [x1-x0, -y1+y0]
>
> def setx(self, xpos):
> x0, y0 = self._origin
> x1, y1 = self._position
> self._goto(x0+xpos, y1)
>
> def sety(self, ypos):
> x0, y0 = self._origin
> x1, y1 = self._position
> self._goto(x1, y0-ypos)
>
> def towards(self, *args):
> """returns the angle, which corresponds to the line
> from turtle-position to point (x,y).
> Argument can be two coordinates or one pair of coordinates
> or a RawPen/Pen instance.
> """
> if len(args) == 2:
> x, y = args
> else:
> arg = args[0]
> if isinstance(arg, RawPen):
> x, y = arg.position()
> else:
> x, y = arg
> x0, y0 = self.position()
> dx = x - x0
> dy = y - y0
> return (atan2(dy,dx) / self._invradian) % self._fullcircle
>
> def goto(self, *args):
> if len(args) == 1:
> try:
> x, y = args[0]
> except:
> raise Error, "bad point argument: %r" % (args[0],)
> else:
> try:
> x, y = args
> except:
> raise Error, "bad coordinates: %r" % (args[0],)
> x0, y0 = self._origin
> self._goto(x0+x, y0-y)
>
> def _goto(self, x1, y1):
> x0, y0 = start = self._position
> self._position = map(float, (x1, y1))
> if self._filling:
> self._path.append(self._position)
> if self._drawing:
> if self._tracing:
> dx = float(x1 - x0)
> dy = float(y1 - y0)
> distance = hypot(dx, dy)
> nhops = int(distance)
> item = self._canvas.create_line(x0, y0, x0, y0,
> width=self._width,
> capstyle="round",
> fill=self._color)
> try:
> for i in range(1, 1+nhops):
> x, y = x0 + dx*i/nhops, y0 + dy*i/nhops
> self._canvas.coords(item, x0, y0, x, y)
> self._draw_turtle((x,y))
> self._canvas.update()
> self._canvas.after(self._delay)
> # in case nhops==0
> self._canvas.coords(item, x0, y0, x1, y1)
> self._canvas.itemconfigure(item, arrow="none")
> except Tkinter.TclError:
> # Probably the window was closed!
> return
> else:
> item = self._canvas.create_line(x0, y0, x1, y1,
> width=self._width,
> capstyle="round",
> fill=self._color)
> self._items.append(item)
> self._draw_turtle()
>
> def speed(self, speed=2):
> """ maps a speed in 4 to 0 to delay given _canvas.after() in
> _goto()
>
> 4 is fastests (0 ms delay)
> 2 is default (10 ms delay)
> 0 is slowest (20 ms delay)"""
>
> ## if speed >=0 and speed <=4: ## more elegantly:
> if 0 <= speed <=4:
> self._delay = 20 - (speed * 5)
>
> def _draw_turtle(self,position=[]):
> if not self._tracing:
> return
> if position == []:
> position = self._position
> x,y = position
> distance = 8
> dx = distance * cos(self._angle*self._invradian)
> dy = distance * sin(self._angle*self._invradian)
> self._delete_turtle()
> self._arrow = self._canvas.create_line(x-dx,y+dy,x,y,
> width=self._width,
> arrow="last",
> capstyle="round",
> fill=self._color)
> self._canvas.update()
>
> def _delete_turtle(self):
> if self._arrow != 0:
> self._canvas.delete(self._arrow)
> self._arrow = 0
>
>
> _root = None
> _canvas = None
> _pen = None
> _width = 0.50 # 50% of window for width
> _height = 0.75 # 75% of window for height
> _startx = 0 # start at upper left corner
> _starty = 0
> _title = "Turtle Graphics" # default title
>
> class Pen(RawPen):
>
> def __init__(self):
> global _root, _canvas, _width, _height
> if _root is None:
> _root = Tkinter.Tk()
> _root.wm_protocol("WM_DELETE_WINDOW", self._destroy)
> _root.title(_title)
> if _width <= 1:
> _width = _root.winfo_screenwidth() * _width
> if _height <= 1:
> _height = _root.winfo_screenheight() * _height
> _root.geometry("%dx%d+%d+%d" % (_width, _height,
> _startx, _starty))
> if _canvas is None:
> # XXX Should have scroll bars
> _canvas = Tkinter.Canvas(_root, background="white")
> _canvas.pack(expand=1, fill="both")
> RawPen.__init__(self, _canvas)
>
> def _destroy(self):
> global _root, _canvas, _pen
> root = self._canvas._root()
> if root is _root:
> _pen = None
> _root = None
> _canvas = None
> root.destroy()
>
> def _getpen():
> global _pen
> if not _pen:
> _pen = Pen()
> return _pen
>
> class Turtle(Pen):
> pass
>
> def degrees(): _getpen().degrees()
> def radians(): _getpen().radians()
> def reset(): _getpen().reset()
> def clear(): _getpen().clear()
> def tracer(flag): _getpen().tracer(flag)
> def forward(distance): _getpen().forward(distance)
> def backward(distance): _getpen().backward(distance)
> def left(angle): _getpen().left(angle)
> def right(angle): _getpen().right(angle)
> def up(): _getpen().up()
> def down(): _getpen().down()
> def width(width): _getpen().width(width)
> def color(*args): _getpen().color(*args)
> def write(arg, move=0): _getpen().write(arg, move)
> def fill(flag): _getpen().fill(flag)
> def circle(radius, extent=None): _getpen().circle(radius, extent)
> def goto(*args): _getpen().goto(*args)
> def heading(): return _getpen().heading()
> def setheading(angle): _getpen().setheading(angle)
> def position(): return _getpen().position()
> def window_width(): return _getpen().window_width()
> def window_height(): return _getpen().window_height()
> def setx(xpos): _getpen().setx(xpos)
> def sety(ypos): _getpen().sety(ypos)
> def towards(*args): return _getpen().towards(*args)
> def done(): _root.mainloop()
> def speed(speed=2): _getpen().speed(speed)
> def setup(geometry=()):
> global _width, _height, _startx, _starty
> if len(geometry) == 4:
> _width, _height, _startx, _starty = geometry
> def title(title):
> global _title
> _title = title
>
> def demo():
> reset()
> tracer(1)
> up()
> backward(100)
> down()
> # draw 3 squares; the last filled
> width(3)
> for i in range(3):
> if i == 2:
> fill(1)
> for j in range(4):
> forward(20)
> left(90)
> if i == 2:
> color("maroon")
> fill(0)
> up()
> forward(30)
> down()
> width(1)
> color("black")
> # move out of the way
> tracer(0)
> up()
> right(90)
> forward(100)
> right(90)
> forward(100)
> right(180)
> down()
> # some text
> write("startstart", 1)
> write("start", 1)
> color("red")
> # staircase
> for i in range(5):
> forward(20)
> left(90)
> forward(20)
> right(90)
> # filled staircase
> fill(1)
> for i in range(5):
> forward(20)
> left(90)
> forward(20)
> right(90)
> fill(0)
> # more text
> write("end")
> if __name__ == '__main__':
> _root.mainloop()
>
> if __name__ == '__main__':
> demo()
--
This time for sure!
-Bullwinkle J. Moose
-----------------------------
Vern Ceder, Director of Technology
Canterbury School, 3210 Smith Road, Ft Wayne, IN 46804
[EMAIL PROTECTED]; 260-436-0746; FAX: 260-436-5137
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"edupython" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at http://groups.google.com/group/edupython
-~----------~----~----~----~------~----~------~--~---
