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

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

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

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

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

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

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

'fillcolor', 'fill', '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', 'poly', 'pos', 'position', 'pu', 'radians', 'right',

'reset', 'resizemode', 'rt', 'seth', 'setheading', 'setpos',

'setposition', 'setundobuffer', 'setx', 'sety', 'shape', 'shapesize',

'shapetransform', 'shearfactor', 'showturtle', 'speed', 'st', 'stamp',

'teleport', '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 the content of a config file into a dict."""

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 and update the 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 two-dimensional vector class, used as a helper class for

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 math.hypot(*self)

def rotate(self, angle):

"""Rotate self counterclockwise by angle."""

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

angle = math.radians(angle)

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 size, background color and scrollbars."""

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

self._updating = False

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 polygon item polyitem according to the given arguments.

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 line item lineitem according to the given 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."""

if self._updating:

# Reentrant call (e.g. a drag handler moving the turtle,

# gh-50966): flush drawing without reprocessing input.

self.cv.update_idletasks()

return

self._updating = True

try:

self.cv.update()

finally:

self._updating = False

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:

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 on the canvas with specified font and color.

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)

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):

"""Return 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.

# 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):

"""Start the event loop by 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":

assert(isinstance(data, TK.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 a 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 undo buffer 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 remove(self, item):

if item not in self.buffer:

return

index = self.buffer.index(item)

self.buffer.remove(item)

if index <= self.ptr:

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

self.buffer.insert((self.ptr+1) % self.bufsize, [None])

def nr_of_items(self):

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

def __repr__(self):

"""Provides screen oriented methods like bgcolor 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.wm_attributes(topmost=True)

rootwindow.wm_attributes(topmost=False)

# A new screen means that turtle graphics is running again.

TurtleScreen._RUNNING = True

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