#

# turtle.py: a Tkinter based turtle graphics module for Python

# Version 1.0b1 - 31. 5. 2008

#

# Copyright (C) 2006 - 2008  Gregor Lingl

# email: glingl@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 2.6   -  30. 5. 2008, 18:08"

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

    """Helper functions for Scrolled Canvas, used to forward

    ScrolledCanvas-methods to Tkinter.Canvas class.

    """

    _dict = {}

    __methodDict(toClass, _dict)

    for ex in _dict.keys():

        if ex[:1] == '_' or ex[-1:] == '_':

            del _dict[ex]

    for ex in exclude:

        if _dict.has_key(ex):

            del _dict[ex]

    for ex in __methods(fromClass):

        if _dict.has_key(ex):

            del _dict[ex]

    for method, func in _dict.items():

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

        if type(toPart) == types.StringType:

            execString = \

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

        exec execString in d

        fromClass.__dict__[method] = d[method]

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._rootwindow = self.winfo_toplevel()

        self.width, self.height = width, height

        self.canvwidth, self.canvheight = canvwidth, canvheight

        self.bg = "white"

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

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

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

                                    orient=TK.HORIZONTAL)

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

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

                               yscrollcommand=self.vscroll.set)

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

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

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

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

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

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

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

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

        self.reset()

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

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

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