Lib/lib-tk/turtle.py

   1 # LogoMation-like turtle graphics
   2
   3 from math import * # Also for export
   4 import Tkinter
   5 class Error(Exception):
   6     pass
   7
   8 class RawPen:
   9
  10     def __init__(self, canvas):
  11         self._canvas = canvas
  12         self._items = []
  13         self._tracing = 1
  14         self._arrow = 0
  15         self.degrees()
  16         self.reset()
  17
  18     def degrees(self, fullcircle=360.0):
  19         self._fullcircle = fullcircle
  20         self._invradian = pi / (fullcircle * 0.5)
  21
  22     def radians(self):
  23         self.degrees(2.0*pi)
  24
  25     def reset(self):
  26         canvas = self._canvas
  27         width = canvas.winfo_width()
  28         height = canvas.winfo_height()
  29         if width <= 1:
  30             width = canvas['width']
  31         if height <= 1:
  32             height = canvas['height']
  33         self._origin = float(width)/2.0, float(height)/2.0
  34         self._position = self._origin
  35         self._angle = 0.0
  36         self._drawing = 1
  37         self._width = 1
  38         self._color = "black"
  39         self._filling = 0
  40         self._path = []
  41         self._tofill = []
  42         self.clear()
  43         canvas._root().tkraise()
  44
  45     def clear(self):
  46         self.fill(0)
  47         canvas = self._canvas
  48         items = self._items
  49         self._items = []
  50         for item in items:
  51             canvas.delete(item)
  52         self._delete_turtle()
  53         self._draw_turtle()
  54
  55
  56     def tracer(self, flag):
  57         self._tracing = flag
  58         if not self._tracing:
  59             self._delete_turtle()
  60         self._draw_turtle()
  61
  62     def forward(self, distance):
  63         x0, y0 = start = self._position
  64         x1 = x0 + distance * cos(self._angle*self._invradian)
  65         y1 = y0 - distance * sin(self._angle*self._invradian)
  66         self._goto(x1, y1)
  67
  68     def backward(self, distance):
  69         self.forward(-distance)
  70
  71     def left(self, angle):
  72         self._angle = (self._angle + angle) % self._fullcircle
  73         self._draw_turtle()
  74
  75     def right(self, angle):
  76         self.left(-angle)
  77
  78     def up(self):
  79         self._drawing = 0
  80
  81     def down(self):
  82         self._drawing = 1
  83
  84     def width(self, width):
  85         self._width = float(width)
  86
  87     def color(self, *args):
  88         if not args:
  89             raise Error, "no color arguments"
  90         if len(args) == 1:
  91             color = args[0]
  92             if type(color) == type(""):
  93                 # Test the color first
  94                 try:
  95                     id = self._canvas.create_line(0, 0, 0, 0, fill=color)
  96                 except Tkinter.TclError:
  97                     raise Error, "bad color string: %s" % `color`
  98                 self._set_color(color)
  99                 return
 100             try:
 101                 r, g, b = color
 102             except:
 103                 raise Error, "bad color sequence: %s" % `color`
 104         else:
 105             try:
 106                 r, g, b = args
 107             except:
 108                 raise Error, "bad color arguments: %s" % `args`
 109         assert 0 <= r <= 1
 110         assert 0 <= g <= 1
 111         assert 0 <= b <= 1
 112         x = 255.0
 113         y = 0.5
 114         self._set_color("#%02x%02x%02x" % (int(r*x+y), int(g*x+y), int(b*x+y)))
 115
 116     def _set_color(self,color):
 117         self._color = color
 118         self._draw_turtle()
 119
 120
 121     def write(self, arg, move=0):
 122         x, y = start = self._position
 123         x = x-1 # correction -- calibrated for Windows
 124         item = self._canvas.create_text(x, y,
 125                                         text=str(arg), anchor="sw",
 126                                         fill=self._color)
 127         self._items.append(item)
 128         if move:
 129             x0, y0, x1, y1 = self._canvas.bbox(item)
 130             self._goto(x1, y1)
 131         self._draw_turtle()
 132
 133     def fill(self, flag):
 134         if self._filling:
 135             path = tuple(self._path)
 136             smooth = self._filling < 0
 137             if len(path) > 2:
 138                 item = self._canvas._create('polygon', path,
 139                                             {'fill': self._color,
 140                                              'smooth': smooth})
 141                 self._items.append(item)
 142                 self._canvas.lower(item)
 143                 if self._tofill:
 144                     for item in self._tofill:
 145                         self._canvas.itemconfigure(item, fill=self._color)
 146                         self._items.append(item)
 147         self._path = []
 148         self._tofill = []
 149         self._filling = flag
 150         if flag:
 151             self._path.append(self._position)
 152
 153     def circle(self, radius, extent=None):
 154         if extent is None:
 155             extent = self._fullcircle
 156         x0, y0 = self._position
 157         xc = x0 - radius * sin(self._angle * self._invradian)
 158         yc = y0 - radius * cos(self._angle * self._invradian)
 159         if radius >= 0.0:
 160             start = self._angle - 90.0
 161         else:
 162             start = self._angle + 90.0
 163             extent = -extent
 164         if self._filling:
 165             if abs(extent) >= self._fullcircle:
 166                 item = self._canvas.create_oval(xc-radius, yc-radius,
 167                                                 xc+radius, yc+radius,
 168                                                 width=self._width,
 169                                                 outline="")
 170                 self._tofill.append(item)
 171             item = self._canvas.create_arc(xc-radius, yc-radius,
 172                                            xc+radius, yc+radius,
 173                                            style="chord",
 174                                            start=start,
 175                                            extent=extent,
 176                                            width=self._width,
 177                                            outline="")
 178             self._tofill.append(item)
 179         if self._drawing:
 180             if abs(extent) >= self._fullcircle:
 181                 item = self._canvas.create_oval(xc-radius, yc-radius,
 182                                                 xc+radius, yc+radius,
 183                                                 width=self._width,
 184                                                 outline=self._color)
 185                 self._items.append(item)
 186             item = self._canvas.create_arc(xc-radius, yc-radius,
 187                                            xc+radius, yc+radius,
 188                                            style="arc",
 189                                            start=start,
 190                                            extent=extent,
 191                                            width=self._width,
 192                                            outline=self._color)
 193             self._items.append(item)
 194         angle = start + extent
 195         x1 = xc + abs(radius) * cos(angle * self._invradian)
 196         y1 = yc - abs(radius) * sin(angle * self._invradian)
 197         self._angle = (self._angle + extent) % self._fullcircle
 198         self._position = x1, y1
 199         if self._filling:
 200             self._path.append(self._position)
 201
 202     def goto(self, *args):
 203         if len(args) == 1:
 204             try:
 205                 x, y = args[0]
 206             except:
 207                 raise Error, "bad point argument: %s" % `args[0]`
 208         else:
 209             try:
 210                 x, y = args
 211             except:
 212                 raise Error, "bad coordinates: %s" % `args[0]`
 213         x0, y0 = self._origin
 214         self._goto(x0+x, y0-y)
 215
 216     def _goto(self, x1, y1):
 217         x0, y0 = start = self._position
 218         self._position = map(float, (x1, y1))
 219         if self._filling:
 220             self._path.append(self._position)
 221         if self._drawing:
 222             if self._tracing:
 223                 dx = float(x1 - x0)
 224                 dy = float(y1 - y0)
 225                 distance = hypot(dx, dy)
 226                 nhops = int(distance)
 227                 item = self._canvas.create_line(x0, y0, x0, y0,
 228                                                 width=self._width,
 229                                                 capstyle="round",
 230                                                 fill=self._color)
 231                 try:
 232                     for i in range(1, 1+nhops):
 233                         x, y = x0 + dx*i/nhops, y0 + dy*i/nhops
 234                         self._canvas.coords(item, x0, y0, x, y)
 235                         self._draw_turtle((x,y))
 236                         self._canvas.update()
 237                         self._canvas.after(10)
 238                     # in case nhops==0
 239                     self._canvas.coords(item, x0, y0, x1, y1)
 240                     self._canvas.itemconfigure(item, arrow="none")
 241                 except Tkinter.TclError:
 242                     # Probably the window was closed!
 243                     return
 244             else:
 245                 item = self._canvas.create_line(x0, y0, x1, y1,
 246                                                 width=self._width,
 247                                                 capstyle="round",
 248                                                 fill=self._color)
 249             self._items.append(item)
 250         self._draw_turtle()
 251
 252     def _draw_turtle(self,position=[]):
 253         if not self._tracing:
 254             return
 255         if position == []:
 256             position = self._position
 257         x,y = position
 258         distance = 8
 259         dx = distance * cos(self._angle*self._invradian)
 260         dy = distance * sin(self._angle*self._invradian)
 261         self._delete_turtle()
 262         self._arrow = self._canvas.create_line(x-dx,y+dy,x,y,
 263                                           width=self._width,
 264                                           arrow="last",
 265                                           capstyle="round",
 266                                           fill=self._color)
 267         self._canvas.update()
 268
 269     def _delete_turtle(self):
 270         if self._arrow != 0:
 271             self._canvas.delete(self._arrow)
 272         self._arrow = 0
 273
 274
 275
 276 _root = None
 277 _canvas = None
 278 _pen = None
 279
 280 class Pen(RawPen):
 281
 282     def __init__(self):
 283         global _root, _canvas
 284         if _root is None:
 285             _root = Tkinter.Tk()
 286             _root.wm_protocol("WM_DELETE_WINDOW", self._destroy)
 287         if _canvas is None:
 288             # XXX Should have scroll bars
 289             _canvas = Tkinter.Canvas(_root, background="white")
 290             _canvas.pack(expand=1, fill="both")
 291         RawPen.__init__(self, _canvas)
 292
 293     def _destroy(self):
 294         global _root, _canvas, _pen
 295         root = self._canvas._root()
 296         if root is _root:
 297             _pen = None
 298             _root = None
 299             _canvas = None
 300         root.destroy()
 301
 302
 303 def _getpen():
 304     global _pen
 305     pen = _pen
 306     if not pen:
 307         _pen = pen = Pen()
 308     return pen
 309
 310 def degrees(): _getpen().degrees()
 311 def radians(): _getpen().radians()
 312 def reset(): _getpen().reset()
 313 def clear(): _getpen().clear()
 314 def tracer(flag): _getpen().tracer(flag)
 315 def forward(distance): _getpen().forward(distance)
 316 def backward(distance): _getpen().backward(distance)
 317 def left(angle): _getpen().left(angle)
 318 def right(angle): _getpen().right(angle)
 319 def up(): _getpen().up()
 320 def down(): _getpen().down()
 321 def width(width): _getpen().width(width)
 322 def color(*args): apply(_getpen().color, args)
 323 def write(arg, move=0): _getpen().write(arg, move)
 324 def fill(flag): _getpen().fill(flag)
 325 def circle(radius, extent=None): _getpen().circle(radius, extent)
 326 def goto(*args): apply(_getpen().goto, args)
 327
 328 def demo():
 329     reset()
 330     tracer(1)
 331     up()
 332     backward(100)
 333     down()
 334     # draw 3 squares; the last filled
 335     width(3)
 336     for i in range(3):
 337         if i == 2:
 338             fill(1)
 339         for j in range(4):
 340             forward(20)
 341             left(90)
 342         if i == 2:
 343             color("maroon")
 344             fill(0)
 345         up()
 346         forward(30)
 347         down()
 348     width(1)
 349     color("black")
 350     # move out of the way
 351     tracer(0)
 352     up()
 353     right(90)
 354     forward(100)
 355     right(90)
 356     forward(100)
 357     right(180)
 358     down()
 359     # some text
 360     write("startstart", 1)
 361     write("start", 1)
 362     color("red")
 363     # staircase
 364     for i in range(5):
 365         forward(20)
 366         left(90)
 367         forward(20)
 368         right(90)
 369     # filled staircase
 370     fill(1)
 371     for i in range(5):
 372         forward(20)
 373         left(90)
 374         forward(20)
 375         right(90)
 376     fill(0)
 377     # more text
 378     write("end")
 379     if __name__ == '__main__':
 380         _root.mainloop()
 381
 382 if __name__ == '__main__':
 383     demo()