'clearscreen', 'colormode', 'delay', 'exitonclick', 'getcanvas',

'getshapes', 'listen', 'mainloop', 'mode', 'numinput',

'onkey', 'onkeypress', 'onkeyrelease', 'onscreenclick', 'ontimer',

'register_shape', 'resetscreen', 'screensize', 'setup',

'setworldcoordinates', 'textinput', 'title', 'tracer', 'turtles', 'update',

'circle', 'clear', 'clearstamp', 'clearstamps', 'clone', 'color',

'degrees', 'distance', 'dot', 'down', 'end_fill', 'end_poly', 'fd',

'fillcolor', 'filling', 'forward', 'get_poly', 'getpen', 'getscreen', 'get_shapepoly',

'getturtle', 'goto', 'heading', 'hideturtle', 'home', 'ht', 'isdown',

'isvisible', 'left', 'lt', 'onclick', 'ondrag', 'onrelease', 'pd',

'pen', 'pencolor', 'pendown', 'pensize', 'penup', 'pos', 'position',

'pu', 'radians', 'right', 'reset', 'resizemode', 'rt',

'seth', 'setheading', 'setpos', 'setposition', 'settiltangle',

'setundobuffer', 'setx', 'sety', 'shape', 'shapesize', 'shapetransform', 'shearfactor', 'showturtle',

'speed', 'st', 'stamp', 'tilt', 'tiltangle', 'towards',

'turtlesize', 'undo', 'undobufferentries', 'up', 'width',

"height" : 0.75,

"canvwidth" : 400,

"canvheight": 300,

"leftright": None,

"topbottom": None,

"mode": "standard", # TurtleScreen

"colormode": 1.0,

"delay": 10,

"undobuffersize": 1000, # RawTurtle

"shape": "classic",

"pencolor" : "black",

"fillcolor" : "black",

"resizemode" : "noresize",

"visible" : True,

"language": "english", # docstrings

"exampleturtle": "turtle",

"examplescreen": "screen",

"title": "Python Turtle Graphics",

"using_IDLE": False

"""Convert content of config-file into dictionary."""

with open(filename, "r") as f:

cfglines = f.readlines()

cfgdict = {}

for line in cfglines:

line = line.strip()

if not line or line.startswith("#"):

continue

try:

key, value = line.split("=")

except ValueError:

print("Bad line in config-file %s:\n%s" % (filename,line))

continue

key = key.strip()

value = value.strip()

if value in ["True", "False", "None", "''", '""']:

value = eval(value)

else:

try:

if "." in value:

value = float(value)

else:

value = int(value)

except ValueError:

pass # value need not be converted

cfgdict[key] = value

"""Read config-files, change configuration-dict accordingly.

default_cfg = "turtle.cfg"

cfgdict1 = {}

cfgdict2 = {}

if isfile(default_cfg):

cfgdict1 = config_dict(default_cfg)

if "importconfig" in cfgdict1:

default_cfg = "turtle_%s.cfg" % cfgdict1["importconfig"]

try:

head, tail = split(__file__)

cfg_file2 = join(head, default_cfg)

except Exception:

cfg_file2 = ""

if isfile(cfg_file2):

cfgdict2 = config_dict(cfg_file2)

_CFG.update(cfgdict2)

"""A 2 dimensional vector class, used as a helper class

def __new__(cls, x, y):

return tuple.__new__(cls, (x, y))

def __add__(self, other):

return Vec2D(self[0]+other[0], self[1]+other[1])

def __mul__(self, other):

if isinstance(other, Vec2D):

return self[0]*other[0]+self[1]*other[1]

return Vec2D(self[0]*other, self[1]*other)

def __rmul__(self, other):

if isinstance(other, int) or isinstance(other, float):

return Vec2D(self[0]*other, self[1]*other)

return NotImplemented

def __sub__(self, other):

return Vec2D(self[0]-other[0], self[1]-other[1])

def __neg__(self):

return Vec2D(-self[0], -self[1])

def __abs__(self):

return (self[0]**2 + self[1]**2)**0.5

def rotate(self, angle):

"""rotate self counterclockwise by angle

perp = Vec2D(-self[1], self[0])

angle = angle * math.pi / 180.0

c, s = math.cos(angle), math.sin(angle)

return Vec2D(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s)

def __getnewargs__(self):

return (self[0], self[1])

def __repr__(self):

"""helper function for Scrolled Canvas"""

baseList = list(cls.__bases__)

baseList.reverse()

for _super in baseList:

__methodDict(_super, _dict)

for key, value in cls.__dict__.items():

if type(value) == types.FunctionType:

"""helper function for Scrolled Canvas"""

_dict = {}

__methodDict(cls, _dict)

### MANY CHANGES ###

_dict_1 = {}

__methodDict(toClass, _dict_1)

_dict = {}

mfc = __methods(fromClass)

for ex in _dict_1.keys():

if ex[:1] == '_' or ex[-1:] == '_' or ex in exclude or ex in mfc:

pass

else:

_dict[ex] = _dict_1[ex]

for method, func in _dict.items():

d = {'method': method, 'func': func}

if isinstance(toPart, str):

execString = \

__stringBody % {'method' : method, 'attribute' : toPart}

exec(execString, d)

"""Modeled after the scrolled canvas class from Grayons's Tkinter book.

def __init__(self, master, width=500, height=350,

canvwidth=600, canvheight=500):

TK.Frame.__init__(self, master, width=width, height=height)

self._rootwindow = self.winfo_toplevel()

self.width, self.height = width, height

self.canvwidth, self.canvheight = canvwidth, canvheight

self.bg = "white"

self._canvas = TK.Canvas(master, width=width, height=height,

bg=self.bg, relief=TK.SUNKEN, borderwidth=2)

self.hscroll = TK.Scrollbar(master, command=self._canvas.xview,

orient=TK.HORIZONTAL)

self.vscroll = TK.Scrollbar(master, command=self._canvas.yview)

self._canvas.configure(xscrollcommand=self.hscroll.set,

yscrollcommand=self.vscroll.set)

self.rowconfigure(0, weight=1, minsize=0)

self.columnconfigure(0, weight=1, minsize=0)

self._canvas.grid(padx=1, in_ = self, pady=1, row=0,

column=0, rowspan=1, columnspan=1, sticky='news')

self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,

column=1, rowspan=1, columnspan=1, sticky='news')

self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,

column=0, rowspan=1, columnspan=1, sticky='news')

self.reset()

self._rootwindow.bind('<Configure>', self.onResize)

def reset(self, canvwidth=None, canvheight=None, bg = None):

"""Adjust canvas and scrollbars according to given canvas size."""

if canvwidth:

self.canvwidth = canvwidth

if canvheight:

self.canvheight = canvheight

if bg:

self.bg = bg

self._canvas.config(bg=bg,

scrollregion=(-self.canvwidth//2, -self.canvheight//2,

self.canvwidth//2, self.canvheight//2))

self._canvas.xview_moveto(0.5*(self.canvwidth - self.width + 30) /

self.canvwidth)

self._canvas.yview_moveto(0.5*(self.canvheight- self.height + 30) /

self.canvheight)

self.adjustScrolls()

def adjustScrolls(self):

""" Adjust scrollbars according to window- and canvas-size.

cwidth = self._canvas.winfo_width()

cheight = self._canvas.winfo_height()

self._canvas.xview_moveto(0.5*(self.canvwidth-cwidth)/self.canvwidth)

self._canvas.yview_moveto(0.5*(self.canvheight-cheight)/self.canvheight)

if cwidth < self.canvwidth or cheight < self.canvheight:

self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,

column=0, rowspan=1, columnspan=1, sticky='news')

self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,

column=1, rowspan=1, columnspan=1, sticky='news')

else:

self.hscroll.grid_forget()

self.vscroll.grid_forget()

def onResize(self, event):

"""self-explanatory"""

self.adjustScrolls()

def bbox(self, *args):

""" 'forward' method, which canvas itself has inherited...

return self._canvas.bbox(*args)

def cget(self, *args, **kwargs):

""" 'forward' method, which canvas itself has inherited...

return self._canvas.cget(*args, **kwargs)

def config(self, *args, **kwargs):

""" 'forward' method, which canvas itself has inherited...

self._canvas.config(*args, **kwargs)

def bind(self, *args, **kwargs):

""" 'forward' method, which canvas itself has inherited...

self._canvas.bind(*args, **kwargs)

def unbind(self, *args, **kwargs):

""" 'forward' method, which canvas itself has inherited...

self._canvas.unbind(*args, **kwargs)

def focus_force(self):

""" 'forward' method, which canvas itself has inherited...

"""Root class for Screen based on Tkinter."""

def __init__(self):

TK.Tk.__init__(self)

def setupcanvas(self, width, height, cwidth, cheight):

self._canvas = ScrolledCanvas(self, width, height, cwidth, cheight)

self._canvas.pack(expand=1, fill="both")

def _getcanvas(self):

return self._canvas

def set_geometry(self, width, height, startx, starty):

self.geometry("%dx%d%+d%+d"%(width, height, startx, starty))

def ondestroy(self, destroy):

self.wm_protocol("WM_DELETE_WINDOW", destroy)

def win_width(self):

return self.winfo_screenwidth()

def win_height(self):

"""Provide the basic graphics functionality.

def _blankimage(self):

"""return a blank image object

img = TK.PhotoImage(width=1, height=1, master=self.cv)

img.blank()

return img

def _image(self, filename):

"""return an image object containing the

return TK.PhotoImage(file=filename, master=self.cv)

def __init__(self, cv):

self.cv = cv

if isinstance(cv, ScrolledCanvas):

w = self.cv.canvwidth

h = self.cv.canvheight

else: # expected: ordinary TK.Canvas

w = int(self.cv.cget("width"))

h = int(self.cv.cget("height"))

self.cv.config(scrollregion = (-w//2, -h//2, w//2, h//2 ))

self.canvwidth = w

self.canvheight = h

self.xscale = self.yscale = 1.0

def _createpoly(self):

"""Create an invisible polygon item on canvas self.cv)

return self.cv.create_polygon((0, 0, 0, 0, 0, 0), fill="", outline="")

def _drawpoly(self, polyitem, coordlist, fill=None,

outline=None, width=None, top=False):

"""Configure polygonitem polyitem according to provided

cl = []

for x, y in coordlist:

cl.append(x * self.xscale)

cl.append(-y * self.yscale)

self.cv.coords(polyitem, *cl)

if fill is not None:

self.cv.itemconfigure(polyitem, fill=fill)

if outline is not None:

self.cv.itemconfigure(polyitem, outline=outline)

if width is not None:

self.cv.itemconfigure(polyitem, width=width)

if top:

self.cv.tag_raise(polyitem)

def _createline(self):

"""Create an invisible line item on canvas self.cv)

return self.cv.create_line(0, 0, 0, 0, fill="", width=2,

capstyle = TK.ROUND)

def _drawline(self, lineitem, coordlist=None,

fill=None, width=None, top=False):

"""Configure lineitem according to provided arguments:

if coordlist is not None:

cl = []

for x, y in coordlist:

cl.append(x * self.xscale)

cl.append(-y * self.yscale)

self.cv.coords(lineitem, *cl)

if fill is not None:

self.cv.itemconfigure(lineitem, fill=fill)

if width is not None:

self.cv.itemconfigure(lineitem, width=width)

if top:

self.cv.tag_raise(lineitem)

def _delete(self, item):

"""Delete graphics item from canvas.

self.cv.delete(item)

def _update(self):

"""Redraw graphics items on canvas

self.cv.update()

def _delay(self, delay):

"""Delay subsequent canvas actions for delay ms."""

self.cv.after(delay)

def _iscolorstring(self, color):

"""Check if the string color is a legal Tkinter color string.

try:

rgb = self.cv.winfo_rgb(color)

ok = True

except TK.TclError:

ok = False

return ok

def _bgcolor(self, color=None):

"""Set canvas' backgroundcolor if color is not None,

if color is not None:

self.cv.config(bg = color)

self._update()

else:

return self.cv.cget("bg")

def _write(self, pos, txt, align, font, pencolor):

"""Write txt at pos in canvas with specified font

x, y = pos

x = x * self.xscale

y = y * self.yscale

anchor = {"left":"sw", "center":"s", "right":"se" }

item = self.cv.create_text(x-1, -y, text = txt, anchor = anchor[align],

fill = pencolor, font = font)

x0, y0, x1, y1 = self.cv.bbox(item)

self.cv.update()

return item, x1-1

def _onclick(self, item, fun, num=1, add=None):

"""Bind fun to mouse-click event on turtle.

if fun is None:

self.cv.tag_unbind(item, "<Button-%s>" % num)

else:

def eventfun(event):

x, y = (self.cv.canvasx(event.x)/self.xscale,

-self.cv.canvasy(event.y)/self.yscale)

fun(x, y)

self.cv.tag_bind(item, "<Button-%s>" % num, eventfun, add)

def _onrelease(self, item, fun, num=1, add=None):

"""Bind fun to mouse-button-release event on turtle.

if fun is None:

self.cv.tag_unbind(item, "<Button%s-ButtonRelease>" % num)

else:

def eventfun(event):

x, y = (self.cv.canvasx(event.x)/self.xscale,

-self.cv.canvasy(event.y)/self.yscale)

fun(x, y)

self.cv.tag_bind(item, "<Button%s-ButtonRelease>" % num,

eventfun, add)

def _ondrag(self, item, fun, num=1, add=None):

"""Bind fun to mouse-move-event (with pressed mouse button) on turtle.

if fun is None:

self.cv.tag_unbind(item, "<Button%s-Motion>" % num)

else:

def eventfun(event):

try:

x, y = (self.cv.canvasx(event.x)/self.xscale,

-self.cv.canvasy(event.y)/self.yscale)

fun(x, y)

except Exception:

pass

self.cv.tag_bind(item, "<Button%s-Motion>" % num, eventfun, add)

def _onscreenclick(self, fun, num=1, add=None):

"""Bind fun to mouse-click event on canvas.

if fun is None:

self.cv.unbind("<Button-%s>" % num)

else:

def eventfun(event):

x, y = (self.cv.canvasx(event.x)/self.xscale,

-self.cv.canvasy(event.y)/self.yscale)

fun(x, y)

self.cv.bind("<Button-%s>" % num, eventfun, add)

def _onkeyrelease(self, fun, key):

"""Bind fun to key-release event of key.

if fun is None:

self.cv.unbind("<KeyRelease-%s>" % key, None)

else:

def eventfun(event):

fun()

self.cv.bind("<KeyRelease-%s>" % key, eventfun)

def _onkeypress(self, fun, key=None):

"""If key is given, bind fun to key-press event of key.

if fun is None:

if key is None:

self.cv.unbind("<KeyPress>", None)

else:

self.cv.unbind("<KeyPress-%s>" % key, None)

else:

def eventfun(event):

fun()

if key is None:

self.cv.bind("<KeyPress>", eventfun)

else:

self.cv.bind("<KeyPress-%s>" % key, eventfun)

def _listen(self):

"""Set focus on canvas (in order to collect key-events)

self.cv.focus_force()

def _ontimer(self, fun, t):

"""Install a timer, which calls fun after t milliseconds.

if t == 0:

self.cv.after_idle(fun)

else:

self.cv.after(t, fun)

def _createimage(self, image):

"""Create and return image item on canvas.

return self.cv.create_image(0, 0, image=image)

def _drawimage(self, item, pos, image):

"""Configure image item as to draw image object

x, y = pos

self.cv.coords(item, (x * self.xscale, -y * self.yscale))

self.cv.itemconfig(item, image=image)

def _setbgpic(self, item, image):

"""Configure image item as to draw image object

self.cv.itemconfig(item, image=image)

self.cv.tag_lower(item)

def _type(self, item):

"""Return 'line' or 'polygon' or 'image' depending on

return self.cv.type(item)

def _pointlist(self, item):

"""returns list of coordinate-pairs of points of item

cl = self.cv.coords(item)

pl = [(cl[i], -cl[i+1]) for i in range(0, len(cl), 2)]

return pl

def _setscrollregion(self, srx1, sry1, srx2, sry2):

self.cv.config(scrollregion=(srx1, sry1, srx2, sry2))

def _rescale(self, xscalefactor, yscalefactor):

items = self.cv.find_all()

for item in items:

coordinates = list(self.cv.coords(item))

newcoordlist = []

while coordinates:

x, y = coordinates[:2]

newcoordlist.append(x * xscalefactor)

newcoordlist.append(y * yscalefactor)

coordinates = coordinates[2:]

self.cv.coords(item, *newcoordlist)

def _resize(self, canvwidth=None, canvheight=None, bg=None):

"""Resize the canvas the turtles are drawing on. Does

# needs amendment

if not isinstance(self.cv, ScrolledCanvas):

return self.canvwidth, self.canvheight

if canvwidth is canvheight is bg is None:

return self.cv.canvwidth, self.cv.canvheight

if canvwidth is not None:

self.canvwidth = canvwidth

if canvheight is not None:

self.canvheight = canvheight

self.cv.reset(canvwidth, canvheight, bg)

def _window_size(self):

""" Return the width and height of the turtle window.

width = self.cv.winfo_width()

if width <= 1: # the window isn't managed by a geometry manager

width = self.cv['width']

height = self.cv.winfo_height()

if height <= 1: # the window isn't managed by a geometry manager

height = self.cv['height']

return width, height

def mainloop(self):

"""Starts event loop - calling Tkinter's mainloop function.

self.cv.tk.mainloop()

def textinput(self, title, prompt):

"""Pop up a dialog window for input of a string.

return simpledialog.askstring(title, prompt, parent=self.cv)

def numinput(self, title, prompt, default=None, minval=None, maxval=None):

"""Pop up a dialog window for input of a number.

return simpledialog.askfloat(title, prompt, initialvalue=default,

minvalue=minval, maxvalue=maxval,

"""Will be raised in TurtleScreen.update, if _RUNNING becomes False.

"""Data structure modeling shapes.

def __init__(self, type_, data=None):

self._type = type_

if type_ == "polygon":

if isinstance(data, list):

data = tuple(data)

elif type_ == "image":

if isinstance(data, str):

if data.lower().endswith(".gif") and isfile(data):

data = TurtleScreen._image(data)

# else data assumed to be Photoimage

elif type_ == "compound":

data = []

else:

raise TurtleGraphicsError("There is no shape type %s" % type_)

self._data = data

def addcomponent(self, poly, fill, outline=None):

"""Add component to a shape of type compound.

if self._type != "compound":

raise TurtleGraphicsError("Cannot add component to %s Shape"

% self._type)

if outline is None:

outline = fill

"""Ring buffer used as undobuffer for RawTurtle objects."""

def __init__(self, bufsize=10):

self.bufsize = bufsize

self.buffer = [[None]] * bufsize

self.ptr = -1

self.cumulate = False

def reset(self, bufsize=None):

if bufsize is None:

for i in range(self.bufsize):

self.buffer[i] = [None]

else:

self.bufsize = bufsize

self.buffer = [[None]] * bufsize

self.ptr = -1

def push(self, item):

if self.bufsize > 0:

if not self.cumulate:

self.ptr = (self.ptr + 1) % self.bufsize

self.buffer[self.ptr] = item

else:

self.buffer[self.ptr].append(item)

def pop(self):

if self.bufsize > 0:

item = self.buffer[self.ptr]

if item is None:

return None

else:

self.buffer[self.ptr] = [None]

self.ptr = (self.ptr - 1) % self.bufsize

return (item)

def nr_of_items(self):

return self.bufsize - self.buffer.count([None])

def __repr__(self):

"""Provides screen oriented methods like setbg etc.

_RUNNING = True

def __init__(self, cv, mode=_CFG["mode"],

colormode=_CFG["colormode"], delay=_CFG["delay"]):

TurtleScreenBase.__init__(self, cv)

self._shapes = {

"arrow" : Shape("polygon", ((-10,0), (10,0), (0,10))),

"turtle" : Shape("polygon", ((0,16), (-2,14), (-1,10), (-4,7),

(-7,9), (-9,8), (-6,5), (-7,1), (-5,-3), (-8,-6),

(-6,-8), (-4,-5), (0,-7), (4,-5), (6,-8), (8,-6),

(5,-3), (7,1), (6,5), (9,8), (7,9), (4,7), (1,10),

(2,14))),

"circle" : Shape("polygon", ((10,0), (9.51,3.09), (8.09,5.88),

(5.88,8.09), (3.09,9.51), (0,10), (-3.09,9.51),

(-5.88,8.09), (-8.09,5.88), (-9.51,3.09), (-10,0),

(-9.51,-3.09), (-8.09,-5.88), (-5.88,-8.09),

(-3.09,-9.51), (-0.00,-10.00), (3.09,-9.51),

(5.88,-8.09), (8.09,-5.88), (9.51,-3.09))),

"square" : Shape("polygon", ((10,-10), (10,10), (-10,10),

(-10,-10))),

"triangle" : Shape("polygon", ((10,-5.77), (0,11.55),

(-10,-5.77))),

"classic": Shape("polygon", ((0,0),(-5,-9),(0,-7),(5,-9))),

"blank" : Shape("image", self._blankimage())

}

self._bgpics = {"nopic" : ""}

self._mode = mode

self._delayvalue = delay

self._colormode = _CFG["colormode"]

self._keys = []

self.clear()

if sys.platform == 'darwin':

# Force Turtle window to the front on OS X. This is needed because

# the Turtle window will show behind the Terminal window when you

# start the demo from the command line.

rootwindow = cv.winfo_toplevel()

rootwindow.call('wm', 'attributes', '.', '-topmost', '1')

rootwindow.call('wm', 'attributes', '.', '-topmost', '0')

def clear(self):

"""Delete all drawings and all turtles from the TurtleScreen.

self._delayvalue = _CFG["delay"]

self._colormode = _CFG["colormode"]

self._delete("all")

self._bgpic = self._createimage("")

self._bgpicname = "nopic"

self._tracing = 1

self._updatecounter = 0

self._turtles = []

self.bgcolor("white")

for btn in 1, 2, 3:

self.onclick(None, btn)

self.onkeypress(None)

for key in self._keys[:]:

self.onkey(None, key)

self.onkeypress(None, key)

Turtle._pen = None

def mode(self, mode=None):

"""Set turtle-mode ('standard', 'logo' or 'world') and perform reset.

if mode is None:

return self._mode

mode = mode.lower()

if mode not in ["standard", "logo", "world"]:

raise TurtleGraphicsError("No turtle-graphics-mode %s" % mode)

self._mode = mode

if mode in ["standard", "logo"]:

self._setscrollregion(-self.canvwidth//2, -self.canvheight//2,

self.canvwidth//2, self.canvheight//2)

self.xscale = self.yscale = 1.0

self.reset()

def setworldcoordinates(self, llx, lly, urx, ury):

"""Set up a user defined coordinate-system.

if self.mode() != "world":

self.mode("world")

xspan = float(urx - llx)

yspan = float(ury - lly)

wx, wy = self._window_size()

self.screensize(wx-20, wy-20)

oldxscale, oldyscale = self.xscale, self.yscale

self.xscale = self.canvwidth / xspan

self.yscale = self.canvheight / yspan

srx1 = llx * self.xscale

sry1 = -ury * self.yscale

srx2 = self.canvwidth + srx1