Commit eaa84ef1 authored by Georg Brandl's avatar Georg Brandl

#5923: update turtle module to version 1.1.

parent 51335296
""" turtle-example-suite:
tdemo_nim.py
Play nim against the computer. The player
who takes the last stick is the winner.
Implements the model-view-controller
design pattern.
"""
import turtle
import random
import time
SCREENWIDTH = 640
SCREENHEIGHT = 480
MINSTICKS = 7
MAXSTICKS = 31
HUNIT = SCREENHEIGHT // 12
WUNIT = SCREENWIDTH // ((MAXSTICKS // 5) * 11 + (MAXSTICKS % 5) * 2)
SCOLOR = (63, 63, 31)
HCOLOR = (255, 204, 204)
COLOR = (204, 204, 255)
def randomrow():
return random.randint(MINSTICKS, MAXSTICKS)
def computerzug(state):
xored = state[0] ^ state[1] ^ state[2]
if xored == 0:
return randommove(state)
for z in range(3):
s = state[z] ^ xored
if s <= state[z]:
move = (z, s)
return move
def randommove(state):
m = max(state)
while True:
z = random.randint(0,2)
if state[z] > (m > 1):
break
rand = random.randint(m > 1, state[z]-1)
return z, rand
class NimModel(object):
def __init__(self, game):
self.game = game
def setup(self):
if self.game.state not in [Nim.CREATED, Nim.OVER]:
return
self.sticks = [randomrow(), randomrow(), randomrow()]
self.player = 0
self.winner = None
self.game.view.setup()
self.game.state = Nim.RUNNING
def move(self, row, col):
maxspalte = self.sticks[row]
self.sticks[row] = col
self.game.view.notify_move(row, col, maxspalte, self.player)
if self.game_over():
self.game.state = Nim.OVER
self.winner = self.player
self.game.view.notify_over()
elif self.player == 0:
self.player = 1
row, col = computerzug(self.sticks)
self.move(row, col)
self.player = 0
def game_over(self):
return self.sticks == [0, 0, 0]
def notify_move(self, row, col):
if self.sticks[row] <= col:
return
self.move(row, col)
class Stick(turtle.Turtle):
def __init__(self, row, col, game):
turtle.Turtle.__init__(self, visible=False)
self.row = row
self.col = col
self.game = game
x, y = self.coords(row, col)
self.shape("square")
self.shapesize(HUNIT/10.0, WUNIT/20.0)
self.speed(0)
self.pu()
self.goto(x,y)
self.color("white")
self.showturtle()
def coords(self, row, col):
packet, remainder = divmod(col, 5)
x = (3 + 11 * packet + 2 * remainder) * WUNIT
y = (2 + 3 * row) * HUNIT
return x - SCREENWIDTH // 2 + WUNIT // 2, SCREENHEIGHT // 2 - y - HUNIT // 2
def makemove(self, x, y):
if self.game.state != Nim.RUNNING:
return
self.game.controller.notify_move(self.row, self.col)
class NimView(object):
def __init__(self, game):
self.game = game
self.screen = game.screen
self.model = game.model
self.screen.colormode(255)
self.screen.tracer(False)
self.screen.bgcolor((240, 240, 255))
self.writer = turtle.Turtle(visible=False)
self.writer.pu()
self.writer.speed(0)
self.sticks = {}
for row in range(3):
for col in range(MAXSTICKS):
self.sticks[(row, col)] = Stick(row, col, game)
self.display("... a moment please ...")
self.screen.tracer(True)
def display(self, msg1, msg2=None):
self.screen.tracer(False)
self.writer.clear()
if msg2 is not None:
self.writer.goto(0, - SCREENHEIGHT // 2 + 48)
self.writer.pencolor("red")
self.writer.write(msg2, align="center", font=("Courier",18,"bold"))
self.writer.goto(0, - SCREENHEIGHT // 2 + 20)
self.writer.pencolor("black")
self.writer.write(msg1, align="center", font=("Courier",14,"bold"))
self.screen.tracer(True)
def setup(self):
self.screen.tracer(False)
for row in range(3):
for col in range(self.model.sticks[row]):
self.sticks[(row, col)].color(SCOLOR)
for row in range(3):
for col in range(self.model.sticks[row], MAXSTICKS):
self.sticks[(row, col)].color("white")
self.display("Your turn! Click leftmost stick to remove.")
self.screen.tracer(True)
def notify_move(self, row, col, maxspalte, player):
if player == 0:
farbe = HCOLOR
for s in range(col, maxspalte):
self.sticks[(row, s)].color(farbe)
else:
self.display(" ... thinking ... ")
time.sleep(0.5)
self.display(" ... thinking ... aaah ...")
farbe = COLOR
for s in range(maxspalte-1, col-1, -1):
time.sleep(0.2)
self.sticks[(row, s)].color(farbe)
self.display("Your turn! Click leftmost stick to remove.")
def notify_over(self):
if self.game.model.winner == 0:
msg2 = "Congrats. You're the winner!!!"
else:
msg2 = "Sorry, the computer is the winner."
self.display("To play again press space bar. To leave press ESC.", msg2)
def clear(self):
if self.game.state == Nim.OVER:
self.screen.clear()
class NimController(object):
def __init__(self, game):
self.game = game
self.sticks = game.view.sticks
self.BUSY = False
for stick in self.sticks.values():
stick.onclick(stick.makemove)
self.game.screen.onkey(self.game.model.setup, "space")
self.game.screen.onkey(self.game.view.clear, "Escape")
self.game.view.display("Press space bar to start game")
self.game.screen.listen()
def notify_move(self, row, col):
if self.BUSY:
return
self.BUSY = True
self.game.model.notify_move(row, col)
self.BUSY = False
class Nim(object):
CREATED = 0
RUNNING = 1
OVER = 2
def __init__(self, screen):
self.state = Nim.CREATED
self.screen = screen
self.model = NimModel(self)
self.view = NimView(self)
self.controller = NimController(self)
mainscreen = turtle.Screen()
mainscreen.mode("standard")
mainscreen.setup(SCREENWIDTH, SCREENHEIGHT)
def main():
nim = Nim(mainscreen)
return "EVENTLOOP!"
if __name__ == "__main__":
main()
turtle.mainloop()
""" turtle-example-suite:
tdemo_round_dance.py
(Needs version 1.1 of the turtle module that
comes with Python 3.1)
Dancing turtles have a compound shape
consisting of a series of triangles of
decreasing size.
Turtles march along a circle while rotating
pairwise in opposite direction, with one
exception. Does that breaking of symmetry
enhance the attractiveness of the example?
Press any key to stop the animation.
Technically: demonstrates use of compound
shapes, transformation of shapes as well as
cloning turtles. The animation is
controlled through update().
"""
from turtle import *
def stop():
global running
running = False
def main():
global running
clearscreen()
bgcolor("gray10")
tracer(False)
shape("triangle")
f = 0.793402
phi = 9.064678
s = 5
c = 1
# create compound shape
sh = Shape("compound")
for i in range(10):
shapesize(s)
p =get_shapepoly()
s *= f
c *= f
tilt(-phi)
sh.addcomponent(p, (c, 0.25, 1-c), "black")
register_shape("multitri", sh)
# create dancers
shapesize(1)
shape("multitri")
pu()
setpos(0, -200)
dancers = []
for i in range(180):
fd(7)
tilt(-4)
lt(2)
update()
if i % 12 == 0:
dancers.append(clone())
home()
# dance
running = True
onkeypress(stop)
listen()
cs = 1
while running:
ta = -4
for dancer in dancers:
dancer.fd(7)
dancer.lt(2)
dancer.tilt(ta)
ta = -4 if ta > 0 else 2
if cs < 180:
right(4)
shapesize(cs)
cs *= 1.005
update()
return "DONE!"
if __name__=='__main__':
print(main())
mainloop()
...@@ -149,9 +149,12 @@ Turtle state ...@@ -149,9 +149,12 @@ Turtle state
| :func:`shape` | :func:`shape`
| :func:`resizemode` | :func:`resizemode`
| :func:`shapesize` | :func:`turtlesize` | :func:`shapesize` | :func:`turtlesize`
| :func:`shearfactor`
| :func:`settiltangle` | :func:`settiltangle`
| :func:`tiltangle` | :func:`tiltangle`
| :func:`tilt` | :func:`tilt`
| :func:`shapetransform`
| :func:`get_shapepoly`
Using events Using events
| :func:`onclick` | :func:`onclick`
...@@ -187,9 +190,11 @@ Animation control ...@@ -187,9 +190,11 @@ Animation control
Using screen events Using screen events
| :func:`listen` | :func:`listen`
| :func:`onkey` | :func:`onkey` | :func:`onkeyrelease`
| :func:`onkeypress`
| :func:`onclick` | :func:`onscreenclick` | :func:`onclick` | :func:`onscreenclick`
| :func:`ontimer` | :func:`ontimer`
| :func:`mainloop`
Settings and special methods Settings and special methods
| :func:`mode` | :func:`mode`
...@@ -201,6 +206,10 @@ Settings and special methods ...@@ -201,6 +206,10 @@ Settings and special methods
| :func:`window_height` | :func:`window_height`
| :func:`window_width` | :func:`window_width`
Input methods
| :func:`textinput`
| :func:`numinput`
Methods specific to Screen Methods specific to Screen
| :func:`bye` | :func:`bye`
| :func:`exitonclick` | :func:`exitonclick`
...@@ -1157,6 +1166,26 @@ Appearance ...@@ -1157,6 +1166,26 @@ Appearance
(5, 5, 8) (5, 5, 8)
.. function:: shearfactor(self, shear=None):
:param shear: number (optional)
Set or return the current shearfactor. Shear the turtleshape according to
the given shearfactor shear, which is the tangent of the shear angle.
Do *not* change the turtle's heading (direction of movement).
If shear is not given: return the current shearfactor, i. e. the
tangent of the shear angle, by which lines parallel to the
heading of the turtle are sheared.
.. doctest::
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()
>>> 0.5
.. function:: tilt(angle) .. function:: tilt(angle)
:param angle: a number :param angle: a number
...@@ -1194,10 +1223,19 @@ Appearance ...@@ -1194,10 +1223,19 @@ Appearance
>>> turtle.fd(50) >>> turtle.fd(50)
.. function:: tiltangle() .. function:: tiltangle(angle=None)
:param angle: a number (optional)
Return the current tilt-angle, i.e. the angle between the orientation of the Set or return the current tilt-angle. If angle is given, rotate the
turtleshape and the heading of the turtle (its direction of movement). 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).
If angle is not given: return the current tilt-angle, i. e. the angle
between the orientation of the turtleshape and the heading of the
turtle (its direction of movement).
Deprecated since Python 3.1
.. doctest:: .. doctest::
...@@ -1209,6 +1247,46 @@ Appearance ...@@ -1209,6 +1247,46 @@ Appearance
45.0 45.0
.. function:: shapetransform(t11=None, t12=None, t21=None, t22=None)
:param t11: a number (optional)
:param t12: a number (optional)
:param t21: a number (optional)
:param t12: a number (optional)
Set or return the current transformation matrix of the turtle shape.
If none of the matrix elements are given, return the transformation
matrix as a tuple of 4 elements.
Otherwise set the given elements and transform the turtleshape
according to the matrix consisting of first row t11, t12 and
second row t21, 22. The determinant t11 * t22 - t12 * t21 must not be
zero, otherwise an error is raised.
Modify stretchfactor, shearfactor and tiltangle according to the
given matrix.
.. doctest::
>>> turtle.shape("square")
>>> turtle.shapesize(4,2)
>>> turtle.shearfactor(-0.5)
>>> turtle.shapetransform()
>>> (4.0, -1.0, -0.0, 2.0)
.. function:: get_shapepoly():
Return the current shape polygon as tuple of coordinate pairs. This
can be used to define a new shape or components of a compound shape.
.. doctest::
>>> turtle.shape("square")
>>> turtle.shapetransform(4, -1, 0, 2)
>>> turtle.get_shapepoly()
((50, -20), (30, 20), (-50, 20), (-30, -20))
Using events Using events
------------ ------------
...@@ -1595,6 +1673,7 @@ Using screen events ...@@ -1595,6 +1673,7 @@ Using screen events
.. function:: onkey(fun, key) .. function:: onkey(fun, key)
onkeyrelease(fun, key)
:param fun: a function with no arguments or ``None`` :param fun: a function with no arguments or ``None``
:param key: a string: key (e.g. "a") or key-symbol (e.g. "space") :param key: a string: key (e.g. "a") or key-symbol (e.g. "space")
...@@ -1613,6 +1692,25 @@ Using screen events ...@@ -1613,6 +1692,25 @@ Using screen events
>>> screen.listen() >>> screen.listen()
.. function:: onkeypress(fun, key=None):
:param fun: a function with no arguments or ``None``
:param key: a string: key (e.g. "a") or key-symbol (e.g. "space")
Bind *fun* to key-press event of key if key is given,
or to any key-press-event if no key is given.
Remark: in order to be able to register key-events, TurtleScreen
must have focus. (See method :func:`listen`.)
.. doctest::
>>> def f():
... fd(50)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
.. function:: onclick(fun, btn=1, add=None) .. function:: onclick(fun, btn=1, add=None)
onscreenclick(fun, btn=1, add=None) onscreenclick(fun, btn=1, add=None)
...@@ -1659,6 +1757,53 @@ Using screen events ...@@ -1659,6 +1757,53 @@ Using screen events
>>> running = False >>> running = False
.. function:: mainloop()
Starts event loop - calling Tkinter's mainloop function.
Must be the last statement in a turtle graphics program.
Must *not* be used if a script is run from within IDLE in -n mode
(No subprocess) - for interactive use of turtle graphics. ::
>>> screen.mainloop()
Input methods
-------------
.. function:: textinput(title, prompt)
:param title: string
:param prompt: string
Pop up a dialog window for input of a string. Parameter title is
the title of the dialog window, propmt is a text mostly describing
what information to input.
Return the string input. If the dialog is canceled, return None. ::
>>> screen.textinput("NIM", "Name of first player:")
.. function:: numinput(self, title, prompt,
default=None, minval=None, maxval=None):
:param title: string
:param prompt: string
:param default: number (optional)
:param prompt: number (optional)
:param prompt: number (optional)
Pop up a dialog window for input of a number. title is the title of the
dialog window, prompt is a text mostly describing what numerical information
to input. default: default value, minval: minimum value for imput,
maxval: maximum value for input
The number input must be in the range minval .. maxval if these are
given. If not, a hint is issued and the dialog remains open for
correction.
Return the number input. If the dialog is canceled, return None. ::
>>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000)
Settings and special methods Settings and special methods
---------------------------- ----------------------------
...@@ -2159,6 +2304,10 @@ The demoscripts are: ...@@ -2159,6 +2304,10 @@ The demoscripts are:
| | | as Hanoi discs | | | | as Hanoi discs |
| | | (shape, shapesize) | | | | (shape, shapesize) |
+----------------+------------------------------+-----------------------+ +----------------+------------------------------+-----------------------+
| nim | play the classical nim game | turtles as nimsticks, |
| | with three heaps of sticks | event driven (mouse, |
| | against the computer. | keyboard) |
+----------------+------------------------------+-----------------------+
| paint | super minimalistic | :func:`onclick` | | paint | super minimalistic | :func:`onclick` |
| | drawing program | | | | drawing program | |
+----------------+------------------------------+-----------------------+ +----------------+------------------------------+-----------------------+
...@@ -2171,6 +2320,10 @@ The demoscripts are: ...@@ -2171,6 +2320,10 @@ The demoscripts are:
| planet_and_moon| simulation of | compound shapes, | | planet_and_moon| simulation of | compound shapes, |
| | gravitational system | :class:`Vec2D` | | | gravitational system | :class:`Vec2D` |
+----------------+------------------------------+-----------------------+ +----------------+------------------------------+-----------------------+
| round_dance | dancing turtles rotating | compound shapes, clone|
| | pairwise in opposite | shapesize, tilt, |
| | direction | get_polyshape, update |
+----------------+------------------------------+-----------------------+
| tree | a (graphical) breadth | :func:`clone` | | tree | a (graphical) breadth | :func:`clone` |
| | first tree (using generators)| | | | first tree (using generators)| |
+----------------+------------------------------+-----------------------+ +----------------+------------------------------+-----------------------+
...@@ -2204,6 +2357,32 @@ Changes since Python 2.6 ...@@ -2204,6 +2357,32 @@ Changes since Python 2.6
This behaviour corresponds to a ``fill()`` call without arguments in This behaviour corresponds to a ``fill()`` call without arguments in
Python 2.6. Python 2.6.
Changes since Python 3.0
========================
- The methods :meth:`Turtle.shearfactor`, :meth:`Turtle.shapetransform` and
:meth:`Turtle.get_shapepoly` have been added. Thus the full range of
regular linear transforms is now available for transforming turtle shapes.
:meth:`Turtle.tiltangle` has been enhanced in functionality: it now can
be used to get or set the tiltangle. :meth:`Turtle.settiltangle` has been
deprecated.
- The method :meth:`Screen.onkeypress` has been added as a complement to
:meth:`Screen.onkey` which in fact binds actions to the keyrelease event.
Accordingly the latter has got an alias: :meth:`Screen.onkeyrelease`.
- The method :meth:`Screen.mainloop` has been added. So when working only
with Screen and Turtle objects one must not additonally import
:func:`mainloop` anymore.
- Two input methods has been added :meth:`Screen.textinput` and
:meth:`Screen.numinput`. These popup input dialogs and return
strings and numbers respectively.
- Two example scripts :file:`tdemo_nim.py` and :file:`tdemo_round_dance.py`
have been added to the Demo directory (source distribution only). As usual
they can be viewed and executed within the demo viewer :file:`turtleDemo.py`.
.. doctest:: .. doctest::
:hide: :hide:
......
# #
# turtle.py: a Tkinter based turtle graphics module for Python # turtle.py: a Tkinter based turtle graphics module for Python
# Version 1.0b1 - 31. 5. 2008 # Version 1.1b - 4. 5. 2009
# #
# Copyright (C) 2006 - 2008 Gregor Lingl # Copyright (C) 2006 - 2009 Gregor Lingl
# email: glingl@aon.at # email: glingl@aon.at
# #
# This software is provided 'as-is', without any express or implied # This software is provided 'as-is', without any express or implied
...@@ -100,7 +100,7 @@ extensions in in mind. These will be commented and documented elsewhere. ...@@ -100,7 +100,7 @@ extensions in in mind. These will be commented and documented elsewhere.
""" """
_ver = "turtle 1.0b1- - for Python 3.0 - 9. 6. 2008, 01:15" _ver = "turtle 1.1b- - for Python 3.1 - 4. 5. 2009"
# print(_ver) # print(_ver)
...@@ -112,36 +112,31 @@ import os ...@@ -112,36 +112,31 @@ import os
from os.path import isfile, split, join from os.path import isfile, split, join
from copy import deepcopy from copy import deepcopy
from tkinter import simpledialog
#from math import * ## for compatibility with old turtle module
_tg_classes = ['ScrolledCanvas', 'TurtleScreen', 'Screen', _tg_classes = ['ScrolledCanvas', 'TurtleScreen', 'Screen',
'RawTurtle', 'Turtle', 'RawPen', 'Pen', 'Shape', 'Vec2D'] 'RawTurtle', 'Turtle', 'RawPen', 'Pen', 'Shape', 'Vec2D']
_tg_screen_functions = ['addshape', 'bgcolor', 'bgpic', 'bye', _tg_screen_functions = ['addshape', 'bgcolor', 'bgpic', 'bye',
'clearscreen', 'colormode', 'delay', 'exitonclick', 'getcanvas', 'clearscreen', 'colormode', 'delay', 'exitonclick', 'getcanvas',
'getshapes', 'listen', 'mode', 'onkey', 'onscreenclick', 'ontimer', 'getshapes', 'listen', 'mainloop', 'mode', 'numinput',
'onkey', 'onkeypress', 'onkeyrelease', 'onscreenclick', 'ontimer',
'register_shape', 'resetscreen', 'screensize', 'setup', 'register_shape', 'resetscreen', 'screensize', 'setup',
'setworldcoordinates', 'title', 'tracer', 'turtles', 'update', 'setworldcoordinates', 'textinput', 'title', 'tracer', 'turtles', 'update',
'window_height', 'window_width'] 'window_height', 'window_width']
_tg_turtle_functions = ['back', 'backward', 'begin_fill', 'begin_poly', 'bk', _tg_turtle_functions = ['back', 'backward', 'begin_fill', 'begin_poly', 'bk',
'circle', 'clear', 'clearstamp', 'clearstamps', 'clone', 'color', 'circle', 'clear', 'clearstamp', 'clearstamps', 'clone', 'color',
'degrees', 'distance', 'dot', 'down', 'end_fill', 'end_poly', 'fd', 'degrees', 'distance', 'dot', 'down', 'end_fill', 'end_poly', 'fd',
#'fill', 'fillcolor', 'forward', 'get_poly', 'getpen', 'getscreen', 'get_shapepoly',
'fillcolor', 'forward', 'get_poly', 'getpen', 'getscreen',
'getturtle', 'goto', 'heading', 'hideturtle', 'home', 'ht', 'isdown', 'getturtle', 'goto', 'heading', 'hideturtle', 'home', 'ht', 'isdown',
'isvisible', 'left', 'lt', 'onclick', 'ondrag', 'onrelease', 'pd', 'isvisible', 'left', 'lt', 'onclick', 'ondrag', 'onrelease', 'pd',
'pen', 'pencolor', 'pendown', 'pensize', 'penup', 'pos', 'position', 'pen', 'pencolor', 'pendown', 'pensize', 'penup', 'pos', 'position',
'pu', 'radians', 'right', 'reset', 'resizemode', 'rt', 'pu', 'radians', 'right', 'reset', 'resizemode', 'rt',
'seth', 'setheading', 'setpos', 'setposition', 'settiltangle', 'seth', 'setheading', 'setpos', 'setposition', 'settiltangle',
'setundobuffer', 'setx', 'sety', 'shape', 'shapesize', 'showturtle', 'setundobuffer', 'setx', 'sety', 'shape', 'shapesize', 'shapetransform', 'shearfactor', 'showturtle',
'speed', 'st', 'stamp', 'tilt', 'tiltangle', 'towards', #'tracer', 'speed', 'st', 'stamp', 'tilt', 'tiltangle', 'towards',
'turtlesize', 'undo', 'undobufferentries', 'up', 'width', 'turtlesize', 'undo', 'undobufferentries', 'up', 'width',
#'window_height', 'window_width',
'write', 'xcor', 'ycor'] 'write', 'xcor', 'ycor']
_tg_utilities = ['write_docstringdict', 'done', 'mainloop'] _tg_utilities = ['write_docstringdict', 'done']
##_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 + __all__ = (_tg_classes + _tg_screen_functions + _tg_turtle_functions +
_tg_utilities) # + _math_functions) _tg_utilities) # + _math_functions)
...@@ -172,16 +167,6 @@ _CFG = {"width" : 0.5, # Screen ...@@ -172,16 +167,6 @@ _CFG = {"width" : 0.5, # Screen
"using_IDLE": False "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): def config_dict(filename):
"""Convert content of config-file into dictionary.""" """Convert content of config-file into dictionary."""
f = open(filename, "r") f = open(filename, "r")
...@@ -230,7 +215,6 @@ def readconfig(cfgdict): ...@@ -230,7 +215,6 @@ def readconfig(cfgdict):
cfgdict2 = {} cfgdict2 = {}
if isfile(default_cfg): if isfile(default_cfg):
cfgdict1 = config_dict(default_cfg) cfgdict1 = config_dict(default_cfg)
#print "1. Loading config-file %s from: %s" % (default_cfg, os.getcwd())
if "importconfig" in cfgdict1: if "importconfig" in cfgdict1:
default_cfg = "turtle_%s.cfg" % cfgdict1["importconfig"] default_cfg = "turtle_%s.cfg" % cfgdict1["importconfig"]
try: try:
...@@ -239,15 +223,9 @@ def readconfig(cfgdict): ...@@ -239,15 +223,9 @@ def readconfig(cfgdict):
except: except:
cfg_file2 = "" cfg_file2 = ""
if isfile(cfg_file2): if isfile(cfg_file2):
#print "2. Loading config-file %s:" % cfg_file2
cfgdict2 = config_dict(cfg_file2) cfgdict2 = config_dict(cfg_file2)
## show(_CFG)
## show(cfgdict2)
_CFG.update(cfgdict2) _CFG.update(cfgdict2)
## show(_CFG)
## show(cfgdict1)
_CFG.update(cfgdict1) _CFG.update(cfgdict1)
## show(_CFG)
try: try:
readconfig(_CFG) readconfig(_CFG)
...@@ -697,7 +675,7 @@ class TurtleScreenBase(object): ...@@ -697,7 +675,7 @@ class TurtleScreenBase(object):
fun(x, y) fun(x, y)
self.cv.bind("<Button-%s>" % num, eventfun, add) self.cv.bind("<Button-%s>" % num, eventfun, add)
def _onkey(self, fun, key): def _onkeyrelease(self, fun, key):
"""Bind fun to key-release event of key. """Bind fun to key-release event of key.
Canvas must have focus. See method listen Canvas must have focus. See method listen
""" """
...@@ -708,6 +686,24 @@ class TurtleScreenBase(object): ...@@ -708,6 +686,24 @@ class TurtleScreenBase(object):
fun() fun()
self.cv.bind("<KeyRelease-%s>" % key, eventfun) self.cv.bind("<KeyRelease-%s>" % key, eventfun)
def _onkeypress(self, fun, key=None):
"""If key is given, bind fun to key-press event of key.
Otherwise bind fun to any key-press.
Canvas must have focus. See method listen.
"""
if fun is None:
if key is None:
self.cv.unbind("<KeyPress>", None)
else:
self.cv.unbind("<KeyPress-%s>" % key, None)
else:
def eventfun(event):
fun()
if key is None:
self.cv.bind("<KeyPress>", eventfun)
else:
self.cv.bind("<KeyPress-%s>" % key, eventfun)
def _listen(self): def _listen(self):
"""Set focus on canvas (in order to collect key-events) """Set focus on canvas (in order to collect key-events)
""" """
...@@ -801,6 +797,57 @@ class TurtleScreenBase(object): ...@@ -801,6 +797,57 @@ class TurtleScreenBase(object):
height = self.cv['height'] height = self.cv['height']
return width, height return width, height
def mainloop(self):
"""Starts event loop - calling Tkinter's mainloop function.
No argument.
Must be last statement in a turtle graphics program.
Must NOT be used if a script is run from within IDLE in -n mode
(No subprocess) - for interactive use of turtle graphics.
Example (for a TurtleScreen instance named screen):
>>> screen.mainloop()
"""
TK.mainloop()
def textinput(self, title, prompt):
"""Pop up a dialog window for input of a string.
Arguments: title is the title of the dialog window,
prompt is a text mostly describing what information to input.
Return the string input
If the dialog is canceled, return None.
Example (for a TurtleScreen instance named screen):
>>> screen.textinput("NIM", "Name of first player:")
"""
return simpledialog.askstring(title, prompt)
def numinput(self, title, prompt, default=None, minval=None, maxval=None):
"""Pop up a dialog window for input of a number.
Arguments: title is the title of the dialog window,
prompt is a text mostly describing what numerical information to input.
default: default value
minval: minimum value for imput
maxval: maximum value for input
The number input must be in the range minval .. maxval if these are
given. If not, a hint is issued and the dialog remains open for
correction. Return the number input.
If the dialog is canceled, return None.
Example (for a TurtleScreen instance named screen):
>>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000)
"""
return simpledialog.askfloat(title, prompt, initialvalue=default,
minvalue=minval, maxvalue=maxval)
############################################################################## ##############################################################################
### End of Tkinter - interface ### ### End of Tkinter - interface ###
...@@ -913,7 +960,6 @@ class TurtleScreen(TurtleScreenBase): ...@@ -913,7 +960,6 @@ class TurtleScreen(TurtleScreenBase):
upon components of the underlying graphics toolkit - upon components of the underlying graphics toolkit -
which is Tkinter in this case. which is Tkinter in this case.
""" """
# _STANDARD_DELAY = 5
_RUNNING = True _RUNNING = True
def __init__(self, cv, mode=_CFG["mode"], def __init__(self, cv, mode=_CFG["mode"],
...@@ -951,11 +997,11 @@ class TurtleScreen(TurtleScreenBase): ...@@ -951,11 +997,11 @@ class TurtleScreen(TurtleScreenBase):
def clear(self): def clear(self):
"""Delete all drawings and all turtles from the TurtleScreen. """Delete all drawings and all turtles from the TurtleScreen.
No argument.
Reset empty TurtleScreen to its initial state: white background, Reset empty TurtleScreen to its initial state: white background,
no backgroundimage, no eventbindings and tracing on. no backgroundimage, no eventbindings and tracing on.
No argument.
Example (for a TurtleScreen instance named screen): Example (for a TurtleScreen instance named screen):
screen.clear() screen.clear()
...@@ -972,8 +1018,10 @@ class TurtleScreen(TurtleScreenBase): ...@@ -972,8 +1018,10 @@ class TurtleScreen(TurtleScreenBase):
self.bgcolor("white") self.bgcolor("white")
for btn in 1, 2, 3: for btn in 1, 2, 3:
self.onclick(None, btn) self.onclick(None, btn)
self.onkeypress(None)
for key in self._keys[:]: for key in self._keys[:]:
self.onkey(None, key) self.onkey(None, key)
self.onkeypress(None, key)
Turtle._pen = None Turtle._pen = None
def mode(self, mode=None): def mode(self, mode=None):
...@@ -1083,7 +1131,6 @@ class TurtleScreen(TurtleScreenBase): ...@@ -1083,7 +1131,6 @@ class TurtleScreen(TurtleScreenBase):
shape = Shape("polygon", shape) shape = Shape("polygon", shape)
## else shape assumed to be Shape-instance ## else shape assumed to be Shape-instance
self._shapes[name] = shape self._shapes[name] = shape
# print "shape added:" , self._shapes
def _colorstr(self, color): def _colorstr(self, color):
"""Return color string corresponding to args. """Return color string corresponding to args.
...@@ -1243,9 +1290,12 @@ class TurtleScreen(TurtleScreenBase): ...@@ -1243,9 +1290,12 @@ class TurtleScreen(TurtleScreenBase):
def update(self): def update(self):
"""Perform a TurtleScreen update. """Perform a TurtleScreen update.
""" """
tracing = self._tracing
self._tracing = True
for t in self.turtles(): for t in self.turtles():
t._update_data() t._update_data()
t._drawturtle() t._drawturtle()
self._tracing = tracing
self._update() self._update()
def window_width(self): def window_width(self):
...@@ -1336,10 +1386,44 @@ class TurtleScreen(TurtleScreenBase): ...@@ -1336,10 +1386,44 @@ class TurtleScreen(TurtleScreenBase):
### consequently drawing a hexagon ### consequently drawing a hexagon
""" """
if fun == None: if fun == None:
if key in self._keys:
self._keys.remove(key) self._keys.remove(key)
elif key not in self._keys: elif key not in self._keys:
self._keys.append(key) self._keys.append(key)
self._onkey(fun, key) self._onkeyrelease(fun, key)
def onkeypress(self, fun, key=None):
"""Bind fun to key-press event of key if key is given,
or to any key-press-event if no key is given.
Arguments:
fun -- a function with no arguments
key -- a string: key (e.g. "a") or key-symbol (e.g. "space")
In order to 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)
>>> screen.onkey(f, "Up")
>>> screen.listen()
### Subsequently the turtle can be moved by
### repeatedly pressing the up-arrow key,
### or by keeping pressed the up-arrow key.
### consequently drawing a hexagon.
"""
if fun == None:
if key in self._keys:
self._keys.remove(key)
elif key is not None and key not in self._keys:
self._keys.append(key)
self._onkeypress(fun, key)
def listen(self, xdummy=None, ydummy=None): def listen(self, xdummy=None, ydummy=None):
"""Set focus on TurtleScreen (in order to collect key-events) """Set focus on TurtleScreen (in order to collect key-events)
...@@ -1421,6 +1505,7 @@ class TurtleScreen(TurtleScreenBase): ...@@ -1421,6 +1505,7 @@ class TurtleScreen(TurtleScreenBase):
resetscreen = reset resetscreen = reset
clearscreen = clear clearscreen = clear
addshape = register_shape addshape = register_shape
onkeyrelease = onkey
class TNavigator(object): class TNavigator(object):
"""Navigation part of the RawTurtle. """Navigation part of the RawTurtle.
...@@ -1947,10 +2032,11 @@ class TPen(object): ...@@ -1947,10 +2032,11 @@ class TPen(object):
self._fillcolor = fillcolor self._fillcolor = fillcolor
self._drawing = True self._drawing = True
self._speed = 3 self._speed = 3
self._stretchfactor = (1, 1) self._stretchfactor = (1., 1.)
self._tilt = 0 self._shearfactor = 0.
self._tilt = 0.
self._shapetrafo = (1., 0., 0., 1.)
self._outlinewidth = 1 self._outlinewidth = 1
### self.screen = None # to override by child class
def resizemode(self, rmode=None): def resizemode(self, rmode=None):
"""Set resizemode to one of the values: "auto", "user", "noresize". """Set resizemode to one of the values: "auto", "user", "noresize".
...@@ -2262,6 +2348,7 @@ class TPen(object): ...@@ -2262,6 +2348,7 @@ class TPen(object):
"speed" : number in range 0..10 "speed" : number in range 0..10
"resizemode" : "auto" or "user" or "noresize" "resizemode" : "auto" or "user" or "noresize"
"stretchfactor": (positive number, positive number) "stretchfactor": (positive number, positive number)
"shearfactor": number
"outline" : positive number "outline" : positive number
"tilt" : number "tilt" : number
...@@ -2276,19 +2363,19 @@ class TPen(object): ...@@ -2276,19 +2363,19 @@ class TPen(object):
>>> turtle.pen() >>> turtle.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1, {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'red', 'pendown': True, 'fillcolor': 'black', 'pencolor': 'red', 'pendown': True, 'fillcolor': 'black',
'stretchfactor': (1,1), 'speed': 3} 'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}
>>> penstate=turtle.pen() >>> penstate=turtle.pen()
>>> turtle.color("yellow","") >>> turtle.color("yellow","")
>>> turtle.penup() >>> turtle.penup()
>>> turtle.pen() >>> turtle.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1, {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'yellow', 'pendown': False, 'fillcolor': '', 'pencolor': 'yellow', 'pendown': False, 'fillcolor': '',
'stretchfactor': (1,1), 'speed': 3} 'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}
>>> p.pen(penstate, fillcolor="green") >>> p.pen(penstate, fillcolor="green")
>>> p.pen() >>> p.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1, {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'pencolor': 'red', 'pendown': True, 'fillcolor': 'green', 'pencolor': 'red', 'pendown': True, 'fillcolor': 'green',
'stretchfactor': (1,1), 'speed': 3} 'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}
""" """
_pd = {"shown" : self._shown, _pd = {"shown" : self._shown,
"pendown" : self._drawing, "pendown" : self._drawing,
...@@ -2298,6 +2385,7 @@ class TPen(object): ...@@ -2298,6 +2385,7 @@ class TPen(object):
"speed" : self._speed, "speed" : self._speed,
"resizemode" : self._resizemode, "resizemode" : self._resizemode,
"stretchfactor" : self._stretchfactor, "stretchfactor" : self._stretchfactor,
"shearfactor" : self._shearfactor,
"outline" : self._outlinewidth, "outline" : self._outlinewidth,
"tilt" : self._tilt "tilt" : self._tilt
} }
...@@ -2351,12 +2439,20 @@ class TPen(object): ...@@ -2351,12 +2439,20 @@ class TPen(object):
if isinstance(sf, (int, float)): if isinstance(sf, (int, float)):
sf = (sf, sf) sf = (sf, sf)
self._stretchfactor = sf self._stretchfactor = sf
if "shearfactor" in p:
self._shearfactor = p["shearfactor"]
if "outline" in p: if "outline" in p:
self._outlinewidth = p["outline"] self._outlinewidth = p["outline"]
if "shown" in p: if "shown" in p:
self._shown = p["shown"] self._shown = p["shown"]
if "tilt" in p: if "tilt" in p:
self._tilt = p["tilt"] self._tilt = p["tilt"]
if "stretchfactor" in p or "tilt" in p or "shearfactor" in p:
scx, scy = self._stretchfactor
shf = self._shearfactor
sa, ca = math.sin(self._tilt), math.cos(self._tilt)
self._shapetrafo = ( scx*ca, scy*(shf*ca + sa),
-scx*sa, scy*(ca - shf*sa))
self._update() self._update()
## three dummy methods to be implemented by child class: ## three dummy methods to be implemented by child class:
...@@ -2389,7 +2485,7 @@ class _TurtleImage(object): ...@@ -2389,7 +2485,7 @@ class _TurtleImage(object):
self._setshape(shapeIndex) self._setshape(shapeIndex)
def _setshape(self, shapeIndex): def _setshape(self, shapeIndex):
screen = self.screen # RawTurtle.screens[self.screenIndex] screen = self.screen
self.shapeIndex = shapeIndex self.shapeIndex = shapeIndex
if self._type == "polygon" == screen._shapes[shapeIndex]._type: if self._type == "polygon" == screen._shapes[shapeIndex]._type:
return return
...@@ -2699,9 +2795,11 @@ class RawTurtle(TPen, TNavigator): ...@@ -2699,9 +2795,11 @@ class RawTurtle(TPen, TNavigator):
>>> turtle.shapesize(5, 5, 12) >>> turtle.shapesize(5, 5, 12)
>>> turtle.shapesize(outline=8) >>> turtle.shapesize(outline=8)
""" """
if stretch_wid is None and stretch_len is None and outline == None: if stretch_wid is stretch_len is outline == None:
stretch_wid, stretch_len = self._stretchfactor stretch_wid, stretch_len = self._stretchfactor
return stretch_wid, stretch_len, self._outlinewidth return stretch_wid, stretch_len, self._outlinewidth
if stretch_wid == 0 or stretch_len == 0:
raise TurtleGraphicsError("stretch_wid/stretch_len must not be zero")
if stretch_wid is not None: if stretch_wid is not None:
if stretch_len is None: if stretch_len is None:
stretchfactor = stretch_wid, stretch_wid stretchfactor = stretch_wid, stretch_wid
...@@ -2716,11 +2814,33 @@ class RawTurtle(TPen, TNavigator): ...@@ -2716,11 +2814,33 @@ class RawTurtle(TPen, TNavigator):
self.pen(resizemode="user", self.pen(resizemode="user",
stretchfactor=stretchfactor, outline=outline) stretchfactor=stretchfactor, outline=outline)
def shearfactor(self, shear=None):
"""Set or return the current shearfactor.
Optional argument: shear -- number, tangent of the shear angle
Shear the turtleshape according to the given shearfactor shear,
which is the tangent of the shear angle. DO NOT change the
turtle's heading (direction of movement).
If shear is not given: return the current shearfactor, i. e. the
tangent of the shear angle, by which lines parallel to the
heading of the turtle are sheared.
Examples (for a Turtle instance named turtle):
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()
>>> 0.5
"""
if shear is None:
return self._shearfactor
self.pen(resizemode="user", shearfactor=shear)
def settiltangle(self, angle): def settiltangle(self, angle):
"""Rotate the turtleshape to point in the specified direction """Rotate the turtleshape to point in the specified direction
Optional argument: Argument: angle -- number
angle -- number
Rotate the turtleshape to point in the direction specified by angle, Rotate the turtleshape to point in the direction specified by angle,
regardless of its current tilt-angle. DO NOT change the turtle's regardless of its current tilt-angle. DO NOT change the turtle's
...@@ -2741,14 +2861,19 @@ class RawTurtle(TPen, TNavigator): ...@@ -2741,14 +2861,19 @@ class RawTurtle(TPen, TNavigator):
tilt = (tilt * math.pi / 180.0) % (2*math.pi) tilt = (tilt * math.pi / 180.0) % (2*math.pi)
self.pen(resizemode="user", tilt=tilt) self.pen(resizemode="user", tilt=tilt)
def tiltangle(self): def tiltangle(self, angle=None):
"""Return the current tilt-angle. """Set or return the current tilt-angle.
No argument. 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).
If angle is not given: return the current tilt-angle, i. e. the angle
between the orientation of the turtleshape and the heading of the
turtle (its direction of movement).
Return the current tilt-angle, i. e. the angle between the Deprecated since Python 3.1
orientation of the turtleshape and the heading of the turtle
(its direction of movement).
Examples (for a Turtle instance named turtle): Examples (for a Turtle instance named turtle):
>>> turtle.shape("circle") >>> turtle.shape("circle")
...@@ -2757,8 +2882,11 @@ class RawTurtle(TPen, TNavigator): ...@@ -2757,8 +2882,11 @@ class RawTurtle(TPen, TNavigator):
>>> turtle.tiltangle() >>> turtle.tiltangle()
>>> >>>
""" """
if angle is None:
tilt = -self._tilt * (180.0/math.pi) * self._angleOrient tilt = -self._tilt * (180.0/math.pi) * self._angleOrient
return (tilt / self._degreesPerAU) % self._fullcircle return (tilt / self._degreesPerAU) % self._fullcircle
else:
self.settiltangle(angle)
def tilt(self, angle): def tilt(self, angle):
"""Rotate the turtleshape by angle. """Rotate the turtleshape by angle.
...@@ -2779,6 +2907,46 @@ class RawTurtle(TPen, TNavigator): ...@@ -2779,6 +2907,46 @@ class RawTurtle(TPen, TNavigator):
""" """
self.settiltangle(angle + self.tiltangle()) self.settiltangle(angle + self.tiltangle())
def shapetransform(self, t11=None, t12=None, t21=None, t22=None):
"""Set or return the current transformation matrix of the turtle shape.
Optional arguments: t11, t12, t21, t22 -- numbers.
If none of the matrix elements are given, return the transformation
matrix.
Otherwise set the given elements and transform the turtleshape
according to the matrix consisting of first row t11, t12 and
second row t21, 22.
Modify stretchfactor, shearfactor and tiltangle according to the
given matrix.
Examples (for a Turtle instance named turtle):
>>> turtle.shape("square")
>>> turtle.shapesize(4,2)
>>> turtle.shearfactor(-0.5)
>>> turtle.shapetransform()
>>> (4.0, -1.0, -0.0, 2.0)
"""
if t11 is t12 is t21 is t22 is None:
return self._shapetrafo
m11, m12, m21, m22 = self._shapetrafo
if t11 is not None: m11 = t11
if t12 is not None: m12 = t12
if t21 is not None: m21 = t21
if t22 is not None: m22 = t22
if t11 * t22 - t12 * t21 == 0:
raise TurtleGraphicsError("Bad shape transform matrix: must not be singular")
self._shapetrafo = (m11, m12, m21, m22)
alfa = math.atan2(-m21, m11) % (2 * math.pi)
sa, ca = math.sin(alfa), math.cos(alfa)
a11, a12, a21, a22 = (ca*m11 - sa*m21, ca*m12 - sa*m22,
sa*m11 + ca*m21, sa*m12 + ca*m22)
self._stretchfactor = a11, a22
self._shearfactor = a12/a22
self._tilt = alfa
self._update()
def _polytrafo(self, poly): def _polytrafo(self, poly):
"""Computes transformed polygon shapes from a shape """Computes transformed polygon shapes from a shape
according to current position and heading. according to current position and heading.
...@@ -2791,6 +2959,36 @@ class RawTurtle(TPen, TNavigator): ...@@ -2791,6 +2959,36 @@ class RawTurtle(TPen, TNavigator):
return [(p0+(e1*x+e0*y)/screen.xscale, p1+(-e0*x+e1*y)/screen.yscale) return [(p0+(e1*x+e0*y)/screen.xscale, p1+(-e0*x+e1*y)/screen.yscale)
for (x, y) in poly] for (x, y) in poly]
def get_shapepoly(self):
"""Return the current shape polygon as tuple of coordinate pairs.
No argument.
Examples (for a Turtle instance named turtle):
>>> turtle.shape("square")
>>> turtle.shapetransform(4, -1, 0, 2)
>>> turtle.get_shapepoly()
((50, -20), (30, 20), (-50, 20), (-30, -20))
"""
shape = self.screen._shapes[self.turtle.shapeIndex]
if shape._type == "polygon":
return self._getshapepoly(shape._data, shape._type == "compound")
# else return None
def _getshapepoly(self, polygon, compound=False):
"""Calculate transformed shape polygon according to resizemode
and shapetransform.
"""
if self._resizemode == "user" or compound:
t11, t12, t21, t22 = self._shapetrafo
elif self._resizemode == "auto":
l = max(1, self._pensize/5.0)
t11, t12, t21, t22 = l, 0, 0, l
elif self._resizemode == "noresize":
return polygon
return tuple([(t11*x + t12*y, t21*x + t22*y) for (x, y) in polygon])
def _drawturtle(self): def _drawturtle(self):
"""Manages the correct rendering of the turtle with respect to """Manages the correct rendering of the turtle with respect to
its shape, resizemode, stretch and tilt etc.""" its shape, resizemode, stretch and tilt etc."""
...@@ -2802,35 +3000,20 @@ class RawTurtle(TPen, TNavigator): ...@@ -2802,35 +3000,20 @@ class RawTurtle(TPen, TNavigator):
self._hidden_from_screen = False self._hidden_from_screen = False
tshape = shape._data tshape = shape._data
if ttype == "polygon": if ttype == "polygon":
if self._resizemode == "noresize": if self._resizemode == "noresize": w = 1
w = 1 elif self._resizemode == "auto": w = self._pensize
shape = tshape else: w =self._outlinewidth
else: shape = self._polytrafo(self._getshapepoly(tshape))
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 fc, oc = self._fillcolor, self._pencolor
screen._drawpoly(titem, shape, fill=fc, outline=oc, screen._drawpoly(titem, shape, fill=fc, outline=oc,
width=w, top=True) width=w, top=True)
elif ttype == "image": elif ttype == "image":
screen._drawimage(titem, self._position, tshape) screen._drawimage(titem, self._position, tshape)
elif ttype == "compound": elif ttype == "compound":
lx, ly = self._stretchfactor
w = self._outlinewidth
for item, (poly, fc, oc) in zip(titem, tshape): for item, (poly, fc, oc) in zip(titem, tshape):
poly = [(lx*x, ly*y) for (x, y) in poly] poly = self._polytrafo(self._getshapepoly(poly, True))
poly = self._polytrafo(poly)
screen._drawpoly(item, poly, fill=self._cc(fc), screen._drawpoly(item, poly, fill=self._cc(fc),
outline=self._cc(oc), width=w, top=True) outline=self._cc(oc), width=self._outlinewidth, top=True)
else: else:
if self._hidden_from_screen: if self._hidden_from_screen:
return return
...@@ -2867,22 +3050,10 @@ class RawTurtle(TPen, TNavigator): ...@@ -2867,22 +3050,10 @@ class RawTurtle(TPen, TNavigator):
tshape = shape._data tshape = shape._data
if ttype == "polygon": if ttype == "polygon":
stitem = screen._createpoly() stitem = screen._createpoly()
if self._resizemode == "noresize": if self._resizemode == "noresize": w = 1
w = 1 elif self._resizemode == "auto": w = self._pensize
shape = tshape else: w =self._outlinewidth
else: shape = self._polytrafo(self._getshapepoly(tshape))
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 fc, oc = self._fillcolor, self._pencolor
screen._drawpoly(stitem, shape, fill=fc, outline=oc, screen._drawpoly(stitem, shape, fill=fc, outline=oc,
width=w, top=True) width=w, top=True)
...@@ -2895,13 +3066,10 @@ class RawTurtle(TPen, TNavigator): ...@@ -2895,13 +3066,10 @@ class RawTurtle(TPen, TNavigator):
item = screen._createpoly() item = screen._createpoly()
stitem.append(item) stitem.append(item)
stitem = tuple(stitem) stitem = tuple(stitem)
lx, ly = self._stretchfactor
w = self._outlinewidth
for item, (poly, fc, oc) in zip(stitem, tshape): for item, (poly, fc, oc) in zip(stitem, tshape):
poly = [(lx*x, ly*y) for (x, y) in poly] poly = self._polytrafo(self._getshapepoly(poly, True))
poly = self._polytrafo(poly)
screen._drawpoly(item, poly, fill=self._cc(fc), screen._drawpoly(item, poly, fill=self._cc(fc),
outline=self._cc(oc), width=w, top=True) outline=self._cc(oc), width=self._outlinewidth, top=True)
self.stampItems.append(stitem) self.stampItems.append(stitem)
self.undobuffer.push(("stamp", stitem)) self.undobuffer.push(("stamp", stitem))
return stitem return stitem
...@@ -3137,57 +3305,6 @@ class RawTurtle(TPen, TNavigator): ...@@ -3137,57 +3305,6 @@ class RawTurtle(TPen, TNavigator):
""" """
return isinstance(self._fillpath, list) 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): def begin_fill(self):
"""Called just before drawing a shape to be filled. """Called just before drawing a shape to be filled.
...@@ -3243,7 +3360,6 @@ class RawTurtle(TPen, TNavigator): ...@@ -3243,7 +3360,6 @@ class RawTurtle(TPen, TNavigator):
>>> turtle.dot() >>> turtle.dot()
>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50) >>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
""" """
#print "dot-1:", size, color
if not color: if not color:
if isinstance(size, (str, tuple)): if isinstance(size, (str, tuple)):
color = self._colorstr(size) color = self._colorstr(size)
...@@ -3256,10 +3372,8 @@ class RawTurtle(TPen, TNavigator): ...@@ -3256,10 +3372,8 @@ class RawTurtle(TPen, TNavigator):
if size is None: if size is None:
size = self._pensize + max(self._pensize, 4) size = self._pensize + max(self._pensize, 4)
color = self._colorstr(color) color = self._colorstr(color)
#print "dot-2:", size, color
if hasattr(self.screen, "_dot"): if hasattr(self.screen, "_dot"):
item = self.screen._dot(self._position, size, color) item = self.screen._dot(self._position, size, color)
#print "dot:", size, color, "item:", item
self.items.append(item) self.items.append(item)
if self.undobuffer: if self.undobuffer:
self.undobuffer.push(("dot", item)) self.undobuffer.push(("dot", item))
...@@ -3355,7 +3469,7 @@ class RawTurtle(TPen, TNavigator): ...@@ -3355,7 +3469,7 @@ class RawTurtle(TPen, TNavigator):
>>> p = turtle.get_poly() >>> p = turtle.get_poly()
>>> turtle.register_shape("myFavouriteShape", p) >>> turtle.register_shape("myFavouriteShape", p)
""" """
## check if there is any poly? -- 1st solution: ## check if there is any poly?
if self._poly is not None: if self._poly is not None:
return tuple(self._poly) return tuple(self._poly)
...@@ -3399,35 +3513,11 @@ class RawTurtle(TPen, TNavigator): ...@@ -3399,35 +3513,11 @@ class RawTurtle(TPen, TNavigator):
### screen oriented methods recurring to methods of TurtleScreen ### 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): def _delay(self, delay=None):
"""Set delay value which determines speed of turtle animation. """Set delay value which determines speed of turtle animation.
""" """
return self.screen.delay(delay) return self.screen.delay(delay)
##### event binding methods #####
def onclick(self, fun, btn=1, add=None): def onclick(self, fun, btn=1, add=None):
"""Bind fun to mouse-click event on this turtle on canvas. """Bind fun to mouse-click event on this turtle on canvas.
...@@ -3593,8 +3683,8 @@ class _Screen(TurtleScreen): ...@@ -3593,8 +3683,8 @@ class _Screen(TurtleScreen):
topbottom = _CFG["topbottom"] topbottom = _CFG["topbottom"]
self._root.setupcanvas(width, height, canvwidth, canvheight) self._root.setupcanvas(width, height, canvwidth, canvheight)
_Screen._canvas = self._root._getcanvas() _Screen._canvas = self._root._getcanvas()
self.setup(width, height, leftright, topbottom)
TurtleScreen.__init__(self, _Screen._canvas) TurtleScreen.__init__(self, _Screen._canvas)
self.setup(width, height, leftright, topbottom)
def setup(self, width=_CFG["width"], height=_CFG["height"], def setup(self, width=_CFG["width"], height=_CFG["height"],
startx=_CFG["leftright"], starty=_CFG["topbottom"]): startx=_CFG["leftright"], starty=_CFG["topbottom"]):
...@@ -3634,6 +3724,7 @@ class _Screen(TurtleScreen): ...@@ -3634,6 +3724,7 @@ class _Screen(TurtleScreen):
if starty is None: if starty is None:
starty = (sh - height) / 2 starty = (sh - height) / 2
self._root.set_geometry(width, height, startx, starty) self._root.set_geometry(width, height, startx, starty)
self.update()
def title(self, titlestring): def title(self, titlestring):
"""Set title of turtle-window """Set title of turtle-window
...@@ -3803,16 +3894,8 @@ def getmethparlist(ob): ...@@ -3803,16 +3894,8 @@ def getmethparlist(ob):
argText1 = argText2 = "" argText1 = argText2 = ""
# bit of a hack for methods - turn it into a function # bit of a hack for methods - turn it into a function
# but we drop the "self" param. # 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 # Try and build one for Python defined functions
argOffset = 1 argOffset = 1
## if type(fob) in [types.FunctionType, types.LambdaType]:
## try:
counter = ob.__code__.co_argcount counter = ob.__code__.co_argcount
items2 = list(ob.__code__.co_varnames[argOffset:counter]) items2 = list(ob.__code__.co_varnames[argOffset:counter])
realArgs = ob.__code__.co_varnames[argOffset:counter] realArgs = ob.__code__.co_varnames[argOffset:counter]
...@@ -3831,8 +3914,6 @@ def getmethparlist(ob): ...@@ -3831,8 +3914,6 @@ def getmethparlist(ob):
argText1 = "(%s)" % argText1 argText1 = "(%s)" % argText1
argText2 = ", ".join(items2) argText2 = ", ".join(items2)
argText2 = "(%s)" % argText2 argText2 = "(%s)" % argText2
## except:
## pass
return argText1, argText2 return argText1, argText2
def _turtle_docrevise(docstr): def _turtle_docrevise(docstr):
...@@ -3871,7 +3952,6 @@ for methodname in _tg_screen_functions: ...@@ -3871,7 +3952,6 @@ for methodname in _tg_screen_functions:
continue continue
defstr = ("def %(key)s%(pl1)s: return _getscreen().%(key)s%(pl2)s" % defstr = ("def %(key)s%(pl1)s: return _getscreen().%(key)s%(pl2)s" %
{'key':methodname, 'pl1':pl1, 'pl2':pl2}) {'key':methodname, 'pl1':pl1, 'pl2':pl2})
## print("Screen:", defstr)
exec(defstr) exec(defstr)
eval(methodname).__doc__ = _screen_docrevise(eval('_Screen.'+methodname).__doc__) eval(methodname).__doc__ = _screen_docrevise(eval('_Screen.'+methodname).__doc__)
...@@ -3882,13 +3962,11 @@ for methodname in _tg_turtle_functions: ...@@ -3882,13 +3962,11 @@ for methodname in _tg_turtle_functions:
continue continue
defstr = ("def %(key)s%(pl1)s: return _getpen().%(key)s%(pl2)s" % defstr = ("def %(key)s%(pl1)s: return _getpen().%(key)s%(pl2)s" %
{'key':methodname, 'pl1':pl1, 'pl2':pl2}) {'key':methodname, 'pl1':pl1, 'pl2':pl2})
## print("Turtle:", defstr)
exec(defstr) exec(defstr)
eval(methodname).__doc__ = _turtle_docrevise(eval('Turtle.'+methodname).__doc__) eval(methodname).__doc__ = _turtle_docrevise(eval('Turtle.'+methodname).__doc__)
done = mainloop = TK.mainloop done = mainloop
#del pl1, pl2, defstr
if __name__ == "__main__": if __name__ == "__main__":
def switchpen(): def switchpen():
......
...@@ -118,6 +118,9 @@ Installation ...@@ -118,6 +118,9 @@ Installation
Library Library
------- -------
- Issue #5923: Update the ``turtle`` module to version 1.1, add two new
turtle demos in Demo/turtle.
- Issue #5692: In :class:`zipfile.Zipfile`, fix wrong path calculation when - Issue #5692: In :class:`zipfile.Zipfile`, fix wrong path calculation when
extracting a file to the root directory. extracting a file to the root directory.
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment