Python code coverage for Lib/lib-tk/turtle.py

#	count	content
1	n/a	#
2	n/a	# turtle.py: a Tkinter based turtle graphics module for Python
3	n/a	# Version 1.0.1 - 24. 9. 2009
4	n/a	#
5	n/a	# Copyright (C) 2006 - 2010 Gregor Lingl
6	n/a	# email: glingl@aon.at
7	n/a	#
8	n/a	# This software is provided 'as-is', without any express or implied
9	n/a	# warranty. In no event will the authors be held liable for any damages
10	n/a	# arising from the use of this software.
11	n/a	#
12	n/a	# Permission is granted to anyone to use this software for any purpose,
13	n/a	# including commercial applications, and to alter it and redistribute it
14	n/a	# freely, subject to the following restrictions:
15	n/a	#
16	n/a	# 1. The origin of this software must not be misrepresented; you must not
17	n/a	# claim that you wrote the original software. If you use this software
18	n/a	# in a product, an acknowledgment in the product documentation would be
19	n/a	# appreciated but is not required.
20	n/a	# 2. Altered source versions must be plainly marked as such, and must not be
21	n/a	# misrepresented as being the original software.
22	n/a	# 3. This notice may not be removed or altered from any source distribution.
23	n/a
24	n/a
25	n/a	"""
26	n/a	Turtle graphics is a popular way for introducing programming to
27	n/a	kids. It was part of the original Logo programming language developed
28	n/a	by Wally Feurzig and Seymour Papert in 1966.
29	n/a
30	n/a	Imagine a robotic turtle starting at (0, 0) in the x-y plane. Give it
31	n/a	the command turtle.forward(15), and it moves (on-screen!) 15 pixels in
32	n/a	the direction it is facing, drawing a line as it moves. Give it the
33	n/a	command turtle.left(25), and it rotates in-place 25 degrees clockwise.
34	n/a
35	n/a	By combining together these and similar commands, intricate shapes and
36	n/a	pictures can easily be drawn.
37	n/a
38	n/a	----- turtle.py
39	n/a
40	n/a	This module is an extended reimplementation of turtle.py from the
41	n/a	Python standard distribution up to Python 2.5. (See: http://www.python.org)
42	n/a
43	n/a	It tries to keep the merits of turtle.py and to be (nearly) 100%
44	n/a	compatible with it. This means in the first place to enable the
45	n/a	learning programmer to use all the commands, classes and methods
46	n/a	interactively when using the module from within IDLE run with
47	n/a	the -n switch.
48	n/a
49	n/a	Roughly it has the following features added:
50	n/a
51	n/a	- Better animation of the turtle movements, especially of turning the
52	n/a	turtle. So the turtles can more easily be used as a visual feedback
53	n/a	instrument by the (beginning) programmer.
54	n/a
55	n/a	- Different turtle shapes, gif-images as turtle shapes, user defined
56	n/a	and user controllable turtle shapes, among them compound
57	n/a	(multicolored) shapes. Turtle shapes can be stretched and tilted, which
58	n/a	makes turtles very versatile geometrical objects.
59	n/a
60	n/a	- Fine control over turtle movement and screen updates via delay(),
61	n/a	and enhanced tracer() and speed() methods.
62	n/a
63	n/a	- Aliases for the most commonly used commands, like fd for forward etc.,
64	n/a	following the early Logo traditions. This reduces the boring work of
65	n/a	typing long sequences of commands, which often occur in a natural way
66	n/a	when kids try to program fancy pictures on their first encounter with
67	n/a	turtle graphics.
68	n/a
69	n/a	- Turtles now have an undo()-method with configurable undo-buffer.
70	n/a
71	n/a	- Some simple commands/methods for creating event driven programs
72	n/a	(mouse-, key-, timer-events). Especially useful for programming games.
73	n/a
74	n/a	- A scrollable Canvas class. The default scrollable Canvas can be
75	n/a	extended interactively as needed while playing around with the turtle(s).
76	n/a
77	n/a	- A TurtleScreen class with methods controlling background color or
78	n/a	background image, window and canvas size and other properties of the
79	n/a	TurtleScreen.
80	n/a
81	n/a	- There is a method, setworldcoordinates(), to install a user defined
82	n/a	coordinate-system for the TurtleScreen.
83	n/a
84	n/a	- The implementation uses a 2-vector class named Vec2D, derived from tuple.
85	n/a	This class is public, so it can be imported by the application programmer,
86	n/a	which makes certain types of computations very natural and compact.
87	n/a
88	n/a	- Appearance of the TurtleScreen and the Turtles at startup/import can be
89	n/a	configured by means of a turtle.cfg configuration file.
90	n/a	The default configuration mimics the appearance of the old turtle module.
91	n/a
92	n/a	- If configured appropriately the module reads in docstrings from a docstring
93	n/a	dictionary in some different language, supplied separately and replaces
94	n/a	the English ones by those read in. There is a utility function
95	n/a	write_docstringdict() to write a dictionary with the original (English)
96	n/a	docstrings to disc, so it can serve as a template for translations.
97	n/a
98	n/a	Behind the scenes there are some features included with possible
99	n/a	extensions in in mind. These will be commented and documented elsewhere.
100	n/a
101	n/a	"""
102	n/a
103	n/a	_ver = "turtle 1.0b1 - for Python 2.6 - 30. 5. 2008, 18:08"
104	n/a
105	n/a	#print _ver
106	n/a
107	n/a	import Tkinter as TK
108	n/a	import types
109	n/a	import math
110	n/a	import time
111	n/a	import os
112	n/a
113	n/a	from os.path import isfile, split, join
114	n/a	from copy import deepcopy
115	n/a
116	n/a	from math import * ## for compatibility with old turtle module
117	n/a
118	n/a	_tg_classes = ['ScrolledCanvas', 'TurtleScreen', 'Screen',
119	n/a	'RawTurtle', 'Turtle', 'RawPen', 'Pen', 'Shape', 'Vec2D']
120	n/a	_tg_screen_functions = ['addshape', 'bgcolor', 'bgpic', 'bye',
121	n/a	'clearscreen', 'colormode', 'delay', 'exitonclick', 'getcanvas',
122	n/a	'getshapes', 'listen', 'mode', 'onkey', 'onscreenclick', 'ontimer',
123	n/a	'register_shape', 'resetscreen', 'screensize', 'setup',
124	n/a	'setworldcoordinates', 'title', 'tracer', 'turtles', 'update',
125	n/a	'window_height', 'window_width']
126	n/a	_tg_turtle_functions = ['back', 'backward', 'begin_fill', 'begin_poly', 'bk',
127	n/a	'circle', 'clear', 'clearstamp', 'clearstamps', 'clone', 'color',
128	n/a	'degrees', 'distance', 'dot', 'down', 'end_fill', 'end_poly', 'fd',
129	n/a	'fill', 'fillcolor', 'forward', 'get_poly', 'getpen', 'getscreen',
130	n/a	'getturtle', 'goto', 'heading', 'hideturtle', 'home', 'ht', 'isdown',
131	n/a	'isvisible', 'left', 'lt', 'onclick', 'ondrag', 'onrelease', 'pd',
132	n/a	'pen', 'pencolor', 'pendown', 'pensize', 'penup', 'pos', 'position',
133	n/a	'pu', 'radians', 'right', 'reset', 'resizemode', 'rt',
134	n/a	'seth', 'setheading', 'setpos', 'setposition', 'settiltangle',
135	n/a	'setundobuffer', 'setx', 'sety', 'shape', 'shapesize', 'showturtle',
136	n/a	'speed', 'st', 'stamp', 'tilt', 'tiltangle', 'towards', 'tracer',
137	n/a	'turtlesize', 'undo', 'undobufferentries', 'up', 'width',
138	n/a	'window_height', 'window_width', 'write', 'xcor', 'ycor']
139	n/a	_tg_utilities = ['write_docstringdict', 'done', 'mainloop']
140	n/a	_math_functions = ['acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh',
141	n/a	'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
142	n/a	'log10', 'modf', 'pi', 'pow', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']
143	n/a
144	n/a	__all__ = (_tg_classes + _tg_screen_functions + _tg_turtle_functions +
145	n/a	_tg_utilities + _math_functions)
146	n/a
147	n/a	_alias_list = ['addshape', 'backward', 'bk', 'fd', 'ht', 'lt', 'pd', 'pos',
148	n/a	'pu', 'rt', 'seth', 'setpos', 'setposition', 'st',
149	n/a	'turtlesize', 'up', 'width']
150	n/a
151	n/a	_CFG = {"width" : 0.5, # Screen
152	n/a	"height" : 0.75,
153	n/a	"canvwidth" : 400,
154	n/a	"canvheight": 300,
155	n/a	"leftright": None,
156	n/a	"topbottom": None,
157	n/a	"mode": "standard", # TurtleScreen
158	n/a	"colormode": 1.0,
159	n/a	"delay": 10,
160	n/a	"undobuffersize": 1000, # RawTurtle
161	n/a	"shape": "classic",
162	n/a	"pencolor" : "black",
163	n/a	"fillcolor" : "black",
164	n/a	"resizemode" : "noresize",
165	n/a	"visible" : True,
166	n/a	"language": "english", # docstrings
167	n/a	"exampleturtle": "turtle",
168	n/a	"examplescreen": "screen",
169	n/a	"title": "Python Turtle Graphics",
170	n/a	"using_IDLE": False
171	n/a	}
172	n/a
173	n/a	##print "cwd:", os.getcwd()
174	n/a	##print "__file__:", __file__
175	n/a	##
176	n/a	##def show(dictionary):
177	n/a	## print "=========================="
178	n/a	## for key in sorted(dictionary.keys()):
179	n/a	## print key, ":", dictionary[key]
180	n/a	## print "=========================="
181	n/a	## print
182	n/a
183	n/a	def config_dict(filename):
184	n/a	"""Convert content of config-file into dictionary."""
185	n/a	f = open(filename, "r")
186	n/a	cfglines = f.readlines()
187	n/a	f.close()
188	n/a	cfgdict = {}
189	n/a	for line in cfglines:
190	n/a	line = line.strip()
191	n/a	if not line or line.startswith("#"):
192	n/a	continue
193	n/a	try:
194	n/a	key, value = line.split("=")
195	n/a	except:
196	n/a	print "Bad line in config-file %s:\n%s" % (filename,line)
197	n/a	continue
198	n/a	key = key.strip()
199	n/a	value = value.strip()
200	n/a	if value in ["True", "False", "None", "''", '""']:
201	n/a	value = eval(value)
202	n/a	else:
203	n/a	try:
204	n/a	if "." in value:
205	n/a	value = float(value)
206	n/a	else:
207	n/a	value = int(value)
208	n/a	except:
209	n/a	pass # value need not be converted
210	n/a	cfgdict[key] = value
211	n/a	return cfgdict
212	n/a
213	n/a	def readconfig(cfgdict):
214	n/a	"""Read config-files, change configuration-dict accordingly.
215	n/a
216	n/a	If there is a turtle.cfg file in the current working directory,
217	n/a	read it from there. If this contains an importconfig-value,
218	n/a	say 'myway', construct filename turtle_mayway.cfg else use
219	n/a	turtle.cfg and read it from the import-directory, where
220	n/a	turtle.py is located.
221	n/a	Update configuration dictionary first according to config-file,
222	n/a	in the import directory, then according to config-file in the
223	n/a	current working directory.
224	n/a	If no config-file is found, the default configuration is used.
225	n/a	"""
226	n/a	default_cfg = "turtle.cfg"
227	n/a	cfgdict1 = {}
228	n/a	cfgdict2 = {}
229	n/a	if isfile(default_cfg):
230	n/a	cfgdict1 = config_dict(default_cfg)
231	n/a	#print "1. Loading config-file %s from: %s" % (default_cfg, os.getcwd())
232	n/a	if "importconfig" in cfgdict1:
233	n/a	default_cfg = "turtle_%s.cfg" % cfgdict1["importconfig"]
234	n/a	try:
235	n/a	head, tail = split(__file__)
236	n/a	cfg_file2 = join(head, default_cfg)
237	n/a	except:
238	n/a	cfg_file2 = ""
239	n/a	if isfile(cfg_file2):
240	n/a	#print "2. Loading config-file %s:" % cfg_file2
241	n/a	cfgdict2 = config_dict(cfg_file2)
242	n/a	## show(_CFG)
243	n/a	## show(cfgdict2)
244	n/a	_CFG.update(cfgdict2)
245	n/a	## show(_CFG)
246	n/a	## show(cfgdict1)
247	n/a	_CFG.update(cfgdict1)
248	n/a	## show(_CFG)
249	n/a
250	n/a	try:
251	n/a	readconfig(_CFG)
252	n/a	except:
253	n/a	print "No configfile read, reason unknown"
254	n/a
255	n/a
256	n/a	class Vec2D(tuple):
257	n/a	"""A 2 dimensional vector class, used as a helper class
258	n/a	for implementing turtle graphics.
259	n/a	May be useful for turtle graphics programs also.
260	n/a	Derived from tuple, so a vector is a tuple!
261	n/a
262	n/a	Provides (for a, b vectors, k number):
263	n/a	a+b vector addition
264	n/a	a-b vector subtraction
265	n/a	a*b inner product
266	n/a	ka and ak multiplication with scalar
267	n/a	\|a\| absolute value of a
268	n/a	a.rotate(angle) rotation
269	n/a	"""
270	n/a	def __new__(cls, x, y):
271	n/a	return tuple.__new__(cls, (x, y))
272	n/a	def __add__(self, other):
273	n/a	return Vec2D(self[0]+other[0], self[1]+other[1])
274	n/a	def __mul__(self, other):
275	n/a	if isinstance(other, Vec2D):
276	n/a	return self[0]other[0]+self[1]other[1]
277	n/a	return Vec2D(self[0]other, self[1]other)
278	n/a	def __rmul__(self, other):
279	n/a	if isinstance(other, int) or isinstance(other, float):
280	n/a	return Vec2D(self[0]other, self[1]other)
281	n/a	def __sub__(self, other):
282	n/a	return Vec2D(self[0]-other[0], self[1]-other[1])
283	n/a	def __neg__(self):
284	n/a	return Vec2D(-self[0], -self[1])
285	n/a	def __abs__(self):
286	n/a	return (self[0]2 + self[1]2)**0.5
287	n/a	def rotate(self, angle):
288	n/a	"""rotate self counterclockwise by angle
289	n/a	"""
290	n/a	perp = Vec2D(-self[1], self[0])
291	n/a	angle = angle * math.pi / 180.0
292	n/a	c, s = math.cos(angle), math.sin(angle)
293	n/a	return Vec2D(self[0]c+perp[0]s, self[1]c+perp[1]s)
294	n/a	def __getnewargs__(self):
295	n/a	return (self[0], self[1])
296	n/a	def __repr__(self):
297	n/a	return "(%.2f,%.2f)" % self
298	n/a
299	n/a
300	n/a	##############################################################################
301	n/a	### From here up to line : Tkinter - Interface for turtle.py ###
302	n/a	### May be replaced by an interface to some different graphics toolkit ###
303	n/a	##############################################################################
304	n/a
305	n/a	## helper functions for Scrolled Canvas, to forward Canvas-methods
306	n/a	## to ScrolledCanvas class
307	n/a
308	n/a	def __methodDict(cls, _dict):
309	n/a	"""helper function for Scrolled Canvas"""
310	n/a	baseList = list(cls.__bases__)
311	n/a	baseList.reverse()
312	n/a	for _super in baseList:
313	n/a	__methodDict(_super, _dict)
314	n/a	for key, value in cls.__dict__.items():
315	n/a	if type(value) == types.FunctionType:
316	n/a	_dict[key] = value
317	n/a
318	n/a	def __methods(cls):
319	n/a	"""helper function for Scrolled Canvas"""
320	n/a	_dict = {}
321	n/a	__methodDict(cls, _dict)
322	n/a	return _dict.keys()
323	n/a
324	n/a	__stringBody = (
325	n/a	'def %(method)s(self, args, *kw): return ' +
326	n/a	'self.%(attribute)s.%(method)s(args, *kw)')
327	n/a
328	n/a	def __forwardmethods(fromClass, toClass, toPart, exclude = ()):
329	n/a	"""Helper functions for Scrolled Canvas, used to forward
330	n/a	ScrolledCanvas-methods to Tkinter.Canvas class.
331	n/a	"""
332	n/a	_dict = {}
333	n/a	__methodDict(toClass, _dict)
334	n/a	for ex in _dict.keys():
335	n/a	if ex[:1] == '_' or ex[-1:] == '_':
336	n/a	del _dict[ex]
337	n/a	for ex in exclude:
338	n/a	if ex in _dict:
339	n/a	del _dict[ex]
340	n/a	for ex in __methods(fromClass):
341	n/a	if ex in _dict:
342	n/a	del _dict[ex]
343	n/a
344	n/a	for method, func in _dict.items():
345	n/a	d = {'method': method, 'func': func}
346	n/a	if type(toPart) == types.StringType:
347	n/a	execString = \
348	n/a	__stringBody % {'method' : method, 'attribute' : toPart}
349	n/a	exec execString in d
350	n/a	fromClass.__dict__[method] = d[method]
351	n/a
352	n/a
353	n/a	class ScrolledCanvas(TK.Frame):
354	n/a	"""Modeled after the scrolled canvas class from Grayons's Tkinter book.
355	n/a
356	n/a	Used as the default canvas, which pops up automatically when
357	n/a	using turtle graphics functions or the Turtle class.
358	n/a	"""
359	n/a	def __init__(self, master, width=500, height=350,
360	n/a	canvwidth=600, canvheight=500):
361	n/a	TK.Frame.__init__(self, master, width=width, height=height)
362	n/a	self._rootwindow = self.winfo_toplevel()
363	n/a	self.width, self.height = width, height
364	n/a	self.canvwidth, self.canvheight = canvwidth, canvheight
365	n/a	self.bg = "white"
366	n/a	self._canvas = TK.Canvas(master, width=width, height=height,
367	n/a	bg=self.bg, relief=TK.SUNKEN, borderwidth=2)
368	n/a	self.hscroll = TK.Scrollbar(master, command=self._canvas.xview,
369	n/a	orient=TK.HORIZONTAL)
370	n/a	self.vscroll = TK.Scrollbar(master, command=self._canvas.yview)
371	n/a	self._canvas.configure(xscrollcommand=self.hscroll.set,
372	n/a	yscrollcommand=self.vscroll.set)
373	n/a	self.rowconfigure(0, weight=1, minsize=0)
374	n/a	self.columnconfigure(0, weight=1, minsize=0)
375	n/a	self._canvas.grid(padx=1, in_ = self, pady=1, row=0,
376	n/a	column=0, rowspan=1, columnspan=1, sticky='news')
377	n/a	self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,
378	n/a	column=1, rowspan=1, columnspan=1, sticky='news')
379	n/a	self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,
380	n/a	column=0, rowspan=1, columnspan=1, sticky='news')
381	n/a	self.reset()
382	n/a	self._rootwindow.bind('<Configure>', self.onResize)
383	n/a
384	n/a	def reset(self, canvwidth=None, canvheight=None, bg = None):
385	n/a	"""Adjust canvas and scrollbars according to given canvas size."""
386	n/a	if canvwidth:
387	n/a	self.canvwidth = canvwidth
388	n/a	if canvheight:
389	n/a	self.canvheight = canvheight
390	n/a	if bg:
391	n/a	self.bg = bg
392	n/a	self._canvas.config(bg=bg,
393	n/a	scrollregion=(-self.canvwidth//2, -self.canvheight//2,
394	n/a	self.canvwidth//2, self.canvheight//2))
395	n/a	self._canvas.xview_moveto(0.5*(self.canvwidth - self.width + 30) /
396	n/a	self.canvwidth)
397	n/a	self._canvas.yview_moveto(0.5*(self.canvheight- self.height + 30) /
398	n/a	self.canvheight)
399	n/a	self.adjustScrolls()
400	n/a
401	n/a
402	n/a	def adjustScrolls(self):
403	n/a	""" Adjust scrollbars according to window- and canvas-size.
404	n/a	"""
405	n/a	cwidth = self._canvas.winfo_width()
406	n/a	cheight = self._canvas.winfo_height()
407	n/a	self._canvas.xview_moveto(0.5*(self.canvwidth-cwidth)/self.canvwidth)
408	n/a	self._canvas.yview_moveto(0.5*(self.canvheight-cheight)/self.canvheight)
409	n/a	if cwidth < self.canvwidth or cheight < self.canvheight:
410	n/a	self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,
411	n/a	column=0, rowspan=1, columnspan=1, sticky='news')
412	n/a	self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,
413	n/a	column=1, rowspan=1, columnspan=1, sticky='news')
414	n/a	else:
415	n/a	self.hscroll.grid_forget()
416	n/a	self.vscroll.grid_forget()
417	n/a
418	n/a	def onResize(self, event):
419	n/a	"""self-explanatory"""
420	n/a	self.adjustScrolls()
421	n/a
422	n/a	def bbox(self, *args):
423	n/a	""" 'forward' method, which canvas itself has inherited...
424	n/a	"""
425	n/a	return self._canvas.bbox(*args)
426	n/a
427	n/a	def cget(self, args, *kwargs):
428	n/a	""" 'forward' method, which canvas itself has inherited...
429	n/a	"""
430	n/a	return self._canvas.cget(args, *kwargs)
431	n/a
432	n/a	def config(self, args, *kwargs):
433	n/a	""" 'forward' method, which canvas itself has inherited...
434	n/a	"""
435	n/a	self._canvas.config(args, *kwargs)
436	n/a
437	n/a	def bind(self, args, *kwargs):
438	n/a	""" 'forward' method, which canvas itself has inherited...
439	n/a	"""
440	n/a	self._canvas.bind(args, *kwargs)
441	n/a
442	n/a	def unbind(self, args, *kwargs):
443	n/a	""" 'forward' method, which canvas itself has inherited...
444	n/a	"""
445	n/a	self._canvas.unbind(args, *kwargs)
446	n/a
447	n/a	def focus_force(self):
448	n/a	""" 'forward' method, which canvas itself has inherited...
449	n/a	"""
450	n/a	self._canvas.focus_force()
451	n/a
452	n/a	__forwardmethods(ScrolledCanvas, TK.Canvas, '_canvas')
453	n/a
454	n/a
455	n/a	class _Root(TK.Tk):
456	n/a	"""Root class for Screen based on Tkinter."""
457	n/a	def __init__(self):
458	n/a	TK.Tk.__init__(self)
459	n/a
460	n/a	def setupcanvas(self, width, height, cwidth, cheight):
461	n/a	self._canvas = ScrolledCanvas(self, width, height, cwidth, cheight)
462	n/a	self._canvas.pack(expand=1, fill="both")
463	n/a
464	n/a	def _getcanvas(self):
465	n/a	return self._canvas
466	n/a
467	n/a	def set_geometry(self, width, height, startx, starty):
468	n/a	self.geometry("%dx%d%+d%+d"%(width, height, startx, starty))
469	n/a
470	n/a	def ondestroy(self, destroy):
471	n/a	self.wm_protocol("WM_DELETE_WINDOW", destroy)
472	n/a
473	n/a	def win_width(self):
474	n/a	return self.winfo_screenwidth()
475	n/a
476	n/a	def win_height(self):
477	n/a	return self.winfo_screenheight()
478	n/a
479	n/a	Canvas = TK.Canvas
480	n/a
481	n/a
482	n/a	class TurtleScreenBase(object):
483	n/a	"""Provide the basic graphics functionality.
484	n/a	Interface between Tkinter and turtle.py.
485	n/a
486	n/a	To port turtle.py to some different graphics toolkit
487	n/a	a corresponding TurtleScreenBase class has to be implemented.
488	n/a	"""
489	n/a
490	n/a	@staticmethod
491	n/a	def _blankimage():
492	n/a	"""return a blank image object
493	n/a	"""
494	n/a	img = TK.PhotoImage(width=1, height=1)
495	n/a	img.blank()
496	n/a	return img
497	n/a
498	n/a	@staticmethod
499	n/a	def _image(filename):
500	n/a	"""return an image object containing the
501	n/a	imagedata from a gif-file named filename.
502	n/a	"""
503	n/a	return TK.PhotoImage(file=filename)
504	n/a
505	n/a	def __init__(self, cv):
506	n/a	self.cv = cv
507	n/a	if isinstance(cv, ScrolledCanvas):
508	n/a	w = self.cv.canvwidth
509	n/a	h = self.cv.canvheight
510	n/a	else: # expected: ordinary TK.Canvas
511	n/a	w = int(self.cv.cget("width"))
512	n/a	h = int(self.cv.cget("height"))
513	n/a	self.cv.config(scrollregion = (-w//2, -h//2, w//2, h//2 ))
514	n/a	self.canvwidth = w
515	n/a	self.canvheight = h
516	n/a	self.xscale = self.yscale = 1.0
517	n/a
518	n/a	def _createpoly(self):
519	n/a	"""Create an invisible polygon item on canvas self.cv)
520	n/a	"""
521	n/a	return self.cv.create_polygon((0, 0, 0, 0, 0, 0), fill="", outline="")
522	n/a
523	n/a	def _drawpoly(self, polyitem, coordlist, fill=None,
524	n/a	outline=None, width=None, top=False):
525	n/a	"""Configure polygonitem polyitem according to provided
526	n/a	arguments:
527	n/a	coordlist is sequence of coordinates
528	n/a	fill is filling color
529	n/a	outline is outline color
530	n/a	top is a boolean value, which specifies if polyitem
531	n/a	will be put on top of the canvas' displaylist so it
532	n/a	will not be covered by other items.
533	n/a	"""
534	n/a	cl = []
535	n/a	for x, y in coordlist:
536	n/a	cl.append(x * self.xscale)
537	n/a	cl.append(-y * self.yscale)
538	n/a	self.cv.coords(polyitem, *cl)
539	n/a	if fill is not None:
540	n/a	self.cv.itemconfigure(polyitem, fill=fill)
541	n/a	if outline is not None:
542	n/a	self.cv.itemconfigure(polyitem, outline=outline)
543	n/a	if width is not None:
544	n/a	self.cv.itemconfigure(polyitem, width=width)
545	n/a	if top:
546	n/a	self.cv.tag_raise(polyitem)
547	n/a
548	n/a	def _createline(self):
549	n/a	"""Create an invisible line item on canvas self.cv)
550	n/a	"""
551	n/a	return self.cv.create_line(0, 0, 0, 0, fill="", width=2,
552	n/a	capstyle = TK.ROUND)
553	n/a
554	n/a	def _drawline(self, lineitem, coordlist=None,
555	n/a	fill=None, width=None, top=False):
556	n/a	"""Configure lineitem according to provided arguments:
557	n/a	coordlist is sequence of coordinates
558	n/a	fill is drawing color
559	n/a	width is width of drawn line.
560	n/a	top is a boolean value, which specifies if polyitem
561	n/a	will be put on top of the canvas' displaylist so it
562	n/a	will not be covered by other items.
563	n/a	"""
564	n/a	if coordlist is not None:
565	n/a	cl = []
566	n/a	for x, y in coordlist:
567	n/a	cl.append(x * self.xscale)
568	n/a	cl.append(-y * self.yscale)
569	n/a	self.cv.coords(lineitem, *cl)
570	n/a	if fill is not None:
571	n/a	self.cv.itemconfigure(lineitem, fill=fill)
572	n/a	if width is not None:
573	n/a	self.cv.itemconfigure(lineitem, width=width)
574	n/a	if top:
575	n/a	self.cv.tag_raise(lineitem)
576	n/a
577	n/a	def _delete(self, item):
578	n/a	"""Delete graphics item from canvas.
579	n/a	If item is"all" delete all graphics items.
580	n/a	"""
581	n/a	self.cv.delete(item)
582	n/a
583	n/a	def _update(self):
584	n/a	"""Redraw graphics items on canvas
585	n/a	"""
586	n/a	self.cv.update()
587	n/a
588	n/a	def _delay(self, delay):
589	n/a	"""Delay subsequent canvas actions for delay ms."""
590	n/a	self.cv.after(delay)
591	n/a
592	n/a	def _iscolorstring(self, color):
593	n/a	"""Check if the string color is a legal Tkinter color string.
594	n/a	"""
595	n/a	try:
596	n/a	rgb = self.cv.winfo_rgb(color)
597	n/a	ok = True
598	n/a	except TK.TclError:
599	n/a	ok = False
600	n/a	return ok
601	n/a
602	n/a	def _bgcolor(self, color=None):
603	n/a	"""Set canvas' backgroundcolor if color is not None,
604	n/a	else return backgroundcolor."""
605	n/a	if color is not None:
606	n/a	self.cv.config(bg = color)
607	n/a	self._update()
608	n/a	else:
609	n/a	return self.cv.cget("bg")
610	n/a
611	n/a	def _write(self, pos, txt, align, font, pencolor):
612	n/a	"""Write txt at pos in canvas with specified font
613	n/a	and color.
614	n/a	Return text item and x-coord of right bottom corner
615	n/a	of text's bounding box."""
616	n/a	x, y = pos
617	n/a	x = x * self.xscale
618	n/a	y = y * self.yscale
619	n/a	anchor = {"left":"sw", "center":"s", "right":"se" }
620	n/a	item = self.cv.create_text(x-1, -y, text = txt, anchor = anchor[align],
621	n/a	fill = pencolor, font = font)
622	n/a	x0, y0, x1, y1 = self.cv.bbox(item)
623	n/a	self.cv.update()
624	n/a	return item, x1-1
625	n/a
626	n/a	## def _dot(self, pos, size, color):
627	n/a	## """may be implemented for some other graphics toolkit"""
628	n/a
629	n/a	def _onclick(self, item, fun, num=1, add=None):
630	n/a	"""Bind fun to mouse-click event on turtle.
631	n/a	fun must be a function with two arguments, the coordinates
632	n/a	of the clicked point on the canvas.
633	n/a	num, the number of the mouse-button defaults to 1
634	n/a	"""
635	n/a	if fun is None:
636	n/a	self.cv.tag_unbind(item, "<Button-%s>" % num)
637	n/a	else:
638	n/a	def eventfun(event):
639	n/a	x, y = (self.cv.canvasx(event.x)/self.xscale,
640	n/a	-self.cv.canvasy(event.y)/self.yscale)
641	n/a	fun(x, y)
642	n/a	self.cv.tag_bind(item, "<Button-%s>" % num, eventfun, add)
643	n/a
644	n/a	def _onrelease(self, item, fun, num=1, add=None):
645	n/a	"""Bind fun to mouse-button-release event on turtle.
646	n/a	fun must be a function with two arguments, the coordinates
647	n/a	of the point on the canvas where mouse button is released.
648	n/a	num, the number of the mouse-button defaults to 1
649	n/a
650	n/a	If a turtle is clicked, first _onclick-event will be performed,
651	n/a	then _onscreensclick-event.
652	n/a	"""
653	n/a	if fun is None:
654	n/a	self.cv.tag_unbind(item, "<Button%s-ButtonRelease>" % num)
655	n/a	else:
656	n/a	def eventfun(event):
657	n/a	x, y = (self.cv.canvasx(event.x)/self.xscale,
658	n/a	-self.cv.canvasy(event.y)/self.yscale)
659	n/a	fun(x, y)
660	n/a	self.cv.tag_bind(item, "<Button%s-ButtonRelease>" % num,
661	n/a	eventfun, add)
662	n/a
663	n/a	def _ondrag(self, item, fun, num=1, add=None):
664	n/a	"""Bind fun to mouse-move-event (with pressed mouse button) on turtle.
665	n/a	fun must be a function with two arguments, the coordinates of the
666	n/a	actual mouse position on the canvas.
667	n/a	num, the number of the mouse-button defaults to 1
668	n/a
669	n/a	Every sequence of mouse-move-events on a turtle is preceded by a
670	n/a	mouse-click event on that turtle.
671	n/a	"""
672	n/a	if fun is None:
673	n/a	self.cv.tag_unbind(item, "<Button%s-Motion>" % num)
674	n/a	else:
675	n/a	def eventfun(event):
676	n/a	try:
677	n/a	x, y = (self.cv.canvasx(event.x)/self.xscale,
678	n/a	-self.cv.canvasy(event.y)/self.yscale)
679	n/a	fun(x, y)
680	n/a	except:
681	n/a	pass
682	n/a	self.cv.tag_bind(item, "<Button%s-Motion>" % num, eventfun, add)
683	n/a
684	n/a	def _onscreenclick(self, fun, num=1, add=None):
685	n/a	"""Bind fun to mouse-click event on canvas.
686	n/a	fun must be a function with two arguments, the coordinates
687	n/a	of the clicked point on the canvas.
688	n/a	num, the number of the mouse-button defaults to 1
689	n/a
690	n/a	If a turtle is clicked, first _onclick-event will be performed,
691	n/a	then _onscreensclick-event.
692	n/a	"""
693	n/a	if fun is None:
694	n/a	self.cv.unbind("<Button-%s>" % num)
695	n/a	else:
696	n/a	def eventfun(event):
697	n/a	x, y = (self.cv.canvasx(event.x)/self.xscale,
698	n/a	-self.cv.canvasy(event.y)/self.yscale)
699	n/a	fun(x, y)
700	n/a	self.cv.bind("<Button-%s>" % num, eventfun, add)
701	n/a
702	n/a	def _onkey(self, fun, key):
703	n/a	"""Bind fun to key-release event of key.
704	n/a	Canvas must have focus. See method listen
705	n/a	"""
706	n/a	if fun is None:
707	n/a	self.cv.unbind("<KeyRelease-%s>" % key, None)
708	n/a	else:
709	n/a	def eventfun(event):
710	n/a	fun()
711	n/a	self.cv.bind("<KeyRelease-%s>" % key, eventfun)
712	n/a
713	n/a	def _listen(self):
714	n/a	"""Set focus on canvas (in order to collect key-events)
715	n/a	"""
716	n/a	self.cv.focus_force()
717	n/a
718	n/a	def _ontimer(self, fun, t):
719	n/a	"""Install a timer, which calls fun after t milliseconds.
720	n/a	"""
721	n/a	if t == 0:
722	n/a	self.cv.after_idle(fun)
723	n/a	else:
724	n/a	self.cv.after(t, fun)
725	n/a
726	n/a	def _createimage(self, image):
727	n/a	"""Create and return image item on canvas.
728	n/a	"""
729	n/a	return self.cv.create_image(0, 0, image=image)
730	n/a
731	n/a	def _drawimage(self, item, (x, y), image):
732	n/a	"""Configure image item as to draw image object
733	n/a	at position (x,y) on canvas)
734	n/a	"""
735	n/a	self.cv.coords(item, (x * self.xscale, -y * self.yscale))
736	n/a	self.cv.itemconfig(item, image=image)
737	n/a
738	n/a	def _setbgpic(self, item, image):
739	n/a	"""Configure image item as to draw image object
740	n/a	at center of canvas. Set item to the first item
741	n/a	in the displaylist, so it will be drawn below
742	n/a	any other item ."""
743	n/a	self.cv.itemconfig(item, image=image)
744	n/a	self.cv.tag_lower(item)
745	n/a
746	n/a	def _type(self, item):
747	n/a	"""Return 'line' or 'polygon' or 'image' depending on
748	n/a	type of item.
749	n/a	"""
750	n/a	return self.cv.type(item)
751	n/a
752	n/a	def _pointlist(self, item):
753	n/a	"""returns list of coordinate-pairs of points of item
754	n/a	Example (for insiders):
755	n/a	>>> from turtle import *
756	n/a	>>> getscreen()._pointlist(getturtle().turtle._item)
757	n/a	[(0.0, 9.9999999999999982), (0.0, -9.9999999999999982),
758	n/a	(9.9999999999999982, 0.0)]
759	n/a	>>> """
760	n/a	cl = self.cv.coords(item)
761	n/a	pl = [(cl[i], -cl[i+1]) for i in range(0, len(cl), 2)]
762	n/a	return pl
763	n/a
764	n/a	def _setscrollregion(self, srx1, sry1, srx2, sry2):
765	n/a	self.cv.config(scrollregion=(srx1, sry1, srx2, sry2))
766	n/a
767	n/a	def _rescale(self, xscalefactor, yscalefactor):
768	n/a	items = self.cv.find_all()
769	n/a	for item in items:
770	n/a	coordinates = self.cv.coords(item)
771	n/a	newcoordlist = []
772	n/a	while coordinates:
773	n/a	x, y = coordinates[:2]
774	n/a	newcoordlist.append(x * xscalefactor)
775	n/a	newcoordlist.append(y * yscalefactor)
776	n/a	coordinates = coordinates[2:]
777	n/a	self.cv.coords(item, *newcoordlist)
778	n/a
779	n/a	def _resize(self, canvwidth=None, canvheight=None, bg=None):
780	n/a	"""Resize the canvas the turtles are drawing on. Does
781	n/a	not alter the drawing window.
782	n/a	"""
783	n/a	# needs amendment
784	n/a	if not isinstance(self.cv, ScrolledCanvas):
785	n/a	return self.canvwidth, self.canvheight
786	n/a	if canvwidth is canvheight is bg is None:
787	n/a	return self.cv.canvwidth, self.cv.canvheight
788	n/a	if canvwidth is not None:
789	n/a	self.canvwidth = canvwidth
790	n/a	if canvheight is not None:
791	n/a	self.canvheight = canvheight
792	n/a	self.cv.reset(canvwidth, canvheight, bg)
793	n/a
794	n/a	def _window_size(self):
795	n/a	""" Return the width and height of the turtle window.
796	n/a	"""
797	n/a	width = self.cv.winfo_width()
798	n/a	if width <= 1: # the window isn't managed by a geometry manager
799	n/a	width = self.cv['width']
800	n/a	height = self.cv.winfo_height()
801	n/a	if height <= 1: # the window isn't managed by a geometry manager
802	n/a	height = self.cv['height']
803	n/a	return width, height
804	n/a
805	n/a
806	n/a	##############################################################################
807	n/a	### End of Tkinter - interface ###
808	n/a	##############################################################################
809	n/a
810	n/a
811	n/a	class Terminator (Exception):
812	n/a	"""Will be raised in TurtleScreen.update, if _RUNNING becomes False.
813	n/a
814	n/a	Thus stops execution of turtle graphics script. Main purpose: use in
815	n/a	in the Demo-Viewer turtle.Demo.py.
816	n/a	"""
817	n/a	pass
818	n/a
819	n/a
820	n/a	class TurtleGraphicsError(Exception):
821	n/a	"""Some TurtleGraphics Error
822	n/a	"""
823	n/a
824	n/a
825	n/a	class Shape(object):
826	n/a	"""Data structure modeling shapes.
827	n/a
828	n/a	attribute _type is one of "polygon", "image", "compound"
829	n/a	attribute _data is - depending on _type a poygon-tuple,
830	n/a	an image or a list constructed using the addcomponent method.
831	n/a	"""
832	n/a	def __init__(self, type_, data=None):
833	n/a	self._type = type_
834	n/a	if type_ == "polygon":
835	n/a	if isinstance(data, list):
836	n/a	data = tuple(data)
837	n/a	elif type_ == "image":
838	n/a	if isinstance(data, str):
839	n/a	if data.lower().endswith(".gif") and isfile(data):
840	n/a	data = TurtleScreen._image(data)
841	n/a	# else data assumed to be Photoimage
842	n/a	elif type_ == "compound":
843	n/a	data = []
844	n/a	else:
845	n/a	raise TurtleGraphicsError("There is no shape type %s" % type_)
846	n/a	self._data = data
847	n/a
848	n/a	def addcomponent(self, poly, fill, outline=None):
849	n/a	"""Add component to a shape of type compound.
850	n/a
851	n/a	Arguments: poly is a polygon, i. e. a tuple of number pairs.
852	n/a	fill is the fillcolor of the component,
853	n/a	outline is the outline color of the component.
854	n/a
855	n/a	call (for a Shapeobject namend s):
856	n/a	-- s.addcomponent(((0,0), (10,10), (-10,10)), "red", "blue")
857	n/a
858	n/a	Example:
859	n/a	>>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
860	n/a	>>> s = Shape("compound")
861	n/a	>>> s.addcomponent(poly, "red", "blue")
862	n/a	### .. add more components and then use register_shape()
863	n/a	"""
864	n/a	if self._type != "compound":
865	n/a	raise TurtleGraphicsError("Cannot add component to %s Shape"
866	n/a	% self._type)
867	n/a	if outline is None:
868	n/a	outline = fill
869	n/a	self._data.append([poly, fill, outline])
870	n/a
871	n/a
872	n/a	class Tbuffer(object):
873	n/a	"""Ring buffer used as undobuffer for RawTurtle objects."""
874	n/a	def __init__(self, bufsize=10):
875	n/a	self.bufsize = bufsize
876	n/a	self.buffer = [[None]] * bufsize
877	n/a	self.ptr = -1
878	n/a	self.cumulate = False
879	n/a	def reset(self, bufsize=None):
880	n/a	if bufsize is None:
881	n/a	for i in range(self.bufsize):
882	n/a	self.buffer[i] = [None]
883	n/a	else:
884	n/a	self.bufsize = bufsize
885	n/a	self.buffer = [[None]] * bufsize
886	n/a	self.ptr = -1
887	n/a	def push(self, item):
888	n/a	if self.bufsize > 0:
889	n/a	if not self.cumulate:
890	n/a	self.ptr = (self.ptr + 1) % self.bufsize
891	n/a	self.buffer[self.ptr] = item
892	n/a	else:
893	n/a	self.buffer[self.ptr].append(item)
894	n/a	def pop(self):
895	n/a	if self.bufsize > 0:
896	n/a	item = self.buffer[self.ptr]
897	n/a	if item is None:
898	n/a	return None
899	n/a	else:
900	n/a	self.buffer[self.ptr] = [None]
901	n/a	self.ptr = (self.ptr - 1) % self.bufsize
902	n/a	return (item)
903	n/a	def nr_of_items(self):
904	n/a	return self.bufsize - self.buffer.count([None])
905	n/a	def __repr__(self):
906	n/a	return str(self.buffer) + " " + str(self.ptr)
907	n/a
908	n/a
909	n/a
910	n/a	class TurtleScreen(TurtleScreenBase):
911	n/a	"""Provides screen oriented methods like setbg etc.
912	n/a
913	n/a	Only relies upon the methods of TurtleScreenBase and NOT
914	n/a	upon components of the underlying graphics toolkit -
915	n/a	which is Tkinter in this case.
916	n/a	"""
917	n/a	# _STANDARD_DELAY = 5
918	n/a	_RUNNING = True
919	n/a
920	n/a	def __init__(self, cv, mode=_CFG["mode"],
921	n/a	colormode=_CFG["colormode"], delay=_CFG["delay"]):
922	n/a	self._shapes = {
923	n/a	"arrow" : Shape("polygon", ((-10,0), (10,0), (0,10))),
924	n/a	"turtle" : Shape("polygon", ((0,16), (-2,14), (-1,10), (-4,7),
925	n/a	(-7,9), (-9,8), (-6,5), (-7,1), (-5,-3), (-8,-6),
926	n/a	(-6,-8), (-4,-5), (0,-7), (4,-5), (6,-8), (8,-6),
927	n/a	(5,-3), (7,1), (6,5), (9,8), (7,9), (4,7), (1,10),
928	n/a	(2,14))),
929	n/a	"circle" : Shape("polygon", ((10,0), (9.51,3.09), (8.09,5.88),
930	n/a	(5.88,8.09), (3.09,9.51), (0,10), (-3.09,9.51),
931	n/a	(-5.88,8.09), (-8.09,5.88), (-9.51,3.09), (-10,0),
932	n/a	(-9.51,-3.09), (-8.09,-5.88), (-5.88,-8.09),
933	n/a	(-3.09,-9.51), (-0.00,-10.00), (3.09,-9.51),
934	n/a	(5.88,-8.09), (8.09,-5.88), (9.51,-3.09))),
935	n/a	"square" : Shape("polygon", ((10,-10), (10,10), (-10,10),
936	n/a	(-10,-10))),
937	n/a	"triangle" : Shape("polygon", ((10,-5.77), (0,11.55),
938	n/a	(-10,-5.77))),
939	n/a	"classic": Shape("polygon", ((0,0),(-5,-9),(0,-7),(5,-9))),
940	n/a	"blank" : Shape("image", self._blankimage())
941	n/a	}
942	n/a
943	n/a	self._bgpics = {"nopic" : ""}
944	n/a
945	n/a	TurtleScreenBase.__init__(self, cv)
946	n/a	self._mode = mode
947	n/a	self._delayvalue = delay
948	n/a	self._colormode = _CFG["colormode"]
949	n/a	self._keys = []
950	n/a	self.clear()
951	n/a
952	n/a	def clear(self):
953	n/a	"""Delete all drawings and all turtles from the TurtleScreen.
954	n/a
955	n/a	Reset empty TurtleScreen to its initial state: white background,
956	n/a	no backgroundimage, no eventbindings and tracing on.
957	n/a
958	n/a	No argument.
959	n/a
960	n/a	Example (for a TurtleScreen instance named screen):
961	n/a	screen.clear()
962	n/a
963	n/a	Note: this method is not available as function.
964	n/a	"""
965	n/a	self._delayvalue = _CFG["delay"]
966	n/a	self._colormode = _CFG["colormode"]
967	n/a	self._delete("all")
968	n/a	self._bgpic = self._createimage("")
969	n/a	self._bgpicname = "nopic"
970	n/a	self._tracing = 1
971	n/a	self._updatecounter = 0
972	n/a	self._turtles = []
973	n/a	self.bgcolor("white")
974	n/a	for btn in 1, 2, 3:
975	n/a	self.onclick(None, btn)
976	n/a	for key in self._keys[:]:
977	n/a	self.onkey(None, key)
978	n/a	Turtle._pen = None
979	n/a
980	n/a	def mode(self, mode=None):
981	n/a	"""Set turtle-mode ('standard', 'logo' or 'world') and perform reset.
982	n/a
983	n/a	Optional argument:
984	n/a	mode -- on of the strings 'standard', 'logo' or 'world'
985	n/a
986	n/a	Mode 'standard' is compatible with turtle.py.
987	n/a	Mode 'logo' is compatible with most Logo-Turtle-Graphics.
988	n/a	Mode 'world' uses userdefined 'worldcoordinates'. Attention: in
989	n/a	this mode angles appear distorted if x/y unit-ratio doesn't equal 1.
990	n/a	If mode is not given, return the current mode.
991	n/a
992	n/a	Mode Initial turtle heading positive angles
993	n/a	------------\|-------------------------\|-------------------
994	n/a	'standard' to the right (east) counterclockwise
995	n/a	'logo' upward (north) clockwise
996	n/a
997	n/a	Examples:
998	n/a	>>> mode('logo') # resets turtle heading to north
999	n/a	>>> mode()
1000	n/a	'logo'
1001	n/a	"""
1002	n/a	if mode is None:
1003	n/a	return self._mode
1004	n/a	mode = mode.lower()
1005	n/a	if mode not in ["standard", "logo", "world"]:
1006	n/a	raise TurtleGraphicsError("No turtle-graphics-mode %s" % mode)
1007	n/a	self._mode = mode
1008	n/a	if mode in ["standard", "logo"]:
1009	n/a	self._setscrollregion(-self.canvwidth//2, -self.canvheight//2,
1010	n/a	self.canvwidth//2, self.canvheight//2)
1011	n/a	self.xscale = self.yscale = 1.0
1012	n/a	self.reset()
1013	n/a
1014	n/a	def setworldcoordinates(self, llx, lly, urx, ury):
1015	n/a	"""Set up a user defined coordinate-system.
1016	n/a
1017	n/a	Arguments:
1018	n/a	llx -- a number, x-coordinate of lower left corner of canvas
1019	n/a	lly -- a number, y-coordinate of lower left corner of canvas
1020	n/a	urx -- a number, x-coordinate of upper right corner of canvas
1021	n/a	ury -- a number, y-coordinate of upper right corner of canvas
1022	n/a
1023	n/a	Set up user coodinat-system and switch to mode 'world' if necessary.
1024	n/a	This performs a screen.reset. If mode 'world' is already active,
1025	n/a	all drawings are redrawn according to the new coordinates.
1026	n/a
1027	n/a	But ATTENTION: in user-defined coordinatesystems angles may appear
1028	n/a	distorted. (see Screen.mode())
1029	n/a
1030	n/a	Example (for a TurtleScreen instance named screen):
1031	n/a	>>> screen.setworldcoordinates(-10,-0.5,50,1.5)
1032	n/a	>>> for _ in range(36):
1033	n/a	left(10)
1034	n/a	forward(0.5)
1035	n/a	"""
1036	n/a	if self.mode() != "world":
1037	n/a	self.mode("world")
1038	n/a	xspan = float(urx - llx)
1039	n/a	yspan = float(ury - lly)
1040	n/a	wx, wy = self._window_size()
1041	n/a	self.screensize(wx-20, wy-20)
1042	n/a	oldxscale, oldyscale = self.xscale, self.yscale
1043	n/a	self.xscale = self.canvwidth / xspan
1044	n/a	self.yscale = self.canvheight / yspan
1045	n/a	srx1 = llx * self.xscale
1046	n/a	sry1 = -ury * self.yscale
1047	n/a	srx2 = self.canvwidth + srx1
1048	n/a	sry2 = self.canvheight + sry1
1049	n/a	self._setscrollregion(srx1, sry1, srx2, sry2)
1050	n/a	self._rescale(self.xscale/oldxscale, self.yscale/oldyscale)
1051	n/a	self.update()
1052	n/a
1053	n/a	def register_shape(self, name, shape=None):
1054	n/a	"""Adds a turtle shape to TurtleScreen's shapelist.
1055	n/a
1056	n/a	Arguments:
1057	n/a	(1) name is the name of a gif-file and shape is None.
1058	n/a	Installs the corresponding image shape.
1059	n/a	!! Image-shapes DO NOT rotate when turning the turtle,
1060	n/a	!! so they do not display the heading of the turtle!
1061	n/a	(2) name is an arbitrary string and shape is a tuple
1062	n/a	of pairs of coordinates. Installs the corresponding
1063	n/a	polygon shape
1064	n/a	(3) name is an arbitrary string and shape is a
1065	n/a	(compound) Shape object. Installs the corresponding
1066	n/a	compound shape.
1067	n/a	To use a shape, you have to issue the command shape(shapename).
1068	n/a
1069	n/a	call: register_shape("turtle.gif")
1070	n/a	--or: register_shape("tri", ((0,0), (10,10), (-10,10)))
1071	n/a
1072	n/a	Example (for a TurtleScreen instance named screen):
1073	n/a	>>> screen.register_shape("triangle", ((5,-3),(0,5),(-5,-3)))
1074	n/a
1075	n/a	"""
1076	n/a	if shape is None:
1077	n/a	# image
1078	n/a	if name.lower().endswith(".gif"):
1079	n/a	shape = Shape("image", self._image(name))
1080	n/a	else:
1081	n/a	raise TurtleGraphicsError("Bad arguments for register_shape.\n"
1082	n/a	+ "Use help(register_shape)" )
1083	n/a	elif isinstance(shape, tuple):
1084	n/a	shape = Shape("polygon", shape)
1085	n/a	## else shape assumed to be Shape-instance
1086	n/a	self._shapes[name] = shape
1087	n/a	# print "shape added:" , self._shapes
1088	n/a
1089	n/a	def _colorstr(self, color):
1090	n/a	"""Return color string corresponding to args.
1091	n/a
1092	n/a	Argument may be a string or a tuple of three
1093	n/a	numbers corresponding to actual colormode,
1094	n/a	i.e. in the range 0<=n<=colormode.
1095	n/a
1096	n/a	If the argument doesn't represent a color,
1097	n/a	an error is raised.
1098	n/a	"""
1099	n/a	if len(color) == 1:
1100	n/a	color = color[0]
1101	n/a	if isinstance(color, str):
1102	n/a	if self._iscolorstring(color) or color == "":
1103	n/a	return color
1104	n/a	else:
1105	n/a	raise TurtleGraphicsError("bad color string: %s" % str(color))
1106	n/a	try:
1107	n/a	r, g, b = color
1108	n/a	except:
1109	n/a	raise TurtleGraphicsError("bad color arguments: %s" % str(color))
1110	n/a	if self._colormode == 1.0:
1111	n/a	r, g, b = [round(255.0*x) for x in (r, g, b)]
1112	n/a	if not ((0 <= r <= 255) and (0 <= g <= 255) and (0 <= b <= 255)):
1113	n/a	raise TurtleGraphicsError("bad color sequence: %s" % str(color))
1114	n/a	return "#%02x%02x%02x" % (r, g, b)
1115	n/a
1116	n/a	def _color(self, cstr):
1117	n/a	if not cstr.startswith("#"):
1118	n/a	return cstr
1119	n/a	if len(cstr) == 7:
1120	n/a	cl = [int(cstr[i:i+2], 16) for i in (1, 3, 5)]
1121	n/a	elif len(cstr) == 4:
1122	n/a	cl = [16*int(cstr[h], 16) for h in cstr[1:]]
1123	n/a	else:
1124	n/a	raise TurtleGraphicsError("bad colorstring: %s" % cstr)
1125	n/a	return tuple([c * self._colormode/255 for c in cl])
1126	n/a
1127	n/a	def colormode(self, cmode=None):
1128	n/a	"""Return the colormode or set it to 1.0 or 255.
1129	n/a
1130	n/a	Optional argument:
1131	n/a	cmode -- one of the values 1.0 or 255
1132	n/a
1133	n/a	r, g, b values of colortriples have to be in range 0..cmode.
1134	n/a
1135	n/a	Example (for a TurtleScreen instance named screen):
1136	n/a	>>> screen.colormode()
1137	n/a	1.0
1138	n/a	>>> screen.colormode(255)
1139	n/a	>>> turtle.pencolor(240,160,80)
1140	n/a	"""
1141	n/a	if cmode is None:
1142	n/a	return self._colormode
1143	n/a	if cmode == 1.0:
1144	n/a	self._colormode = float(cmode)
1145	n/a	elif cmode == 255:
1146	n/a	self._colormode = int(cmode)
1147	n/a
1148	n/a	def reset(self):
1149	n/a	"""Reset all Turtles on the Screen to their initial state.
1150	n/a
1151	n/a	No argument.
1152	n/a
1153	n/a	Example (for a TurtleScreen instance named screen):
1154	n/a	>>> screen.reset()
1155	n/a	"""
1156	n/a	for turtle in self._turtles:
1157	n/a	turtle._setmode(self._mode)
1158	n/a	turtle.reset()
1159	n/a
1160	n/a	def turtles(self):
1161	n/a	"""Return the list of turtles on the screen.
1162	n/a
1163	n/a	Example (for a TurtleScreen instance named screen):
1164	n/a	>>> screen.turtles()
1165	n/a	[<turtle.Turtle object at 0x00E11FB0>]
1166	n/a	"""
1167	n/a	return self._turtles
1168	n/a
1169	n/a	def bgcolor(self, *args):
1170	n/a	"""Set or return backgroundcolor of the TurtleScreen.
1171	n/a
1172	n/a	Arguments (if given): a color string or three numbers
1173	n/a	in the range 0..colormode or a 3-tuple of such numbers.
1174	n/a
1175	n/a	Example (for a TurtleScreen instance named screen):
1176	n/a	>>> screen.bgcolor("orange")
1177	n/a	>>> screen.bgcolor()
1178	n/a	'orange'
1179	n/a	>>> screen.bgcolor(0.5,0,0.5)
1180	n/a	>>> screen.bgcolor()
1181	n/a	'#800080'
1182	n/a	"""
1183	n/a	if args:
1184	n/a	color = self._colorstr(args)
1185	n/a	else:
1186	n/a	color = None
1187	n/a	color = self._bgcolor(color)
1188	n/a	if color is not None:
1189	n/a	color = self._color(color)
1190	n/a	return color
1191	n/a
1192	n/a	def tracer(self, n=None, delay=None):
1193	n/a	"""Turns turtle animation on/off and set delay for update drawings.
1194	n/a
1195	n/a	Optional arguments:
1196	n/a	n -- nonnegative integer
1197	n/a	delay -- nonnegative integer
1198	n/a
1199	n/a	If n is given, only each n-th regular screen update is really performed.
1200	n/a	(Can be used to accelerate the drawing of complex graphics.)
1201	n/a	Second arguments sets delay value (see RawTurtle.delay())
1202	n/a
1203	n/a	Example (for a TurtleScreen instance named screen):
1204	n/a	>>> screen.tracer(8, 25)
1205	n/a	>>> dist = 2
1206	n/a	>>> for i in range(200):
1207	n/a	fd(dist)
1208	n/a	rt(90)
1209	n/a	dist += 2
1210	n/a	"""
1211	n/a	if n is None:
1212	n/a	return self._tracing
1213	n/a	self._tracing = int(n)
1214	n/a	self._updatecounter = 0
1215	n/a	if delay is not None:
1216	n/a	self._delayvalue = int(delay)
1217	n/a	if self._tracing:
1218	n/a	self.update()
1219	n/a
1220	n/a	def delay(self, delay=None):
1221	n/a	""" Return or set the drawing delay in milliseconds.
1222	n/a
1223	n/a	Optional argument:
1224	n/a	delay -- positive integer
1225	n/a
1226	n/a	Example (for a TurtleScreen instance named screen):
1227	n/a	>>> screen.delay(15)
1228	n/a	>>> screen.delay()
1229	n/a	15
1230	n/a	"""
1231	n/a	if delay is None:
1232	n/a	return self._delayvalue
1233	n/a	self._delayvalue = int(delay)
1234	n/a
1235	n/a	def _incrementudc(self):
1236	n/a	"Increment upadate counter."""
1237	n/a	if not TurtleScreen._RUNNING:
1238	n/a	TurtleScreen._RUNNNING = True
1239	n/a	raise Terminator
1240	n/a	if self._tracing > 0:
1241	n/a	self._updatecounter += 1
1242	n/a	self._updatecounter %= self._tracing
1243	n/a
1244	n/a	def update(self):
1245	n/a	"""Perform a TurtleScreen update.
1246	n/a	"""
1247	n/a	tracing = self._tracing
1248	n/a	self._tracing = True
1249	n/a	for t in self.turtles():
1250	n/a	t._update_data()
1251	n/a	t._drawturtle()
1252	n/a	self._tracing = tracing
1253	n/a	self._update()
1254	n/a
1255	n/a	def window_width(self):
1256	n/a	""" Return the width of the turtle window.
1257	n/a
1258	n/a	Example (for a TurtleScreen instance named screen):
1259	n/a	>>> screen.window_width()
1260	n/a	640
1261	n/a	"""
1262	n/a	return self._window_size()[0]
1263	n/a
1264	n/a	def window_height(self):
1265	n/a	""" Return the height of the turtle window.
1266	n/a
1267	n/a	Example (for a TurtleScreen instance named screen):
1268	n/a	>>> screen.window_height()
1269	n/a	480
1270	n/a	"""
1271	n/a	return self._window_size()[1]
1272	n/a
1273	n/a	def getcanvas(self):
1274	n/a	"""Return the Canvas of this TurtleScreen.
1275	n/a
1276	n/a	No argument.
1277	n/a
1278	n/a	Example (for a Screen instance named screen):
1279	n/a	>>> cv = screen.getcanvas()
1280	n/a	>>> cv
1281	n/a	<turtle.ScrolledCanvas instance at 0x010742D8>
1282	n/a	"""
1283	n/a	return self.cv
1284	n/a
1285	n/a	def getshapes(self):
1286	n/a	"""Return a list of names of all currently available turtle shapes.
1287	n/a
1288	n/a	No argument.
1289	n/a
1290	n/a	Example (for a TurtleScreen instance named screen):
1291	n/a	>>> screen.getshapes()
1292	n/a	['arrow', 'blank', 'circle', ... , 'turtle']
1293	n/a	"""
1294	n/a	return sorted(self._shapes.keys())
1295	n/a
1296	n/a	def onclick(self, fun, btn=1, add=None):
1297	n/a	"""Bind fun to mouse-click event on canvas.
1298	n/a
1299	n/a	Arguments:
1300	n/a	fun -- a function with two arguments, the coordinates of the
1301	n/a	clicked point on the canvas.
1302	n/a	num -- the number of the mouse-button, defaults to 1
1303	n/a
1304	n/a	Example (for a TurtleScreen instance named screen
1305	n/a	and a Turtle instance named turtle):
1306	n/a
1307	n/a	>>> screen.onclick(turtle.goto)
1308	n/a
1309	n/a	### Subsequently clicking into the TurtleScreen will
1310	n/a	### make the turtle move to the clicked point.
1311	n/a	>>> screen.onclick(None)
1312	n/a
1313	n/a	### event-binding will be removed
1314	n/a	"""
1315	n/a	self._onscreenclick(fun, btn, add)
1316	n/a
1317	n/a	def onkey(self, fun, key):
1318	n/a	"""Bind fun to key-release event of key.
1319	n/a
1320	n/a	Arguments:
1321	n/a	fun -- a function with no arguments
1322	n/a	key -- a string: key (e.g. "a") or key-symbol (e.g. "space")
1323	n/a
1324	n/a	In order to be able to register key-events, TurtleScreen
1325	n/a	must have focus. (See method listen.)
1326	n/a
1327	n/a	Example (for a TurtleScreen instance named screen
1328	n/a	and a Turtle instance named turtle):
1329	n/a
1330	n/a	>>> def f():
1331	n/a	fd(50)
1332	n/a	lt(60)
1333	n/a
1334	n/a
1335	n/a	>>> screen.onkey(f, "Up")
1336	n/a	>>> screen.listen()
1337	n/a
1338	n/a	### Subsequently the turtle can be moved by
1339	n/a	### repeatedly pressing the up-arrow key,
1340	n/a	### consequently drawing a hexagon
1341	n/a	"""
1342	n/a	if fun is None:
1343	n/a	if key in self._keys:
1344	n/a	self._keys.remove(key)
1345	n/a	elif key not in self._keys:
1346	n/a	self._keys.append(key)
1347	n/a	self._onkey(fun, key)
1348	n/a
1349	n/a	def listen(self, xdummy=None, ydummy=None):
1350	n/a	"""Set focus on TurtleScreen (in order to collect key-events)
1351	n/a
1352	n/a	No arguments.
1353	n/a	Dummy arguments are provided in order
1354	n/a	to be able to pass listen to the onclick method.
1355	n/a
1356	n/a	Example (for a TurtleScreen instance named screen):
1357	n/a	>>> screen.listen()
1358	n/a	"""
1359	n/a	self._listen()
1360	n/a
1361	n/a	def ontimer(self, fun, t=0):
1362	n/a	"""Install a timer, which calls fun after t milliseconds.
1363	n/a
1364	n/a	Arguments:
1365	n/a	fun -- a function with no arguments.
1366	n/a	t -- a number >= 0
1367	n/a
1368	n/a	Example (for a TurtleScreen instance named screen):
1369	n/a
1370	n/a	>>> running = True
1371	n/a	>>> def f():
1372	n/a	if running:
1373	n/a	fd(50)
1374	n/a	lt(60)
1375	n/a	screen.ontimer(f, 250)
1376	n/a
1377	n/a	>>> f() ### makes the turtle marching around
1378	n/a	>>> running = False
1379	n/a	"""
1380	n/a	self._ontimer(fun, t)
1381	n/a
1382	n/a	def bgpic(self, picname=None):
1383	n/a	"""Set background image or return name of current backgroundimage.
1384	n/a
1385	n/a	Optional argument:
1386	n/a	picname -- a string, name of a gif-file or "nopic".
1387	n/a
1388	n/a	If picname is a filename, set the corresponing image as background.
1389	n/a	If picname is "nopic", delete backgroundimage, if present.
1390	n/a	If picname is None, return the filename of the current backgroundimage.
1391	n/a
1392	n/a	Example (for a TurtleScreen instance named screen):
1393	n/a	>>> screen.bgpic()
1394	n/a	'nopic'
1395	n/a	>>> screen.bgpic("landscape.gif")
1396	n/a	>>> screen.bgpic()
1397	n/a	'landscape.gif'
1398	n/a	"""
1399	n/a	if picname is None:
1400	n/a	return self._bgpicname
1401	n/a	if picname not in self._bgpics:
1402	n/a	self._bgpics[picname] = self._image(picname)
1403	n/a	self._setbgpic(self._bgpic, self._bgpics[picname])
1404	n/a	self._bgpicname = picname
1405	n/a
1406	n/a	def screensize(self, canvwidth=None, canvheight=None, bg=None):
1407	n/a	"""Resize the canvas the turtles are drawing on.
1408	n/a
1409	n/a	Optional arguments:
1410	n/a	canvwidth -- positive integer, new width of canvas in pixels
1411	n/a	canvheight -- positive integer, new height of canvas in pixels
1412	n/a	bg -- colorstring or color-tupel, new backgroundcolor
1413	n/a	If no arguments are given, return current (canvaswidth, canvasheight)
1414	n/a
1415	n/a	Do not alter the drawing window. To observe hidden parts of
1416	n/a	the canvas use the scrollbars. (Can make visible those parts
1417	n/a	of a drawing, which were outside the canvas before!)
1418	n/a
1419	n/a	Example (for a Turtle instance named turtle):
1420	n/a	>>> turtle.screensize(2000,1500)
1421	n/a	### e. g. to search for an erroneously escaped turtle ;-)
1422	n/a	"""
1423	n/a	return self._resize(canvwidth, canvheight, bg)
1424	n/a
1425	n/a	onscreenclick = onclick
1426	n/a	resetscreen = reset
1427	n/a	clearscreen = clear
1428	n/a	addshape = register_shape
1429	n/a
1430	n/a	class TNavigator(object):
1431	n/a	"""Navigation part of the RawTurtle.
1432	n/a	Implements methods for turtle movement.
1433	n/a	"""
1434	n/a	START_ORIENTATION = {
1435	n/a	"standard": Vec2D(1.0, 0.0),
1436	n/a	"world" : Vec2D(1.0, 0.0),
1437	n/a	"logo" : Vec2D(0.0, 1.0) }
1438	n/a	DEFAULT_MODE = "standard"
1439	n/a	DEFAULT_ANGLEOFFSET = 0
1440	n/a	DEFAULT_ANGLEORIENT = 1
1441	n/a
1442	n/a	def __init__(self, mode=DEFAULT_MODE):
1443	n/a	self._angleOffset = self.DEFAULT_ANGLEOFFSET
1444	n/a	self._angleOrient = self.DEFAULT_ANGLEORIENT
1445	n/a	self._mode = mode
1446	n/a	self.undobuffer = None
1447	n/a	self.degrees()
1448	n/a	self._mode = None
1449	n/a	self._setmode(mode)
1450	n/a	TNavigator.reset(self)
1451	n/a
1452	n/a	def reset(self):
1453	n/a	"""reset turtle to its initial values
1454	n/a
1455	n/a	Will be overwritten by parent class
1456	n/a	"""
1457	n/a	self._position = Vec2D(0.0, 0.0)
1458	n/a	self._orient = TNavigator.START_ORIENTATION[self._mode]
1459	n/a
1460	n/a	def _setmode(self, mode=None):
1461	n/a	"""Set turtle-mode to 'standard', 'world' or 'logo'.
1462	n/a	"""
1463	n/a	if mode is None:
1464	n/a	return self._mode
1465	n/a	if mode not in ["standard", "logo", "world"]:
1466	n/a	return
1467	n/a	self._mode = mode
1468	n/a	if mode in ["standard", "world"]:
1469	n/a	self._angleOffset = 0
1470	n/a	self._angleOrient = 1
1471	n/a	else: # mode == "logo":
1472	n/a	self._angleOffset = self._fullcircle/4.
1473	n/a	self._angleOrient = -1
1474	n/a
1475	n/a	def _setDegreesPerAU(self, fullcircle):
1476	n/a	"""Helper function for degrees() and radians()"""
1477	n/a	self._fullcircle = fullcircle
1478	n/a	self._degreesPerAU = 360/fullcircle
1479	n/a	if self._mode == "standard":
1480	n/a	self._angleOffset = 0
1481	n/a	else:
1482	n/a	self._angleOffset = fullcircle/4.
1483	n/a
1484	n/a	def degrees(self, fullcircle=360.0):
1485	n/a	""" Set angle measurement units to degrees.
1486	n/a
1487	n/a	Optional argument:
1488	n/a	fullcircle - a number
1489	n/a
1490	n/a	Set angle measurement units, i. e. set number
1491	n/a	of 'degrees' for a full circle. Dafault value is
1492	n/a	360 degrees.
1493	n/a
1494	n/a	Example (for a Turtle instance named turtle):
1495	n/a	>>> turtle.left(90)
1496	n/a	>>> turtle.heading()
1497	n/a	90
1498	n/a	>>> turtle.degrees(400.0) # angle measurement in gon
1499	n/a	>>> turtle.heading()
1500	n/a	100
1501	n/a
1502	n/a	"""
1503	n/a	self._setDegreesPerAU(fullcircle)
1504	n/a
1505	n/a	def radians(self):
1506	n/a	""" Set the angle measurement units to radians.
1507	n/a
1508	n/a	No arguments.
1509	n/a
1510	n/a	Example (for a Turtle instance named turtle):
1511	n/a	>>> turtle.heading()
1512	n/a	90
1513	n/a	>>> turtle.radians()
1514	n/a	>>> turtle.heading()
1515	n/a	1.5707963267948966
1516	n/a	"""
1517	n/a	self._setDegreesPerAU(2*math.pi)
1518	n/a
1519	n/a	def _go(self, distance):
1520	n/a	"""move turtle forward by specified distance"""
1521	n/a	ende = self._position + self._orient * distance
1522	n/a	self._goto(ende)
1523	n/a
1524	n/a	def _rotate(self, angle):
1525	n/a	"""Turn turtle counterclockwise by specified angle if angle > 0."""
1526	n/a	angle *= self._degreesPerAU
1527	n/a	self._orient = self._orient.rotate(angle)
1528	n/a
1529	n/a	def _goto(self, end):
1530	n/a	"""move turtle to position end."""
1531	n/a	self._position = end
1532	n/a
1533	n/a	def forward(self, distance):
1534	n/a	"""Move the turtle forward by the specified distance.
1535	n/a
1536	n/a	Aliases: forward \| fd
1537	n/a
1538	n/a	Argument:
1539	n/a	distance -- a number (integer or float)
1540	n/a
1541	n/a	Move the turtle forward by the specified distance, in the direction
1542	n/a	the turtle is headed.
1543	n/a
1544	n/a	Example (for a Turtle instance named turtle):
1545	n/a	>>> turtle.position()
1546	n/a	(0.00, 0.00)
1547	n/a	>>> turtle.forward(25)
1548	n/a	>>> turtle.position()
1549	n/a	(25.00,0.00)
1550	n/a	>>> turtle.forward(-75)
1551	n/a	>>> turtle.position()
1552	n/a	(-50.00,0.00)
1553	n/a	"""
1554	n/a	self._go(distance)
1555	n/a
1556	n/a	def back(self, distance):
1557	n/a	"""Move the turtle backward by distance.
1558	n/a
1559	n/a	Aliases: back \| backward \| bk
1560	n/a
1561	n/a	Argument:
1562	n/a	distance -- a number
1563	n/a
1564	n/a	Move the turtle backward by distance ,opposite to the direction the
1565	n/a	turtle is headed. Do not change the turtle's heading.
1566	n/a
1567	n/a	Example (for a Turtle instance named turtle):
1568	n/a	>>> turtle.position()
1569	n/a	(0.00, 0.00)
1570	n/a	>>> turtle.backward(30)
1571	n/a	>>> turtle.position()
1572	n/a	(-30.00, 0.00)
1573	n/a	"""
1574	n/a	self._go(-distance)
1575	n/a
1576	n/a	def right(self, angle):
1577	n/a	"""Turn turtle right by angle units.
1578	n/a
1579	n/a	Aliases: right \| rt
1580	n/a
1581	n/a	Argument:
1582	n/a	angle -- a number (integer or float)
1583	n/a
1584	n/a	Turn turtle right by angle units. (Units are by default degrees,
1585	n/a	but can be set via the degrees() and radians() functions.)
1586	n/a	Angle orientation depends on mode. (See this.)
1587	n/a
1588	n/a	Example (for a Turtle instance named turtle):
1589	n/a	>>> turtle.heading()
1590	n/a	22.0
1591	n/a	>>> turtle.right(45)
1592	n/a	>>> turtle.heading()
1593	n/a	337.0
1594	n/a	"""
1595	n/a	self._rotate(-angle)
1596	n/a
1597	n/a	def left(self, angle):
1598	n/a	"""Turn turtle left by angle units.
1599	n/a
1600	n/a	Aliases: left \| lt
1601	n/a
1602	n/a	Argument:
1603	n/a	angle -- a number (integer or float)
1604	n/a
1605	n/a	Turn turtle left by angle units. (Units are by default degrees,
1606	n/a	but can be set via the degrees() and radians() functions.)
1607	n/a	Angle orientation depends on mode. (See this.)
1608	n/a
1609	n/a	Example (for a Turtle instance named turtle):
1610	n/a	>>> turtle.heading()
1611	n/a	22.0
1612	n/a	>>> turtle.left(45)
1613	n/a	>>> turtle.heading()
1614	n/a	67.0
1615	n/a	"""
1616	n/a	self._rotate(angle)
1617	n/a
1618	n/a	def pos(self):
1619	n/a	"""Return the turtle's current location (x,y), as a Vec2D-vector.
1620	n/a
1621	n/a	Aliases: pos \| position
1622	n/a
1623	n/a	No arguments.
1624	n/a
1625	n/a	Example (for a Turtle instance named turtle):
1626	n/a	>>> turtle.pos()
1627	n/a	(0.00, 240.00)
1628	n/a	"""
1629	n/a	return self._position
1630	n/a
1631	n/a	def xcor(self):
1632	n/a	""" Return the turtle's x coordinate.
1633	n/a
1634	n/a	No arguments.
1635	n/a
1636	n/a	Example (for a Turtle instance named turtle):
1637	n/a	>>> reset()
1638	n/a	>>> turtle.left(60)
1639	n/a	>>> turtle.forward(100)
1640	n/a	>>> print turtle.xcor()
1641	n/a	50.0
1642	n/a	"""
1643	n/a	return self._position[0]
1644	n/a
1645	n/a	def ycor(self):
1646	n/a	""" Return the turtle's y coordinate
1647	n/a	---
1648	n/a	No arguments.
1649	n/a
1650	n/a	Example (for a Turtle instance named turtle):
1651	n/a	>>> reset()
1652	n/a	>>> turtle.left(60)
1653	n/a	>>> turtle.forward(100)
1654	n/a	>>> print turtle.ycor()
1655	n/a	86.6025403784
1656	n/a	"""
1657	n/a	return self._position[1]
1658	n/a
1659	n/a
1660	n/a	def goto(self, x, y=None):
1661	n/a	"""Move turtle to an absolute position.
1662	n/a
1663	n/a	Aliases: setpos \| setposition \| goto:
1664	n/a
1665	n/a	Arguments:
1666	n/a	x -- a number or a pair/vector of numbers
1667	n/a	y -- a number None
1668	n/a
1669	n/a	call: goto(x, y) # two coordinates
1670	n/a	--or: goto((x, y)) # a pair (tuple) of coordinates
1671	n/a	--or: goto(vec) # e.g. as returned by pos()
1672	n/a
1673	n/a	Move turtle to an absolute position. If the pen is down,
1674	n/a	a line will be drawn. The turtle's orientation does not change.
1675	n/a
1676	n/a	Example (for a Turtle instance named turtle):
1677	n/a	>>> tp = turtle.pos()
1678	n/a	>>> tp
1679	n/a	(0.00, 0.00)
1680	n/a	>>> turtle.setpos(60,30)
1681	n/a	>>> turtle.pos()
1682	n/a	(60.00,30.00)
1683	n/a	>>> turtle.setpos((20,80))
1684	n/a	>>> turtle.pos()
1685	n/a	(20.00,80.00)
1686	n/a	>>> turtle.setpos(tp)
1687	n/a	>>> turtle.pos()
1688	n/a	(0.00,0.00)
1689	n/a	"""
1690	n/a	if y is None:
1691	n/a	self._goto(Vec2D(*x))
1692	n/a	else:
1693	n/a	self._goto(Vec2D(x, y))
1694	n/a
1695	n/a	def home(self):
1696	n/a	"""Move turtle to the origin - coordinates (0,0).
1697	n/a
1698	n/a	No arguments.
1699	n/a
1700	n/a	Move turtle to the origin - coordinates (0,0) and set its
1701	n/a	heading to its start-orientation (which depends on mode).
1702	n/a
1703	n/a	Example (for a Turtle instance named turtle):
1704	n/a	>>> turtle.home()
1705	n/a	"""
1706	n/a	self.goto(0, 0)
1707	n/a	self.setheading(0)
1708	n/a
1709	n/a	def setx(self, x):
1710	n/a	"""Set the turtle's first coordinate to x
1711	n/a
1712	n/a	Argument:
1713	n/a	x -- a number (integer or float)
1714	n/a
1715	n/a	Set the turtle's first coordinate to x, leave second coordinate
1716	n/a	unchanged.
1717	n/a
1718	n/a	Example (for a Turtle instance named turtle):
1719	n/a	>>> turtle.position()
1720	n/a	(0.00, 240.00)
1721	n/a	>>> turtle.setx(10)
1722	n/a	>>> turtle.position()
1723	n/a	(10.00, 240.00)
1724	n/a	"""
1725	n/a	self._goto(Vec2D(x, self._position[1]))
1726	n/a
1727	n/a	def sety(self, y):
1728	n/a	"""Set the turtle's second coordinate to y
1729	n/a
1730	n/a	Argument:
1731	n/a	y -- a number (integer or float)
1732	n/a
1733	n/a	Set the turtle's first coordinate to x, second coordinate remains
1734	n/a	unchanged.
1735	n/a
1736	n/a	Example (for a Turtle instance named turtle):
1737	n/a	>>> turtle.position()
1738	n/a	(0.00, 40.00)
1739	n/a	>>> turtle.sety(-10)
1740	n/a	>>> turtle.position()
1741	n/a	(0.00, -10.00)
1742	n/a	"""
1743	n/a	self._goto(Vec2D(self._position[0], y))
1744	n/a
1745	n/a	def distance(self, x, y=None):
1746	n/a	"""Return the distance from the turtle to (x,y) in turtle step units.
1747	n/a
1748	n/a	Arguments:
1749	n/a	x -- a number or a pair/vector of numbers or a turtle instance
1750	n/a	y -- a number None None
1751	n/a
1752	n/a	call: distance(x, y) # two coordinates
1753	n/a	--or: distance((x, y)) # a pair (tuple) of coordinates
1754	n/a	--or: distance(vec) # e.g. as returned by pos()
1755	n/a	--or: distance(mypen) # where mypen is another turtle
1756	n/a
1757	n/a	Example (for a Turtle instance named turtle):
1758	n/a	>>> turtle.pos()
1759	n/a	(0.00, 0.00)
1760	n/a	>>> turtle.distance(30,40)
1761	n/a	50.0
1762	n/a	>>> pen = Turtle()
1763	n/a	>>> pen.forward(77)
1764	n/a	>>> turtle.distance(pen)
1765	n/a	77.0
1766	n/a	"""
1767	n/a	if y is not None:
1768	n/a	pos = Vec2D(x, y)
1769	n/a	if isinstance(x, Vec2D):
1770	n/a	pos = x
1771	n/a	elif isinstance(x, tuple):
1772	n/a	pos = Vec2D(*x)
1773	n/a	elif isinstance(x, TNavigator):
1774	n/a	pos = x._position
1775	n/a	return abs(pos - self._position)
1776	n/a
1777	n/a	def towards(self, x, y=None):
1778	n/a	"""Return the angle of the line from the turtle's position to (x, y).
1779	n/a
1780	n/a	Arguments:
1781	n/a	x -- a number or a pair/vector of numbers or a turtle instance
1782	n/a	y -- a number None None
1783	n/a
1784	n/a	call: distance(x, y) # two coordinates
1785	n/a	--or: distance((x, y)) # a pair (tuple) of coordinates
1786	n/a	--or: distance(vec) # e.g. as returned by pos()
1787	n/a	--or: distance(mypen) # where mypen is another turtle
1788	n/a
1789	n/a	Return the angle, between the line from turtle-position to position
1790	n/a	specified by x, y and the turtle's start orientation. (Depends on
1791	n/a	modes - "standard" or "logo")
1792	n/a
1793	n/a	Example (for a Turtle instance named turtle):
1794	n/a	>>> turtle.pos()
1795	n/a	(10.00, 10.00)
1796	n/a	>>> turtle.towards(0,0)
1797	n/a	225.0
1798	n/a	"""
1799	n/a	if y is not None:
1800	n/a	pos = Vec2D(x, y)
1801	n/a	if isinstance(x, Vec2D):
1802	n/a	pos = x
1803	n/a	elif isinstance(x, tuple):
1804	n/a	pos = Vec2D(*x)
1805	n/a	elif isinstance(x, TNavigator):
1806	n/a	pos = x._position
1807	n/a	x, y = pos - self._position
1808	n/a	result = round(math.atan2(y, x)*180.0/math.pi, 10) % 360.0
1809	n/a	result /= self._degreesPerAU
1810	n/a	return (self._angleOffset + self._angleOrient*result) % self._fullcircle
1811	n/a
1812	n/a	def heading(self):
1813	n/a	""" Return the turtle's current heading.
1814	n/a
1815	n/a	No arguments.
1816	n/a
1817	n/a	Example (for a Turtle instance named turtle):
1818	n/a	>>> turtle.left(67)
1819	n/a	>>> turtle.heading()
1820	n/a	67.0
1821	n/a	"""
1822	n/a	x, y = self._orient
1823	n/a	result = round(math.atan2(y, x)*180.0/math.pi, 10) % 360.0
1824	n/a	result /= self._degreesPerAU
1825	n/a	return (self._angleOffset + self._angleOrient*result) % self._fullcircle
1826	n/a
1827	n/a	def setheading(self, to_angle):
1828	n/a	"""Set the orientation of the turtle to to_angle.
1829	n/a
1830	n/a	Aliases: setheading \| seth
1831	n/a
1832	n/a	Argument:
1833	n/a	to_angle -- a number (integer or float)
1834	n/a
1835	n/a	Set the orientation of the turtle to to_angle.
1836	n/a	Here are some common directions in degrees:
1837	n/a
1838	n/a	standard - mode: logo-mode:
1839	n/a	-------------------\|--------------------
1840	n/a	0 - east 0 - north
1841	n/a	90 - north 90 - east
1842	n/a	180 - west 180 - south
1843	n/a	270 - south 270 - west
1844	n/a
1845	n/a	Example (for a Turtle instance named turtle):
1846	n/a	>>> turtle.setheading(90)
1847	n/a	>>> turtle.heading()
1848	n/a	90
1849	n/a	"""
1850	n/a	angle = (to_angle - self.heading())*self._angleOrient
1851	n/a	full = self._fullcircle
1852	n/a	angle = (angle+full/2.)%full - full/2.
1853	n/a	self._rotate(angle)
1854	n/a
1855	n/a	def circle(self, radius, extent = None, steps = None):
1856	n/a	""" Draw a circle with given radius.
1857	n/a
1858	n/a	Arguments:
1859	n/a	radius -- a number
1860	n/a	extent (optional) -- a number
1861	n/a	steps (optional) -- an integer
1862	n/a
1863	n/a	Draw a circle with given radius. The center is radius units left
1864	n/a	of the turtle; extent - an angle - determines which part of the
1865	n/a	circle is drawn. If extent is not given, draw the entire circle.
1866	n/a	If extent is not a full circle, one endpoint of the arc is the
1867	n/a	current pen position. Draw the arc in counterclockwise direction
1868	n/a	if radius is positive, otherwise in clockwise direction. Finally
1869	n/a	the direction of the turtle is changed by the amount of extent.
1870	n/a
1871	n/a	As the circle is approximated by an inscribed regular polygon,
1872	n/a	steps determines the number of steps to use. If not given,
1873	n/a	it will be calculated automatically. Maybe used to draw regular
1874	n/a	polygons.
1875	n/a
1876	n/a	call: circle(radius) # full circle
1877	n/a	--or: circle(radius, extent) # arc
1878	n/a	--or: circle(radius, extent, steps)
1879	n/a	--or: circle(radius, steps=6) # 6-sided polygon
1880	n/a
1881	n/a	Example (for a Turtle instance named turtle):
1882	n/a	>>> turtle.circle(50)
1883	n/a	>>> turtle.circle(120, 180) # semicircle
1884	n/a	"""
1885	n/a	if self.undobuffer:
1886	n/a	self.undobuffer.push(["seq"])
1887	n/a	self.undobuffer.cumulate = True
1888	n/a	speed = self.speed()
1889	n/a	if extent is None:
1890	n/a	extent = self._fullcircle
1891	n/a	if steps is None:
1892	n/a	frac = abs(extent)/self._fullcircle
1893	n/a	steps = 1+int(min(11+abs(radius)/6.0, 59.0)*frac)
1894	n/a	w = 1.0 * extent / steps
1895	n/a	w2 = 0.5 * w
1896	n/a	l = 2.0 * radius * math.sin(w2math.pi/180.0self._degreesPerAU)
1897	n/a	if radius < 0:
1898	n/a	l, w, w2 = -l, -w, -w2
1899	n/a	tr = self.tracer()
1900	n/a	dl = self._delay()
1901	n/a	if speed == 0:
1902	n/a	self.tracer(0, 0)
1903	n/a	else:
1904	n/a	self.speed(0)
1905	n/a	self._rotate(w2)
1906	n/a	for i in range(steps):
1907	n/a	self.speed(speed)
1908	n/a	self._go(l)
1909	n/a	self.speed(0)
1910	n/a	self._rotate(w)
1911	n/a	self._rotate(-w2)
1912	n/a	if speed == 0:
1913	n/a	self.tracer(tr, dl)
1914	n/a	self.speed(speed)
1915	n/a	if self.undobuffer:
1916	n/a	self.undobuffer.cumulate = False
1917	n/a
1918	n/a	## three dummy methods to be implemented by child class:
1919	n/a
1920	n/a	def speed(self, s=0):
1921	n/a	"""dummy method - to be overwritten by child class"""
1922	n/a	def tracer(self, a=None, b=None):
1923	n/a	"""dummy method - to be overwritten by child class"""
1924	n/a	def _delay(self, n=None):
1925	n/a	"""dummy method - to be overwritten by child class"""
1926	n/a
1927	n/a	fd = forward
1928	n/a	bk = back
1929	n/a	backward = back
1930	n/a	rt = right
1931	n/a	lt = left
1932	n/a	position = pos
1933	n/a	setpos = goto
1934	n/a	setposition = goto
1935	n/a	seth = setheading
1936	n/a
1937	n/a
1938	n/a	class TPen(object):
1939	n/a	"""Drawing part of the RawTurtle.
1940	n/a	Implements drawing properties.
1941	n/a	"""
1942	n/a	def __init__(self, resizemode=_CFG["resizemode"]):
1943	n/a	self._resizemode = resizemode # or "user" or "noresize"
1944	n/a	self.undobuffer = None
1945	n/a	TPen._reset(self)
1946	n/a
1947	n/a	def _reset(self, pencolor=_CFG["pencolor"],
1948	n/a	fillcolor=_CFG["fillcolor"]):
1949	n/a	self._pensize = 1
1950	n/a	self._shown = True
1951	n/a	self._pencolor = pencolor
1952	n/a	self._fillcolor = fillcolor
1953	n/a	self._drawing = True
1954	n/a	self._speed = 3
1955	n/a	self._stretchfactor = (1, 1)
1956	n/a	self._tilt = 0
1957	n/a	self._outlinewidth = 1
1958	n/a	### self.screen = None # to override by child class
1959	n/a
1960	n/a	def resizemode(self, rmode=None):
1961	n/a	"""Set resizemode to one of the values: "auto", "user", "noresize".
1962	n/a
1963	n/a	(Optional) Argument:
1964	n/a	rmode -- one of the strings "auto", "user", "noresize"
1965	n/a
1966	n/a	Different resizemodes have the following effects:
1967	n/a	- "auto" adapts the appearance of the turtle
1968	n/a	corresponding to the value of pensize.
1969	n/a	- "user" adapts the appearance of the turtle according to the
1970	n/a	values of stretchfactor and outlinewidth (outline),
1971	n/a	which are set by shapesize()
1972	n/a	- "noresize" no adaption of the turtle's appearance takes place.
1973	n/a	If no argument is given, return current resizemode.
1974	n/a	resizemode("user") is called by a call of shapesize with arguments.
1975	n/a
1976	n/a
1977	n/a	Examples (for a Turtle instance named turtle):
1978	n/a	>>> turtle.resizemode("noresize")
1979	n/a	>>> turtle.resizemode()
1980	n/a	'noresize'
1981	n/a	"""
1982	n/a	if rmode is None:
1983	n/a	return self._resizemode
1984	n/a	rmode = rmode.lower()
1985	n/a	if rmode in ["auto", "user", "noresize"]:
1986	n/a	self.pen(resizemode=rmode)
1987	n/a
1988	n/a	def pensize(self, width=None):
1989	n/a	"""Set or return the line thickness.
1990	n/a
1991	n/a	Aliases: pensize \| width
1992	n/a
1993	n/a	Argument:
1994	n/a	width -- positive number
1995	n/a
1996	n/a	Set the line thickness to width or return it. If resizemode is set
1997	n/a	to "auto" and turtleshape is a polygon, that polygon is drawn with
1998	n/a	the same line thickness. If no argument is given, current pensize
1999	n/a	is returned.
2000	n/a
2001	n/a	Example (for a Turtle instance named turtle):
2002	n/a	>>> turtle.pensize()
2003	n/a	1
2004	n/a	turtle.pensize(10) # from here on lines of width 10 are drawn
2005	n/a	"""
2006	n/a	if width is None:
2007	n/a	return self._pensize
2008	n/a	self.pen(pensize=width)
2009	n/a
2010	n/a
2011	n/a	def penup(self):
2012	n/a	"""Pull the pen up -- no drawing when moving.
2013	n/a
2014	n/a	Aliases: penup \| pu \| up
2015	n/a
2016	n/a	No argument
2017	n/a
2018	n/a	Example (for a Turtle instance named turtle):
2019	n/a	>>> turtle.penup()
2020	n/a	"""
2021	n/a	if not self._drawing:
2022	n/a	return
2023	n/a	self.pen(pendown=False)
2024	n/a
2025	n/a	def pendown(self):
2026	n/a	"""Pull the pen down -- drawing when moving.
2027	n/a
2028	n/a	Aliases: pendown \| pd \| down
2029	n/a
2030	n/a	No argument.
2031	n/a
2032	n/a	Example (for a Turtle instance named turtle):
2033	n/a	>>> turtle.pendown()
2034	n/a	"""
2035	n/a	if self._drawing:
2036	n/a	return
2037	n/a	self.pen(pendown=True)
2038	n/a
2039	n/a	def isdown(self):
2040	n/a	"""Return True if pen is down, False if it's up.
2041	n/a
2042	n/a	No argument.
2043	n/a
2044	n/a	Example (for a Turtle instance named turtle):
2045	n/a	>>> turtle.penup()
2046	n/a	>>> turtle.isdown()
2047	n/a	False
2048	n/a	>>> turtle.pendown()
2049	n/a	>>> turtle.isdown()
2050	n/a	True
2051	n/a	"""
2052	n/a	return self._drawing
2053	n/a
2054	n/a	def speed(self, speed=None):
2055	n/a	""" Return or set the turtle's speed.
2056	n/a
2057	n/a	Optional argument:
2058	n/a	speed -- an integer in the range 0..10 or a speedstring (see below)
2059	n/a
2060	n/a	Set the turtle's speed to an integer value in the range 0 .. 10.
2061	n/a	If no argument is given: return current speed.
2062	n/a
2063	n/a	If input is a number greater than 10 or smaller than 0.5,
2064	n/a	speed is set to 0.
2065	n/a	Speedstrings are mapped to speedvalues in the following way:
2066	n/a	'fastest' : 0
2067	n/a	'fast' : 10
2068	n/a	'normal' : 6
2069	n/a	'slow' : 3
2070	n/a	'slowest' : 1
2071	n/a	speeds from 1 to 10 enforce increasingly faster animation of
2072	n/a	line drawing and turtle turning.
2073	n/a
2074	n/a	Attention:
2075	n/a	speed = 0 : no animation takes place. forward/back makes turtle jump
2076	n/a	and likewise left/right make the turtle turn instantly.
2077	n/a
2078	n/a	Example (for a Turtle instance named turtle):
2079	n/a	>>> turtle.speed(3)
2080	n/a	"""
2081	n/a	speeds = {'fastest':0, 'fast':10, 'normal':6, 'slow':3, 'slowest':1 }
2082	n/a	if speed is None:
2083	n/a	return self._speed
2084	n/a	if speed in speeds:
2085	n/a	speed = speeds[speed]
2086	n/a	elif 0.5 < speed < 10.5:
2087	n/a	speed = int(round(speed))
2088	n/a	else:
2089	n/a	speed = 0
2090	n/a	self.pen(speed=speed)
2091	n/a
2092	n/a	def color(self, *args):
2093	n/a	"""Return or set the pencolor and fillcolor.
2094	n/a
2095	n/a	Arguments:
2096	n/a	Several input formats are allowed.
2097	n/a	They use 0, 1, 2, or 3 arguments as follows:
2098	n/a
2099	n/a	color()
2100	n/a	Return the current pencolor and the current fillcolor
2101	n/a	as a pair of color specification strings as are returned
2102	n/a	by pencolor and fillcolor.
2103	n/a	color(colorstring), color((r,g,b)), color(r,g,b)
2104	n/a	inputs as in pencolor, set both, fillcolor and pencolor,
2105	n/a	to the given value.
2106	n/a	color(colorstring1, colorstring2),
2107	n/a	color((r1,g1,b1), (r2,g2,b2))
2108	n/a	equivalent to pencolor(colorstring1) and fillcolor(colorstring2)
2109	n/a	and analogously, if the other input format is used.
2110	n/a
2111	n/a	If turtleshape is a polygon, outline and interior of that polygon
2112	n/a	is drawn with the newly set colors.
2113	n/a	For mor info see: pencolor, fillcolor
2114	n/a
2115	n/a	Example (for a Turtle instance named turtle):
2116	n/a	>>> turtle.color('red', 'green')
2117	n/a	>>> turtle.color()
2118	n/a	('red', 'green')
2119	n/a	>>> colormode(255)
2120	n/a	>>> color((40, 80, 120), (160, 200, 240))
2121	n/a	>>> color()
2122	n/a	('#285078', '#a0c8f0')
2123	n/a	"""
2124	n/a	if args:
2125	n/a	l = len(args)
2126	n/a	if l == 1:
2127	n/a	pcolor = fcolor = args[0]
2128	n/a	elif l == 2:
2129	n/a	pcolor, fcolor = args
2130	n/a	elif l == 3:
2131	n/a	pcolor = fcolor = args
2132	n/a	pcolor = self._colorstr(pcolor)
2133	n/a	fcolor = self._colorstr(fcolor)
2134	n/a	self.pen(pencolor=pcolor, fillcolor=fcolor)
2135	n/a	else:
2136	n/a	return self._color(self._pencolor), self._color(self._fillcolor)
2137	n/a
2138	n/a	def pencolor(self, *args):
2139	n/a	""" Return or set the pencolor.
2140	n/a
2141	n/a	Arguments:
2142	n/a	Four input formats are allowed:
2143	n/a	- pencolor()
2144	n/a	Return the current pencolor as color specification string,
2145	n/a	possibly in hex-number format (see example).
2146	n/a	May be used as input to another color/pencolor/fillcolor call.
2147	n/a	- pencolor(colorstring)
2148	n/a	s is a Tk color specification string, such as "red" or "yellow"
2149	n/a	- pencolor((r, g, b))
2150	n/a	a tuple of r, g, and b, which represent, an RGB color,
2151	n/a	and each of r, g, and b are in the range 0..colormode,
2152	n/a	where colormode is either 1.0 or 255
2153	n/a	- pencolor(r, g, b)
2154	n/a	r, g, and b represent an RGB color, and each of r, g, and b
2155	n/a	are in the range 0..colormode
2156	n/a
2157	n/a	If turtleshape is a polygon, the outline of that polygon is drawn
2158	n/a	with the newly set pencolor.
2159	n/a
2160	n/a	Example (for a Turtle instance named turtle):
2161	n/a	>>> turtle.pencolor('brown')
2162	n/a	>>> tup = (0.2, 0.8, 0.55)
2163	n/a	>>> turtle.pencolor(tup)
2164	n/a	>>> turtle.pencolor()
2165	n/a	'#33cc8c'
2166	n/a	"""
2167	n/a	if args:
2168	n/a	color = self._colorstr(args)
2169	n/a	if color == self._pencolor:
2170	n/a	return
2171	n/a	self.pen(pencolor=color)
2172	n/a	else:
2173	n/a	return self._color(self._pencolor)
2174	n/a
2175	n/a	def fillcolor(self, *args):
2176	n/a	""" Return or set the fillcolor.
2177	n/a
2178	n/a	Arguments:
2179	n/a	Four input formats are allowed:
2180	n/a	- fillcolor()
2181	n/a	Return the current fillcolor as color specification string,
2182	n/a	possibly in hex-number format (see example).
2183	n/a	May be used as input to another color/pencolor/fillcolor call.
2184	n/a	- fillcolor(colorstring)
2185	n/a	s is a Tk color specification string, such as "red" or "yellow"
2186	n/a	- fillcolor((r, g, b))
2187	n/a	a tuple of r, g, and b, which represent, an RGB color,
2188	n/a	and each of r, g, and b are in the range 0..colormode,
2189	n/a	where colormode is either 1.0 or 255
2190	n/a	- fillcolor(r, g, b)
2191	n/a	r, g, and b represent an RGB color, and each of r, g, and b
2192	n/a	are in the range 0..colormode
2193	n/a
2194	n/a	If turtleshape is a polygon, the interior of that polygon is drawn
2195	n/a	with the newly set fillcolor.
2196	n/a
2197	n/a	Example (for a Turtle instance named turtle):
2198	n/a	>>> turtle.fillcolor('violet')
2199	n/a	>>> col = turtle.pencolor()
2200	n/a	>>> turtle.fillcolor(col)
2201	n/a	>>> turtle.fillcolor(0, .5, 0)
2202	n/a	"""
2203	n/a	if args:
2204	n/a	color = self._colorstr(args)
2205	n/a	if color == self._fillcolor:
2206	n/a	return
2207	n/a	self.pen(fillcolor=color)
2208	n/a	else:
2209	n/a	return self._color(self._fillcolor)
2210	n/a
2211	n/a	def showturtle(self):
2212	n/a	"""Makes the turtle visible.
2213	n/a
2214	n/a	Aliases: showturtle \| st
2215	n/a
2216	n/a	No argument.
2217	n/a
2218	n/a	Example (for a Turtle instance named turtle):
2219	n/a	>>> turtle.hideturtle()
2220	n/a	>>> turtle.showturtle()
2221	n/a	"""
2222	n/a	self.pen(shown=True)
2223	n/a
2224	n/a	def hideturtle(self):
2225	n/a	"""Makes the turtle invisible.
2226	n/a
2227	n/a	Aliases: hideturtle \| ht
2228	n/a
2229	n/a	No argument.
2230	n/a
2231	n/a	It's a good idea to do this while you're in the
2232	n/a	middle of a complicated drawing, because hiding
2233	n/a	the turtle speeds up the drawing observably.
2234	n/a
2235	n/a	Example (for a Turtle instance named turtle):
2236	n/a	>>> turtle.hideturtle()
2237	n/a	"""
2238	n/a	self.pen(shown=False)
2239	n/a
2240	n/a	def isvisible(self):
2241	n/a	"""Return True if the Turtle is shown, False if it's hidden.
2242	n/a
2243	n/a	No argument.
2244	n/a
2245	n/a	Example (for a Turtle instance named turtle):
2246	n/a	>>> turtle.hideturtle()
2247	n/a	>>> print turtle.isvisible():
2248	n/a	False
2249	n/a	"""
2250	n/a	return self._shown
2251	n/a
2252	n/a	def pen(self, pen=None, **pendict):
2253	n/a	"""Return or set the pen's attributes.
2254	n/a
2255	n/a	Arguments:
2256	n/a	pen -- a dictionary with some or all of the below listed keys.
2257	n/a	**pendict -- one or more keyword-arguments with the below
2258	n/a	listed keys as keywords.
2259	n/a
2260	n/a	Return or set the pen's attributes in a 'pen-dictionary'
2261	n/a	with the following key/value pairs:
2262	n/a	"shown" : True/False
2263	n/a	"pendown" : True/False
2264	n/a	"pencolor" : color-string or color-tuple
2265	n/a	"fillcolor" : color-string or color-tuple
2266	n/a	"pensize" : positive number
2267	n/a	"speed" : number in range 0..10
2268	n/a	"resizemode" : "auto" or "user" or "noresize"
2269	n/a	"stretchfactor": (positive number, positive number)
2270	n/a	"outline" : positive number
2271	n/a	"tilt" : number
2272	n/a
2273	n/a	This dictionary can be used as argument for a subsequent
2274	n/a	pen()-call to restore the former pen-state. Moreover one
2275	n/a	or more of these attributes can be provided as keyword-arguments.
2276	n/a	This can be used to set several pen attributes in one statement.
2277	n/a
2278	n/a
2279	n/a	Examples (for a Turtle instance named turtle):
2280	n/a	>>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
2281	n/a	>>> turtle.pen()
2282	n/a	{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
2283	n/a	'pencolor': 'red', 'pendown': True, 'fillcolor': 'black',
2284	n/a	'stretchfactor': (1,1), 'speed': 3}
2285	n/a	>>> penstate=turtle.pen()
2286	n/a	>>> turtle.color("yellow","")
2287	n/a	>>> turtle.penup()
2288	n/a	>>> turtle.pen()
2289	n/a	{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
2290	n/a	'pencolor': 'yellow', 'pendown': False, 'fillcolor': '',
2291	n/a	'stretchfactor': (1,1), 'speed': 3}
2292	n/a	>>> p.pen(penstate, fillcolor="green")
2293	n/a	>>> p.pen()
2294	n/a	{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
2295	n/a	'pencolor': 'red', 'pendown': True, 'fillcolor': 'green',
2296	n/a	'stretchfactor': (1,1), 'speed': 3}
2297	n/a	"""
2298	n/a	_pd = {"shown" : self._shown,
2299	n/a	"pendown" : self._drawing,
2300	n/a	"pencolor" : self._pencolor,
2301	n/a	"fillcolor" : self._fillcolor,
2302	n/a	"pensize" : self._pensize,
2303	n/a	"speed" : self._speed,
2304	n/a	"resizemode" : self._resizemode,
2305	n/a	"stretchfactor" : self._stretchfactor,
2306	n/a	"outline" : self._outlinewidth,
2307	n/a	"tilt" : self._tilt
2308	n/a	}
2309	n/a
2310	n/a	if not (pen or pendict):
2311	n/a	return _pd
2312	n/a
2313	n/a	if isinstance(pen, dict):
2314	n/a	p = pen
2315	n/a	else:
2316	n/a	p = {}
2317	n/a	p.update(pendict)
2318	n/a
2319	n/a	_p_buf = {}
2320	n/a	for key in p:
2321	n/a	_p_buf[key] = _pd[key]
2322	n/a
2323	n/a	if self.undobuffer:
2324	n/a	self.undobuffer.push(("pen", _p_buf))
2325	n/a
2326	n/a	newLine = False
2327	n/a	if "pendown" in p:
2328	n/a	if self._drawing != p["pendown"]:
2329	n/a	newLine = True
2330	n/a	if "pencolor" in p:
2331	n/a	if isinstance(p["pencolor"], tuple):
2332	n/a	p["pencolor"] = self._colorstr((p["pencolor"],))
2333	n/a	if self._pencolor != p["pencolor"]:
2334	n/a	newLine = True
2335	n/a	if "pensize" in p:
2336	n/a	if self._pensize != p["pensize"]:
2337	n/a	newLine = True
2338	n/a	if newLine:
2339	n/a	self._newLine()
2340	n/a	if "pendown" in p:
2341	n/a	self._drawing = p["pendown"]
2342	n/a	if "pencolor" in p:
2343	n/a	self._pencolor = p["pencolor"]
2344	n/a	if "pensize" in p:
2345	n/a	self._pensize = p["pensize"]
2346	n/a	if "fillcolor" in p:
2347	n/a	if isinstance(p["fillcolor"], tuple):
2348	n/a	p["fillcolor"] = self._colorstr((p["fillcolor"],))
2349	n/a	self._fillcolor = p["fillcolor"]
2350	n/a	if "speed" in p:
2351	n/a	self._speed = p["speed"]
2352	n/a	if "resizemode" in p:
2353	n/a	self._resizemode = p["resizemode"]
2354	n/a	if "stretchfactor" in p:
2355	n/a	sf = p["stretchfactor"]
2356	n/a	if isinstance(sf, (int, float)):
2357	n/a	sf = (sf, sf)
2358	n/a	self._stretchfactor = sf
2359	n/a	if "outline" in p:
2360	n/a	self._outlinewidth = p["outline"]
2361	n/a	if "shown" in p:
2362	n/a	self._shown = p["shown"]
2363	n/a	if "tilt" in p:
2364	n/a	self._tilt = p["tilt"]
2365	n/a	self._update()
2366	n/a
2367	n/a	## three dummy methods to be implemented by child class:
2368	n/a
2369	n/a	def _newLine(self, usePos = True):
2370	n/a	"""dummy method - to be overwritten by child class"""
2371	n/a	def _update(self, count=True, forced=False):
2372	n/a	"""dummy method - to be overwritten by child class"""
2373	n/a	def _color(self, args):
2374	n/a	"""dummy method - to be overwritten by child class"""
2375	n/a	def _colorstr(self, args):
2376	n/a	"""dummy method - to be overwritten by child class"""
2377	n/a
2378	n/a	width = pensize
2379	n/a	up = penup
2380	n/a	pu = penup
2381	n/a	pd = pendown
2382	n/a	down = pendown
2383	n/a	st = showturtle
2384	n/a	ht = hideturtle
2385	n/a
2386	n/a
2387	n/a	class _TurtleImage(object):
2388	n/a	"""Helper class: Datatype to store Turtle attributes
2389	n/a	"""
2390	n/a
2391	n/a	def __init__(self, screen, shapeIndex):
2392	n/a	self.screen = screen
2393	n/a	self._type = None
2394	n/a	self._setshape(shapeIndex)
2395	n/a
2396	n/a	def _setshape(self, shapeIndex):
2397	n/a	screen = self.screen # RawTurtle.screens[self.screenIndex]
2398	n/a	self.shapeIndex = shapeIndex
2399	n/a	if self._type == "polygon" == screen._shapes[shapeIndex]._type:
2400	n/a	return
2401	n/a	if self._type == "image" == screen._shapes[shapeIndex]._type:
2402	n/a	return
2403	n/a	if self._type in ["image", "polygon"]:
2404	n/a	screen._delete(self._item)
2405	n/a	elif self._type == "compound":
2406	n/a	for item in self._item:
2407	n/a	screen._delete(item)
2408	n/a	self._type = screen._shapes[shapeIndex]._type
2409	n/a	if self._type == "polygon":
2410	n/a	self._item = screen._createpoly()
2411	n/a	elif self._type == "image":
2412	n/a	self._item = screen._createimage(screen._shapes["blank"]._data)
2413	n/a	elif self._type == "compound":
2414	n/a	self._item = [screen._createpoly() for item in
2415	n/a	screen._shapes[shapeIndex]._data]
2416	n/a
2417	n/a
2418	n/a	class RawTurtle(TPen, TNavigator):
2419	n/a	"""Animation part of the RawTurtle.
2420	n/a	Puts RawTurtle upon a TurtleScreen and provides tools for
2421	n/a	its animation.
2422	n/a	"""
2423	n/a	screens = []
2424	n/a
2425	n/a	def __init__(self, canvas=None,
2426	n/a	shape=_CFG["shape"],
2427	n/a	undobuffersize=_CFG["undobuffersize"],
2428	n/a	visible=_CFG["visible"]):
2429	n/a	if isinstance(canvas, _Screen):
2430	n/a	self.screen = canvas
2431	n/a	elif isinstance(canvas, TurtleScreen):
2432	n/a	if canvas not in RawTurtle.screens:
2433	n/a	RawTurtle.screens.append(canvas)
2434	n/a	self.screen = canvas
2435	n/a	elif isinstance(canvas, (ScrolledCanvas, Canvas)):
2436	n/a	for screen in RawTurtle.screens:
2437	n/a	if screen.cv == canvas:
2438	n/a	self.screen = screen
2439	n/a	break
2440	n/a	else:
2441	n/a	self.screen = TurtleScreen(canvas)
2442	n/a	RawTurtle.screens.append(self.screen)
2443	n/a	else:
2444	n/a	raise TurtleGraphicsError("bad cavas argument %s" % canvas)
2445	n/a
2446	n/a	screen = self.screen
2447	n/a	TNavigator.__init__(self, screen.mode())
2448	n/a	TPen.__init__(self)
2449	n/a	screen._turtles.append(self)
2450	n/a	self.drawingLineItem = screen._createline()
2451	n/a	self.turtle = _TurtleImage(screen, shape)
2452	n/a	self._poly = None
2453	n/a	self._creatingPoly = False
2454	n/a	self._fillitem = self._fillpath = None
2455	n/a	self._shown = visible
2456	n/a	self._hidden_from_screen = False
2457	n/a	self.currentLineItem = screen._createline()
2458	n/a	self.currentLine = [self._position]
2459	n/a	self.items = [self.currentLineItem]
2460	n/a	self.stampItems = []
2461	n/a	self._undobuffersize = undobuffersize
2462	n/a	self.undobuffer = Tbuffer(undobuffersize)
2463	n/a	self._update()
2464	n/a
2465	n/a	def reset(self):
2466	n/a	"""Delete the turtle's drawings and restore its default values.
2467	n/a
2468	n/a	No argument.
2469	n/a	,
2470	n/a	Delete the turtle's drawings from the screen, re-center the turtle
2471	n/a	and set variables to the default values.
2472	n/a
2473	n/a	Example (for a Turtle instance named turtle):
2474	n/a	>>> turtle.position()
2475	n/a	(0.00,-22.00)
2476	n/a	>>> turtle.heading()
2477	n/a	100.0
2478	n/a	>>> turtle.reset()
2479	n/a	>>> turtle.position()
2480	n/a	(0.00,0.00)
2481	n/a	>>> turtle.heading()
2482	n/a	0.0
2483	n/a	"""
2484	n/a	TNavigator.reset(self)
2485	n/a	TPen._reset(self)
2486	n/a	self._clear()
2487	n/a	self._drawturtle()
2488	n/a	self._update()
2489	n/a
2490	n/a	def setundobuffer(self, size):
2491	n/a	"""Set or disable undobuffer.
2492	n/a
2493	n/a	Argument:
2494	n/a	size -- an integer or None
2495	n/a
2496	n/a	If size is an integer an empty undobuffer of given size is installed.
2497	n/a	Size gives the maximum number of turtle-actions that can be undone
2498	n/a	by the undo() function.
2499	n/a	If size is None, no undobuffer is present.
2500	n/a
2501	n/a	Example (for a Turtle instance named turtle):
2502	n/a	>>> turtle.setundobuffer(42)
2503	n/a	"""
2504	n/a	if size is None:
2505	n/a	self.undobuffer = None
2506	n/a	else:
2507	n/a	self.undobuffer = Tbuffer(size)
2508	n/a
2509	n/a	def undobufferentries(self):
2510	n/a	"""Return count of entries in the undobuffer.
2511	n/a
2512	n/a	No argument.
2513	n/a
2514	n/a	Example (for a Turtle instance named turtle):
2515	n/a	>>> while undobufferentries():
2516	n/a	undo()
2517	n/a	"""
2518	n/a	if self.undobuffer is None:
2519	n/a	return 0
2520	n/a	return self.undobuffer.nr_of_items()
2521	n/a
2522	n/a	def _clear(self):
2523	n/a	"""Delete all of pen's drawings"""
2524	n/a	self._fillitem = self._fillpath = None
2525	n/a	for item in self.items:
2526	n/a	self.screen._delete(item)
2527	n/a	self.currentLineItem = self.screen._createline()
2528	n/a	self.currentLine = []
2529	n/a	if self._drawing:
2530	n/a	self.currentLine.append(self._position)
2531	n/a	self.items = [self.currentLineItem]
2532	n/a	self.clearstamps()
2533	n/a	self.setundobuffer(self._undobuffersize)
2534	n/a
2535	n/a
2536	n/a	def clear(self):
2537	n/a	"""Delete the turtle's drawings from the screen. Do not move turtle.
2538	n/a
2539	n/a	No arguments.
2540	n/a
2541	n/a	Delete the turtle's drawings from the screen. Do not move turtle.
2542	n/a	State and position of the turtle as well as drawings of other
2543	n/a	turtles are not affected.
2544	n/a
2545	n/a	Examples (for a Turtle instance named turtle):
2546	n/a	>>> turtle.clear()
2547	n/a	"""
2548	n/a	self._clear()
2549	n/a	self._update()
2550	n/a
2551	n/a	def _update_data(self):
2552	n/a	self.screen._incrementudc()
2553	n/a	if self.screen._updatecounter != 0:
2554	n/a	return
2555	n/a	if len(self.currentLine)>1:
2556	n/a	self.screen._drawline(self.currentLineItem, self.currentLine,
2557	n/a	self._pencolor, self._pensize)
2558	n/a
2559	n/a	def _update(self):
2560	n/a	"""Perform a Turtle-data update.
2561	n/a	"""
2562	n/a	screen = self.screen
2563	n/a	if screen._tracing == 0:
2564	n/a	return
2565	n/a	elif screen._tracing == 1:
2566	n/a	self._update_data()
2567	n/a	self._drawturtle()
2568	n/a	screen._update() # TurtleScreenBase
2569	n/a	screen._delay(screen._delayvalue) # TurtleScreenBase
2570	n/a	else:
2571	n/a	self._update_data()
2572	n/a	if screen._updatecounter == 0:
2573	n/a	for t in screen.turtles():
2574	n/a	t._drawturtle()
2575	n/a	screen._update()
2576	n/a
2577	n/a	def tracer(self, flag=None, delay=None):
2578	n/a	"""Turns turtle animation on/off and set delay for update drawings.
2579	n/a
2580	n/a	Optional arguments:
2581	n/a	n -- nonnegative integer
2582	n/a	delay -- nonnegative integer
2583	n/a
2584	n/a	If n is given, only each n-th regular screen update is really performed.
2585	n/a	(Can be used to accelerate the drawing of complex graphics.)
2586	n/a	Second arguments sets delay value (see RawTurtle.delay())
2587	n/a
2588	n/a	Example (for a Turtle instance named turtle):
2589	n/a	>>> turtle.tracer(8, 25)
2590	n/a	>>> dist = 2
2591	n/a	>>> for i in range(200):
2592	n/a	turtle.fd(dist)
2593	n/a	turtle.rt(90)
2594	n/a	dist += 2
2595	n/a	"""
2596	n/a	return self.screen.tracer(flag, delay)
2597	n/a
2598	n/a	def _color(self, args):
2599	n/a	return self.screen._color(args)
2600	n/a
2601	n/a	def _colorstr(self, args):
2602	n/a	return self.screen._colorstr(args)
2603	n/a
2604	n/a	def _cc(self, args):
2605	n/a	"""Convert colortriples to hexstrings.
2606	n/a	"""
2607	n/a	if isinstance(args, str):
2608	n/a	return args
2609	n/a	try:
2610	n/a	r, g, b = args
2611	n/a	except:
2612	n/a	raise TurtleGraphicsError("bad color arguments: %s" % str(args))
2613	n/a	if self.screen._colormode == 1.0:
2614	n/a	r, g, b = [round(255.0*x) for x in (r, g, b)]
2615	n/a	if not ((0 <= r <= 255) and (0 <= g <= 255) and (0 <= b <= 255)):
2616	n/a	raise TurtleGraphicsError("bad color sequence: %s" % str(args))
2617	n/a	return "#%02x%02x%02x" % (r, g, b)
2618	n/a
2619	n/a	def clone(self):
2620	n/a	"""Create and return a clone of the turtle.
2621	n/a
2622	n/a	No argument.
2623	n/a
2624	n/a	Create and return a clone of the turtle with same position, heading
2625	n/a	and turtle properties.
2626	n/a
2627	n/a	Example (for a Turtle instance named mick):
2628	n/a	mick = Turtle()
2629	n/a	joe = mick.clone()
2630	n/a	"""
2631	n/a	screen = self.screen
2632	n/a	self._newLine(self._drawing)
2633	n/a
2634	n/a	turtle = self.turtle
2635	n/a	self.screen = None
2636	n/a	self.turtle = None # too make self deepcopy-able
2637	n/a
2638	n/a	q = deepcopy(self)
2639	n/a
2640	n/a	self.screen = screen
2641	n/a	self.turtle = turtle
2642	n/a
2643	n/a	q.screen = screen
2644	n/a	q.turtle = _TurtleImage(screen, self.turtle.shapeIndex)
2645	n/a
2646	n/a	screen._turtles.append(q)
2647	n/a	ttype = screen._shapes[self.turtle.shapeIndex]._type
2648	n/a	if ttype == "polygon":
2649	n/a	q.turtle._item = screen._createpoly()
2650	n/a	elif ttype == "image":
2651	n/a	q.turtle._item = screen._createimage(screen._shapes["blank"]._data)
2652	n/a	elif ttype == "compound":
2653	n/a	q.turtle._item = [screen._createpoly() for item in
2654	n/a	screen._shapes[self.turtle.shapeIndex]._data]
2655	n/a	q.currentLineItem = screen._createline()
2656	n/a	q._update()
2657	n/a	return q
2658	n/a
2659	n/a	def shape(self, name=None):
2660	n/a	"""Set turtle shape to shape with given name / return current shapename.
2661	n/a
2662	n/a	Optional argument:
2663	n/a	name -- a string, which is a valid shapename
2664	n/a
2665	n/a	Set turtle shape to shape with given name or, if name is not given,
2666	n/a	return name of current shape.
2667	n/a	Shape with name must exist in the TurtleScreen's shape dictionary.
2668	n/a	Initially there are the following polygon shapes:
2669	n/a	'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'.
2670	n/a	To learn about how to deal with shapes see Screen-method register_shape.
2671	n/a
2672	n/a	Example (for a Turtle instance named turtle):
2673	n/a	>>> turtle.shape()
2674	n/a	'arrow'
2675	n/a	>>> turtle.shape("turtle")
2676	n/a	>>> turtle.shape()
2677	n/a	'turtle'
2678	n/a	"""
2679	n/a	if name is None:
2680	n/a	return self.turtle.shapeIndex
2681	n/a	if not name in self.screen.getshapes():
2682	n/a	raise TurtleGraphicsError("There is no shape named %s" % name)
2683	n/a	self.turtle._setshape(name)
2684	n/a	self._update()
2685	n/a
2686	n/a	def shapesize(self, stretch_wid=None, stretch_len=None, outline=None):
2687	n/a	"""Set/return turtle's stretchfactors/outline. Set resizemode to "user".
2688	n/a
2689	n/a	Optinonal arguments:
2690	n/a	stretch_wid : positive number
2691	n/a	stretch_len : positive number
2692	n/a	outline : positive number
2693	n/a
2694	n/a	Return or set the pen's attributes x/y-stretchfactors and/or outline.
2695	n/a	Set resizemode to "user".
2696	n/a	If and only if resizemode is set to "user", the turtle will be displayed
2697	n/a	stretched according to its stretchfactors:
2698	n/a	stretch_wid is stretchfactor perpendicular to orientation
2699	n/a	stretch_len is stretchfactor in direction of turtles orientation.
2700	n/a	outline determines the width of the shapes's outline.
2701	n/a
2702	n/a	Examples (for a Turtle instance named turtle):
2703	n/a	>>> turtle.resizemode("user")
2704	n/a	>>> turtle.shapesize(5, 5, 12)
2705	n/a	>>> turtle.shapesize(outline=8)
2706	n/a	"""
2707	n/a	if stretch_wid is stretch_len is outline is None:
2708	n/a	stretch_wid, stretch_len = self._stretchfactor
2709	n/a	return stretch_wid, stretch_len, self._outlinewidth
2710	n/a	if stretch_wid is not None:
2711	n/a	if stretch_len is None:
2712	n/a	stretchfactor = stretch_wid, stretch_wid
2713	n/a	else:
2714	n/a	stretchfactor = stretch_wid, stretch_len
2715	n/a	elif stretch_len is not None:
2716	n/a	stretchfactor = self._stretchfactor[0], stretch_len
2717	n/a	else:
2718	n/a	stretchfactor = self._stretchfactor
2719	n/a	if outline is None:
2720	n/a	outline = self._outlinewidth
2721	n/a	self.pen(resizemode="user",
2722	n/a	stretchfactor=stretchfactor, outline=outline)
2723	n/a
2724	n/a	def settiltangle(self, angle):
2725	n/a	"""Rotate the turtleshape to point in the specified direction
2726	n/a
2727	n/a	Optional argument:
2728	n/a	angle -- number
2729	n/a
2730	n/a	Rotate the turtleshape to point in the direction specified by angle,
2731	n/a	regardless of its current tilt-angle. DO NOT change the turtle's
2732	n/a	heading (direction of movement).
2733	n/a
2734	n/a
2735	n/a	Examples (for a Turtle instance named turtle):
2736	n/a	>>> turtle.shape("circle")
2737	n/a	>>> turtle.shapesize(5,2)
2738	n/a	>>> turtle.settiltangle(45)
2739	n/a	>>> stamp()
2740	n/a	>>> turtle.fd(50)
2741	n/a	>>> turtle.settiltangle(-45)
2742	n/a	>>> stamp()
2743	n/a	>>> turtle.fd(50)
2744	n/a	"""
2745	n/a	tilt = -angle * self._degreesPerAU * self._angleOrient
2746	n/a	tilt = (tilt * math.pi / 180.0) % (2*math.pi)
2747	n/a	self.pen(resizemode="user", tilt=tilt)
2748	n/a
2749	n/a	def tiltangle(self):
2750	n/a	"""Return the current tilt-angle.
2751	n/a
2752	n/a	No argument.
2753	n/a
2754	n/a	Return the current tilt-angle, i. e. the angle between the
2755	n/a	orientation of the turtleshape and the heading of the turtle
2756	n/a	(its direction of movement).
2757	n/a
2758	n/a	Examples (for a Turtle instance named turtle):
2759	n/a	>>> turtle.shape("circle")
2760	n/a	>>> turtle.shapesize(5,2)
2761	n/a	>>> turtle.tilt(45)
2762	n/a	>>> turtle.tiltangle()
2763	n/a	>>>
2764	n/a	"""
2765	n/a	tilt = -self._tilt * (180.0/math.pi) * self._angleOrient
2766	n/a	return (tilt / self._degreesPerAU) % self._fullcircle
2767	n/a
2768	n/a	def tilt(self, angle):
2769	n/a	"""Rotate the turtleshape by angle.
2770	n/a
2771	n/a	Argument:
2772	n/a	angle - a number
2773	n/a
2774	n/a	Rotate the turtleshape by angle from its current tilt-angle,
2775	n/a	but do NOT change the turtle's heading (direction of movement).
2776	n/a
2777	n/a	Examples (for a Turtle instance named turtle):
2778	n/a	>>> turtle.shape("circle")
2779	n/a	>>> turtle.shapesize(5,2)
2780	n/a	>>> turtle.tilt(30)
2781	n/a	>>> turtle.fd(50)
2782	n/a	>>> turtle.tilt(30)
2783	n/a	>>> turtle.fd(50)
2784	n/a	"""
2785	n/a	self.settiltangle(angle + self.tiltangle())
2786	n/a
2787	n/a	def _polytrafo(self, poly):
2788	n/a	"""Computes transformed polygon shapes from a shape
2789	n/a	according to current position and heading.
2790	n/a	"""
2791	n/a	screen = self.screen
2792	n/a	p0, p1 = self._position
2793	n/a	e0, e1 = self._orient
2794	n/a	e = Vec2D(e0, e1 * screen.yscale / screen.xscale)
2795	n/a	e0, e1 = (1.0 / abs(e)) * e
2796	n/a	return [(p0+(e1x+e0y)/screen.xscale, p1+(-e0x+e1y)/screen.yscale)
2797	n/a	for (x, y) in poly]
2798	n/a
2799	n/a	def _drawturtle(self):
2800	n/a	"""Manages the correct rendering of the turtle with respect to
2801	n/a	its shape, resizemode, stretch and tilt etc."""
2802	n/a	screen = self.screen
2803	n/a	shape = screen._shapes[self.turtle.shapeIndex]
2804	n/a	ttype = shape._type
2805	n/a	titem = self.turtle._item
2806	n/a	if self._shown and screen._updatecounter == 0 and screen._tracing > 0:
2807	n/a	self._hidden_from_screen = False
2808	n/a	tshape = shape._data
2809	n/a	if ttype == "polygon":
2810	n/a	if self._resizemode == "noresize":
2811	n/a	w = 1
2812	n/a	shape = tshape
2813	n/a	else:
2814	n/a	if self._resizemode == "auto":
2815	n/a	lx = ly = max(1, self._pensize/5.0)
2816	n/a	w = self._pensize
2817	n/a	tiltangle = 0
2818	n/a	elif self._resizemode == "user":
2819	n/a	lx, ly = self._stretchfactor
2820	n/a	w = self._outlinewidth
2821	n/a	tiltangle = self._tilt
2822	n/a	shape = [(lxx, lyy) for (x, y) in tshape]
2823	n/a	t0, t1 = math.sin(tiltangle), math.cos(tiltangle)
2824	n/a	shape = [(t1x+t0y, -t0x+t1y) for (x, y) in shape]
2825	n/a	shape = self._polytrafo(shape)
2826	n/a	fc, oc = self._fillcolor, self._pencolor
2827	n/a	screen._drawpoly(titem, shape, fill=fc, outline=oc,
2828	n/a	width=w, top=True)
2829	n/a	elif ttype == "image":
2830	n/a	screen._drawimage(titem, self._position, tshape)
2831	n/a	elif ttype == "compound":
2832	n/a	lx, ly = self._stretchfactor
2833	n/a	w = self._outlinewidth
2834	n/a	for item, (poly, fc, oc) in zip(titem, tshape):
2835	n/a	poly = [(lxx, lyy) for (x, y) in poly]
2836	n/a	poly = self._polytrafo(poly)
2837	n/a	screen._drawpoly(item, poly, fill=self._cc(fc),
2838	n/a	outline=self._cc(oc), width=w, top=True)
2839	n/a	else:
2840	n/a	if self._hidden_from_screen:
2841	n/a	return
2842	n/a	if ttype == "polygon":
2843	n/a	screen._drawpoly(titem, ((0, 0), (0, 0), (0, 0)), "", "")
2844	n/a	elif ttype == "image":
2845	n/a	screen._drawimage(titem, self._position,
2846	n/a	screen._shapes["blank"]._data)
2847	n/a	elif ttype == "compound":
2848	n/a	for item in titem:
2849	n/a	screen._drawpoly(item, ((0, 0), (0, 0), (0, 0)), "", "")
2850	n/a	self._hidden_from_screen = True
2851	n/a
2852	n/a	############################## stamp stuff ###############################
2853	n/a
2854	n/a	def stamp(self):
2855	n/a	"""Stamp a copy of the turtleshape onto the canvas and return its id.
2856	n/a
2857	n/a	No argument.
2858	n/a
2859	n/a	Stamp a copy of the turtle shape onto the canvas at the current
2860	n/a	turtle position. Return a stamp_id for that stamp, which can be
2861	n/a	used to delete it by calling clearstamp(stamp_id).
2862	n/a
2863	n/a	Example (for a Turtle instance named turtle):
2864	n/a	>>> turtle.color("blue")
2865	n/a	>>> turtle.stamp()
2866	n/a	13
2867	n/a	>>> turtle.fd(50)
2868	n/a	"""
2869	n/a	screen = self.screen
2870	n/a	shape = screen._shapes[self.turtle.shapeIndex]
2871	n/a	ttype = shape._type
2872	n/a	tshape = shape._data
2873	n/a	if ttype == "polygon":
2874	n/a	stitem = screen._createpoly()
2875	n/a	if self._resizemode == "noresize":
2876	n/a	w = 1
2877	n/a	shape = tshape
2878	n/a	else:
2879	n/a	if self._resizemode == "auto":
2880	n/a	lx = ly = max(1, self._pensize/5.0)
2881	n/a	w = self._pensize
2882	n/a	tiltangle = 0
2883	n/a	elif self._resizemode == "user":
2884	n/a	lx, ly = self._stretchfactor
2885	n/a	w = self._outlinewidth
2886	n/a	tiltangle = self._tilt
2887	n/a	shape = [(lxx, lyy) for (x, y) in tshape]
2888	n/a	t0, t1 = math.sin(tiltangle), math.cos(tiltangle)
2889	n/a	shape = [(t1x+t0y, -t0x+t1y) for (x, y) in shape]
2890	n/a	shape = self._polytrafo(shape)
2891	n/a	fc, oc = self._fillcolor, self._pencolor
2892	n/a	screen._drawpoly(stitem, shape, fill=fc, outline=oc,
2893	n/a	width=w, top=True)
2894	n/a	elif ttype == "image":
2895	n/a	stitem = screen._createimage("")
2896	n/a	screen._drawimage(stitem, self._position, tshape)
2897	n/a	elif ttype == "compound":
2898	n/a	stitem = []
2899	n/a	for element in tshape:
2900	n/a	item = screen._createpoly()
2901	n/a	stitem.append(item)
2902	n/a	stitem = tuple(stitem)
2903	n/a	lx, ly = self._stretchfactor
2904	n/a	w = self._outlinewidth
2905	n/a	for item, (poly, fc, oc) in zip(stitem, tshape):
2906	n/a	poly = [(lxx, lyy) for (x, y) in poly]
2907	n/a	poly = self._polytrafo(poly)
2908	n/a	screen._drawpoly(item, poly, fill=self._cc(fc),
2909	n/a	outline=self._cc(oc), width=w, top=True)
2910	n/a	self.stampItems.append(stitem)
2911	n/a	self.undobuffer.push(("stamp", stitem))
2912	n/a	return stitem
2913	n/a
2914	n/a	def _clearstamp(self, stampid):
2915	n/a	"""does the work for clearstamp() and clearstamps()
2916	n/a	"""
2917	n/a	if stampid in self.stampItems:
2918	n/a	if isinstance(stampid, tuple):
2919	n/a	for subitem in stampid:
2920	n/a	self.screen._delete(subitem)
2921	n/a	else:
2922	n/a	self.screen._delete(stampid)
2923	n/a	self.stampItems.remove(stampid)
2924	n/a	# Delete stampitem from undobuffer if necessary
2925	n/a	# if clearstamp is called directly.
2926	n/a	item = ("stamp", stampid)
2927	n/a	buf = self.undobuffer
2928	n/a	if item not in buf.buffer:
2929	n/a	return
2930	n/a	index = buf.buffer.index(item)
2931	n/a	buf.buffer.remove(item)
2932	n/a	if index <= buf.ptr:
2933	n/a	buf.ptr = (buf.ptr - 1) % buf.bufsize
2934	n/a	buf.buffer.insert((buf.ptr+1)%buf.bufsize, [None])
2935	n/a
2936	n/a	def clearstamp(self, stampid):
2937	n/a	"""Delete stamp with given stampid
2938	n/a
2939	n/a	Argument:
2940	n/a	stampid - an integer, must be return value of previous stamp() call.
2941	n/a
2942	n/a	Example (for a Turtle instance named turtle):
2943	n/a	>>> turtle.color("blue")
2944	n/a	>>> astamp = turtle.stamp()
2945	n/a	>>> turtle.fd(50)
2946	n/a	>>> turtle.clearstamp(astamp)
2947	n/a	"""
2948	n/a	self._clearstamp(stampid)
2949	n/a	self._update()
2950	n/a
2951	n/a	def clearstamps(self, n=None):
2952	n/a	"""Delete all or first/last n of turtle's stamps.
2953	n/a
2954	n/a	Optional argument:
2955	n/a	n -- an integer
2956	n/a
2957	n/a	If n is None, delete all of pen's stamps,
2958	n/a	else if n > 0 delete first n stamps
2959	n/a	else if n < 0 delete last n stamps.
2960	n/a
2961	n/a	Example (for a Turtle instance named turtle):
2962	n/a	>>> for i in range(8):
2963	n/a	turtle.stamp(); turtle.fd(30)
2964	n/a	...
2965	n/a	>>> turtle.clearstamps(2)
2966	n/a	>>> turtle.clearstamps(-2)
2967	n/a	>>> turtle.clearstamps()
2968	n/a	"""
2969	n/a	if n is None:
2970	n/a	toDelete = self.stampItems[:]
2971	n/a	elif n >= 0:
2972	n/a	toDelete = self.stampItems[:n]
2973	n/a	else:
2974	n/a	toDelete = self.stampItems[n:]
2975	n/a	for item in toDelete:
2976	n/a	self._clearstamp(item)
2977	n/a	self._update()
2978	n/a
2979	n/a	def _goto(self, end):
2980	n/a	"""Move the pen to the point end, thereby drawing a line
2981	n/a	if pen is down. All other methodes for turtle movement depend
2982	n/a	on this one.
2983	n/a	"""
2984	n/a	## Version mit undo-stuff
2985	n/a	go_modes = ( self._drawing,
2986	n/a	self._pencolor,
2987	n/a	self._pensize,
2988	n/a	isinstance(self._fillpath, list))
2989	n/a	screen = self.screen
2990	n/a	undo_entry = ("go", self._position, end, go_modes,
2991	n/a	(self.currentLineItem,
2992	n/a	self.currentLine[:],
2993	n/a	screen._pointlist(self.currentLineItem),
2994	n/a	self.items[:])
2995	n/a	)
2996	n/a	if self.undobuffer:
2997	n/a	self.undobuffer.push(undo_entry)
2998	n/a	start = self._position
2999	n/a	if self._speed and screen._tracing == 1:
3000	n/a	diff = (end-start)
3001	n/a	diffsq = (diff[0]screen.xscale)2 + (diff[1]screen.yscale)**2
3002	n/a	nhops = 1+int((diffsq*0.5)/(3(1.1*self._speed)self._speed))
3003	n/a	delta = diff * (1.0/nhops)
3004	n/a	for n in range(1, nhops):
3005	n/a	if n == 1:
3006	n/a	top = True
3007	n/a	else:
3008	n/a	top = False
3009	n/a	self._position = start + delta * n
3010	n/a	if self._drawing:
3011	n/a	screen._drawline(self.drawingLineItem,
3012	n/a	(start, self._position),
3013	n/a	self._pencolor, self._pensize, top)
3014	n/a	self._update()
3015	n/a	if self._drawing:
3016	n/a	screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)),
3017	n/a	fill="", width=self._pensize)
3018	n/a	# Turtle now at end,
3019	n/a	if self._drawing: # now update currentLine
3020	n/a	self.currentLine.append(end)
3021	n/a	if isinstance(self._fillpath, list):
3022	n/a	self._fillpath.append(end)
3023	n/a	###### vererbung!!!!!!!!!!!!!!!!!!!!!!
3024	n/a	self._position = end
3025	n/a	if self._creatingPoly:
3026	n/a	self._poly.append(end)
3027	n/a	if len(self.currentLine) > 42: # 42! answer to the ultimate question
3028	n/a	# of life, the universe and everything
3029	n/a	self._newLine()
3030	n/a	self._update() #count=True)
3031	n/a
3032	n/a	def _undogoto(self, entry):
3033	n/a	"""Reverse a _goto. Used for undo()
3034	n/a	"""
3035	n/a	old, new, go_modes, coodata = entry
3036	n/a	drawing, pc, ps, filling = go_modes
3037	n/a	cLI, cL, pl, items = coodata
3038	n/a	screen = self.screen
3039	n/a	if abs(self._position - new) > 0.5:
3040	n/a	print "undogoto: HALLO-DA-STIMMT-WAS-NICHT!"
3041	n/a	# restore former situation
3042	n/a	self.currentLineItem = cLI
3043	n/a	self.currentLine = cL
3044	n/a
3045	n/a	if pl == [(0, 0), (0, 0)]:
3046	n/a	usepc = ""
3047	n/a	else:
3048	n/a	usepc = pc
3049	n/a	screen._drawline(cLI, pl, fill=usepc, width=ps)
3050	n/a
3051	n/a	todelete = [i for i in self.items if (i not in items) and
3052	n/a	(screen._type(i) == "line")]
3053	n/a	for i in todelete:
3054	n/a	screen._delete(i)
3055	n/a	self.items.remove(i)
3056	n/a
3057	n/a	start = old
3058	n/a	if self._speed and screen._tracing == 1:
3059	n/a	diff = old - new
3060	n/a	diffsq = (diff[0]screen.xscale)2 + (diff[1]screen.yscale)**2
3061	n/a	nhops = 1+int((diffsq*0.5)/(3(1.1*self._speed)self._speed))
3062	n/a	delta = diff * (1.0/nhops)
3063	n/a	for n in range(1, nhops):
3064	n/a	if n == 1:
3065	n/a	top = True
3066	n/a	else:
3067	n/a	top = False
3068	n/a	self._position = new + delta * n
3069	n/a	if drawing:
3070	n/a	screen._drawline(self.drawingLineItem,
3071	n/a	(start, self._position),
3072	n/a	pc, ps, top)
3073	n/a	self._update()
3074	n/a	if drawing:
3075	n/a	screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)),
3076	n/a	fill="", width=ps)
3077	n/a	# Turtle now at position old,
3078	n/a	self._position = old
3079	n/a	## if undo is done during crating a polygon, the last vertex
3080	n/a	## will be deleted. if the polygon is entirel deleted,
3081	n/a	## creatigPoly will be set to False.
3082	n/a	## Polygons created before the last one will not be affected by undo()
3083	n/a	if self._creatingPoly:
3084	n/a	if len(self._poly) > 0:
3085	n/a	self._poly.pop()
3086	n/a	if self._poly == []:
3087	n/a	self._creatingPoly = False
3088	n/a	self._poly = None
3089	n/a	if filling:
3090	n/a	if self._fillpath == []:
3091	n/a	self._fillpath = None
3092	n/a	print "Unwahrscheinlich in _undogoto!"
3093	n/a	elif self._fillpath is not None:
3094	n/a	self._fillpath.pop()
3095	n/a	self._update() #count=True)
3096	n/a
3097	n/a	def _rotate(self, angle):
3098	n/a	"""Turns pen clockwise by angle.
3099	n/a	"""
3100	n/a	if self.undobuffer:
3101	n/a	self.undobuffer.push(("rot", angle, self._degreesPerAU))
3102	n/a	angle *= self._degreesPerAU
3103	n/a	neworient = self._orient.rotate(angle)
3104	n/a	tracing = self.screen._tracing
3105	n/a	if tracing == 1 and self._speed > 0:
3106	n/a	anglevel = 3.0 * self._speed
3107	n/a	steps = 1 + int(abs(angle)/anglevel)
3108	n/a	delta = 1.0*angle/steps
3109	n/a	for _ in range(steps):
3110	n/a	self._orient = self._orient.rotate(delta)
3111	n/a	self._update()
3112	n/a	self._orient = neworient
3113	n/a	self._update()
3114	n/a
3115	n/a	def _newLine(self, usePos=True):
3116	n/a	"""Closes current line item and starts a new one.
3117	n/a	Remark: if current line became too long, animation
3118	n/a	performance (via _drawline) slowed down considerably.
3119	n/a	"""
3120	n/a	if len(self.currentLine) > 1:
3121	n/a	self.screen._drawline(self.currentLineItem, self.currentLine,
3122	n/a	self._pencolor, self._pensize)
3123	n/a	self.currentLineItem = self.screen._createline()
3124	n/a	self.items.append(self.currentLineItem)
3125	n/a	else:
3126	n/a	self.screen._drawline(self.currentLineItem, top=True)
3127	n/a	self.currentLine = []
3128	n/a	if usePos:
3129	n/a	self.currentLine = [self._position]
3130	n/a
3131	n/a	def fill(self, flag=None):
3132	n/a	"""Call fill(True) before drawing a shape to fill, fill(False) when done.
3133	n/a
3134	n/a	Optional argument:
3135	n/a	flag -- True/False (or 1/0 respectively)
3136	n/a
3137	n/a	Call fill(True) before drawing the shape you want to fill,
3138	n/a	and fill(False) when done.
3139	n/a	When used without argument: return fillstate (True if filling,
3140	n/a	False else)
3141	n/a
3142	n/a	Example (for a Turtle instance named turtle):
3143	n/a	>>> turtle.fill(True)
3144	n/a	>>> turtle.forward(100)
3145	n/a	>>> turtle.left(90)
3146	n/a	>>> turtle.forward(100)
3147	n/a	>>> turtle.left(90)
3148	n/a	>>> turtle.forward(100)
3149	n/a	>>> turtle.left(90)
3150	n/a	>>> turtle.forward(100)
3151	n/a	>>> turtle.fill(False)
3152	n/a	"""
3153	n/a	filling = isinstance(self._fillpath, list)
3154	n/a	if flag is None:
3155	n/a	return filling
3156	n/a	screen = self.screen
3157	n/a	entry1 = entry2 = ()
3158	n/a	if filling:
3159	n/a	if len(self._fillpath) > 2:
3160	n/a	self.screen._drawpoly(self._fillitem, self._fillpath,
3161	n/a	fill=self._fillcolor)
3162	n/a	entry1 = ("dofill", self._fillitem)
3163	n/a	if flag:
3164	n/a	self._fillitem = self.screen._createpoly()
3165	n/a	self.items.append(self._fillitem)
3166	n/a	self._fillpath = [self._position]
3167	n/a	entry2 = ("beginfill", self._fillitem) # , self._fillpath)
3168	n/a	self._newLine()
3169	n/a	else:
3170	n/a	self._fillitem = self._fillpath = None
3171	n/a	if self.undobuffer:
3172	n/a	if entry1 == ():
3173	n/a	if entry2 != ():
3174	n/a	self.undobuffer.push(entry2)
3175	n/a	else:
3176	n/a	if entry2 == ():
3177	n/a	self.undobuffer.push(entry1)
3178	n/a	else:
3179	n/a	self.undobuffer.push(["seq", entry1, entry2])
3180	n/a	self._update()
3181	n/a
3182	n/a	def begin_fill(self):
3183	n/a	"""Called just before drawing a shape to be filled.
3184	n/a
3185	n/a	No argument.
3186	n/a
3187	n/a	Example (for a Turtle instance named turtle):
3188	n/a	>>> turtle.begin_fill()
3189	n/a	>>> turtle.forward(100)
3190	n/a	>>> turtle.left(90)
3191	n/a	>>> turtle.forward(100)
3192	n/a	>>> turtle.left(90)
3193	n/a	>>> turtle.forward(100)
3194	n/a	>>> turtle.left(90)
3195	n/a	>>> turtle.forward(100)
3196	n/a	>>> turtle.end_fill()
3197	n/a	"""
3198	n/a	self.fill(True)
3199	n/a
3200	n/a	def end_fill(self):
3201	n/a	"""Fill the shape drawn after the call begin_fill().
3202	n/a
3203	n/a	No argument.
3204	n/a
3205	n/a	Example (for a Turtle instance named turtle):
3206	n/a	>>> turtle.begin_fill()
3207	n/a	>>> turtle.forward(100)
3208	n/a	>>> turtle.left(90)
3209	n/a	>>> turtle.forward(100)
3210	n/a	>>> turtle.left(90)
3211	n/a	>>> turtle.forward(100)
3212	n/a	>>> turtle.left(90)
3213	n/a	>>> turtle.forward(100)
3214	n/a	>>> turtle.end_fill()
3215	n/a	"""
3216	n/a	self.fill(False)
3217	n/a
3218	n/a	def dot(self, size=None, *color):
3219	n/a	"""Draw a dot with diameter size, using color.
3220	n/a
3221	n/a	Optional argumentS:
3222	n/a	size -- an integer >= 1 (if given)
3223	n/a	color -- a colorstring or a numeric color tuple
3224	n/a
3225	n/a	Draw a circular dot with diameter size, using color.
3226	n/a	If size is not given, the maximum of pensize+4 and 2*pensize is used.
3227	n/a
3228	n/a	Example (for a Turtle instance named turtle):
3229	n/a	>>> turtle.dot()
3230	n/a	>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
3231	n/a	"""
3232	n/a	#print "dot-1:", size, color
3233	n/a	if not color:
3234	n/a	if isinstance(size, (str, tuple)):
3235	n/a	color = self._colorstr(size)
3236	n/a	size = self._pensize + max(self._pensize, 4)
3237	n/a	else:
3238	n/a	color = self._pencolor
3239	n/a	if not size:
3240	n/a	size = self._pensize + max(self._pensize, 4)
3241	n/a	else:
3242	n/a	if size is None:
3243	n/a	size = self._pensize + max(self._pensize, 4)
3244	n/a	color = self._colorstr(color)
3245	n/a	#print "dot-2:", size, color
3246	n/a	if hasattr(self.screen, "_dot"):
3247	n/a	item = self.screen._dot(self._position, size, color)
3248	n/a	#print "dot:", size, color, "item:", item
3249	n/a	self.items.append(item)
3250	n/a	if self.undobuffer:
3251	n/a	self.undobuffer.push(("dot", item))
3252	n/a	else:
3253	n/a	pen = self.pen()
3254	n/a	if self.undobuffer:
3255	n/a	self.undobuffer.push(["seq"])
3256	n/a	self.undobuffer.cumulate = True
3257	n/a	try:
3258	n/a	if self.resizemode() == 'auto':
3259	n/a	self.ht()
3260	n/a	self.pendown()
3261	n/a	self.pensize(size)
3262	n/a	self.pencolor(color)
3263	n/a	self.forward(0)
3264	n/a	finally:
3265	n/a	self.pen(pen)
3266	n/a	if self.undobuffer:
3267	n/a	self.undobuffer.cumulate = False
3268	n/a
3269	n/a	def _write(self, txt, align, font):
3270	n/a	"""Performs the writing for write()
3271	n/a	"""
3272	n/a	item, end = self.screen._write(self._position, txt, align, font,
3273	n/a	self._pencolor)
3274	n/a	self.items.append(item)
3275	n/a	if self.undobuffer:
3276	n/a	self.undobuffer.push(("wri", item))
3277	n/a	return end
3278	n/a
3279	n/a	def write(self, arg, move=False, align="left", font=("Arial", 8, "normal")):
3280	n/a	"""Write text at the current turtle position.
3281	n/a
3282	n/a	Arguments:
3283	n/a	arg -- info, which is to be written to the TurtleScreen
3284	n/a	move (optional) -- True/False
3285	n/a	align (optional) -- one of the strings "left", "center" or right"
3286	n/a	font (optional) -- a triple (fontname, fontsize, fonttype)
3287	n/a
3288	n/a	Write text - the string representation of arg - at the current
3289	n/a	turtle position according to align ("left", "center" or right")
3290	n/a	and with the given font.
3291	n/a	If move is True, the pen is moved to the bottom-right corner
3292	n/a	of the text. By default, move is False.
3293	n/a
3294	n/a	Example (for a Turtle instance named turtle):
3295	n/a	>>> turtle.write('Home = ', True, align="center")
3296	n/a	>>> turtle.write((0,0), True)
3297	n/a	"""
3298	n/a	if self.undobuffer:
3299	n/a	self.undobuffer.push(["seq"])
3300	n/a	self.undobuffer.cumulate = True
3301	n/a	end = self._write(str(arg), align.lower(), font)
3302	n/a	if move:
3303	n/a	x, y = self.pos()
3304	n/a	self.setpos(end, y)
3305	n/a	if self.undobuffer:
3306	n/a	self.undobuffer.cumulate = False
3307	n/a
3308	n/a	def begin_poly(self):
3309	n/a	"""Start recording the vertices of a polygon.
3310	n/a
3311	n/a	No argument.
3312	n/a
3313	n/a	Start recording the vertices of a polygon. Current turtle position
3314	n/a	is first point of polygon.
3315	n/a
3316	n/a	Example (for a Turtle instance named turtle):
3317	n/a	>>> turtle.begin_poly()
3318	n/a	"""
3319	n/a	self._poly = [self._position]
3320	n/a	self._creatingPoly = True
3321	n/a
3322	n/a	def end_poly(self):
3323	n/a	"""Stop recording the vertices of a polygon.
3324	n/a
3325	n/a	No argument.
3326	n/a
3327	n/a	Stop recording the vertices of a polygon. Current turtle position is
3328	n/a	last point of polygon. This will be connected with the first point.
3329	n/a
3330	n/a	Example (for a Turtle instance named turtle):
3331	n/a	>>> turtle.end_poly()
3332	n/a	"""
3333	n/a	self._creatingPoly = False
3334	n/a
3335	n/a	def get_poly(self):
3336	n/a	"""Return the lastly recorded polygon.
3337	n/a
3338	n/a	No argument.
3339	n/a
3340	n/a	Example (for a Turtle instance named turtle):
3341	n/a	>>> p = turtle.get_poly()
3342	n/a	>>> turtle.register_shape("myFavouriteShape", p)
3343	n/a	"""
3344	n/a	## check if there is any poly? -- 1st solution:
3345	n/a	if self._poly is not None:
3346	n/a	return tuple(self._poly)
3347	n/a
3348	n/a	def getscreen(self):
3349	n/a	"""Return the TurtleScreen object, the turtle is drawing on.
3350	n/a
3351	n/a	No argument.
3352	n/a
3353	n/a	Return the TurtleScreen object, the turtle is drawing on.
3354	n/a	So TurtleScreen-methods can be called for that object.
3355	n/a
3356	n/a	Example (for a Turtle instance named turtle):
3357	n/a	>>> ts = turtle.getscreen()
3358	n/a	>>> ts
3359	n/a	<turtle.TurtleScreen object at 0x0106B770>
3360	n/a	>>> ts.bgcolor("pink")
3361	n/a	"""
3362	n/a	return self.screen
3363	n/a
3364	n/a	def getturtle(self):
3365	n/a	"""Return the Turtleobject itself.
3366	n/a
3367	n/a	No argument.
3368	n/a
3369	n/a	Only reasonable use: as a function to return the 'anonymous turtle':
3370	n/a
3371	n/a	Example:
3372	n/a	>>> pet = getturtle()
3373	n/a	>>> pet.fd(50)
3374	n/a	>>> pet
3375	n/a	<turtle.Turtle object at 0x0187D810>
3376	n/a	>>> turtles()
3377	n/a	[<turtle.Turtle object at 0x0187D810>]
3378	n/a	"""
3379	n/a	return self
3380	n/a
3381	n/a	getpen = getturtle
3382	n/a
3383	n/a
3384	n/a	################################################################
3385	n/a	### screen oriented methods recurring to methods of TurtleScreen
3386	n/a	################################################################
3387	n/a
3388	n/a	def window_width(self):
3389	n/a	""" Returns the width of the turtle window.
3390	n/a
3391	n/a	No argument.
3392	n/a
3393	n/a	Example (for a TurtleScreen instance named screen):
3394	n/a	>>> screen.window_width()
3395	n/a	640
3396	n/a	"""
3397	n/a	return self.screen._window_size()[0]
3398	n/a
3399	n/a	def window_height(self):
3400	n/a	""" Return the height of the turtle window.
3401	n/a
3402	n/a	No argument.
3403	n/a
3404	n/a	Example (for a TurtleScreen instance named screen):
3405	n/a	>>> screen.window_height()
3406	n/a	480
3407	n/a	"""
3408	n/a	return self.screen._window_size()[1]
3409	n/a
3410	n/a	def _delay(self, delay=None):
3411	n/a	"""Set delay value which determines speed of turtle animation.
3412	n/a	"""
3413	n/a	return self.screen.delay(delay)
3414	n/a
3415	n/a	##### event binding methods #####
3416	n/a
3417	n/a	def onclick(self, fun, btn=1, add=None):
3418	n/a	"""Bind fun to mouse-click event on this turtle on canvas.
3419	n/a
3420	n/a	Arguments:
3421	n/a	fun -- a function with two arguments, to which will be assigned
3422	n/a	the coordinates of the clicked point on the canvas.
3423	n/a	num -- number of the mouse-button defaults to 1 (left mouse button).
3424	n/a	add -- True or False. If True, new binding will be added, otherwise
3425	n/a	it will replace a former binding.
3426	n/a
3427	n/a	Example for the anonymous turtle, i. e. the procedural way:
3428	n/a
3429	n/a	>>> def turn(x, y):
3430	n/a	left(360)
3431	n/a
3432	n/a	>>> onclick(turn) # Now clicking into the turtle will turn it.
3433	n/a	>>> onclick(None) # event-binding will be removed
3434	n/a	"""
3435	n/a	self.screen._onclick(self.turtle._item, fun, btn, add)
3436	n/a	self._update()
3437	n/a
3438	n/a	def onrelease(self, fun, btn=1, add=None):
3439	n/a	"""Bind fun to mouse-button-release event on this turtle on canvas.
3440	n/a
3441	n/a	Arguments:
3442	n/a	fun -- a function with two arguments, to which will be assigned
3443	n/a	the coordinates of the clicked point on the canvas.
3444	n/a	num -- number of the mouse-button defaults to 1 (left mouse button).
3445	n/a
3446	n/a	Example (for a MyTurtle instance named joe):
3447	n/a	>>> class MyTurtle(Turtle):
3448	n/a	def glow(self,x,y):
3449	n/a	self.fillcolor("red")
3450	n/a	def unglow(self,x,y):
3451	n/a	self.fillcolor("")
3452	n/a
3453	n/a	>>> joe = MyTurtle()
3454	n/a	>>> joe.onclick(joe.glow)
3455	n/a	>>> joe.onrelease(joe.unglow)
3456	n/a	### clicking on joe turns fillcolor red,
3457	n/a	### unclicking turns it to transparent.
3458	n/a	"""
3459	n/a	self.screen._onrelease(self.turtle._item, fun, btn, add)
3460	n/a	self._update()
3461	n/a
3462	n/a	def ondrag(self, fun, btn=1, add=None):
3463	n/a	"""Bind fun to mouse-move event on this turtle on canvas.
3464	n/a
3465	n/a	Arguments:
3466	n/a	fun -- a function with two arguments, to which will be assigned
3467	n/a	the coordinates of the clicked point on the canvas.
3468	n/a	num -- number of the mouse-button defaults to 1 (left mouse button).
3469	n/a
3470	n/a	Every sequence of mouse-move-events on a turtle is preceded by a
3471	n/a	mouse-click event on that turtle.
3472	n/a
3473	n/a	Example (for a Turtle instance named turtle):
3474	n/a	>>> turtle.ondrag(turtle.goto)
3475	n/a
3476	n/a	### Subsequently clicking and dragging a Turtle will
3477	n/a	### move it across the screen thereby producing handdrawings
3478	n/a	### (if pen is down).
3479	n/a	"""
3480	n/a	self.screen._ondrag(self.turtle._item, fun, btn, add)
3481	n/a
3482	n/a
3483	n/a	def _undo(self, action, data):
3484	n/a	"""Does the main part of the work for undo()
3485	n/a	"""
3486	n/a	if self.undobuffer is None:
3487	n/a	return
3488	n/a	if action == "rot":
3489	n/a	angle, degPAU = data
3490	n/a	self._rotate(-angle*degPAU/self._degreesPerAU)
3491	n/a	dummy = self.undobuffer.pop()
3492	n/a	elif action == "stamp":
3493	n/a	stitem = data[0]
3494	n/a	self.clearstamp(stitem)
3495	n/a	elif action == "go":
3496	n/a	self._undogoto(data)
3497	n/a	elif action in ["wri", "dot"]:
3498	n/a	item = data[0]
3499	n/a	self.screen._delete(item)
3500	n/a	self.items.remove(item)
3501	n/a	elif action == "dofill":
3502	n/a	item = data[0]
3503	n/a	self.screen._drawpoly(item, ((0, 0),(0, 0),(0, 0)),
3504	n/a	fill="", outline="")
3505	n/a	elif action == "beginfill":
3506	n/a	item = data[0]
3507	n/a	self._fillitem = self._fillpath = None
3508	n/a	self.screen._delete(item)
3509	n/a	self.items.remove(item)
3510	n/a	elif action == "pen":
3511	n/a	TPen.pen(self, data[0])
3512	n/a	self.undobuffer.pop()
3513	n/a
3514	n/a	def undo(self):
3515	n/a	"""undo (repeatedly) the last turtle action.
3516	n/a
3517	n/a	No argument.
3518	n/a
3519	n/a	undo (repeatedly) the last turtle action.
3520	n/a	Number of available undo actions is determined by the size of
3521	n/a	the undobuffer.
3522	n/a
3523	n/a	Example (for a Turtle instance named turtle):
3524	n/a	>>> for i in range(4):
3525	n/a	turtle.fd(50); turtle.lt(80)
3526	n/a
3527	n/a	>>> for i in range(8):
3528	n/a	turtle.undo()
3529	n/a	"""
3530	n/a	if self.undobuffer is None:
3531	n/a	return
3532	n/a	item = self.undobuffer.pop()
3533	n/a	action = item[0]
3534	n/a	data = item[1:]
3535	n/a	if action == "seq":
3536	n/a	while data:
3537	n/a	item = data.pop()
3538	n/a	self._undo(item[0], item[1:])
3539	n/a	else:
3540	n/a	self._undo(action, data)
3541	n/a
3542	n/a	turtlesize = shapesize
3543	n/a
3544	n/a	RawPen = RawTurtle
3545	n/a
3546	n/a	### Screen - Singleton ########################
3547	n/a
3548	n/a	def Screen():
3549	n/a	"""Return the singleton screen object.
3550	n/a	If none exists at the moment, create a new one and return it,
3551	n/a	else return the existing one."""
3552	n/a	if Turtle._screen is None:
3553	n/a	Turtle._screen = _Screen()
3554	n/a	return Turtle._screen
3555	n/a
3556	n/a	class _Screen(TurtleScreen):
3557	n/a
3558	n/a	_root = None
3559	n/a	_canvas = None
3560	n/a	_title = _CFG["title"]
3561	n/a
3562	n/a	def __init__(self):
3563	n/a	# XXX there is no need for this code to be conditional,
3564	n/a	# as there will be only a single _Screen instance, anyway
3565	n/a	# XXX actually, the turtle demo is injecting root window,
3566	n/a	# so perhaps the conditional creation of a root should be
3567	n/a	# preserved (perhaps by passing it as an optional parameter)
3568	n/a	if _Screen._root is None:
3569	n/a	_Screen._root = self._root = _Root()
3570	n/a	self._root.title(_Screen._title)
3571	n/a	self._root.ondestroy(self._destroy)
3572	n/a	if _Screen._canvas is None:
3573	n/a	width = _CFG["width"]
3574	n/a	height = _CFG["height"]
3575	n/a	canvwidth = _CFG["canvwidth"]
3576	n/a	canvheight = _CFG["canvheight"]
3577	n/a	leftright = _CFG["leftright"]
3578	n/a	topbottom = _CFG["topbottom"]
3579	n/a	self._root.setupcanvas(width, height, canvwidth, canvheight)
3580	n/a	_Screen._canvas = self._root._getcanvas()
3581	n/a	TurtleScreen.__init__(self, _Screen._canvas)
3582	n/a	self.setup(width, height, leftright, topbottom)
3583	n/a
3584	n/a	def setup(self, width=_CFG["width"], height=_CFG["height"],
3585	n/a	startx=_CFG["leftright"], starty=_CFG["topbottom"]):
3586	n/a	""" Set the size and position of the main window.
3587	n/a
3588	n/a	Arguments:
3589	n/a	width: as integer a size in pixels, as float a fraction of the screen.
3590	n/a	Default is 50% of screen.
3591	n/a	height: as integer the height in pixels, as float a fraction of the
3592	n/a	screen. Default is 75% of screen.
3593	n/a	startx: if positive, starting position in pixels from the left
3594	n/a	edge of the screen, if negative from the right edge
3595	n/a	Default, startx=None is to center window horizontally.
3596	n/a	starty: if positive, starting position in pixels from the top
3597	n/a	edge of the screen, if negative from the bottom edge
3598	n/a	Default, starty=None is to center window vertically.
3599	n/a
3600	n/a	Examples (for a Screen instance named screen):
3601	n/a	>>> screen.setup (width=200, height=200, startx=0, starty=0)
3602	n/a
3603	n/a	sets window to 200x200 pixels, in upper left of screen
3604	n/a
3605	n/a	>>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
3606	n/a
3607	n/a	sets window to 75% of screen by 50% of screen and centers
3608	n/a	"""
3609	n/a	if not hasattr(self._root, "set_geometry"):
3610	n/a	return
3611	n/a	sw = self._root.win_width()
3612	n/a	sh = self._root.win_height()
3613	n/a	if isinstance(width, float) and 0 <= width <= 1:
3614	n/a	width = sw*width
3615	n/a	if startx is None:
3616	n/a	startx = (sw - width) / 2
3617	n/a	if isinstance(height, float) and 0 <= height <= 1:
3618	n/a	height = sh*height
3619	n/a	if starty is None:
3620	n/a	starty = (sh - height) / 2
3621	n/a	self._root.set_geometry(width, height, startx, starty)
3622	n/a	self.update()
3623	n/a
3624	n/a	def title(self, titlestring):
3625	n/a	"""Set title of turtle-window
3626	n/a
3627	n/a	Argument:
3628	n/a	titlestring -- a string, to appear in the titlebar of the
3629	n/a	turtle graphics window.
3630	n/a
3631	n/a	This is a method of Screen-class. Not available for TurtleScreen-
3632	n/a	objects.
3633	n/a
3634	n/a	Example (for a Screen instance named screen):
3635	n/a	>>> screen.title("Welcome to the turtle-zoo!")
3636	n/a	"""
3637	n/a	if _Screen._root is not None:
3638	n/a	_Screen._root.title(titlestring)
3639	n/a	_Screen._title = titlestring
3640	n/a
3641	n/a	def _destroy(self):
3642	n/a	root = self._root
3643	n/a	if root is _Screen._root:
3644	n/a	Turtle._pen = None
3645	n/a	Turtle._screen = None
3646	n/a	_Screen._root = None
3647	n/a	_Screen._canvas = None
3648	n/a	TurtleScreen._RUNNING = True
3649	n/a	root.destroy()
3650	n/a
3651	n/a	def bye(self):
3652	n/a	"""Shut the turtlegraphics window.
3653	n/a
3654	n/a	Example (for a TurtleScreen instance named screen):
3655	n/a	>>> screen.bye()
3656	n/a	"""
3657	n/a	self._destroy()
3658	n/a
3659	n/a	def exitonclick(self):
3660	n/a	"""Go into mainloop until the mouse is clicked.
3661	n/a
3662	n/a	No arguments.
3663	n/a
3664	n/a	Bind bye() method to mouseclick on TurtleScreen.
3665	n/a	If "using_IDLE" - value in configuration dictionary is False
3666	n/a	(default value), enter mainloop.
3667	n/a	If IDLE with -n switch (no subprocess) is used, this value should be
3668	n/a	set to True in turtle.cfg. In this case IDLE's mainloop
3669	n/a	is active also for the client script.
3670	n/a
3671	n/a	This is a method of the Screen-class and not available for
3672	n/a	TurtleScreen instances.
3673	n/a
3674	n/a	Example (for a Screen instance named screen):
3675	n/a	>>> screen.exitonclick()
3676	n/a
3677	n/a	"""
3678	n/a	def exitGracefully(x, y):
3679	n/a	"""Screen.bye() with two dummy-parameters"""
3680	n/a	self.bye()
3681	n/a	self.onclick(exitGracefully)
3682	n/a	if _CFG["using_IDLE"]:
3683	n/a	return
3684	n/a	try:
3685	n/a	mainloop()
3686	n/a	except AttributeError:
3687	n/a	exit(0)
3688	n/a
3689	n/a
3690	n/a	class Turtle(RawTurtle):
3691	n/a	"""RawTurtle auto-crating (scrolled) canvas.
3692	n/a
3693	n/a	When a Turtle object is created or a function derived from some
3694	n/a	Turtle method is called a TurtleScreen object is automatically created.
3695	n/a	"""
3696	n/a	_pen = None
3697	n/a	_screen = None
3698	n/a
3699	n/a	def __init__(self,
3700	n/a	shape=_CFG["shape"],
3701	n/a	undobuffersize=_CFG["undobuffersize"],
3702	n/a	visible=_CFG["visible"]):
3703	n/a	if Turtle._screen is None:
3704	n/a	Turtle._screen = Screen()
3705	n/a	RawTurtle.__init__(self, Turtle._screen,
3706	n/a	shape=shape,
3707	n/a	undobuffersize=undobuffersize,
3708	n/a	visible=visible)
3709	n/a
3710	n/a	Pen = Turtle
3711	n/a
3712	n/a	def _getpen():
3713	n/a	"""Create the 'anonymous' turtle if not already present."""
3714	n/a	if Turtle._pen is None:
3715	n/a	Turtle._pen = Turtle()
3716	n/a	return Turtle._pen
3717	n/a
3718	n/a	def _getscreen():
3719	n/a	"""Create a TurtleScreen if not already present."""
3720	n/a	if Turtle._screen is None:
3721	n/a	Turtle._screen = Screen()
3722	n/a	return Turtle._screen
3723	n/a
3724	n/a	def write_docstringdict(filename="turtle_docstringdict"):
3725	n/a	"""Create and write docstring-dictionary to file.
3726	n/a
3727	n/a	Optional argument:
3728	n/a	filename -- a string, used as filename
3729	n/a	default value is turtle_docstringdict
3730	n/a
3731	n/a	Has to be called explicitely, (not used by the turtle-graphics classes)
3732	n/a	The docstring dictionary will be written to the Python script <filname>.py
3733	n/a	It is intended to serve as a template for translation of the docstrings
3734	n/a	into different languages.
3735	n/a	"""
3736	n/a	docsdict = {}
3737	n/a
3738	n/a	for methodname in _tg_screen_functions:
3739	n/a	key = "_Screen."+methodname
3740	n/a	docsdict[key] = eval(key).__doc__
3741	n/a	for methodname in _tg_turtle_functions:
3742	n/a	key = "Turtle."+methodname
3743	n/a	docsdict[key] = eval(key).__doc__
3744	n/a
3745	n/a	f = open("%s.py" % filename,"w")
3746	n/a	keys = sorted([x for x in docsdict.keys()
3747	n/a	if x.split('.')[1] not in _alias_list])
3748	n/a	f.write('docsdict = {\n\n')
3749	n/a	for key in keys[:-1]:
3750	n/a	f.write('%s :\n' % repr(key))
3751	n/a	f.write(' """%s\n""",\n\n' % docsdict[key])
3752	n/a	key = keys[-1]
3753	n/a	f.write('%s :\n' % repr(key))
3754	n/a	f.write(' """%s\n"""\n\n' % docsdict[key])
3755	n/a	f.write("}\n")
3756	n/a	f.close()
3757	n/a
3758	n/a	def read_docstrings(lang):
3759	n/a	"""Read in docstrings from lang-specific docstring dictionary.
3760	n/a
3761	n/a	Transfer docstrings, translated to lang, from a dictionary-file
3762	n/a	to the methods of classes Screen and Turtle and - in revised form -
3763	n/a	to the corresponding functions.
3764	n/a	"""
3765	n/a	modname = "turtle_docstringdict_%(language)s" % {'language':lang.lower()}
3766	n/a	module = __import__(modname)
3767	n/a	docsdict = module.docsdict
3768	n/a	for key in docsdict:
3769	n/a	#print key
3770	n/a	try:
3771	n/a	eval(key).im_func.__doc__ = docsdict[key]
3772	n/a	except:
3773	n/a	print "Bad docstring-entry: %s" % key
3774	n/a
3775	n/a	_LANGUAGE = _CFG["language"]
3776	n/a
3777	n/a	try:
3778	n/a	if _LANGUAGE != "english":
3779	n/a	read_docstrings(_LANGUAGE)
3780	n/a	except ImportError:
3781	n/a	print "Cannot find docsdict for", _LANGUAGE
3782	n/a	except:
3783	n/a	print ("Unknown Error when trying to import %s-docstring-dictionary" %
3784	n/a	_LANGUAGE)
3785	n/a
3786	n/a
3787	n/a	def getmethparlist(ob):
3788	n/a	"Get strings describing the arguments for the given object"
3789	n/a	argText1 = argText2 = ""
3790	n/a	# bit of a hack for methods - turn it into a function
3791	n/a	# but we drop the "self" param.
3792	n/a	if type(ob)==types.MethodType:
3793	n/a	fob = ob.im_func
3794	n/a	argOffset = 1
3795	n/a	else:
3796	n/a	fob = ob
3797	n/a	argOffset = 0
3798	n/a	# Try and build one for Python defined functions
3799	n/a	if type(fob) in [types.FunctionType, types.LambdaType]:
3800	n/a	try:
3801	n/a	counter = fob.func_code.co_argcount
3802	n/a	items2 = list(fob.func_code.co_varnames[argOffset:counter])
3803	n/a	realArgs = fob.func_code.co_varnames[argOffset:counter]
3804	n/a	defaults = fob.func_defaults or []
3805	n/a	defaults = list(map(lambda name: "=%s" % repr(name), defaults))
3806	n/a	defaults = [""] * (len(realArgs)-len(defaults)) + defaults
3807	n/a	items1 = map(lambda arg, dflt: arg+dflt, realArgs, defaults)
3808	n/a	if fob.func_code.co_flags & 0x4:
3809	n/a	items1.append("*"+fob.func_code.co_varnames[counter])
3810	n/a	items2.append("*"+fob.func_code.co_varnames[counter])
3811	n/a	counter += 1
3812	n/a	if fob.func_code.co_flags & 0x8:
3813	n/a	items1.append("**"+fob.func_code.co_varnames[counter])
3814	n/a	items2.append("**"+fob.func_code.co_varnames[counter])
3815	n/a	argText1 = ", ".join(items1)
3816	n/a	argText1 = "(%s)" % argText1
3817	n/a	argText2 = ", ".join(items2)
3818	n/a	argText2 = "(%s)" % argText2
3819	n/a	except:
3820	n/a	pass
3821	n/a	return argText1, argText2
3822	n/a
3823	n/a	def _turtle_docrevise(docstr):
3824	n/a	"""To reduce docstrings from RawTurtle class for functions
3825	n/a	"""
3826	n/a	import re
3827	n/a	if docstr is None:
3828	n/a	return None
3829	n/a	turtlename = _CFG["exampleturtle"]
3830	n/a	newdocstr = docstr.replace("%s." % turtlename,"")
3831	n/a	parexp = re.compile(r' \(.+ %s\):' % turtlename)
3832	n/a	newdocstr = parexp.sub(":", newdocstr)
3833	n/a	return newdocstr
3834	n/a
3835	n/a	def _screen_docrevise(docstr):
3836	n/a	"""To reduce docstrings from TurtleScreen class for functions
3837	n/a	"""
3838	n/a	import re
3839	n/a	if docstr is None:
3840	n/a	return None
3841	n/a	screenname = _CFG["examplescreen"]
3842	n/a	newdocstr = docstr.replace("%s." % screenname,"")
3843	n/a	parexp = re.compile(r' \(.+ %s\):' % screenname)
3844	n/a	newdocstr = parexp.sub(":", newdocstr)
3845	n/a	return newdocstr
3846	n/a
3847	n/a	## The following mechanism makes all methods of RawTurtle and Turtle available
3848	n/a	## as functions. So we can enhance, change, add, delete methods to these
3849	n/a	## classes and do not need to change anything here.
3850	n/a
3851	n/a
3852	n/a	for methodname in _tg_screen_functions:
3853	n/a	pl1, pl2 = getmethparlist(eval('_Screen.' + methodname))
3854	n/a	if pl1 == "":
3855	n/a	print ">>>>>>", pl1, pl2
3856	n/a	continue
3857	n/a	defstr = ("def %(key)s%(pl1)s: return _getscreen().%(key)s%(pl2)s" %
3858	n/a	{'key':methodname, 'pl1':pl1, 'pl2':pl2})
3859	n/a	exec defstr
3860	n/a	eval(methodname).__doc__ = _screen_docrevise(eval('_Screen.'+methodname).__doc__)
3861	n/a
3862	n/a	for methodname in _tg_turtle_functions:
3863	n/a	pl1, pl2 = getmethparlist(eval('Turtle.' + methodname))
3864	n/a	if pl1 == "":
3865	n/a	print ">>>>>>", pl1, pl2
3866	n/a	continue
3867	n/a	defstr = ("def %(key)s%(pl1)s: return _getpen().%(key)s%(pl2)s" %
3868	n/a	{'key':methodname, 'pl1':pl1, 'pl2':pl2})
3869	n/a	exec defstr
3870	n/a	eval(methodname).__doc__ = _turtle_docrevise(eval('Turtle.'+methodname).__doc__)
3871	n/a
3872	n/a
3873	n/a	done = mainloop = TK.mainloop
3874	n/a	del pl1, pl2, defstr
3875	n/a
3876	n/a	if __name__ == "__main__":
3877	n/a	def switchpen():
3878	n/a	if isdown():
3879	n/a	pu()
3880	n/a	else:
3881	n/a	pd()
3882	n/a
3883	n/a	def demo1():
3884	n/a	"""Demo of old turtle.py - module"""
3885	n/a	reset()
3886	n/a	tracer(True)
3887	n/a	up()
3888	n/a	backward(100)
3889	n/a	down()
3890	n/a	# draw 3 squares; the last filled
3891	n/a	width(3)
3892	n/a	for i in range(3):
3893	n/a	if i == 2:
3894	n/a	fill(1)
3895	n/a	for _ in range(4):
3896	n/a	forward(20)
3897	n/a	left(90)
3898	n/a	if i == 2:
3899	n/a	color("maroon")
3900	n/a	fill(0)
3901	n/a	up()
3902	n/a	forward(30)
3903	n/a	down()
3904	n/a	width(1)
3905	n/a	color("black")
3906	n/a	# move out of the way
3907	n/a	tracer(False)
3908	n/a	up()
3909	n/a	right(90)
3910	n/a	forward(100)
3911	n/a	right(90)
3912	n/a	forward(100)
3913	n/a	right(180)
3914	n/a	down()
3915	n/a	# some text
3916	n/a	write("startstart", 1)
3917	n/a	write("start", 1)
3918	n/a	color("red")
3919	n/a	# staircase
3920	n/a	for i in range(5):
3921	n/a	forward(20)
3922	n/a	left(90)
3923	n/a	forward(20)
3924	n/a	right(90)
3925	n/a	# filled staircase
3926	n/a	tracer(True)
3927	n/a	fill(1)
3928	n/a	for i in range(5):
3929	n/a	forward(20)
3930	n/a	left(90)
3931	n/a	forward(20)
3932	n/a	right(90)
3933	n/a	fill(0)
3934	n/a	# more text
3935	n/a
3936	n/a	def demo2():
3937	n/a	"""Demo of some new features."""
3938	n/a	speed(1)
3939	n/a	st()
3940	n/a	pensize(3)
3941	n/a	setheading(towards(0, 0))
3942	n/a	radius = distance(0, 0)/2.0
3943	n/a	rt(90)
3944	n/a	for _ in range(18):
3945	n/a	switchpen()
3946	n/a	circle(radius, 10)
3947	n/a	write("wait a moment...")
3948	n/a	while undobufferentries():
3949	n/a	undo()
3950	n/a	reset()
3951	n/a	lt(90)
3952	n/a	colormode(255)
3953	n/a	laenge = 10
3954	n/a	pencolor("green")
3955	n/a	pensize(3)
3956	n/a	lt(180)
3957	n/a	for i in range(-2, 16):
3958	n/a	if i > 0:
3959	n/a	begin_fill()
3960	n/a	fillcolor(255-15i, 0, 15i)
3961	n/a	for _ in range(3):
3962	n/a	fd(laenge)
3963	n/a	lt(120)
3964	n/a	laenge += 10
3965	n/a	lt(15)
3966	n/a	speed((speed()+1)%12)
3967	n/a	end_fill()
3968	n/a
3969	n/a	lt(120)
3970	n/a	pu()
3971	n/a	fd(70)
3972	n/a	rt(30)
3973	n/a	pd()
3974	n/a	color("red","yellow")
3975	n/a	speed(0)
3976	n/a	fill(1)
3977	n/a	for _ in range(4):
3978	n/a	circle(50, 90)
3979	n/a	rt(90)
3980	n/a	fd(30)
3981	n/a	rt(90)
3982	n/a	fill(0)
3983	n/a	lt(90)
3984	n/a	pu()
3985	n/a	fd(30)
3986	n/a	pd()
3987	n/a	shape("turtle")
3988	n/a
3989	n/a	tri = getturtle()
3990	n/a	tri.resizemode("auto")
3991	n/a	turtle = Turtle()
3992	n/a	turtle.resizemode("auto")
3993	n/a	turtle.shape("turtle")
3994	n/a	turtle.reset()
3995	n/a	turtle.left(90)
3996	n/a	turtle.speed(0)
3997	n/a	turtle.up()
3998	n/a	turtle.goto(280, 40)
3999	n/a	turtle.lt(30)
4000	n/a	turtle.down()
4001	n/a	turtle.speed(6)
4002	n/a	turtle.color("blue","orange")
4003	n/a	turtle.pensize(2)
4004	n/a	tri.speed(6)
4005	n/a	setheading(towards(turtle))
4006	n/a	count = 1
4007	n/a	while tri.distance(turtle) > 4:
4008	n/a	turtle.fd(3.5)
4009	n/a	turtle.lt(0.6)
4010	n/a	tri.setheading(tri.towards(turtle))
4011	n/a	tri.fd(4)
4012	n/a	if count % 20 == 0:
4013	n/a	turtle.stamp()
4014	n/a	tri.stamp()
4015	n/a	switchpen()
4016	n/a	count += 1
4017	n/a	tri.write("CAUGHT! ", font=("Arial", 16, "bold"), align="right")
4018	n/a	tri.pencolor("black")
4019	n/a	tri.pencolor("red")
4020	n/a
4021	n/a	def baba(xdummy, ydummy):
4022	n/a	clearscreen()
4023	n/a	bye()
4024	n/a
4025	n/a	time.sleep(2)
4026	n/a
4027	n/a	while undobufferentries():
4028	n/a	tri.undo()
4029	n/a	turtle.undo()
4030	n/a	tri.fd(50)
4031	n/a	tri.write(" Click me!", font = ("Courier", 12, "bold") )
4032	n/a	tri.onclick(baba, 1)
4033	n/a
4034	n/a	demo1()
4035	n/a	demo2()
4036	n/a	exitonclick()