Lib/lib-tk/turtle.py

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