[Python-3000-checkins] r66531 - in python/branches/py3k: Demo/turtle/tdemo_I_dontlike_tiltdemo.py Demo/turtle/tdemo_bytedesign.py Demo/turtle/tdemo_chaos.py Demo/turtle/tdemo_clock.py Demo/turtle/tdemo_colormixer.py Demo/turtle/tdemo_forest.py Demo/turtle/tdemo_fractalcurves.py Demo/turtle/tdemo_lindenmayer_indian.py Demo/turtle/tdemo_minimal_hanoi.py Demo/turtle/tdemo_paint.py Demo/turtle/tdemo_peace.py Demo/turtle/tdemo_penrose.py Demo/turtle/tdemo_planet_and_moon.py Demo/turtle/tdemo_tree.py Demo/turtle/tdemo_wikipedia.py Demo/turtle/tdemo_yinyang.py Demo/turtle/turtleDemo.py Demo/turtle/turtledemo_two_canvases.py Lib/tkinter/turtle.py Lib/turtle.py Misc/NEWS
martin.v.loewis
python-3000-checkins at python.org
Sun Sep 21 09:32:12 CEST 2008
Author: martin.v.loewis
Date: Sun Sep 21 09:32:10 2008
New Revision: 66531
Log:
Bug #3884: Make the turtle module toplevel again.
Added:
python/branches/py3k/Lib/turtle.py
- copied unchanged from r66520, /python/branches/py3k/Lib/tkinter/turtle.py
Removed:
python/branches/py3k/Lib/tkinter/turtle.py
Modified:
python/branches/py3k/Demo/turtle/tdemo_I_dontlike_tiltdemo.py
python/branches/py3k/Demo/turtle/tdemo_bytedesign.py
python/branches/py3k/Demo/turtle/tdemo_chaos.py
python/branches/py3k/Demo/turtle/tdemo_clock.py
python/branches/py3k/Demo/turtle/tdemo_colormixer.py
python/branches/py3k/Demo/turtle/tdemo_forest.py
python/branches/py3k/Demo/turtle/tdemo_fractalcurves.py
python/branches/py3k/Demo/turtle/tdemo_lindenmayer_indian.py
python/branches/py3k/Demo/turtle/tdemo_minimal_hanoi.py
python/branches/py3k/Demo/turtle/tdemo_paint.py
python/branches/py3k/Demo/turtle/tdemo_peace.py
python/branches/py3k/Demo/turtle/tdemo_penrose.py
python/branches/py3k/Demo/turtle/tdemo_planet_and_moon.py
python/branches/py3k/Demo/turtle/tdemo_tree.py
python/branches/py3k/Demo/turtle/tdemo_wikipedia.py
python/branches/py3k/Demo/turtle/tdemo_yinyang.py
python/branches/py3k/Demo/turtle/turtleDemo.py
python/branches/py3k/Demo/turtle/turtledemo_two_canvases.py
python/branches/py3k/Misc/NEWS
Modified: python/branches/py3k/Demo/turtle/tdemo_I_dontlike_tiltdemo.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_I_dontlike_tiltdemo.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_I_dontlike_tiltdemo.py Sun Sep 21 09:32:10 2008
@@ -12,7 +12,7 @@
Without using reset() ;-)
---------------------------------------
"""
-from tkinter.turtle import *
+from turtle import *
import time
def main():
Modified: python/branches/py3k/Demo/turtle/tdemo_bytedesign.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_bytedesign.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_bytedesign.py Sun Sep 21 09:32:10 2008
@@ -23,7 +23,7 @@
"""
import math
-from tkinter.turtle import Turtle, mainloop
+from turtle import Turtle, mainloop
from time import clock
# wrapper for any additional drawing routines
Modified: python/branches/py3k/Demo/turtle/tdemo_chaos.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_chaos.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_chaos.py Sun Sep 21 09:32:10 2008
@@ -4,7 +4,7 @@
# Ein einfaches Programm zur Demonstration von "chaotischem Verhalten".
-from tkinter.turtle import *
+from turtle import *
def f(x):
return 3.9*x*(1-x)
Modified: python/branches/py3k/Demo/turtle/tdemo_clock.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_clock.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_clock.py Sun Sep 21 09:32:10 2008
@@ -10,7 +10,7 @@
Press STOP to exit the program!
------------------------------------
"""
-from tkinter.turtle import *
+from turtle import *
from datetime import datetime
mode("logo")
Modified: python/branches/py3k/Demo/turtle/tdemo_colormixer.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_colormixer.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_colormixer.py Sun Sep 21 09:32:10 2008
@@ -1,6 +1,6 @@
# colormixer
-from tkinter.turtle import Screen, Turtle, mainloop
+from turtle import Screen, Turtle, mainloop
import sys
sys.setrecursionlimit(20000) # overcomes, for now, an instability of Python 3.0
Modified: python/branches/py3k/Demo/turtle/tdemo_forest.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_forest.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_forest.py Sun Sep 21 09:32:10 2008
@@ -11,7 +11,7 @@
a Logo program written by Erich Neuwirth. See:
http://homepage.univie.ac.at/erich.neuwirth/
"""
-from tkinter.turtle import Turtle, colormode, tracer, mainloop
+from turtle import Turtle, colormode, tracer, mainloop
from random import randrange
from time import clock
Modified: python/branches/py3k/Demo/turtle/tdemo_fractalcurves.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_fractalcurves.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_fractalcurves.py Sun Sep 21 09:32:10 2008
@@ -11,7 +11,7 @@
methods are taken from the PythonCard example
scripts for turtle-graphics.
"""
-from tkinter.turtle import *
+from turtle import *
from time import sleep, clock
class CurvesTurtle(Pen):
Modified: python/branches/py3k/Demo/turtle/tdemo_lindenmayer_indian.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_lindenmayer_indian.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_lindenmayer_indian.py Sun Sep 21 09:32:10 2008
@@ -25,7 +25,7 @@
# Mini Lindenmayer tool
###############################
-from tkinter.turtle import *
+from turtle import *
def replace( seq, replacementRules, n ):
for i in range(n):
Modified: python/branches/py3k/Demo/turtle/tdemo_minimal_hanoi.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_minimal_hanoi.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_minimal_hanoi.py Sun Sep 21 09:32:10 2008
@@ -17,7 +17,7 @@
To exit press STOP button
---------------------------------------
"""
-from tkinter.turtle import *
+from turtle import *
class Disc(Turtle):
def __init__(self, n):
Modified: python/branches/py3k/Demo/turtle/tdemo_paint.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_paint.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_paint.py Sun Sep 21 09:32:10 2008
@@ -15,7 +15,7 @@
To exit press STOP button
-------------------------------------------
"""
-from tkinter.turtle import *
+from turtle import *
def switchupdown(x=0, y=0):
if pen()["pendown"]:
Modified: python/branches/py3k/Demo/turtle/tdemo_peace.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_peace.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_peace.py Sun Sep 21 09:32:10 2008
@@ -13,7 +13,7 @@
colorloop:
"""
-from tkinter.turtle import *
+from turtle import *
def main():
peacecolors = ("red3", "orange", "yellow",
Modified: python/branches/py3k/Demo/turtle/tdemo_penrose.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_penrose.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_penrose.py Sun Sep 21 09:32:10 2008
@@ -15,7 +15,7 @@
http://en.wikipedia.org/wiki/Penrose_tiling
-------------------------------------------
"""
-from tkinter.turtle import *
+from turtle import *
from math import cos, pi
from time import clock, sleep
Modified: python/branches/py3k/Demo/turtle/tdemo_planet_and_moon.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_planet_and_moon.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_planet_and_moon.py Sun Sep 21 09:32:10 2008
@@ -17,7 +17,7 @@
scrollbar of the canvas.
"""
-from tkinter.turtle import Shape, Turtle, mainloop, Vec2D as Vec
+from turtle import Shape, Turtle, mainloop, Vec2D as Vec
from time import sleep
G = 8
Modified: python/branches/py3k/Demo/turtle/tdemo_tree.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_tree.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_tree.py Sun Sep 21 09:32:10 2008
@@ -15,7 +15,7 @@
current pen is cloned. So in the end there
are 1024 turtles.
"""
-from tkinter.turtle import Turtle, mainloop
+from turtle import Turtle, mainloop
from time import clock
def tree(plist, l, a, f):
Modified: python/branches/py3k/Demo/turtle/tdemo_wikipedia.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_wikipedia.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_wikipedia.py Sun Sep 21 09:32:10 2008
@@ -13,7 +13,7 @@
Followed by a complete undo().
"""
-from tkinter.turtle import Screen, Turtle, mainloop
+from turtle import Screen, Turtle, mainloop
from time import clock, sleep
def mn_eck(p, ne,sz):
Modified: python/branches/py3k/Demo/turtle/tdemo_yinyang.py
==============================================================================
--- python/branches/py3k/Demo/turtle/tdemo_yinyang.py (original)
+++ python/branches/py3k/Demo/turtle/tdemo_yinyang.py Sun Sep 21 09:32:10 2008
@@ -11,7 +11,7 @@
"""
-from tkinter.turtle import *
+from turtle import *
def yin(radius, color1, color2):
width(3)
Modified: python/branches/py3k/Demo/turtle/turtleDemo.py
==============================================================================
--- python/branches/py3k/Demo/turtle/turtleDemo.py (original)
+++ python/branches/py3k/Demo/turtle/turtleDemo.py Sun Sep 21 09:32:10 2008
@@ -8,7 +8,7 @@
from idlelib.textView import view_file # TextViewer
from imp import reload
-from tkinter import turtle
+import turtle
import time
STARTUP = 1
Modified: python/branches/py3k/Demo/turtle/turtledemo_two_canvases.py
==============================================================================
--- python/branches/py3k/Demo/turtle/turtledemo_two_canvases.py (original)
+++ python/branches/py3k/Demo/turtle/turtledemo_two_canvases.py Sun Sep 21 09:32:10 2008
@@ -3,7 +3,7 @@
"""turtle example: Using TurtleScreen and RawTurtle
for drawing on two distinct canvases.
"""
-from tkinter.turtle import TurtleScreen, RawTurtle, TK
+from turtle import TurtleScreen, RawTurtle, TK
root = TK.Tk()
cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff")
Deleted: python/branches/py3k/Lib/tkinter/turtle.py
==============================================================================
--- python/branches/py3k/Lib/tkinter/turtle.py Sun Sep 21 09:32:10 2008
+++ (empty file)
@@ -1,4051 +0,0 @@
-#
-# turtle.py: a Tkinter based turtle graphics module for Python
-# Version 1.0b1 - 31. 5. 2008
-#
-# Copyright (C) 2006 - 2008 Gregor Lingl
-# email: glingl at aon.at
-#
-# This software is provided 'as-is', without any express or implied
-# warranty. In no event will the authors be held liable for any damages
-# arising from the use of this software.
-#
-# Permission is granted to anyone to use this software for any purpose,
-# including commercial applications, and to alter it and redistribute it
-# freely, subject to the following restrictions:
-#
-# 1. The origin of this software must not be misrepresented; you must not
-# claim that you wrote the original software. If you use this software
-# in a product, an acknowledgment in the product documentation would be
-# appreciated but is not required.
-# 2. Altered source versions must be plainly marked as such, and must not be
-# misrepresented as being the original software.
-# 3. This notice may not be removed or altered from any source distribution.
-
-
-"""
-Turtle graphics is a popular way for introducing programming to
-kids. It was part of the original Logo programming language developed
-by Wally Feurzig and Seymour Papert in 1966.
-
-Imagine a robotic turtle starting at (0, 0) in the x-y plane. Give it
-the command turtle.forward(15), and it moves (on-screen!) 15 pixels in
-the direction it is facing, drawing a line as it moves. Give it the
-command turtle.left(25), and it rotates in-place 25 degrees clockwise.
-
-By combining together these and similar commands, intricate shapes and
-pictures can easily be drawn.
-
------ turtle.py
-
-This module is an extended reimplementation of turtle.py from the
-Python standard distribution up to Python 2.5. (See: http:\\www.python.org)
-
-It tries to keep the merits of turtle.py and to be (nearly) 100%
-compatible with it. This means in the first place to enable the
-learning programmer to use all the commands, classes and methods
-interactively when using the module from within IDLE run with
-the -n switch.
-
-Roughly it has the following features added:
-
-- Better animation of the turtle movements, especially of turning the
- turtle. So the turtles can more easily be used as a visual feedback
- instrument by the (beginning) programmer.
-
-- Different turtle shapes, gif-images as turtle shapes, user defined
- and user controllable turtle shapes, among them compound
- (multicolored) shapes. Turtle shapes can be stgretched and tilted, which
- makes turtles zu very versatile geometrical objects.
-
-- Fine control over turtle movement and screen updates via delay(),
- and enhanced tracer() and speed() methods.
-
-- Aliases for the most commonly used commands, like fd for forward etc.,
- following the early Logo traditions. This reduces the boring work of
- typing long sequences of commands, which often occur in a natural way
- when kids try to program fancy pictures on their first encounter with
- turtle graphcis.
-
-- Turtles now have an undo()-method with configurable undo-buffer.
-
-- Some simple commands/methods for creating event driven programs
- (mouse-, key-, timer-events). Especially useful for programming games.
-
-- A scrollable Canvas class. The default scrollable Canvas can be
- extended interactively as needed while playing around with the turtle(s).
-
-- A TurtleScreen class with methods controlling background color or
- background image, window and canvas size and other properties of the
- TurtleScreen.
-
-- There is a method, setworldcoordinates(), to install a user defined
- coordinate-system for the TurtleScreen.
-
-- The implementation uses a 2-vector class named Vec2D, derived from tuple.
- This class is public, so it can be imported by the application programmer,
- which makes certain types of computations very natural and compact.
-
-- Appearance of the TurtleScreen and the Turtles at startup/import can be
- configured by means of a turtle.cfg configuration file.
- The default configuration mimics the appearance of the old turtle module.
-
-- If configured appropriately the module reads in docstrings from a docstring
- dictionary in some different language, supplied separately and replaces
- the english ones by those read in. There is a utility function
- write_docstringdict() to write a dictionary with the original (english)
- docstrings to disc, so it can serve as a template for translations.
-
-Behind the scenes there are some features included with possible
-extensionsin in mind. These will be commented and documented elsewhere.
-
-"""
-
-_ver = "turtle 1.0b1- - for Python 3.0 - 9. 6. 2008, 01:15"
-
-# print(_ver)
-
-import tkinter as TK
-import types
-import math
-import time
-import os
-
-from os.path import isfile, split, join
-from copy import deepcopy
-
-#from math import * ## for compatibility with old turtle module
-
-_tg_classes = ['ScrolledCanvas', 'TurtleScreen', 'Screen',
- 'RawTurtle', 'Turtle', 'RawPen', 'Pen', 'Shape', 'Vec2D']
-_tg_screen_functions = ['addshape', 'bgcolor', 'bgpic', 'bye',
- 'clearscreen', 'colormode', 'delay', 'exitonclick', 'getcanvas',
- 'getshapes', 'listen', 'mode', 'onkey', 'onscreenclick', 'ontimer',
- 'register_shape', 'resetscreen', 'screensize', 'setup',
- 'setworldcoordinates', 'title', 'tracer', 'turtles', 'update',
- 'window_height', 'window_width']
-_tg_turtle_functions = ['back', 'backward', 'begin_fill', 'begin_poly', 'bk',
- 'circle', 'clear', 'clearstamp', 'clearstamps', 'clone', 'color',
- 'degrees', 'distance', 'dot', 'down', 'end_fill', 'end_poly', 'fd',
- #'fill',
- 'fillcolor', 'forward', 'get_poly', 'getpen', 'getscreen',
- 'getturtle', 'goto', 'heading', 'hideturtle', 'home', 'ht', 'isdown',
- 'isvisible', 'left', 'lt', 'onclick', 'ondrag', 'onrelease', 'pd',
- 'pen', 'pencolor', 'pendown', 'pensize', 'penup', 'pos', 'position',
- 'pu', 'radians', 'right', 'reset', 'resizemode', 'rt',
- 'seth', 'setheading', 'setpos', 'setposition', 'settiltangle',
- 'setundobuffer', 'setx', 'sety', 'shape', 'shapesize', 'showturtle',
- 'speed', 'st', 'stamp', 'tilt', 'tiltangle', 'towards', #'tracer',
- 'turtlesize', 'undo', 'undobufferentries', 'up', 'width',
- #'window_height', 'window_width',
- 'write', 'xcor', 'ycor']
-_tg_utilities = ['write_docstringdict', 'done', 'mainloop']
-##_math_functions = ['acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh',
-## 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
-## 'log10', 'modf', 'pi', 'pow', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']
-
-__all__ = (_tg_classes + _tg_screen_functions + _tg_turtle_functions +
- _tg_utilities) # + _math_functions)
-
-_alias_list = ['addshape', 'backward', 'bk', 'fd', 'ht', 'lt', 'pd', 'pos',
- 'pu', 'rt', 'seth', 'setpos', 'setposition', 'st',
- 'turtlesize', 'up', 'width']
-
-_CFG = {"width" : 0.5, # Screen
- "height" : 0.75,
- "canvwidth" : 400,
- "canvheight": 300,
- "leftright": None,
- "topbottom": None,
- "mode": "standard", # TurtleScreen
- "colormode": 1.0,
- "delay": 10,
- "undobuffersize": 1000, # RawTurtle
- "shape": "classic",
- "pencolor" : "black",
- "fillcolor" : "black",
- "resizemode" : "noresize",
- "visible" : True,
- "language": "english", # docstrings
- "exampleturtle": "turtle",
- "examplescreen": "screen",
- "title": "Python Turtle Graphics",
- "using_IDLE": False
- }
-
-##print "cwd:", os.getcwd()
-##print "__file__:", __file__
-##
-##def show(dictionary):
-## print "=========================="
-## for key in sorted(dictionary.keys()):
-## print key, ":", dictionary[key]
-## print "=========================="
-## print
-
-def config_dict(filename):
- """Convert content of config-file into dictionary."""
- f = open(filename, "r")
- cfglines = f.readlines()
- f.close()
- cfgdict = {}
- for line in cfglines:
- line = line.strip()
- if not line or line.startswith("#"):
- continue
- try:
- key, value = line.split("=")
- except:
- print("Bad line in config-file %s:\n%s" % (filename,line))
- continue
- key = key.strip()
- value = value.strip()
- if value in ["True", "False", "None", "''", '""']:
- value = eval(value)
- else:
- try:
- if "." in value:
- value = float(value)
- else:
- value = int(value)
- except:
- pass # value need not be converted
- cfgdict[key] = value
- return cfgdict
-
-def readconfig(cfgdict):
- """Read config-files, change configuration-dict accordingly.
-
- If there is a turtle.cfg file in the current working directory,
- read it from there. If this contains an importconfig-value,
- say 'myway', construct filename turtle_mayway.cfg else use
- turtle.cfg and read it from the import-directory, where
- turtle.py is located.
- Update configuration dictionary first according to config-file,
- in the import directory, then according to config-file in the
- current working directory.
- If no config-file is found, the default configuration is used.
- """
- default_cfg = "turtle.cfg"
- cfgdict1 = {}
- cfgdict2 = {}
- if isfile(default_cfg):
- cfgdict1 = config_dict(default_cfg)
- #print "1. Loading config-file %s from: %s" % (default_cfg, os.getcwd())
- if "importconfig" in cfgdict1:
- default_cfg = "turtle_%s.cfg" % cfgdict1["importconfig"]
- try:
- head, tail = split(__file__)
- cfg_file2 = join(head, default_cfg)
- except:
- cfg_file2 = ""
- if isfile(cfg_file2):
- #print "2. Loading config-file %s:" % cfg_file2
- cfgdict2 = config_dict(cfg_file2)
-## show(_CFG)
-## show(cfgdict2)
- _CFG.update(cfgdict2)
-## show(_CFG)
-## show(cfgdict1)
- _CFG.update(cfgdict1)
-## show(_CFG)
-
-try:
- readconfig(_CFG)
-except:
- print ("No configfile read, reason unknown")
-
-
-class Vec2D(tuple):
- """A 2 dimensional vector class, used as a helper class
- for implementing turtle graphics.
- May be useful for turtle graphics programs also.
- Derived from tuple, so a vector is a tuple!
-
- Provides (for a, b vectors, k number):
- a+b vector addition
- a-b vector subtraction
- a*b inner product
- k*a and a*k multiplication with scalar
- |a| absolute value of a
- a.rotate(angle) rotation
- """
- def __new__(cls, x, y):
- return tuple.__new__(cls, (x, y))
- def __add__(self, other):
- return Vec2D(self[0]+other[0], self[1]+other[1])
- def __mul__(self, other):
- if isinstance(other, Vec2D):
- return self[0]*other[0]+self[1]*other[1]
- return Vec2D(self[0]*other, self[1]*other)
- def __rmul__(self, other):
- if isinstance(other, int) or isinstance(other, float):
- return Vec2D(self[0]*other, self[1]*other)
- def __sub__(self, other):
- return Vec2D(self[0]-other[0], self[1]-other[1])
- def __neg__(self):
- return Vec2D(-self[0], -self[1])
- def __abs__(self):
- return (self[0]**2 + self[1]**2)**0.5
- def rotate(self, angle):
- """rotate self counterclockwise by angle
- """
- perp = Vec2D(-self[1], self[0])
- angle = angle * math.pi / 180.0
- c, s = math.cos(angle), math.sin(angle)
- return Vec2D(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s)
- def __getnewargs__(self):
- return (self[0], self[1])
- def __repr__(self):
- return "(%.2f,%.2f)" % self
-
-
-##############################################################################
-### From here up to line : Tkinter - Interface for turtle.py ###
-### May be replaced by an interface to some different graphcis-toolkit ###
-##############################################################################
-
-## helper functions for Scrolled Canvas, to forward Canvas-methods
-## to ScrolledCanvas class
-
-def __methodDict(cls, _dict):
- """helper function for Scrolled Canvas"""
- baseList = list(cls.__bases__)
- baseList.reverse()
- for _super in baseList:
- __methodDict(_super, _dict)
- for key, value in cls.__dict__.items():
- if type(value) == types.FunctionType:
- _dict[key] = value
-
-def __methods(cls):
- """helper function for Scrolled Canvas"""
- _dict = {}
- __methodDict(cls, _dict)
- return _dict.keys()
-
-__stringBody = (
- 'def %(method)s(self, *args, **kw): return ' +
- 'self.%(attribute)s.%(method)s(*args, **kw)')
-
-def __forwardmethods(fromClass, toClass, toPart, exclude = ()):
- ### MANY CHANGES ###
- _dict_1 = {}
- __methodDict(toClass, _dict_1)
- _dict = {}
- mfc = __methods(fromClass)
- for ex in _dict_1.keys():
- if ex[:1] == '_' or ex[-1:] == '_' or ex in exclude or ex in mfc:
- pass
- else:
- _dict[ex] = _dict_1[ex]
-
- for method, func in _dict.items():
- d = {'method': method, 'func': func}
- if isinstance(toPart, str):
- execString = \
- __stringBody % {'method' : method, 'attribute' : toPart}
- exec(execString, d)
- setattr(fromClass, method, d[method]) ### NEWU!
-
-
-class ScrolledCanvas(TK.Frame):
- """Modeled after the scrolled canvas class from Grayons's Tkinter book.
-
- Used as the default canvas, which pops up automatically when
- using turtle graphics functions or the Turtle class.
- """
- def __init__(self, master, width=500, height=350,
- canvwidth=600, canvheight=500):
- TK.Frame.__init__(self, master, width=width, height=height)
- self._root = self.winfo_toplevel()
- self.width, self.height = width, height
- self.canvwidth, self.canvheight = canvwidth, canvheight
- self.bg = "white"
- self._canvas = TK.Canvas(master, width=width, height=height,
- bg=self.bg, relief=TK.SUNKEN, borderwidth=2)
- self.hscroll = TK.Scrollbar(master, command=self._canvas.xview,
- orient=TK.HORIZONTAL)
- self.vscroll = TK.Scrollbar(master, command=self._canvas.yview)
- self._canvas.configure(xscrollcommand=self.hscroll.set,
- yscrollcommand=self.vscroll.set)
- self.rowconfigure(0, weight=1, minsize=0)
- self.columnconfigure(0, weight=1, minsize=0)
- self._canvas.grid(padx=1, in_ = self, pady=1, row=0,
- column=0, rowspan=1, columnspan=1, sticky='news')
- self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,
- column=1, rowspan=1, columnspan=1, sticky='news')
- self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,
- column=0, rowspan=1, columnspan=1, sticky='news')
- self.reset()
- self._root.bind('<Configure>', self.onResize)
-
- def reset(self, canvwidth=None, canvheight=None, bg = None):
- """Ajust canvas and scrollbars according to given canvas size."""
- if canvwidth:
- self.canvwidth = canvwidth
- if canvheight:
- self.canvheight = canvheight
- if bg:
- self.bg = bg
- self._canvas.config(bg=bg,
- scrollregion=(-self.canvwidth//2, -self.canvheight//2,
- self.canvwidth//2, self.canvheight//2))
- self._canvas.xview_moveto(0.5*(self.canvwidth - self.width + 30) /
- self.canvwidth)
- self._canvas.yview_moveto(0.5*(self.canvheight- self.height + 30) /
- self.canvheight)
- self.adjustScrolls()
-
-
- def adjustScrolls(self):
- """ Adjust scrollbars according to window- and canvas-size.
- """
- cwidth = self._canvas.winfo_width()
- cheight = self._canvas.winfo_height()
- self._canvas.xview_moveto(0.5*(self.canvwidth-cwidth)/self.canvwidth)
- self._canvas.yview_moveto(0.5*(self.canvheight-cheight)/self.canvheight)
- if cwidth < self.canvwidth or cheight < self.canvheight:
- self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,
- column=0, rowspan=1, columnspan=1, sticky='news')
- self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,
- column=1, rowspan=1, columnspan=1, sticky='news')
- else:
- self.hscroll.grid_forget()
- self.vscroll.grid_forget()
-
- def onResize(self, event):
- """self-explanatory"""
- self.adjustScrolls()
-
- def bbox(self, *args):
- """ 'forward' method, which canvas itself has inherited...
- """
- return self._canvas.bbox(*args)
-
- def cget(self, *args, **kwargs):
- """ 'forward' method, which canvas itself has inherited...
- """
- return self._canvas.cget(*args, **kwargs)
-
- def config(self, *args, **kwargs):
- """ 'forward' method, which canvas itself has inherited...
- """
- self._canvas.config(*args, **kwargs)
-
- def bind(self, *args, **kwargs):
- """ 'forward' method, which canvas itself has inherited...
- """
- self._canvas.bind(*args, **kwargs)
-
- def unbind(self, *args, **kwargs):
- """ 'forward' method, which canvas itself has inherited...
- """
- self._canvas.unbind(*args, **kwargs)
-
- def focus_force(self):
- """ 'forward' method, which canvas itself has inherited...
- """
- self._canvas.focus_force()
-
-__forwardmethods(ScrolledCanvas, TK.Canvas, '_canvas')
-
-
-class _Root(TK.Tk):
- """Root class for Screen based on Tkinter."""
- def __init__(self):
- TK.Tk.__init__(self)
-
- def setupcanvas(self, width, height, cwidth, cheight):
- self._canvas = ScrolledCanvas(self, width, height, cwidth, cheight)
- self._canvas.pack(expand=1, fill="both")
-
- def _getcanvas(self):
- return self._canvas
-
- def set_geometry(self, width, height, startx, starty):
- self.geometry("%dx%d%+d%+d"%(width, height, startx, starty))
-
- def ondestroy(self, destroy):
- self.wm_protocol("WM_DELETE_WINDOW", destroy)
-
- def win_width(self):
- return self.winfo_screenwidth()
-
- def win_height(self):
- return self.winfo_screenheight()
-
-Canvas = TK.Canvas
-
-
-class TurtleScreenBase(object):
- """Provide the basic graphics functionality.
- Interface between Tkinter and turtle.py.
-
- To port turtle.py to some different graphics toolkit
- a corresponding TurtleScreenBase class has to be implemented.
- """
-
- @staticmethod
- def _blankimage():
- """return a blank image object
- """
- img = TK.PhotoImage(width=1, height=1)
- img.blank()
- return img
-
- @staticmethod
- def _image(filename):
- """return an image object containing the
- imagedata from a gif-file named filename.
- """
- return TK.PhotoImage(file=filename)
-
- def __init__(self, cv):
- self.cv = cv
- if isinstance(cv, ScrolledCanvas):
- w = self.cv.canvwidth
- h = self.cv.canvheight
- else: # expected: ordinary TK.Canvas
- w = int(self.cv.cget("width"))
- h = int(self.cv.cget("height"))
- self.cv.config(scrollregion = (-w//2, -h//2, w//2, h//2 ))
- self.canvwidth = w
- self.canvheight = h
- self.xscale = self.yscale = 1.0
-
- def _createpoly(self):
- """Create an invisible polygon item on canvas self.cv)
- """
- return self.cv.create_polygon((0, 0, 0, 0, 0, 0), fill="", outline="")
-
- def _drawpoly(self, polyitem, coordlist, fill=None,
- outline=None, width=None, top=False):
- """Configure polygonitem polyitem according to provided
- arguments:
- coordlist is sequence of coordinates
- fill is filling color
- outline is outline color
- top is a boolean value, which specifies if polyitem
- will be put on top of the canvas' displaylist so it
- will not be covered by other items.
- """
- cl = []
- for x, y in coordlist:
- cl.append(x * self.xscale)
- cl.append(-y * self.yscale)
- self.cv.coords(polyitem, *cl)
- if fill is not None:
- self.cv.itemconfigure(polyitem, fill=fill)
- if outline is not None:
- self.cv.itemconfigure(polyitem, outline=outline)
- if width is not None:
- self.cv.itemconfigure(polyitem, width=width)
- if top:
- self.cv.tag_raise(polyitem)
-
- def _createline(self):
- """Create an invisible line item on canvas self.cv)
- """
- return self.cv.create_line(0, 0, 0, 0, fill="", width=2,
- capstyle = TK.ROUND)
-
- def _drawline(self, lineitem, coordlist=None,
- fill=None, width=None, top=False):
- """Configure lineitem according to provided arguments:
- coordlist is sequence of coordinates
- fill is drawing color
- width is width of drawn line.
- top is a boolean value, which specifies if polyitem
- will be put on top of the canvas' displaylist so it
- will not be covered by other items.
- """
- if coordlist is not None:
- cl = []
- for x, y in coordlist:
- cl.append(x * self.xscale)
- cl.append(-y * self.yscale)
- self.cv.coords(lineitem, *cl)
- if fill is not None:
- self.cv.itemconfigure(lineitem, fill=fill)
- if width is not None:
- self.cv.itemconfigure(lineitem, width=width)
- if top:
- self.cv.tag_raise(lineitem)
-
- def _delete(self, item):
- """Delete graphics item from canvas.
- If item is"all" delete all graphics items.
- """
- self.cv.delete(item)
-
- def _update(self):
- """Redraw graphics items on canvas
- """
- self.cv.update()
-
- def _delay(self, delay):
- """Delay subsequent canvas actions for delay ms."""
- self.cv.after(delay)
-
- def _iscolorstring(self, color):
- """Check if the string color is a legal Tkinter color string.
- """
- try:
- rgb = self.cv.winfo_rgb(color)
- ok = True
- except TK.TclError:
- ok = False
- return ok
-
- def _bgcolor(self, color=None):
- """Set canvas' backgroundcolor if color is not None,
- else return backgroundcolor."""
- if color is not None:
- self.cv.config(bg = color)
- self._update()
- else:
- return self.cv.cget("bg")
-
- def _write(self, pos, txt, align, font, pencolor):
- """Write txt at pos in canvas with specified font
- and color.
- Return text item and x-coord of right bottom corner
- of text's bounding box."""
- x, y = pos
- x = x * self.xscale
- y = y * self.yscale
- anchor = {"left":"sw", "center":"s", "right":"se" }
- item = self.cv.create_text(x-1, -y, text = txt, anchor = anchor[align],
- fill = pencolor, font = font)
- x0, y0, x1, y1 = self.cv.bbox(item)
- self.cv.update()
- return item, x1-1
-
-## def _dot(self, pos, size, color):
-## """may be implemented for some other graphics toolkit"""
-
- def _onclick(self, item, fun, num=1, add=None):
- """Bind fun to mouse-click event on turtle.
- fun must be a function with two arguments, the coordinates
- of the clicked point on the canvas.
- num, the number of the mouse-button defaults to 1
- """
- if fun is None:
- self.cv.tag_unbind(item, "<Button-%s>" % num)
- else:
- def eventfun(event):
- x, y = (self.cv.canvasx(event.x)/self.xscale,
- -self.cv.canvasy(event.y)/self.yscale)
- fun(x, y)
- self.cv.tag_bind(item, "<Button-%s>" % num, eventfun, add)
-
- def _onrelease(self, item, fun, num=1, add=None):
- """Bind fun to mouse-button-release event on turtle.
- fun must be a function with two arguments, the coordinates
- of the point on the canvas where mouse button is released.
- num, the number of the mouse-button defaults to 1
-
- If a turtle is clicked, first _onclick-event will be performed,
- then _onscreensclick-event.
- """
- if fun is None:
- self.cv.tag_unbind(item, "<Button%s-ButtonRelease>" % num)
- else:
- def eventfun(event):
- x, y = (self.cv.canvasx(event.x)/self.xscale,
- -self.cv.canvasy(event.y)/self.yscale)
- fun(x, y)
- self.cv.tag_bind(item, "<Button%s-ButtonRelease>" % num,
- eventfun, add)
-
- def _ondrag(self, item, fun, num=1, add=None):
- """Bind fun to mouse-move-event (with pressed mouse button) on turtle.
- fun must be a function with two arguments, the coordinates of the
- actual mouse position on the canvas.
- num, the number of the mouse-button defaults to 1
-
- Every sequence of mouse-move-events on a turtle is preceded by a
- mouse-click event on that turtle.
- """
- if fun is None:
- self.cv.tag_unbind(item, "<Button%s-Motion>" % num)
- else:
- def eventfun(event):
- try:
- x, y = (self.cv.canvasx(event.x)/self.xscale,
- -self.cv.canvasy(event.y)/self.yscale)
- fun(x, y)
- except:
- pass
- self.cv.tag_bind(item, "<Button%s-Motion>" % num, eventfun, add)
-
- def _onscreenclick(self, fun, num=1, add=None):
- """Bind fun to mouse-click event on canvas.
- fun must be a function with two arguments, the coordinates
- of the clicked point on the canvas.
- num, the number of the mouse-button defaults to 1
-
- If a turtle is clicked, first _onclick-event will be performed,
- then _onscreensclick-event.
- """
- if fun is None:
- self.cv.unbind("<Button-%s>" % num)
- else:
- def eventfun(event):
- x, y = (self.cv.canvasx(event.x)/self.xscale,
- -self.cv.canvasy(event.y)/self.yscale)
- fun(x, y)
- self.cv.bind("<Button-%s>" % num, eventfun, add)
-
- def _onkey(self, fun, key):
- """Bind fun to key-release event of key.
- Canvas must have focus. See method listen
- """
- if fun is None:
- self.cv.unbind("<KeyRelease-%s>" % key, None)
- else:
- def eventfun(event):
- fun()
- self.cv.bind("<KeyRelease-%s>" % key, eventfun)
-
- def _listen(self):
- """Set focus on canvas (in order to collect key-events)
- """
- self.cv.focus_force()
-
- def _ontimer(self, fun, t):
- """Install a timer, which calls fun after t milliseconds.
- """
- if t == 0:
- self.cv.after_idle(fun)
- else:
- self.cv.after(t, fun)
-
- def _createimage(self, image):
- """Create and return image item on canvas.
- """
- return self.cv.create_image(0, 0, image=image)
-
- def _drawimage(self, item, pos, image):
- """Configure image item as to draw image object
- at position (x,y) on canvas)
- """
- x, y = pos
- self.cv.coords(item, (x * self.xscale, -y * self.yscale))
- self.cv.itemconfig(item, image=image)
-
- def _setbgpic(self, item, image):
- """Configure image item as to draw image object
- at center of canvas. Set item to the first item
- in the displaylist, so it will be drawn below
- any other item ."""
- self.cv.itemconfig(item, image=image)
- self.cv.tag_lower(item)
-
- def _type(self, item):
- """Return 'line' or 'polygon' or 'image' depending on
- type of item.
- """
- return self.cv.type(item)
-
- def _pointlist(self, item):
- """returns list of coordinate-pairs of points of item
- Example (for insiders):
- >>> from turtle import *
- >>> getscreen()._pointlist(getturtle().turtle._item)
- [(0.0, 9.9999999999999982), (0.0, -9.9999999999999982),
- (9.9999999999999982, 0.0)]
- >>> """
- cl = list(self.cv.coords(item))
- pl = [(cl[i], -cl[i+1]) for i in range(0, len(cl), 2)]
- return pl
-
- def _setscrollregion(self, srx1, sry1, srx2, sry2):
- self.cv.config(scrollregion=(srx1, sry1, srx2, sry2))
-
- def _rescale(self, xscalefactor, yscalefactor):
- items = self.cv.find_all()
- for item in items:
- coordinates = list(self.cv.coords(item))
- newcoordlist = []
- while coordinates:
- x, y = coordinates[:2]
- newcoordlist.append(x * xscalefactor)
- newcoordlist.append(y * yscalefactor)
- coordinates = coordinates[2:]
- self.cv.coords(item, *newcoordlist)
-
- def _resize(self, canvwidth=None, canvheight=None, bg=None):
- """Resize the canvas, the turtles are drawing on. Does
- not alter the drawing window.
- """
- # needs amendment
- if not isinstance(self.cv, ScrolledCanvas):
- return self.canvwidth, self.canvheight
- if canvwidth is None and canvheight is None and bg is None:
- return self.cv.canvwidth, self.cv.canvheight
- if canvwidth is not None:
- self.canvwidth = canvwidth
- if canvheight is not None:
- self.canvheight = canvheight
- self.cv.reset(canvwidth, canvheight, bg)
-
- def _window_size(self):
- """ Return the width and height of the turtle window.
- """
- width = self.cv.winfo_width()
- if width <= 1: # the window isn't managed by a geometry manager
- width = self.cv['width']
- height = self.cv.winfo_height()
- if height <= 1: # the window isn't managed by a geometry manager
- height = self.cv['height']
- return width, height
-
-
-##############################################################################
-### End of Tkinter - interface ###
-##############################################################################
-
-
-class Terminator (Exception):
- """Will be raised in TurtleScreen.update, if _RUNNING becomes False.
-
- Thus stops execution of turtle graphics script. Main purpose: use in
- in the Demo-Viewer turtle.Demo.py.
- """
- pass
-
-
-class TurtleGraphicsError(Exception):
- """Some TurtleGraphics Error
- """
-
-
-class Shape(object):
- """Data structure modeling shapes.
-
- attribute _type is one of "polygon", "image", "compound"
- attribute _data is - depending on _type a poygon-tuple,
- an image or a list constructed using the addcomponent method.
- """
- def __init__(self, type_, data=None):
- self._type = type_
- if type_ == "polygon":
- if isinstance(data, list):
- data = tuple(data)
- elif type_ == "image":
- if isinstance(data, str):
- if data.lower().endswith(".gif") and isfile(data):
- data = TurtleScreen._image(data)
- # else data assumed to be Photoimage
- elif type_ == "compound":
- data = []
- else:
- raise TurtleGraphicsError("There is no shape type %s" % type_)
- self._data = data
-
- def addcomponent(self, poly, fill, outline=None):
- """Add component to a shape of type compound.
-
- Arguments: poly is a polygon, i. e. a tuple of number pairs.
- fill is the fillcolor of the component,
- outline is the outline color of the component.
-
- call (for a Shapeobject namend s):
- -- s.addcomponent(((0,0), (10,10), (-10,10)), "red", "blue")
-
- Example:
- >>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
- >>> s = Shape("compound")
- >>> s.addcomponent(poly, "red", "blue")
- ### .. add more components and then use register_shape()
- """
- if self._type != "compound":
- raise TurtleGraphicsError("Cannot add component to %s Shape"
- % self._type)
- if outline is None:
- outline = fill
- self._data.append([poly, fill, outline])
-
-
-class Tbuffer(object):
- """Ring buffer used as undobuffer for RawTurtle objects."""
- def __init__(self, bufsize=10):
- self.bufsize = bufsize
- self.buffer = [[None]] * bufsize
- self.ptr = -1
- self.cumulate = False
- def reset(self, bufsize=None):
- if bufsize is None:
- for i in range(self.bufsize):
- self.buffer[i] = [None]
- else:
- self.bufsize = bufsize
- self.buffer = [[None]] * bufsize
- self.ptr = -1
- def push(self, item):
- if self.bufsize > 0:
- if not self.cumulate:
- self.ptr = (self.ptr + 1) % self.bufsize
- self.buffer[self.ptr] = item
- else:
- self.buffer[self.ptr].append(item)
- def pop(self):
- if self.bufsize > 0:
- item = self.buffer[self.ptr]
- if item is None:
- return None
- else:
- self.buffer[self.ptr] = [None]
- self.ptr = (self.ptr - 1) % self.bufsize
- return (item)
- def nr_of_items(self):
- return self.bufsize - self.buffer.count([None])
- def __repr__(self):
- return str(self.buffer) + " " + str(self.ptr)
-
-
-
-class TurtleScreen(TurtleScreenBase):
- """Provides screen oriented methods like setbg etc.
-
- Only relies upon the methods of TurtleScreenBase and NOT
- upon components of the underlying graphics toolkit -
- which is Tkinter in this case.
- """
-# _STANDARD_DELAY = 5
- _RUNNING = True
-
- def __init__(self, cv, mode=_CFG["mode"],
- colormode=_CFG["colormode"], delay=_CFG["delay"]):
- self._shapes = {
- "arrow" : Shape("polygon", ((-10,0), (10,0), (0,10))),
- "turtle" : Shape("polygon", ((0,16), (-2,14), (-1,10), (-4,7),
- (-7,9), (-9,8), (-6,5), (-7,1), (-5,-3), (-8,-6),
- (-6,-8), (-4,-5), (0,-7), (4,-5), (6,-8), (8,-6),
- (5,-3), (7,1), (6,5), (9,8), (7,9), (4,7), (1,10),
- (2,14))),
- "circle" : Shape("polygon", ((10,0), (9.51,3.09), (8.09,5.88),
- (5.88,8.09), (3.09,9.51), (0,10), (-3.09,9.51),
- (-5.88,8.09), (-8.09,5.88), (-9.51,3.09), (-10,0),
- (-9.51,-3.09), (-8.09,-5.88), (-5.88,-8.09),
- (-3.09,-9.51), (-0.00,-10.00), (3.09,-9.51),
- (5.88,-8.09), (8.09,-5.88), (9.51,-3.09))),
- "square" : Shape("polygon", ((10,-10), (10,10), (-10,10),
- (-10,-10))),
- "triangle" : Shape("polygon", ((10,-5.77), (0,11.55),
- (-10,-5.77))),
- "classic": Shape("polygon", ((0,0),(-5,-9),(0,-7),(5,-9))),
- "blank" : Shape("image", self._blankimage())
- }
-
- self._bgpics = {"nopic" : ""}
-
- TurtleScreenBase.__init__(self, cv)
- self._mode = mode
- self._delayvalue = delay
- self._colormode = _CFG["colormode"]
- self._keys = []
- self.clear()
-
- def clear(self):
- """Delete all drawings and all turtles from the TurtleScreen.
-
- Reset empty TurtleScreen to it's initial state: white background,
- no backgroundimage, no eventbindings and tracing on.
-
- No argument.
-
- Example (for a TurtleScreen instance named screen):
- screen.clear()
-
- Note: this method is not available as function.
- """
- self._delayvalue = _CFG["delay"]
- self._colormode = _CFG["colormode"]
- self._delete("all")
- self._bgpic = self._createimage("")
- self._bgpicname = "nopic"
- self._tracing = 1
- self._updatecounter = 0
- self._turtles = []
- self.bgcolor("white")
- for btn in 1, 2, 3:
- self.onclick(None, btn)
- for key in self._keys[:]:
- self.onkey(None, key)
- Turtle._pen = None
-
- def mode(self, mode=None):
- """Set turtle-mode ('standard', 'logo' or 'world') and perform reset.
-
- Optional argument:
- mode -- on of the strings 'standard', 'logo' or 'world'
-
- Mode 'standard' is compatible with turtle.py.
- Mode 'logo' is compatible with most Logo-Turtle-Graphics.
- Mode 'world' uses userdefined 'worldcoordinates'. *Attention*: in
- this mode angles appear distorted if x/y unit-ratio doesn't equal 1.
- If mode is not given, return the current mode.
-
- Mode Initial turtle heading positive angles
- ------------|-------------------------|-------------------
- 'standard' to the right (east) counterclockwise
- 'logo' upward (north) clockwise
-
- Examples:
- >>> mode('logo') # resets turtle heading to north
- >>> mode()
- 'logo'
- """
- if mode == None:
- return self._mode
- mode = mode.lower()
- if mode not in ["standard", "logo", "world"]:
- raise TurtleGraphicsError("No turtle-graphics-mode %s" % mode)
- self._mode = mode
- if mode in ["standard", "logo"]:
- self._setscrollregion(-self.canvwidth//2, -self.canvheight//2,
- self.canvwidth//2, self.canvheight//2)
- self.xscale = self.yscale = 1.0
- self.reset()
-
- def setworldcoordinates(self, llx, lly, urx, ury):
- """Set up a user defined coordinate-system.
-
- Arguments:
- llx -- a number, x-coordinate of lower left corner of canvas
- lly -- a number, y-coordinate of lower left corner of canvas
- urx -- a number, x-coordinate of upper right corner of canvas
- ury -- a number, y-coordinate of upper right corner of canvas
-
- Set up user coodinat-system and switch to mode 'world' if necessary.
- This performs a screen.reset. If mode 'world' is already active,
- all drawings are redrawn according to the new coordinates.
-
- But ATTENTION: in user-defined coordinatesystems angles may appear
- distorted. (see Screen.mode())
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.setworldcoordinates(-10,-0.5,50,1.5)
- >>> for _ in range(36):
- left(10)
- forward(0.5)
- """
- if self.mode() != "world":
- self.mode("world")
- xspan = float(urx - llx)
- yspan = float(ury - lly)
- wx, wy = self._window_size()
- self.screensize(wx-20, wy-20)
- oldxscale, oldyscale = self.xscale, self.yscale
- self.xscale = self.canvwidth / xspan
- self.yscale = self.canvheight / yspan
- srx1 = llx * self.xscale
- sry1 = -ury * self.yscale
- srx2 = self.canvwidth + srx1
- sry2 = self.canvheight + sry1
- self._setscrollregion(srx1, sry1, srx2, sry2)
- self._rescale(self.xscale/oldxscale, self.yscale/oldyscale)
- self.update()
-
- def register_shape(self, name, shape=None):
- """Adds a turtle shape to TurtleScreen's shapelist.
-
- Arguments:
- (1) name is the name of a gif-file and shape is None.
- Installs the corresponding image shape.
- !! Image-shapes DO NOT rotate when turning the turtle,
- !! so they do not display the heading of the turtle!
- (2) name is an arbitrary string and shape is a tuple
- of pairs of coordinates. Installs the corresponding
- polygon shape
- (3) name is an arbitrary string and shape is a
- (compound) Shape object. Installs the corresponding
- compound shape.
- To use a shape, you have to issue the command shape(shapename).
-
- call: register_shape("turtle.gif")
- --or: register_shape("tri", ((0,0), (10,10), (-10,10)))
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.register_shape("triangle", ((5,-3),(0,5),(-5,-3)))
-
- """
- if shape is None:
- # image
- if name.lower().endswith(".gif"):
- shape = Shape("image", self._image(name))
- else:
- raise TurtleGraphicsError("Bad arguments for register_shape.\n"
- + "Use help(register_shape)" )
- elif isinstance(shape, tuple):
- shape = Shape("polygon", shape)
- ## else shape assumed to be Shape-instance
- self._shapes[name] = shape
- # print "shape added:" , self._shapes
-
- def _colorstr(self, color):
- """Return color string corresponding to args.
-
- Argument may be a string or a tuple of three
- numbers corresponding to actual colormode,
- i.e. in the range 0<=n<=colormode.
-
- If the argument doesn't represent a color,
- an error is raised.
- """
- if len(color) == 1:
- color = color[0]
- if isinstance(color, str):
- if self._iscolorstring(color) or color == "":
- return color
- else:
- raise TurtleGraphicsError("bad color string: %s" % str(color))
- try:
- r, g, b = color
- except:
- raise TurtleGraphicsError("bad color arguments: %s" % str(color))
- if self._colormode == 1.0:
- r, g, b = [round(255.0*x) for x in (r, g, b)]
- if not ((0 <= r <= 255) and (0 <= g <= 255) and (0 <= b <= 255)):
- raise TurtleGraphicsError("bad color sequence: %s" % str(color))
- return "#%02x%02x%02x" % (r, g, b)
-
- def _color(self, cstr):
- if not cstr.startswith("#"):
- return cstr
- if len(cstr) == 7:
- cl = [int(cstr[i:i+2], 16) for i in (1, 3, 5)]
- elif len(cstr) == 4:
- cl = [16*int(cstr[h], 16) for h in cstr[1:]]
- else:
- raise TurtleGraphicsError("bad colorstring: %s" % cstr)
- return tuple([c * self._colormode/255 for c in cl])
-
- def colormode(self, cmode=None):
- """Return the colormode or set it to 1.0 or 255.
-
- Optional argument:
- cmode -- one of the values 1.0 or 255
-
- r, g, b values of colortriples have to be in range 0..cmode.
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.colormode()
- 1.0
- >>> screen.colormode(255)
- >>> turtle.pencolor(240,160,80)
- """
- if cmode is None:
- return self._colormode
- if cmode == 1.0:
- self._colormode = float(cmode)
- elif cmode == 255:
- self._colormode = int(cmode)
-
- def reset(self):
- """Reset all Turtles on the Screen to their initial state.
-
- No argument.
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.reset()
- """
- for turtle in self._turtles:
- turtle._setmode(self._mode)
- turtle.reset()
-
- def turtles(self):
- """Return the list of turtles on the screen.
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.turtles()
- [<turtle.Turtle object at 0x00E11FB0>]
- """
- return self._turtles
-
- def bgcolor(self, *args):
- """Set or return backgroundcolor of the TurtleScreen.
-
- Arguments (if given): a color string or three numbers
- in the range 0..colormode or a 3-tuple of such numbers.
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.bgcolor("orange")
- >>> screen.bgcolor()
- 'orange'
- >>> screen.bgcolor(0.5,0,0.5)
- >>> screen.bgcolor()
- '#800080'
- """
- if args:
- color = self._colorstr(args)
- else:
- color = None
- color = self._bgcolor(color)
- if color is not None:
- color = self._color(color)
- return color
-
- def tracer(self, n=None, delay=None):
- """Turns turtle animation on/off and set delay for update drawings.
-
- Optional arguments:
- n -- nonnegative integer
- delay -- nonnegative integer
-
- If n is given, only each n-th regular screen update is really performed.
- (Can be used to accelerate the drawing of complex graphics.)
- Second arguments sets delay value (see RawTurtle.delay())
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.tracer(8, 25)
- >>> dist = 2
- >>> for i in range(200):
- fd(dist)
- rt(90)
- dist += 2
- """
- if n is None:
- return self._tracing
- self._tracing = int(n)
- self._updatecounter = 0
- if delay is not None:
- self._delayvalue = int(delay)
- if self._tracing:
- self.update()
-
- def delay(self, delay=None):
- """ Return or set the drawing delay in milliseconds.
-
- Optional argument:
- delay -- positive integer
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.delay(15)
- >>> screen.delay()
- 15
- """
- if delay is None:
- return self._delayvalue
- self._delayvalue = int(delay)
-
- def _incrementudc(self):
- "Increment upadate counter."""
- if not TurtleScreen._RUNNING:
- TurtleScreen._RUNNNING = True
- raise Terminator
- if self._tracing > 0:
- self._updatecounter += 1
- self._updatecounter %= self._tracing
-
- def update(self):
- """Perform a TurtleScreen update.
- """
- for t in self.turtles():
- t._update_data()
- t._drawturtle()
- self._update()
-
- def window_width(self):
- """ Return the width of the turtle window.
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.window_width()
- 640
- """
- return self._window_size()[0]
-
- def window_height(self):
- """ Return the height of the turtle window.
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.window_height()
- 480
- """
- return self._window_size()[1]
-
- def getcanvas(self):
- """Return the Canvas of this TurtleScreen.
-
- No argument.
-
- Example (for a Screen instance named screen):
- >>> cv = screen.getcanvas()
- >>> cv
- <turtle.ScrolledCanvas instance at 0x010742D8>
- """
- return self.cv
-
- def getshapes(self):
- """Return a list of names of all currently available turtle shapes.
-
- No argument.
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.getshapes()
- ['arrow', 'blank', 'circle', ... , 'turtle']
- """
- return sorted(self._shapes.keys())
-
- def onclick(self, fun, btn=1, add=None):
- """Bind fun to mouse-click event on canvas.
-
- Arguments:
- fun -- a function with two arguments, the coordinates of the
- clicked point on the canvas.
- num -- the number of the mouse-button, defaults to 1
-
- Example (for a TurtleScreen instance named screen
- and a Turtle instance named turtle):
-
- >>> screen.onclick(turtle.goto)
-
- ### Subsequently clicking into the TurtleScreen will
- ### make the turtle move to the clicked point.
- >>> screen.onclick(None)
-
- ### event-binding will be removed
- """
- self._onscreenclick(fun, btn, add)
-
- def onkey(self, fun, key):
- """Bind fun to key-release event of key.
-
- Arguments:
- fun -- a function with no arguments
- key -- a string: key (e.g. "a") or key-symbol (e.g. "space")
-
- In order ro be able to register key-events, TurtleScreen
- must have focus. (See method listen.)
-
- Example (for a TurtleScreen instance named screen
- and a Turtle instance named turtle):
-
- >>> def f():
- fd(50)
- lt(60)
-
-
- >>> screen.onkey(f, "Up")
- >>> screen.listen()
-
- ### Subsequently the turtle can be moved by
- ### repeatedly pressing the up-arrow key,
- ### consequently drawing a hexagon
- """
- if fun == None:
- self._keys.remove(key)
- elif key not in self._keys:
- self._keys.append(key)
- self._onkey(fun, key)
-
- def listen(self, xdummy=None, ydummy=None):
- """Set focus on TurtleScreen (in order to collect key-events)
-
- No arguments.
- Dummy arguments are provided in order
- to be able to pass listen to the onclick method.
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.listen()
- """
- self._listen()
-
- def ontimer(self, fun, t=0):
- """Install a timer, which calls fun after t milliseconds.
-
- Arguments:
- fun -- a function with no arguments.
- t -- a number >= 0
-
- Example (for a TurtleScreen instance named screen):
-
- >>> running = True
- >>> def f():
- if running:
- fd(50)
- lt(60)
- screen.ontimer(f, 250)
-
- >>> f() ### makes the turtle marching around
- >>> running = False
- """
- self._ontimer(fun, t)
-
- def bgpic(self, picname=None):
- """Set background image or return name of current backgroundimage.
-
- Optional argument:
- picname -- a string, name of a gif-file or "nopic".
-
- If picname is a filename, set the corresponing image as background.
- If picname is "nopic", delete backgroundimage, if present.
- If picname is None, return the filename of the current backgroundimage.
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.bgpic()
- 'nopic'
- >>> screen.bgpic("landscape.gif")
- >>> screen.bgpic()
- 'landscape.gif'
- """
- if picname is None:
- return self._bgpicname
- if picname not in self._bgpics:
- self._bgpics[picname] = self._image(picname)
- self._setbgpic(self._bgpic, self._bgpics[picname])
- self._bgpicname = picname
-
- def screensize(self, canvwidth=None, canvheight=None, bg=None):
- """Resize the canvas, the turtles are drawing on.
-
- Optional arguments:
- canvwidth -- positive integer, new width of canvas in pixels
- canvheight -- positive integer, new height of canvas in pixels
- bg -- colorstring or color-tupel, new backgroundcolor
- If no arguments are given, return current (canvaswidth, canvasheight)
-
- Do not alter the drawing window. To observe hidden parts of
- the canvas use the scrollbars. (Can make visible those parts
- of a drawing, which were outside the canvas before!)
-
- Example (for a Turtle instance named turtle):
- >>> turtle.screensize(2000,1500)
- ### e. g. to search for an erroneously escaped turtle ;-)
- """
- return self._resize(canvwidth, canvheight, bg)
-
- onscreenclick = onclick
- resetscreen = reset
- clearscreen = clear
- addshape = register_shape
-
-class TNavigator(object):
- """Navigation part of the RawTurtle.
- Implements methods for turtle movement.
- """
- START_ORIENTATION = {
- "standard": Vec2D(1.0, 0.0),
- "world" : Vec2D(1.0, 0.0),
- "logo" : Vec2D(0.0, 1.0) }
- DEFAULT_MODE = "standard"
- DEFAULT_ANGLEOFFSET = 0
- DEFAULT_ANGLEORIENT = 1
-
- def __init__(self, mode=DEFAULT_MODE):
- self._angleOffset = self.DEFAULT_ANGLEOFFSET
- self._angleOrient = self.DEFAULT_ANGLEORIENT
- self._mode = mode
- self.undobuffer = None
- self.degrees()
- self._mode = None
- self._setmode(mode)
- TNavigator.reset(self)
-
- def reset(self):
- """reset turtle to its initial values
-
- Will be overwritten by parent class
- """
- self._position = Vec2D(0.0, 0.0)
- self._orient = TNavigator.START_ORIENTATION[self._mode]
-
- def _setmode(self, mode=None):
- """Set turtle-mode to 'standard', 'world' or 'logo'.
- """
- if mode == None:
- return self._mode
- if mode not in ["standard", "logo", "world"]:
- return
- self._mode = mode
- if mode in ["standard", "world"]:
- self._angleOffset = 0
- self._angleOrient = 1
- else: # mode == "logo":
- self._angleOffset = self._fullcircle/4.
- self._angleOrient = -1
-
- def _setDegreesPerAU(self, fullcircle):
- """Helper function for degrees() and radians()"""
- self._fullcircle = fullcircle
- self._degreesPerAU = 360/fullcircle
- if self._mode == "standard":
- self._angleOffset = 0
- else:
- self._angleOffset = fullcircle/4.
-
- def degrees(self, fullcircle=360.0):
- """ Set angle measurement units to degrees.
-
- Optional argument:
- fullcircle - a number
-
- Set angle measurement units, i. e. set number
- of 'degrees' for a full circle. Dafault value is
- 360 degrees.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.left(90)
- >>> turtle.heading()
- 90
- >>> turtle.degrees(400.0) # angle measurement in gon
- >>> turtle.heading()
- 100
-
- """
- self._setDegreesPerAU(fullcircle)
-
- def radians(self):
- """ Set the angle measurement units to radians.
-
- No arguments.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.heading()
- 90
- >>> turtle.radians()
- >>> turtle.heading()
- 1.5707963267948966
- """
- self._setDegreesPerAU(2*math.pi)
-
- def _go(self, distance):
- """move turtle forward by specified distance"""
- ende = self._position + self._orient * distance
- self._goto(ende)
-
- def _rotate(self, angle):
- """Turn turtle counterclockwise by specified angle if angle > 0."""
- angle *= self._degreesPerAU
- self._orient = self._orient.rotate(angle)
-
- def _goto(self, end):
- """move turtle to position end."""
- self._position = end
-
- def forward(self, distance):
- """Move the turtle forward by the specified distance.
-
- Aliases: forward | fd
-
- Argument:
- distance -- a number (integer or float)
-
- Move the turtle forward by the specified distance, in the direction
- the turtle is headed.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.position()
- (0.00, 0.00)
- >>> turtle.forward(25)
- >>> turtle.position()
- (25.00,0.00)
- >>> turtle.forward(-75)
- >>> turtle.position()
- (-50.00,0.00)
- """
- self._go(distance)
-
- def back(self, distance):
- """Move the turtle backward by distance.
-
- Aliases: back | backward | bk
-
- Argument:
- distance -- a number
-
- Move the turtle backward by distance ,opposite to the direction the
- turtle is headed. Do not change the turtle's heading.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.position()
- (0.00, 0.00)
- >>> turtle.backward(30)
- >>> turtle.position()
- (-30.00, 0.00)
- """
- self._go(-distance)
-
- def right(self, angle):
- """Turn turtle right by angle units.
-
- Aliases: right | rt
-
- Argument:
- angle -- a number (integer or float)
-
- Turn turtle right by angle units. (Units are by default degrees,
- but can be set via the degrees() and radians() functions.)
- Angle orientation depends on mode. (See this.)
-
- Example (for a Turtle instance named turtle):
- >>> turtle.heading()
- 22.0
- >>> turtle.right(45)
- >>> turtle.heading()
- 337.0
- """
- self._rotate(-angle)
-
- def left(self, angle):
- """Turn turtle left by angle units.
-
- Aliases: left | lt
-
- Argument:
- angle -- a number (integer or float)
-
- Turn turtle left by angle units. (Units are by default degrees,
- but can be set via the degrees() and radians() functions.)
- Angle orientation depends on mode. (See this.)
-
- Example (for a Turtle instance named turtle):
- >>> turtle.heading()
- 22.0
- >>> turtle.left(45)
- >>> turtle.heading()
- 67.0
- """
- self._rotate(angle)
-
- def pos(self):
- """Return the turtle's current location (x,y), as a Vec2D-vector.
-
- Aliases: pos | position
-
- No arguments.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.pos()
- (0.00, 240.00)
- """
- return self._position
-
- def xcor(self):
- """ Return the turtle's x coordinate.
-
- No arguments.
-
- Example (for a Turtle instance named turtle):
- >>> reset()
- >>> turtle.left(60)
- >>> turtle.forward(100)
- >>> print turtle.xcor()
- 50.0
- """
- return self._position[0]
-
- def ycor(self):
- """ Return the turtle's y coordinate
- ---
- No arguments.
-
- Example (for a Turtle instance named turtle):
- >>> reset()
- >>> turtle.left(60)
- >>> turtle.forward(100)
- >>> print turtle.ycor()
- 86.6025403784
- """
- return self._position[1]
-
-
- def goto(self, x, y=None):
- """Move turtle to an absolute position.
-
- Aliases: setpos | setposition | goto:
-
- Arguments:
- x -- a number or a pair/vector of numbers
- y -- a number None
-
- call: goto(x, y) # two coordinates
- --or: goto((x, y)) # a pair (tuple) of coordinates
- --or: goto(vec) # e.g. as returned by pos()
-
- Move turtle to an absolute position. If the pen is down,
- a line will be drawn. The turtle's orientation does not change.
-
- Example (for a Turtle instance named turtle):
- >>> tp = turtle.pos()
- >>> tp
- (0.00, 0.00)
- >>> turtle.setpos(60,30)
- >>> turtle.pos()
- (60.00,30.00)
- >>> turtle.setpos((20,80))
- >>> turtle.pos()
- (20.00,80.00)
- >>> turtle.setpos(tp)
- >>> turtle.pos()
- (0.00,0.00)
- """
- if y is None:
- self._goto(Vec2D(*x))
- else:
- self._goto(Vec2D(x, y))
-
- def home(self):
- """Move turtle to the origin - coordinates (0,0).
-
- No arguments.
-
- Move turtle to the origin - coordinates (0,0) and set it's
- heading to it's start-orientation (which depends on mode).
-
- Example (for a Turtle instance named turtle):
- >>> turtle.home()
- """
- self.goto(0, 0)
- self.setheading(0)
-
- def setx(self, x):
- """Set the turtle's first coordinate to x
-
- Argument:
- x -- a number (integer or float)
-
- Set the turtle's first coordinate to x, leave second coordinate
- unchanged.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.position()
- (0.00, 240.00)
- >>> turtle.setx(10)
- >>> turtle.position()
- (10.00, 240.00)
- """
- self._goto(Vec2D(x, self._position[1]))
-
- def sety(self, y):
- """Set the turtle's second coordinate to y
-
- Argument:
- y -- a number (integer or float)
-
- Set the turtle's first coordinate to x, second coordinate remains
- unchanged.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.position()
- (0.00, 40.00)
- >>> turtle.sety(-10)
- >>> turtle.position()
- (0.00, -10.00)
- """
- self._goto(Vec2D(self._position[0], y))
-
- def distance(self, x, y=None):
- """Return the distance from the turtle to (x,y) in turtle step units.
-
- Arguments:
- x -- a number or a pair/vector of numbers or a turtle instance
- y -- a number None None
-
- call: distance(x, y) # two coordinates
- --or: distance((x, y)) # a pair (tuple) of coordinates
- --or: distance(vec) # e.g. as returned by pos()
- --or: distance(mypen) # where mypen is another turtle
-
- Example (for a Turtle instance named turtle):
- >>> turtle.pos()
- (0.00, 0.00)
- >>> turtle.distance(30,40)
- 50.0
- >>> pen = Turtle()
- >>> pen.forward(77)
- >>> turtle.distance(pen)
- 77.0
- """
- if y is not None:
- pos = Vec2D(x, y)
- if isinstance(x, Vec2D):
- pos = x
- elif isinstance(x, tuple):
- pos = Vec2D(*x)
- elif isinstance(x, TNavigator):
- pos = x._position
- return abs(pos - self._position)
-
- def towards(self, x, y=None):
- """Return the angle of the line from the turtle's position to (x, y).
-
- Arguments:
- x -- a number or a pair/vector of numbers or a turtle instance
- y -- a number None None
-
- call: distance(x, y) # two coordinates
- --or: distance((x, y)) # a pair (tuple) of coordinates
- --or: distance(vec) # e.g. as returned by pos()
- --or: distance(mypen) # where mypen is another turtle
-
- Return the angle, between the line from turtle-position to position
- specified by x, y and the turtle's start orientation. (Depends on
- modes - "standard" or "logo")
-
- Example (for a Turtle instance named turtle):
- >>> turtle.pos()
- (10.00, 10.00)
- >>> turtle.towards(0,0)
- 225.0
- """
- if y is not None:
- pos = Vec2D(x, y)
- if isinstance(x, Vec2D):
- pos = x
- elif isinstance(x, tuple):
- pos = Vec2D(*x)
- elif isinstance(x, TNavigator):
- pos = x._position
- x, y = pos - self._position
- result = round(math.atan2(y, x)*180.0/math.pi, 10) % 360.0
- result /= self._degreesPerAU
- return (self._angleOffset + self._angleOrient*result) % self._fullcircle
-
- def heading(self):
- """ Return the turtle's current heading.
-
- No arguments.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.left(67)
- >>> turtle.heading()
- 67.0
- """
- x, y = self._orient
- result = round(math.atan2(y, x)*180.0/math.pi, 10) % 360.0
- result /= self._degreesPerAU
- return (self._angleOffset + self._angleOrient*result) % self._fullcircle
-
- def setheading(self, to_angle):
- """Set the orientation of the turtle to to_angle.
-
- Aliases: setheading | seth
-
- Argument:
- to_angle -- a number (integer or float)
-
- Set the orientation of the turtle to to_angle.
- Here are some common directions in degrees:
-
- standard - mode: logo-mode:
- -------------------|--------------------
- 0 - east 0 - north
- 90 - north 90 - east
- 180 - west 180 - south
- 270 - south 270 - west
-
- Example (for a Turtle instance named turtle):
- >>> turtle.setheading(90)
- >>> turtle.heading()
- 90
- """
- angle = (to_angle - self.heading())*self._angleOrient
- full = self._fullcircle
- angle = (angle+full/2.)%full - full/2.
- self._rotate(angle)
-
- def circle(self, radius, extent = None, steps = None):
- """ Draw a circle with given radius.
-
- Arguments:
- radius -- a number
- extent (optional) -- a number
- steps (optional) -- an integer
-
- Draw a circle with given radius. The center is radius units left
- of the turtle; extent - an angle - determines which part of the
- circle is drawn. If extent is not given, draw the entire circle.
- If extent is not a full circle, one endpoint of the arc is the
- current pen position. Draw the arc in counterclockwise direction
- if radius is positive, otherwise in clockwise direction. Finally
- the direction of the turtle is changed by the amount of extent.
-
- As the circle is approximated by an inscribed regular polygon,
- steps determines the number of steps to use. If not given,
- it will be calculated automatically. Maybe used to draw regular
- polygons.
-
- call: circle(radius) # full circle
- --or: circle(radius, extent) # arc
- --or: circle(radius, extent, steps)
- --or: circle(radius, steps=6) # 6-sided polygon
-
- Example (for a Turtle instance named turtle):
- >>> turtle.circle(50)
- >>> turtle.circle(120, 180) # semicircle
- """
- if self.undobuffer:
- self.undobuffer.push(["seq"])
- self.undobuffer.cumulate = True
- speed = self.speed()
- if extent is None:
- extent = self._fullcircle
- if steps is None:
- frac = abs(extent)/self._fullcircle
- steps = 1+int(min(11+abs(radius)/6.0, 59.0)*frac)
- w = 1.0 * extent / steps
- w2 = 0.5 * w
- l = 2.0 * radius * math.sin(w2*math.pi/180.0*self._degreesPerAU)
- if radius < 0:
- l, w, w2 = -l, -w, -w2
- tr = self._tracer()
- dl = self._delay()
- if speed == 0:
- self._tracer(0, 0)
- else:
- self.speed(0)
- self._rotate(w2)
- for i in range(steps):
- self.speed(speed)
- self._go(l)
- self.speed(0)
- self._rotate(w)
- self._rotate(-w2)
- if speed == 0:
- self._tracer(tr, dl)
- self.speed(speed)
- if self.undobuffer:
- self.undobuffer.cumulate = False
-
-## three dummy methods to be implemented by child class:
-
- def speed(self, s=0):
- """dummy method - to be overwritten by child class"""
- def _tracer(self, a=None, b=None):
- """dummy method - to be overwritten by child class"""
- def _delay(self, n=None):
- """dummy method - to be overwritten by child class"""
-
- fd = forward
- bk = back
- backward = back
- rt = right
- lt = left
- position = pos
- setpos = goto
- setposition = goto
- seth = setheading
-
-
-class TPen(object):
- """Drawing part of the RawTurtle.
- Implements drawing properties.
- """
- def __init__(self, resizemode=_CFG["resizemode"]):
- self._resizemode = resizemode # or "user" or "noresize"
- self.undobuffer = None
- TPen._reset(self)
-
- def _reset(self, pencolor=_CFG["pencolor"],
- fillcolor=_CFG["fillcolor"]):
- self._pensize = 1
- self._shown = True
- self._pencolor = pencolor
- self._fillcolor = fillcolor
- self._drawing = True
- self._speed = 3
- self._stretchfactor = (1, 1)
- self._tilt = 0
- self._outlinewidth = 1
- ### self.screen = None # to override by child class
-
- def resizemode(self, rmode=None):
- """Set resizemode to one of the values: "auto", "user", "noresize".
-
- (Optional) Argument:
- rmode -- one of the strings "auto", "user", "noresize"
-
- Different resizemodes have the following effects:
- - "auto" adapts the appearance of the turtle
- corresponding to the value of pensize.
- - "user" adapts the appearance of the turtle according to the
- values of stretchfactor and outlinewidth (outline),
- which are set by shapesize()
- - "noresize" no adaption of the turtle's appearance takes place.
- If no argument is given, return current resizemode.
- resizemode("user") is called by a call of shapesize with arguments.
-
-
- Examples (for a Turtle instance named turtle):
- >>> turtle.resizemode("noresize")
- >>> turtle.resizemode()
- 'noresize'
- """
- if rmode is None:
- return self._resizemode
- rmode = rmode.lower()
- if rmode in ["auto", "user", "noresize"]:
- self.pen(resizemode=rmode)
-
- def pensize(self, width=None):
- """Set or return the line thickness.
-
- Aliases: pensize | width
-
- Argument:
- width -- positive number
-
- Set the line thickness to width or return it. If resizemode is set
- to "auto" and turtleshape is a polygon, that polygon is drawn with
- the same line thickness. If no argument is given, current pensize
- is returned.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.pensize()
- 1
- turtle.pensize(10) # from here on lines of width 10 are drawn
- """
- if width is None:
- return self._pensize
- self.pen(pensize=width)
-
-
- def penup(self):
- """Pull the pen up -- no drawing when moving.
-
- Aliases: penup | pu | up
-
- No argument
-
- Example (for a Turtle instance named turtle):
- >>> turtle.penup()
- """
- if not self._drawing:
- return
- self.pen(pendown=False)
-
- def pendown(self):
- """Pull the pen down -- drawing when moving.
-
- Aliases: pendown | pd | down
-
- No argument.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.pendown()
- """
- if self._drawing:
- return
- self.pen(pendown=True)
-
- def isdown(self):
- """Return True if pen is down, False if it's up.
-
- No argument.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.penup()
- >>> turtle.isdown()
- False
- >>> turtle.pendown()
- >>> turtle.isdown()
- True
- """
- return self._drawing
-
- def speed(self, speed=None):
- """ Return or set the turtle's speed.
-
- Optional argument:
- speed -- an integer in the range 0..10 or a speedstring (see below)
-
- Set the turtle's speed to an integer value in the range 0 .. 10.
- If no argument is given: return current speed.
-
- If input is a number greater than 10 or smaller than 0.5,
- speed is set to 0.
- Speedstrings are mapped to speedvalues in the following way:
- 'fastest' : 0
- 'fast' : 10
- 'normal' : 6
- 'slow' : 3
- 'slowest' : 1
- speeds from 1 to 10 enforce increasingly faster animation of
- line drawing and turtle turning.
-
- Attention:
- speed = 0 : *no* animation takes place. forward/back makes turtle jump
- and likewise left/right make the turtle turn instantly.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.speed(3)
- """
- speeds = {'fastest':0, 'fast':10, 'normal':6, 'slow':3, 'slowest':1 }
- if speed is None:
- return self._speed
- if speed in speeds:
- speed = speeds[speed]
- elif 0.5 < speed < 10.5:
- speed = int(round(speed))
- else:
- speed = 0
- self.pen(speed=speed)
-
- def color(self, *args):
- """Return or set the pencolor and fillcolor.
-
- Arguments:
- Several input formats are allowed.
- They use 0, 1, 2, or 3 arguments as follows:
-
- color()
- Return the current pencolor and the current fillcolor
- as a pair of color specification strings as are returned
- by pencolor and fillcolor.
- color(colorstring), color((r,g,b)), color(r,g,b)
- inputs as in pencolor, set both, fillcolor and pencolor,
- to the given value.
- color(colorstring1, colorstring2),
- color((r1,g1,b1), (r2,g2,b2))
- equivalent to pencolor(colorstring1) and fillcolor(colorstring2)
- and analogously, if the other input format is used.
-
- If turtleshape is a polygon, outline and interior of that polygon
- is drawn with the newly set colors.
- For mor info see: pencolor, fillcolor
-
- Example (for a Turtle instance named turtle):
- >>> turtle.color('red', 'green')
- >>> turtle.color()
- ('red', 'green')
- >>> colormode(255)
- >>> color((40, 80, 120), (160, 200, 240))
- >>> color()
- ('#285078', '#a0c8f0')
- """
- if args:
- l = len(args)
- if l == 1:
- pcolor = fcolor = args[0]
- elif l == 2:
- pcolor, fcolor = args
- elif l == 3:
- pcolor = fcolor = args
- pcolor = self._colorstr(pcolor)
- fcolor = self._colorstr(fcolor)
- self.pen(pencolor=pcolor, fillcolor=fcolor)
- else:
- return self._color(self._pencolor), self._color(self._fillcolor)
-
- def pencolor(self, *args):
- """ Return or set the pencolor.
-
- Arguments:
- Four input formats are allowed:
- - pencolor()
- Return the current pencolor as color specification string,
- possibly in hex-number format (see example).
- May be used as input to another color/pencolor/fillcolor call.
- - pencolor(colorstring)
- s is a Tk color specification string, such as "red" or "yellow"
- - pencolor((r, g, b))
- *a tuple* of r, g, and b, which represent, an RGB color,
- and each of r, g, and b are in the range 0..colormode,
- where colormode is either 1.0 or 255
- - pencolor(r, g, b)
- r, g, and b represent an RGB color, and each of r, g, and b
- are in the range 0..colormode
-
- If turtleshape is a polygon, the outline of that polygon is drawn
- with the newly set pencolor.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.pencolor('brown')
- >>> tup = (0.2, 0.8, 0.55)
- >>> turtle.pencolor(tup)
- >>> turtle.pencolor()
- '#33cc8c'
- """
- if args:
- color = self._colorstr(args)
- if color == self._pencolor:
- return
- self.pen(pencolor=color)
- else:
- return self._color(self._pencolor)
-
- def fillcolor(self, *args):
- """ Return or set the fillcolor.
-
- Arguments:
- Four input formats are allowed:
- - fillcolor()
- Return the current fillcolor as color specification string,
- possibly in hex-number format (see example).
- May be used as input to another color/pencolor/fillcolor call.
- - fillcolor(colorstring)
- s is a Tk color specification string, such as "red" or "yellow"
- - fillcolor((r, g, b))
- *a tuple* of r, g, and b, which represent, an RGB color,
- and each of r, g, and b are in the range 0..colormode,
- where colormode is either 1.0 or 255
- - fillcolor(r, g, b)
- r, g, and b represent an RGB color, and each of r, g, and b
- are in the range 0..colormode
-
- If turtleshape is a polygon, the interior of that polygon is drawn
- with the newly set fillcolor.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.fillcolor('violet')
- >>> col = turtle.pencolor()
- >>> turtle.fillcolor(col)
- >>> turtle.fillcolor(0, .5, 0)
- """
- if args:
- color = self._colorstr(args)
- if color == self._fillcolor:
- return
- self.pen(fillcolor=color)
- else:
- return self._color(self._fillcolor)
-
- def showturtle(self):
- """Makes the turtle visible.
-
- Aliases: showturtle | st
-
- No argument.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.hideturtle()
- >>> turtle.showturtle()
- """
- self.pen(shown=True)
-
- def hideturtle(self):
- """Makes the turtle invisible.
-
- Aliases: hideturtle | ht
-
- No argument.
-
- It's a good idea to do this while you're in the
- middle of a complicated drawing, because hiding
- the turtle speeds up the drawing observably.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.hideturtle()
- """
- self.pen(shown=False)
-
- def isvisible(self):
- """Return True if the Turtle is shown, False if it's hidden.
-
- No argument.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.hideturtle()
- >>> print turtle.isvisible():
- False
- """
- return self._shown
-
- def pen(self, pen=None, **pendict):
- """Return or set the pen's attributes.
-
- Arguments:
- pen -- a dictionary with some or all of the below listed keys.
- **pendict -- one or more keyword-arguments with the below
- listed keys as keywords.
-
- Return or set the pen's attributes in a 'pen-dictionary'
- with the following key/value pairs:
- "shown" : True/False
- "pendown" : True/False
- "pencolor" : color-string or color-tuple
- "fillcolor" : color-string or color-tuple
- "pensize" : positive number
- "speed" : number in range 0..10
- "resizemode" : "auto" or "user" or "noresize"
- "stretchfactor": (positive number, positive number)
- "outline" : positive number
- "tilt" : number
-
- This dicionary can be used as argument for a subsequent
- pen()-call to restore the former pen-state. Moreover one
- or more of these attributes can be provided as keyword-arguments.
- This can be used to set several pen attributes in one statement.
-
-
- Examples (for a Turtle instance named turtle):
- >>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
- >>> turtle.pen()
- {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
- 'pencolor': 'red', 'pendown': True, 'fillcolor': 'black',
- 'stretchfactor': (1,1), 'speed': 3}
- >>> penstate=turtle.pen()
- >>> turtle.color("yellow","")
- >>> turtle.penup()
- >>> turtle.pen()
- {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
- 'pencolor': 'yellow', 'pendown': False, 'fillcolor': '',
- 'stretchfactor': (1,1), 'speed': 3}
- >>> p.pen(penstate, fillcolor="green")
- >>> p.pen()
- {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
- 'pencolor': 'red', 'pendown': True, 'fillcolor': 'green',
- 'stretchfactor': (1,1), 'speed': 3}
- """
- _pd = {"shown" : self._shown,
- "pendown" : self._drawing,
- "pencolor" : self._pencolor,
- "fillcolor" : self._fillcolor,
- "pensize" : self._pensize,
- "speed" : self._speed,
- "resizemode" : self._resizemode,
- "stretchfactor" : self._stretchfactor,
- "outline" : self._outlinewidth,
- "tilt" : self._tilt
- }
-
- if not (pen or pendict):
- return _pd
-
- if isinstance(pen, dict):
- p = pen
- else:
- p = {}
- p.update(pendict)
-
- _p_buf = {}
- for key in p:
- _p_buf[key] = _pd[key]
-
- if self.undobuffer:
- self.undobuffer.push(("pen", _p_buf))
-
- newLine = False
- if "pendown" in p:
- if self._drawing != p["pendown"]:
- newLine = True
- if "pencolor" in p:
- if isinstance(p["pencolor"], tuple):
- p["pencolor"] = self._colorstr((p["pencolor"],))
- if self._pencolor != p["pencolor"]:
- newLine = True
- if "pensize" in p:
- if self._pensize != p["pensize"]:
- newLine = True
- if newLine:
- self._newLine()
- if "pendown" in p:
- self._drawing = p["pendown"]
- if "pencolor" in p:
- self._pencolor = p["pencolor"]
- if "pensize" in p:
- self._pensize = p["pensize"]
- if "fillcolor" in p:
- if isinstance(p["fillcolor"], tuple):
- p["fillcolor"] = self._colorstr((p["fillcolor"],))
- self._fillcolor = p["fillcolor"]
- if "speed" in p:
- self._speed = p["speed"]
- if "resizemode" in p:
- self._resizemode = p["resizemode"]
- if "stretchfactor" in p:
- sf = p["stretchfactor"]
- if isinstance(sf, (int, float)):
- sf = (sf, sf)
- self._stretchfactor = sf
- if "outline" in p:
- self._outlinewidth = p["outline"]
- if "shown" in p:
- self._shown = p["shown"]
- if "tilt" in p:
- self._tilt = p["tilt"]
- self._update()
-
-## three dummy methods to be implemented by child class:
-
- def _newLine(self, usePos = True):
- """dummy method - to be overwritten by child class"""
- def _update(self, count=True, forced=False):
- """dummy method - to be overwritten by child class"""
- def _color(self, args):
- """dummy method - to be overwritten by child class"""
- def _colorstr(self, args):
- """dummy method - to be overwritten by child class"""
-
- width = pensize
- up = penup
- pu = penup
- pd = pendown
- down = pendown
- st = showturtle
- ht = hideturtle
-
-
-class _TurtleImage(object):
- """Helper class: Datatype to store Turtle attributes
- """
-
- def __init__(self, screen, shapeIndex):
- self.screen = screen
- self._type = None
- self._setshape(shapeIndex)
-
- def _setshape(self, shapeIndex):
- screen = self.screen # RawTurtle.screens[self.screenIndex]
- self.shapeIndex = shapeIndex
- if self._type == "polygon" == screen._shapes[shapeIndex]._type:
- return
- if self._type == "image" == screen._shapes[shapeIndex]._type:
- return
- if self._type in ["image", "polygon"]:
- screen._delete(self._item)
- elif self._type == "compound":
- for item in self._item:
- screen._delete(item)
- self._type = screen._shapes[shapeIndex]._type
- if self._type == "polygon":
- self._item = screen._createpoly()
- elif self._type == "image":
- self._item = screen._createimage(screen._shapes["blank"]._data)
- elif self._type == "compound":
- self._item = [screen._createpoly() for item in
- screen._shapes[shapeIndex]._data]
-
-
-class RawTurtle(TPen, TNavigator):
- """Animation part of the RawTurtle.
- Puts RawTurtle upon a TurtleScreen and provides tools for
- it's animation.
- """
- screens = []
-
- def __init__(self, canvas=None,
- shape=_CFG["shape"],
- undobuffersize=_CFG["undobuffersize"],
- visible=_CFG["visible"]):
- if isinstance(canvas, Screen):
- self.screen = canvas
- elif isinstance(canvas, TurtleScreen):
- if canvas not in RawTurtle.screens:
- RawTurtle.screens.append(canvas)
- self.screen = canvas
- elif isinstance(canvas, (ScrolledCanvas, Canvas)):
- for screen in RawTurtle.screens:
- if screen.cv == canvas:
- self.screen = screen
- break
- else:
- self.screen = TurtleScreen(canvas)
- RawTurtle.screens.append(self.screen)
- else:
- raise TurtleGraphicsError("bad cavas argument %s" % canvas)
-
- screen = self.screen
- TNavigator.__init__(self, screen.mode())
- TPen.__init__(self)
- screen._turtles.append(self)
- self.drawingLineItem = screen._createline()
- self.turtle = _TurtleImage(screen, shape)
- self._poly = None
- self._creatingPoly = False
- self._fillitem = self._fillpath = None
- self._shown = visible
- self._hidden_from_screen = False
- self.currentLineItem = screen._createline()
- self.currentLine = [self._position]
- self.items = [self.currentLineItem]
- self.stampItems = []
- self._undobuffersize = undobuffersize
- self.undobuffer = Tbuffer(undobuffersize)
- self._update()
-
- def reset(self):
- """Delete the turtle's drawings and restore it's default values.
-
- No argument.
-,
- Delete the turtle's drawings from the screen, re-center the turtle
- and set variables to the default values.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.position()
- (0.00,-22.00)
- >>> turtle.heading()
- 100.0
- >>> turtle.reset()
- >>> turtle.position()
- (0.00,0.00)
- >>> turtle.heading()
- 0.0
- """
- TNavigator.reset(self)
- TPen._reset(self)
- self._clear()
- self._drawturtle()
- self._update()
-
- def setundobuffer(self, size):
- """Set or disable undobuffer.
-
- Argument:
- size -- an integer or None
-
- If size is an integer an empty undobuffer of given size is installed.
- Size gives the maximum number of turtle-actions that can be undone
- by the undo() function.
- If size is None, no undobuffer is present.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.setundobuffer(42)
- """
- if size is None:
- self.undobuffer = None
- else:
- self.undobuffer = Tbuffer(size)
-
- def undobufferentries(self):
- """Return count of entries in the undobuffer.
-
- No argument.
-
- Example (for a Turtle instance named turtle):
- >>> while undobufferentries():
- undo()
- """
- if self.undobuffer is None:
- return 0
- return self.undobuffer.nr_of_items()
-
- def _clear(self):
- """Delete all of pen's drawings"""
- self._fillitem = self._fillpath = None
- for item in self.items:
- self.screen._delete(item)
- self.currentLineItem = self.screen._createline()
- self.currentLine = []
- if self._drawing:
- self.currentLine.append(self._position)
- self.items = [self.currentLineItem]
- self.clearstamps()
- self.setundobuffer(self._undobuffersize)
-
-
- def clear(self):
- """Delete the turtle's drawings from the screen. Do not move turtle.
-
- No arguments.
-
- Delete the turtle's drawings from the screen. Do not move turtle.
- State and position of the turtle as well as drawings of other
- turtles are not affected.
-
- Examples (for a Turtle instance named turtle):
- >>> turtle.clear()
- """
- self._clear()
- self._update()
-
- def _update_data(self):
- self.screen._incrementudc()
- if self.screen._updatecounter != 0:
- return
- if len(self.currentLine)>1:
- self.screen._drawline(self.currentLineItem, self.currentLine,
- self._pencolor, self._pensize)
-
- def _update(self):
- """Perform a Turtle-data update.
- """
- screen = self.screen
- if screen._tracing == 0:
- return
- elif screen._tracing == 1:
- self._update_data()
- self._drawturtle()
- screen._update() # TurtleScreenBase
- screen._delay(screen._delayvalue) # TurtleScreenBase
- else:
- self._update_data()
- if screen._updatecounter == 0:
- for t in screen.turtles():
- t._drawturtle()
- screen._update()
-
- def _tracer(self, flag=None, delay=None):
- """Turns turtle animation on/off and set delay for update drawings.
-
- Optional arguments:
- n -- nonnegative integer
- delay -- nonnegative integer
-
- If n is given, only each n-th regular screen update is really performed.
- (Can be used to accelerate the drawing of complex graphics.)
- Second arguments sets delay value (see RawTurtle.delay())
-
- Example (for a Turtle instance named turtle):
- >>> turtle.tracer(8, 25)
- >>> dist = 2
- >>> for i in range(200):
- turtle.fd(dist)
- turtle.rt(90)
- dist += 2
- """
- return self.screen.tracer(flag, delay)
-
- def _color(self, args):
- return self.screen._color(args)
-
- def _colorstr(self, args):
- return self.screen._colorstr(args)
-
- def _cc(self, args):
- """Convert colortriples to hexstrings.
- """
- if isinstance(args, str):
- return args
- try:
- r, g, b = args
- except:
- raise TurtleGraphicsError("bad color arguments: %s" % str(args))
- if self.screen._colormode == 1.0:
- r, g, b = [round(255.0*x) for x in (r, g, b)]
- if not ((0 <= r <= 255) and (0 <= g <= 255) and (0 <= b <= 255)):
- raise TurtleGraphicsError("bad color sequence: %s" % str(args))
- return "#%02x%02x%02x" % (r, g, b)
-
- def clone(self):
- """Create and return a clone of the turtle.
-
- No argument.
-
- Create and return a clone of the turtle with same position, heading
- and turtle properties.
-
- Example (for a Turtle instance named mick):
- mick = Turtle()
- joe = mick.clone()
- """
- screen = self.screen
- self._newLine(self._drawing)
-
- turtle = self.turtle
- self.screen = None
- self.turtle = None # too make self deepcopy-able
-
- q = deepcopy(self)
-
- self.screen = screen
- self.turtle = turtle
-
- q.screen = screen
- q.turtle = _TurtleImage(screen, self.turtle.shapeIndex)
-
- screen._turtles.append(q)
- ttype = screen._shapes[self.turtle.shapeIndex]._type
- if ttype == "polygon":
- q.turtle._item = screen._createpoly()
- elif ttype == "image":
- q.turtle._item = screen._createimage(screen._shapes["blank"]._data)
- elif ttype == "compound":
- q.turtle._item = [screen._createpoly() for item in
- screen._shapes[self.turtle.shapeIndex]._data]
- q.currentLineItem = screen._createline()
- q._update()
- return q
-
- def shape(self, name=None):
- """Set turtle shape to shape with given name / return current shapename.
-
- Optional argument:
- name -- a string, which is a valid shapename
-
- Set turtle shape to shape with given name or, if name is not given,
- return name of current shape.
- Shape with name must exist in the TurtleScreen's shape dictionary.
- Initially there are the following polygon shapes:
- 'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'.
- To learn about how to deal with shapes see Screen-method register_shape.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.shape()
- 'arrow'
- >>> turtle.shape("turtle")
- >>> turtle.shape()
- 'turtle'
- """
- if name is None:
- return self.turtle.shapeIndex
- if not name in self.screen.getshapes():
- raise TurtleGraphicsError("There is no shape named %s" % name)
- self.turtle._setshape(name)
- self._update()
-
- def shapesize(self, stretch_wid=None, stretch_len=None, outline=None):
- """Set/return turtle's stretchfactors/outline. Set resizemode to "user".
-
- Optinonal arguments:
- stretch_wid : positive number
- stretch_len : positive number
- outline : positive number
-
- Return or set the pen's attributes x/y-stretchfactors and/or outline.
- Set resizemode to "user".
- If and only if resizemode is set to "user", the turtle will be displayed
- stretched according to its stretchfactors:
- stretch_wid is stretchfactor perpendicular to orientation
- stretch_len is stretchfactor in direction of turtles orientation.
- outline determines the width of the shapes's outline.
-
- Examples (for a Turtle instance named turtle):
- >>> turtle.resizemode("user")
- >>> turtle.shapesize(5, 5, 12)
- >>> turtle.shapesize(outline=8)
- """
- if stretch_wid is None and stretch_len is None and outline == None:
- stretch_wid, stretch_len = self._stretchfactor
- return stretch_wid, stretch_len, self._outlinewidth
- if stretch_wid is not None:
- if stretch_len is None:
- stretchfactor = stretch_wid, stretch_wid
- else:
- stretchfactor = stretch_wid, stretch_len
- elif stretch_len is not None:
- stretchfactor = self._stretchfactor[0], stretch_len
- else:
- stretchfactor = self._stretchfactor
- if outline is None:
- outline = self._outlinewidth
- self.pen(resizemode="user",
- stretchfactor=stretchfactor, outline=outline)
-
- def settiltangle(self, angle):
- """Rotate the turtleshape to point in the specified direction
-
- Optional argument:
- angle -- number
-
- Rotate the turtleshape to point in the direction specified by angle,
- regardless of its current tilt-angle. DO NOT change the turtle's
- heading (direction of movement).
-
-
- Examples (for a Turtle instance named turtle):
- >>> turtle.shape("circle")
- >>> turtle.shapesize(5,2)
- >>> turtle.settiltangle(45)
- >>> stamp()
- >>> turtle.fd(50)
- >>> turtle.settiltangle(-45)
- >>> stamp()
- >>> turtle.fd(50)
- """
- tilt = -angle * self._degreesPerAU * self._angleOrient
- tilt = (tilt * math.pi / 180.0) % (2*math.pi)
- self.pen(resizemode="user", tilt=tilt)
-
- def tiltangle(self):
- """Return the current tilt-angle.
-
- No argument.
-
- Return the current tilt-angle, i. e. the angle between the
- orientation of the turtleshape and the heading of the turtle
- (it's direction of movement).
-
- Examples (for a Turtle instance named turtle):
- >>> turtle.shape("circle")
- >>> turtle.shapesize(5,2)
- >>> turtle.tilt(45)
- >>> turtle.tiltangle()
- >>>
- """
- tilt = -self._tilt * (180.0/math.pi) * self._angleOrient
- return (tilt / self._degreesPerAU) % self._fullcircle
-
- def tilt(self, angle):
- """Rotate the turtleshape by angle.
-
- Argument:
- angle - a number
-
- Rotate the turtleshape by angle from its current tilt-angle,
- but do NOT change the turtle's heading (direction of movement).
-
- Examples (for a Turtle instance named turtle):
- >>> turtle.shape("circle")
- >>> turtle.shapesize(5,2)
- >>> turtle.tilt(30)
- >>> turtle.fd(50)
- >>> turtle.tilt(30)
- >>> turtle.fd(50)
- """
- self.settiltangle(angle + self.tiltangle())
-
- def _polytrafo(self, poly):
- """Computes transformed polygon shapes from a shape
- according to current position and heading.
- """
- screen = self.screen
- p0, p1 = self._position
- e0, e1 = self._orient
- e = Vec2D(e0, e1 * screen.yscale / screen.xscale)
- e0, e1 = (1.0 / abs(e)) * e
- return [(p0+(e1*x+e0*y)/screen.xscale, p1+(-e0*x+e1*y)/screen.yscale)
- for (x, y) in poly]
-
- def _drawturtle(self):
- """Manages the correct rendering of the turtle with respect to
- it's shape, resizemode, strech and tilt etc."""
- screen = self.screen
- shape = screen._shapes[self.turtle.shapeIndex]
- ttype = shape._type
- titem = self.turtle._item
- if self._shown and screen._updatecounter == 0 and screen._tracing > 0:
- self._hidden_from_screen = False
- tshape = shape._data
- if ttype == "polygon":
- if self._resizemode == "noresize":
- w = 1
- shape = tshape
- else:
- if self._resizemode == "auto":
- lx = ly = max(1, self._pensize/5.0)
- w = self._pensize
- tiltangle = 0
- elif self._resizemode == "user":
- lx, ly = self._stretchfactor
- w = self._outlinewidth
- tiltangle = self._tilt
- shape = [(lx*x, ly*y) for (x, y) in tshape]
- t0, t1 = math.sin(tiltangle), math.cos(tiltangle)
- shape = [(t1*x+t0*y, -t0*x+t1*y) for (x, y) in shape]
- shape = self._polytrafo(shape)
- fc, oc = self._fillcolor, self._pencolor
- screen._drawpoly(titem, shape, fill=fc, outline=oc,
- width=w, top=True)
- elif ttype == "image":
- screen._drawimage(titem, self._position, tshape)
- elif ttype == "compound":
- lx, ly = self._stretchfactor
- w = self._outlinewidth
- for item, (poly, fc, oc) in zip(titem, tshape):
- poly = [(lx*x, ly*y) for (x, y) in poly]
- poly = self._polytrafo(poly)
- screen._drawpoly(item, poly, fill=self._cc(fc),
- outline=self._cc(oc), width=w, top=True)
- else:
- if self._hidden_from_screen:
- return
- if ttype == "polygon":
- screen._drawpoly(titem, ((0, 0), (0, 0), (0, 0)), "", "")
- elif ttype == "image":
- screen._drawimage(titem, self._position,
- screen._shapes["blank"]._data)
- elif ttype == "compound":
- for item in titem:
- screen._drawpoly(item, ((0, 0), (0, 0), (0, 0)), "", "")
- self._hidden_from_screen = True
-
-############################## stamp stuff ###############################
-
- def stamp(self):
- """Stamp a copy of the turtleshape onto the canvas and return it's id.
-
- No argument.
-
- Stamp a copy of the turtle shape onto the canvas at the current
- turtle position. Return a stamp_id for that stamp, which can be
- used to delete it by calling clearstamp(stamp_id).
-
- Example (for a Turtle instance named turtle):
- >>> turtle.color("blue")
- >>> turtle.stamp()
- 13
- >>> turtle.fd(50)
- """
- screen = self.screen
- shape = screen._shapes[self.turtle.shapeIndex]
- ttype = shape._type
- tshape = shape._data
- if ttype == "polygon":
- stitem = screen._createpoly()
- if self._resizemode == "noresize":
- w = 1
- shape = tshape
- else:
- if self._resizemode == "auto":
- lx = ly = max(1, self._pensize/5.0)
- w = self._pensize
- tiltangle = 0
- elif self._resizemode == "user":
- lx, ly = self._stretchfactor
- w = self._outlinewidth
- tiltangle = self._tilt
- shape = [(lx*x, ly*y) for (x, y) in tshape]
- t0, t1 = math.sin(tiltangle), math.cos(tiltangle)
- shape = [(t1*x+t0*y, -t0*x+t1*y) for (x, y) in shape]
- shape = self._polytrafo(shape)
- fc, oc = self._fillcolor, self._pencolor
- screen._drawpoly(stitem, shape, fill=fc, outline=oc,
- width=w, top=True)
- elif ttype == "image":
- stitem = screen._createimage("")
- screen._drawimage(stitem, self._position, tshape)
- elif ttype == "compound":
- stitem = []
- for element in tshape:
- item = screen._createpoly()
- stitem.append(item)
- stitem = tuple(stitem)
- lx, ly = self._stretchfactor
- w = self._outlinewidth
- for item, (poly, fc, oc) in zip(stitem, tshape):
- poly = [(lx*x, ly*y) for (x, y) in poly]
- poly = self._polytrafo(poly)
- screen._drawpoly(item, poly, fill=self._cc(fc),
- outline=self._cc(oc), width=w, top=True)
- self.stampItems.append(stitem)
- self.undobuffer.push(("stamp", stitem))
- return stitem
-
- def _clearstamp(self, stampid):
- """does the work for clearstamp() and clearstamps()
- """
- if stampid in self.stampItems:
- if isinstance(stampid, tuple):
- for subitem in stampid:
- self.screen._delete(subitem)
- else:
- self.screen._delete(stampid)
- self.stampItems.remove(stampid)
- # Delete stampitem from undobuffer if necessary
- # if clearstamp is called directly.
- item = ("stamp", stampid)
- buf = self.undobuffer
- if item not in buf.buffer:
- return
- index = buf.buffer.index(item)
- buf.buffer.remove(item)
- if index <= buf.ptr:
- buf.ptr = (buf.ptr - 1) % buf.bufsize
- buf.buffer.insert((buf.ptr+1)%buf.bufsize, [None])
-
- def clearstamp(self, stampid):
- """Delete stamp with given stampid
-
- Argument:
- stampid - an integer, must be return value of previous stamp() call.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.color("blue")
- >>> astamp = turtle.stamp()
- >>> turtle.fd(50)
- >>> turtle.clearstamp(astamp)
- """
- self._clearstamp(stampid)
- self._update()
-
- def clearstamps(self, n=None):
- """Delete all or first/last n of turtle's stamps.
-
- Optional argument:
- n -- an integer
-
- If n is None, delete all of pen's stamps,
- else if n > 0 delete first n stamps
- else if n < 0 delete last n stamps.
-
- Example (for a Turtle instance named turtle):
- >>> for i in range(8):
- turtle.stamp(); turtle.fd(30)
- ...
- >>> turtle.clearstamps(2)
- >>> turtle.clearstamps(-2)
- >>> turtle.clearstamps()
- """
- if n is None:
- toDelete = self.stampItems[:]
- elif n >= 0:
- toDelete = self.stampItems[:n]
- else:
- toDelete = self.stampItems[n:]
- for item in toDelete:
- self._clearstamp(item)
- self._update()
-
- def _goto(self, end):
- """Move the pen to the point end, thereby drawing a line
- if pen is down. All other methodes for turtle movement depend
- on this one.
- """
- ## Version mit undo-stuff
- go_modes = ( self._drawing,
- self._pencolor,
- self._pensize,
- isinstance(self._fillpath, list))
- screen = self.screen
- undo_entry = ("go", self._position, end, go_modes,
- (self.currentLineItem,
- self.currentLine[:],
- screen._pointlist(self.currentLineItem),
- self.items[:])
- )
- if self.undobuffer:
- self.undobuffer.push(undo_entry)
- start = self._position
- if self._speed and screen._tracing == 1:
- diff = (end-start)
- diffsq = (diff[0]*screen.xscale)**2 + (diff[1]*screen.yscale)**2
- nhops = 1+int((diffsq**0.5)/(3*(1.1**self._speed)*self._speed))
- delta = diff * (1.0/nhops)
- for n in range(1, nhops):
- if n == 1:
- top = True
- else:
- top = False
- self._position = start + delta * n
- if self._drawing:
- screen._drawline(self.drawingLineItem,
- (start, self._position),
- self._pencolor, self._pensize, top)
- self._update()
- if self._drawing:
- screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)),
- fill="", width=self._pensize)
- # Turtle now at end,
- if self._drawing: # now update currentLine
- self.currentLine.append(end)
- if isinstance(self._fillpath, list):
- self._fillpath.append(end)
- ###### vererbung!!!!!!!!!!!!!!!!!!!!!!
- self._position = end
- if self._creatingPoly:
- self._poly.append(end)
- if len(self.currentLine) > 42: # 42! answer to the ultimate question
- # of life, the universe and everything
- self._newLine()
- self._update() #count=True)
-
- def _undogoto(self, entry):
- """Reverse a _goto. Used for undo()
- """
- old, new, go_modes, coodata = entry
- drawing, pc, ps, filling = go_modes
- cLI, cL, pl, items = coodata
- screen = self.screen
- if abs(self._position - new) > 0.5:
- print ("undogoto: HALLO-DA-STIMMT-WAS-NICHT!")
- # restore former situation
- self.currentLineItem = cLI
- self.currentLine = cL
-
- if pl == [(0, 0), (0, 0)]:
- usepc = ""
- else:
- usepc = pc
- screen._drawline(cLI, pl, fill=usepc, width=ps)
-
- todelete = [i for i in self.items if (i not in items) and
- (screen._type(i) == "line")]
- for i in todelete:
- screen._delete(i)
- self.items.remove(i)
-
- start = old
- if self._speed and screen._tracing == 1:
- diff = old - new
- diffsq = (diff[0]*screen.xscale)**2 + (diff[1]*screen.yscale)**2
- nhops = 1+int((diffsq**0.5)/(3*(1.1**self._speed)*self._speed))
- delta = diff * (1.0/nhops)
- for n in range(1, nhops):
- if n == 1:
- top = True
- else:
- top = False
- self._position = new + delta * n
- if drawing:
- screen._drawline(self.drawingLineItem,
- (start, self._position),
- pc, ps, top)
- self._update()
- if drawing:
- screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)),
- fill="", width=ps)
- # Turtle now at position old,
- self._position = old
- ## if undo is done during crating a polygon, the last vertex
- ## will be deleted. if the polygon is entirel deleted,
- ## creatigPoly will be set to False.
- ## Polygons created before the last one will not be affected by undo()
- if self._creatingPoly:
- if len(self._poly) > 0:
- self._poly.pop()
- if self._poly == []:
- self._creatingPoly = False
- self._poly = None
- if filling:
- if self._fillpath == []:
- self._fillpath = None
- print("Unwahrscheinlich in _undogoto!")
- elif self._fillpath is not None:
- self._fillpath.pop()
- self._update() #count=True)
-
- def _rotate(self, angle):
- """Turns pen clockwise by angle.
- """
- if self.undobuffer:
- self.undobuffer.push(("rot", angle, self._degreesPerAU))
- angle *= self._degreesPerAU
- neworient = self._orient.rotate(angle)
- tracing = self.screen._tracing
- if tracing == 1 and self._speed > 0:
- anglevel = 3.0 * self._speed
- steps = 1 + int(abs(angle)/anglevel)
- delta = 1.0*angle/steps
- for _ in range(steps):
- self._orient = self._orient.rotate(delta)
- self._update()
- self._orient = neworient
- self._update()
-
- def _newLine(self, usePos=True):
- """Closes current line item and starts a new one.
- Remark: if current line became too long, animation
- performance (via _drawline) slowed down considerably.
- """
- if len(self.currentLine) > 1:
- self.screen._drawline(self.currentLineItem, self.currentLine,
- self._pencolor, self._pensize)
- self.currentLineItem = self.screen._createline()
- self.items.append(self.currentLineItem)
- else:
- self.screen._drawline(self.currentLineItem, top=True)
- self.currentLine = []
- if usePos:
- self.currentLine = [self._position]
-
- def filling(self):
- """Return fillstate (True if filling, False else).
-
- No argument.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.begin_fill()
- >>> if turtle.filling():
- turtle.pensize(5)
- else:
- turtle.pensize(3)
- """
- return isinstance(self._fillpath, list)
-
-## def fill(self, flag=None):
-## """Call fill(True) before drawing a shape to fill, fill(False) when done.
-##
-## Optional argument:
-## flag -- True/False (or 1/0 respectively)
-##
-## Call fill(True) before drawing the shape you want to fill,
-## and fill(False) when done.
-## When used without argument: return fillstate (True if filling,
-## False else)
-##
-## Example (for a Turtle instance named turtle):
-## >>> turtle.fill(True)
-## >>> turtle.forward(100)
-## >>> turtle.left(90)
-## >>> turtle.forward(100)
-## >>> turtle.left(90)
-## >>> turtle.forward(100)
-## >>> turtle.left(90)
-## >>> turtle.forward(100)
-## >>> turtle.fill(False)
-## """
-## filling = isinstance(self._fillpath, list)
-## if flag is None:
-## return filling
-## screen = self.screen
-## entry1 = entry2 = ()
-## if filling:
-## if len(self._fillpath) > 2:
-## self.screen._drawpoly(self._fillitem, self._fillpath,
-## fill=self._fillcolor)
-## entry1 = ("dofill", self._fillitem)
-## if flag:
-## self._fillitem = self.screen._createpoly()
-## self.items.append(self._fillitem)
-## self._fillpath = [self._position]
-## entry2 = ("beginfill", self._fillitem) # , self._fillpath)
-## self._newLine()
-## else:
-## self._fillitem = self._fillpath = None
-## if self.undobuffer:
-## if entry1 == ():
-## if entry2 != ():
-## self.undobuffer.push(entry2)
-## else:
-## if entry2 == ():
-## self.undobuffer.push(entry1)
-## else:
-## self.undobuffer.push(["seq", entry1, entry2])
-## self._update()
-
- def begin_fill(self):
- """Called just before drawing a shape to be filled.
-
- No argument.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.color("black", "red")
- >>> turtle.begin_fill()
- >>> turtle.circle(60)
- >>> turtle.end_fill()
- """
- if not self.filling():
- self._fillitem = self.screen._createpoly()
- self.items.append(self._fillitem)
- self._fillpath = [self._position]
- self._newLine()
- if self.undobuffer:
- self.undobuffer.push(("beginfill", self._fillitem))
- self._update()
-
-
- def end_fill(self):
- """Fill the shape drawn after the call begin_fill().
-
- No argument.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.color("black", "red")
- >>> turtle.begin_fill()
- >>> turtle.circle(60)
- >>> turtle.end_fill()
- """
- if self.filling():
- if len(self._fillpath) > 2:
- self.screen._drawpoly(self._fillitem, self._fillpath,
- fill=self._fillcolor)
- if self.undobuffer:
- self.undobuffer.push(("dofill", self._fillitem))
- self._fillitem = self._fillpath = None
- self._update()
-
- def dot(self, size=None, *color):
- """Draw a dot with diameter size, using color.
-
- Optional argumentS:
- size -- an integer >= 1 (if given)
- color -- a colorstring or a numeric color tuple
-
- Draw a circular dot with diameter size, using color.
- If size is not given, the maximum of pensize+4 and 2*pensize is used.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.dot()
- >>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
- """
- #print "dot-1:", size, color
- if not color:
- if isinstance(size, (str, tuple)):
- color = self._colorstr(size)
- size = self._pensize + max(self._pensize, 4)
- else:
- color = self._pencolor
- if not size:
- size = self._pensize + max(self._pensize, 4)
- else:
- if size is None:
- size = self._pensize + max(self._pensize, 4)
- color = self._colorstr(color)
- #print "dot-2:", size, color
- if hasattr(self.screen, "_dot"):
- item = self.screen._dot(self._position, size, color)
- #print "dot:", size, color, "item:", item
- self.items.append(item)
- if self.undobuffer:
- self.undobuffer.push(("dot", item))
- else:
- pen = self.pen()
- if self.undobuffer:
- self.undobuffer.push(["seq"])
- self.undobuffer.cumulate = True
- try:
- if self.resizemode() == 'auto':
- self.ht()
- self.pendown()
- self.pensize(size)
- self.pencolor(color)
- self.forward(0)
- finally:
- self.pen(pen)
- if self.undobuffer:
- self.undobuffer.cumulate = False
-
- def _write(self, txt, align, font):
- """Performs the writing for write()
- """
- item, end = self.screen._write(self._position, txt, align, font,
- self._pencolor)
- self.items.append(item)
- if self.undobuffer:
- self.undobuffer.push(("wri", item))
- return end
-
- def write(self, arg, move=False, align="left", font=("Arial", 8, "normal")):
- """Write text at the current turtle position.
-
- Arguments:
- arg -- info, which is to be written to the TurtleScreen
- move (optional) -- True/False
- align (optional) -- one of the strings "left", "center" or right"
- font (optional) -- a triple (fontname, fontsize, fonttype)
-
- Write text - the string representation of arg - at the current
- turtle position according to align ("left", "center" or right")
- and with the given font.
- If move is True, the pen is moved to the bottom-right corner
- of the text. By default, move is False.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.write('Home = ', True, align="center")
- >>> turtle.write((0,0), True)
- """
- if self.undobuffer:
- self.undobuffer.push(["seq"])
- self.undobuffer.cumulate = True
- end = self._write(str(arg), align.lower(), font)
- if move:
- x, y = self.pos()
- self.setpos(end, y)
- if self.undobuffer:
- self.undobuffer.cumulate = False
-
- def begin_poly(self):
- """Start recording the vertices of a polygon.
-
- No argument.
-
- Start recording the vertices of a polygon. Current turtle position
- is first point of polygon.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.begin_poly()
- """
- self._poly = [self._position]
- self._creatingPoly = True
-
- def end_poly(self):
- """Stop recording the vertices of a polygon.
-
- No argument.
-
- Stop recording the vertices of a polygon. Current turtle position is
- last point of polygon. This will be connected with the first point.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.end_poly()
- """
- self._creatingPoly = False
-
- def get_poly(self):
- """Return the lastly recorded polygon.
-
- No argument.
-
- Example (for a Turtle instance named turtle):
- >>> p = turtle.get_poly()
- >>> turtle.register_shape("myFavouriteShape", p)
- """
- ## check if there is any poly? -- 1st solution:
- if self._poly is not None:
- return tuple(self._poly)
-
- def getscreen(self):
- """Return the TurtleScreen object, the turtle is drawing on.
-
- No argument.
-
- Return the TurtleScreen object, the turtle is drawing on.
- So TurtleScreen-methods can be called for that object.
-
- Example (for a Turtle instance named turtle):
- >>> ts = turtle.getscreen()
- >>> ts
- <turtle.TurtleScreen object at 0x0106B770>
- >>> ts.bgcolor("pink")
- """
- return self.screen
-
- def getturtle(self):
- """Return the Turtleobject itself.
-
- No argument.
-
- Only reasonable use: as a function to return the 'anonymous turtle':
-
- Example:
- >>> pet = getturtle()
- >>> pet.fd(50)
- >>> pet
- <turtle.Turtle object at 0x0187D810>
- >>> turtles()
- [<turtle.Turtle object at 0x0187D810>]
- """
- return self
-
- getpen = getturtle
-
-
- ################################################################
- ### screen oriented methods recurring to methods of TurtleScreen
- ################################################################
-
-## def window_width(self):
-## """ Returns the width of the turtle window.
-##
-## No argument.
-##
-## Example (for a TurtleScreen instance named screen):
-## >>> screen.window_width()
-## 640
-## """
-## return self.screen._window_size()[0]
-##
-## def window_height(self):
-## """ Return the height of the turtle window.
-##
-## No argument.
-##
-## Example (for a TurtleScreen instance named screen):
-## >>> screen.window_height()
-## 480
-## """
-## return self.screen._window_size()[1]
-
- def _delay(self, delay=None):
- """Set delay value which determines speed of turtle animation.
- """
- return self.screen.delay(delay)
-
- ##### event binding methods #####
-
- def onclick(self, fun, btn=1, add=None):
- """Bind fun to mouse-click event on this turtle on canvas.
-
- Arguments:
- fun -- a function with two arguments, to which will be assigned
- the coordinates of the clicked point on the canvas.
- num -- number of the mouse-button defaults to 1 (left mouse button).
- add -- True or False. If True, new binding will be added, otherwise
- it will replace a former binding.
-
- Example for the anonymous turtle, i. e. the procedural way:
-
- >>> def turn(x, y):
- left(360)
-
- >>> onclick(turn) # Now clicking into the turtle will turn it.
- >>> onclick(None) # event-binding will be removed
- """
- self.screen._onclick(self.turtle._item, fun, btn, add)
- self._update()
-
- def onrelease(self, fun, btn=1, add=None):
- """Bind fun to mouse-button-release event on this turtle on canvas.
-
- Arguments:
- fun -- a function with two arguments, to which will be assigned
- the coordinates of the clicked point on the canvas.
- num -- number of the mouse-button defaults to 1 (left mouse button).
-
- Example (for a MyTurtle instance named joe):
- >>> class MyTurtle(Turtle):
- def glow(self,x,y):
- self.fillcolor("red")
- def unglow(self,x,y):
- self.fillcolor("")
-
- >>> joe = MyTurtle()
- >>> joe.onclick(joe.glow)
- >>> joe.onrelease(joe.unglow)
- ### clicking on joe turns fillcolor red,
- ### unclicking turns it to transparent.
- """
- self.screen._onrelease(self.turtle._item, fun, btn, add)
- self._update()
-
- def ondrag(self, fun, btn=1, add=None):
- """Bind fun to mouse-move event on this turtle on canvas.
-
- Arguments:
- fun -- a function with two arguments, to which will be assigned
- the coordinates of the clicked point on the canvas.
- num -- number of the mouse-button defaults to 1 (left mouse button).
-
- Every sequence of mouse-move-events on a turtle is preceded by a
- mouse-click event on that turtle.
-
- Example (for a Turtle instance named turtle):
- >>> turtle.ondrag(turtle.goto)
-
- ### Subsequently clicking and dragging a Turtle will
- ### move it across the screen thereby producing handdrawings
- ### (if pen is down).
- """
- self.screen._ondrag(self.turtle._item, fun, btn, add)
-
-
- def _undo(self, action, data):
- """Does the main part of the work for undo()
- """
- if self.undobuffer is None:
- return
- if action == "rot":
- angle, degPAU = data
- self._rotate(-angle*degPAU/self._degreesPerAU)
- dummy = self.undobuffer.pop()
- elif action == "stamp":
- stitem = data[0]
- self.clearstamp(stitem)
- elif action == "go":
- self._undogoto(data)
- elif action in ["wri", "dot"]:
- item = data[0]
- self.screen._delete(item)
- self.items.remove(item)
- elif action == "dofill":
- item = data[0]
- self.screen._drawpoly(item, ((0, 0),(0, 0),(0, 0)),
- fill="", outline="")
- elif action == "beginfill":
- item = data[0]
- self._fillitem = self._fillpath = None
- if item in self.items:
- self.screen._delete(item)
- self.items.remove(item)
- elif action == "pen":
- TPen.pen(self, data[0])
- self.undobuffer.pop()
-
- def undo(self):
- """undo (repeatedly) the last turtle action.
-
- No argument.
-
- undo (repeatedly) the last turtle action.
- Number of available undo actions is determined by the size of
- the undobuffer.
-
- Example (for a Turtle instance named turtle):
- >>> for i in range(4):
- turtle.fd(50); turtle.lt(80)
-
- >>> for i in range(8):
- turtle.undo()
- """
- if self.undobuffer is None:
- return
- item = self.undobuffer.pop()
- action = item[0]
- data = item[1:]
- if action == "seq":
- while data:
- item = data.pop()
- self._undo(item[0], item[1:])
- else:
- self._undo(action, data)
-
- turtlesize = shapesize
-
-RawPen = RawTurtle
-
-### Screen - Klasse ########################
-
-class Screen(TurtleScreen):
-
- _root = None
- _canvas = None
- _title = _CFG["title"]
-
- # Borg-Idiom
-
- _shared_state = {}
-
- def __new__(cls, *args, **kwargs):
- obj = object.__new__(cls, *args, **kwargs)
- obj.__dict__ = cls._shared_state
- return obj
-
- def __init__(self):
- if Screen._root is None:
- Screen._root = self._root = _Root()
- self._root.title(Screen._title)
- self._root.ondestroy(self._destroy)
- if Screen._canvas is None:
- width = _CFG["width"]
- height = _CFG["height"]
- canvwidth = _CFG["canvwidth"]
- canvheight = _CFG["canvheight"]
- leftright = _CFG["leftright"]
- topbottom = _CFG["topbottom"]
- self._root.setupcanvas(width, height, canvwidth, canvheight)
- Screen._canvas = self._root._getcanvas()
- self.setup(width, height, leftright, topbottom)
- TurtleScreen.__init__(self, Screen._canvas)
- Turtle._screen = self
-
- def setup(self, width=_CFG["width"], height=_CFG["height"],
- startx=_CFG["leftright"], starty=_CFG["topbottom"]):
- """ Set the size and position of the main window.
-
- Arguments:
- width: as integer a size in pixels, as float a fraction of the screen.
- Default is 50% of screen.
- height: as integer the height in pixels, as float a fraction of the
- screen. Default is 75% of screen.
- startx: if positive, starting position in pixels from the left
- edge of the screen, if negative from the right edge
- Default, startx=None is to center window horizontally.
- starty: if positive, starting position in pixels from the top
- edge of the screen, if negative from the bottom edge
- Default, starty=None is to center window vertically.
-
- Examples (for a Screen instance named screen):
- >>> screen.setup (width=200, height=200, startx=0, starty=0)
-
- sets window to 200x200 pixels, in upper left of screen
-
- >>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
-
- sets window to 75% of screen by 50% of screen and centers
- """
- if not hasattr(self._root, "set_geometry"):
- return
- sw = self._root.win_width()
- sh = self._root.win_height()
- if isinstance(width, float) and 0 <= width <= 1:
- width = sw*width
- if startx is None:
- startx = (sw - width) / 2
- if isinstance(height, float) and 0 <= height <= 1:
- height = sh*height
- if starty is None:
- starty = (sh - height) / 2
- self._root.set_geometry(width, height, startx, starty)
-
- def title(self, titlestring):
- """Set title of turtle-window
-
- Argument:
- titlestring -- a string, to appear in the titlebar of the
- turtle graphics window.
-
- This is a method of Screen-class. Not available for TurtleScreen-
- objects.
-
- Example (for a Screen instance named screen):
- >>> screen.title("Welcome to the turtle-zoo!")
- """
- if Screen._root is not None:
- Screen._root.title(titlestring)
- Screen._title = titlestring
-
- def _destroy(self):
- root = self._root
- if root is Screen._root:
- Turtle._pen = None
- Turtle._screen = None
- Screen._root = None
- Screen._canvas = None
- TurtleScreen._RUNNING = True
- root.destroy()
-
- def bye(self):
- """Shut the turtlegraphics window.
-
- Example (for a TurtleScreen instance named screen):
- >>> screen.bye()
- """
- self._destroy()
-
- def exitonclick(self):
- """Go into mainloop until the mouse is clicked.
-
- No arguments.
-
- Bind bye() method to mouseclick on TurtleScreen.
- If "using_IDLE" - value in configuration dictionary is False
- (default value), enter mainloop.
- If IDLE with -n switch (no subprocess) is used, this value should be
- set to True in turtle.cfg. In this case IDLE's mainloop
- is active also for the client script.
-
- This is a method of the Screen-class and not available for
- TurtleScreen instances.
-
- Example (for a Screen instance named screen):
- >>> screen.exitonclick()
-
- """
- def exitGracefully(x, y):
- """Screen.bye() with two dummy-parameters"""
- self.bye()
- self.onclick(exitGracefully)
- if _CFG["using_IDLE"]:
- return
- try:
- mainloop()
- except AttributeError:
- exit(0)
-
-
-class Turtle(RawTurtle):
- """RawTurtle auto-crating (scrolled) canvas.
-
- When a Turtle object is created or a function derived from some
- Turtle method is called a TurtleScreen object is automatically created.
- """
- _pen = None
- _screen = None
-
- def __init__(self,
- shape=_CFG["shape"],
- undobuffersize=_CFG["undobuffersize"],
- visible=_CFG["visible"]):
- if Turtle._screen is None:
- Turtle._screen = Screen()
- RawTurtle.__init__(self, Turtle._screen,
- shape=shape,
- undobuffersize=undobuffersize,
- visible=visible)
-
-Pen = Turtle
-
-def _getpen():
- """Create the 'anonymous' turtle if not already present."""
- if Turtle._pen is None:
- Turtle._pen = Turtle()
- return Turtle._pen
-
-def _getscreen():
- """Create a TurtleScreen if not already present."""
- if Turtle._screen is None:
- Turtle._screen = Screen()
- return Turtle._screen
-
-def write_docstringdict(filename="turtle_docstringdict"):
- """Create and write docstring-dictionary to file.
-
- Optional argument:
- filename -- a string, used as filename
- default value is turtle_docstringdict
-
- Has to be called explicitely, (not used by the turtle-graphics classes)
- The docstring dictionary will be written to the Python script <filname>.py
- It is intended to serve as a template for translation of the docstrings
- into different languages.
- """
- docsdict = {}
-
- for methodname in _tg_screen_functions:
- key = "Screen."+methodname
- docsdict[key] = eval(key).__doc__
- for methodname in _tg_turtle_functions:
- key = "Turtle."+methodname
- docsdict[key] = eval(key).__doc__
-
- f = open("%s.py" % filename,"w")
- keys = sorted([x for x in docsdict.keys()
- if x.split('.')[1] not in _alias_list])
- f.write('docsdict = {\n\n')
- for key in keys[:-1]:
- f.write('%s :\n' % repr(key))
- f.write(' """%s\n""",\n\n' % docsdict[key])
- key = keys[-1]
- f.write('%s :\n' % repr(key))
- f.write(' """%s\n"""\n\n' % docsdict[key])
- f.write("}\n")
- f.close()
-
-def read_docstrings(lang):
- """Read in docstrings from lang-specific docstring dictionary.
-
- Transfer docstrings, translated to lang, from a dictionary-file
- to the methods of classes Screen and Turtle and - in revised form -
- to the corresponding functions.
- """
- modname = "turtle_docstringdict_%(language)s" % {'language':lang.lower()}
- module = __import__(modname)
- docsdict = module.docsdict
- for key in docsdict:
- try:
-# eval(key).im_func.__doc__ = docsdict[key]
- eval(key).__doc__ = docsdict[key]
- except:
- print("Bad docstring-entry: %s" % key)
-
-_LANGUAGE = _CFG["language"]
-
-try:
- if _LANGUAGE != "english":
- read_docstrings(_LANGUAGE)
-except ImportError:
- print("Cannot find docsdict for", _LANGUAGE)
-except:
- print ("Unknown Error when trying to import %s-docstring-dictionary" %
- _LANGUAGE)
-
-
-def getmethparlist(ob):
- "Get strings describing the arguments for the given object"
- argText1 = argText2 = ""
- # bit of a hack for methods - turn it into a function
- # but we drop the "self" param.
-## if type(ob)==types.MethodType:
-## fob = ob.im_func
-## argOffset = 1
-## else:
-## fob = ob
-## argOffset = 0
- # Try and build one for Python defined functions
- argOffset = 1
-## if type(fob) in [types.FunctionType, types.LambdaType]:
-## try:
- counter = ob.__code__.co_argcount
- items2 = list(ob.__code__.co_varnames[argOffset:counter])
- realArgs = ob.__code__.co_varnames[argOffset:counter]
- defaults = ob.__defaults__ or []
- defaults = list(map(lambda name: "=%s" % repr(name), defaults))
- defaults = [""] * (len(realArgs)-len(defaults)) + defaults
- items1 = list(map(lambda arg, dflt: arg+dflt, realArgs, defaults))
- if ob.__code__.co_flags & 0x4:
- items1.append("*"+ob.__code__.co_varnames[counter])
- items2.append("*"+ob.__code__.co_varnames[counter])
- counter += 1
- if ob.__code__.co_flags & 0x8:
- items1.append("**"+ob.__code__.co_varnames[counter])
- items2.append("**"+ob.__code__.co_varnames[counter])
- argText1 = ", ".join(items1)
- argText1 = "(%s)" % argText1
- argText2 = ", ".join(items2)
- argText2 = "(%s)" % argText2
-## except:
-## pass
- return argText1, argText2
-
-def _turtle_docrevise(docstr):
- """To reduce docstrings from RawTurtle class for functions
- """
- import re
- if docstr is None:
- return None
- turtlename = _CFG["exampleturtle"]
- newdocstr = docstr.replace("%s." % turtlename,"")
- parexp = re.compile(r' \(.+ %s\):' % turtlename)
- newdocstr = parexp.sub(":", newdocstr)
- return newdocstr
-
-def _screen_docrevise(docstr):
- """To reduce docstrings from TurtleScreen class for functions
- """
- import re
- if docstr is None:
- return None
- screenname = _CFG["examplescreen"]
- newdocstr = docstr.replace("%s." % screenname,"")
- parexp = re.compile(r' \(.+ %s\):' % screenname)
- newdocstr = parexp.sub(":", newdocstr)
- return newdocstr
-
-## The following mechanism makes all methods of RawTurtle and Turtle available
-## as functions. So we can enhance, change, add, delete methods to these
-## classes and do not need to change anything here.
-
-
-for methodname in _tg_screen_functions:
- pl1, pl2 = getmethparlist(eval('Screen.' + methodname))
- if pl1 == "":
- print(">>>>>>", pl1, pl2)
- continue
- defstr = ("def %(key)s%(pl1)s: return _getscreen().%(key)s%(pl2)s" %
- {'key':methodname, 'pl1':pl1, 'pl2':pl2})
-## print("Screen:", defstr)
- exec(defstr)
- eval(methodname).__doc__ = _screen_docrevise(eval('Screen.'+methodname).__doc__)
-
-for methodname in _tg_turtle_functions:
- pl1, pl2 = getmethparlist(eval('Turtle.' + methodname))
- if pl1 == "":
- print(">>>>>>", pl1, pl2)
- continue
- defstr = ("def %(key)s%(pl1)s: return _getpen().%(key)s%(pl2)s" %
- {'key':methodname, 'pl1':pl1, 'pl2':pl2})
-## print("Turtle:", defstr)
- exec(defstr)
- eval(methodname).__doc__ = _turtle_docrevise(eval('Turtle.'+methodname).__doc__)
-
-
-done = mainloop = TK.mainloop
-#del pl1, pl2, defstr
-
-if __name__ == "__main__":
- def switchpen():
- if isdown():
- pu()
- else:
- pd()
-
- def demo1():
- """Demo of old turtle.py - module"""
- reset()
- tracer(True)
- up()
- backward(100)
- down()
- # draw 3 squares; the last filled
- width(3)
- for i in range(3):
- if i == 2:
- begin_fill()
- for _ in range(4):
- forward(20)
- left(90)
- if i == 2:
- color("maroon")
- end_fill()
- up()
- forward(30)
- down()
- width(1)
- color("black")
- # move out of the way
- tracer(False)
- up()
- right(90)
- forward(100)
- right(90)
- forward(100)
- right(180)
- down()
- # some text
- write("startstart", 1)
- write("start", 1)
- color("red")
- # staircase
- for i in range(5):
- forward(20)
- left(90)
- forward(20)
- right(90)
- # filled staircase
- tracer(True)
- begin_fill()
- for i in range(5):
- forward(20)
- left(90)
- forward(20)
- right(90)
- end_fill()
- # more text
-
- def demo2():
- """Demo of some new features."""
- speed(1)
- st()
- pensize(3)
- setheading(towards(0, 0))
- radius = distance(0, 0)/2.0
- rt(90)
- for _ in range(18):
- switchpen()
- circle(radius, 10)
- write("wait a moment...")
- while undobufferentries():
- undo()
- reset()
- lt(90)
- colormode(255)
- laenge = 10
- pencolor("green")
- pensize(3)
- lt(180)
- for i in range(-2, 16):
- if i > 0:
- begin_fill()
- fillcolor(255-15*i, 0, 15*i)
- for _ in range(3):
- fd(laenge)
- lt(120)
- end_fill()
- laenge += 10
- lt(15)
- speed((speed()+1)%12)
- #end_fill()
-
- lt(120)
- pu()
- fd(70)
- rt(30)
- pd()
- color("red","yellow")
- speed(0)
- begin_fill()
- for _ in range(4):
- circle(50, 90)
- rt(90)
- fd(30)
- rt(90)
- end_fill()
- lt(90)
- pu()
- fd(30)
- pd()
- shape("turtle")
-
- tri = getturtle()
- tri.resizemode("auto")
- turtle = Turtle()
- turtle.resizemode("auto")
- turtle.shape("turtle")
- turtle.reset()
- turtle.left(90)
- turtle.speed(0)
- turtle.up()
- turtle.goto(280, 40)
- turtle.lt(30)
- turtle.down()
- turtle.speed(6)
- turtle.color("blue","orange")
- turtle.pensize(2)
- tri.speed(6)
- setheading(towards(turtle))
- count = 1
- while tri.distance(turtle) > 4:
- turtle.fd(3.5)
- turtle.lt(0.6)
- tri.setheading(tri.towards(turtle))
- tri.fd(4)
- if count % 20 == 0:
- turtle.stamp()
- tri.stamp()
- switchpen()
- count += 1
- tri.write("CAUGHT! ", font=("Arial", 16, "bold"), align="right")
- tri.pencolor("black")
- tri.pencolor("red")
-
- def baba(xdummy, ydummy):
- clearscreen()
- bye()
-
- time.sleep(2)
-
- while undobufferentries():
- tri.undo()
- turtle.undo()
- tri.fd(50)
- tri.write(" Click me!", font = ("Courier", 12, "bold") )
- tri.onclick(baba, 1)
-
- demo1()
- demo2()
- exitonclick()
Modified: python/branches/py3k/Misc/NEWS
==============================================================================
--- python/branches/py3k/Misc/NEWS (original)
+++ python/branches/py3k/Misc/NEWS Sun Sep 21 09:32:10 2008
@@ -15,6 +15,8 @@
Library
-------
+- Bug #3884: Make the turtle module toplevel again.
+
What's New in Python 3.0 release candidate 1
============================================
More information about the Python-3000-checkins
mailing list