Lines Matching refs:self
253 def __add__(self, other):
254 return Vec2D(self[0]+other[0], self[1]+other[1])
255 def __mul__(self, other):
257 return self[0]*other[0]+self[1]*other[1]
258 return Vec2D(self[0]*other, self[1]*other)
259 def __rmul__(self, other):
261 return Vec2D(self[0]*other, self[1]*other)
263 def __sub__(self, other):
264 return Vec2D(self[0]-other[0], self[1]-other[1])
265 def __neg__(self):
266 return Vec2D(-self[0], -self[1])
267 def __abs__(self):
268 return math.hypot(*self)
269 def rotate(self, angle):
270 """rotate self counterclockwise by angle
272 perp = Vec2D(-self[1], self[0])
275 return Vec2D(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s)
276 def __getnewargs__(self):
277 return (self[0], self[1])
278 def __repr__(self):
279 return "(%.2f,%.2f)" % self
307 'def %(method)s(self, *args, **kw): return ' +
308 'self.%(attribute)s.%(method)s(*args, **kw)')
337 def __init__(self, master, width=500, height=350,
339 TK.Frame.__init__(self, master, width=width, height=height)
340 self._rootwindow = self.winfo_toplevel()
341 self.width, self.height = width, height
342 self.canvwidth, self.canvheight = canvwidth, canvheight
343 self.bg = "white"
344 self._canvas = TK.Canvas(master, width=width, height=height,
345 bg=self.bg, relief=TK.SUNKEN, borderwidth=2)
346 self.hscroll = TK.Scrollbar(master, command=self._canvas.xview,
348 self.vscroll = TK.Scrollbar(master, command=self._canvas.yview)
349 self._canvas.configure(xscrollcommand=self.hscroll.set,
350 yscrollcommand=self.vscroll.set)
351 self.rowconfigure(0, weight=1, minsize=0)
352 self.columnconfigure(0, weight=1, minsize=0)
353 self._canvas.grid(padx=1, in_ = self, pady=1, row=0,
355 self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,
357 self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,
359 self.reset()
360 self._rootwindow.bind('<Configure>', self.onResize)
362 def reset(self, canvwidth=None, canvheight=None, bg = None):
365 self.canvwidth = canvwidth
367 self.canvheight = canvheight
369 self.bg = bg
370 self._canvas.config(bg=bg,
371 scrollregion=(-self.canvwidth//2, -self.canvheight//2,
372 self.canvwidth//2, self.canvheight//2))
373 self._canvas.xview_moveto(0.5*(self.canvwidth - self.width + 30) /
374 self.canvwidth)
375 self._canvas.yview_moveto(0.5*(self.canvheight- self.height + 30) /
376 self.canvheight)
377 self.adjustScrolls()
380 def adjustScrolls(self):
383 cwidth = self._canvas.winfo_width()
384 cheight = self._canvas.winfo_height()
385 self._canvas.xview_moveto(0.5*(self.canvwidth-cwidth)/self.canvwidth)
386 self._canvas.yview_moveto(0.5*(self.canvheight-cheight)/self.canvheight)
387 if cwidth < self.canvwidth or cheight < self.canvheight:
388 self.hscroll.grid(padx=1, in_ = self, pady=1, row=1,
390 self.vscroll.grid(padx=1, in_ = self, pady=1, row=0,
393 self.hscroll.grid_forget()
394 self.vscroll.grid_forget()
396 def onResize(self, event):
397 """self-explanatory"""
398 self.adjustScrolls()
400 def bbox(self, *args):
403 return self._canvas.bbox(*args)
405 def cget(self, *args, **kwargs):
408 return self._canvas.cget(*args, **kwargs)
410 def config(self, *args, **kwargs):
413 self._canvas.config(*args, **kwargs)
415 def bind(self, *args, **kwargs):
418 self._canvas.bind(*args, **kwargs)
420 def unbind(self, *args, **kwargs):
423 self._canvas.unbind(*args, **kwargs)
425 def focus_force(self):
428 self._canvas.focus_force()
435 def __init__(self):
436 TK.Tk.__init__(self)
438 def setupcanvas(self, width, height, cwidth, cheight):
439 self._canvas = ScrolledCanvas(self, width, height, cwidth, cheight)
440 self._canvas.pack(expand=1, fill="both")
442 def _getcanvas(self):
443 return self._canvas
445 def set_geometry(self, width, height, startx, starty):
446 self.geometry("%dx%d%+d%+d"%(width, height, startx, starty))
448 def ondestroy(self, destroy):
449 self.wm_protocol("WM_DELETE_WINDOW", destroy)
451 def win_width(self):
452 return self.winfo_screenwidth()
454 def win_height(self):
455 return self.winfo_screenheight()
468 def _blankimage(self):
471 img = TK.PhotoImage(width=1, height=1, master=self.cv)
475 def _image(self, filename):
479 return TK.PhotoImage(file=filename, master=self.cv)
481 def __init__(self, cv):
482 self.cv = cv
484 w = self.cv.canvwidth
485 h = self.cv.canvheight
487 w = int(self.cv.cget("width"))
488 h = int(self.cv.cget("height"))
489 self.cv.config(scrollregion = (-w//2, -h//2, w//2, h//2 ))
490 self.canvwidth = w
491 self.canvheight = h
492 self.xscale = self.yscale = 1.0
494 def _createpoly(self):
495 """Create an invisible polygon item on canvas self.cv)
497 return self.cv.create_polygon((0, 0, 0, 0, 0, 0), fill="", outline="")
499 def _drawpoly(self, polyitem, coordlist, fill=None,
512 cl.append(x * self.xscale)
513 cl.append(-y * self.yscale)
514 self.cv.coords(polyitem, *cl)
516 self.cv.itemconfigure(polyitem, fill=fill)
518 self.cv.itemconfigure(polyitem, outline=outline)
520 self.cv.itemconfigure(polyitem, width=width)
522 self.cv.tag_raise(polyitem)
524 def _createline(self):
525 """Create an invisible line item on canvas self.cv)
527 return self.cv.create_line(0, 0, 0, 0, fill="", width=2,
530 def _drawline(self, lineitem, coordlist=None,
543 cl.append(x * self.xscale)
544 cl.append(-y * self.yscale)
545 self.cv.coords(lineitem, *cl)
547 self.cv.itemconfigure(lineitem, fill=fill)
549 self.cv.itemconfigure(lineitem, width=width)
551 self.cv.tag_raise(lineitem)
553 def _delete(self, item):
557 self.cv.delete(item)
559 def _update(self):
562 self.cv.update()
564 def _delay(self, delay):
566 self.cv.after(delay)
568 def _iscolorstring(self, color):
572 rgb = self.cv.winfo_rgb(color)
578 def _bgcolor(self, color=None):
582 self.cv.config(bg = color)
583 self._update()
585 return self.cv.cget("bg")
587 def _write(self, pos, txt, align, font, pencolor):
593 x = x * self.xscale
594 y = y * self.yscale
596 item = self.cv.create_text(x-1, -y, text = txt, anchor = anchor[align],
598 x0, y0, x1, y1 = self.cv.bbox(item)
601 ## def _dot(self, pos, size, color):
604 def _onclick(self, item, fun, num=1, add=None):
611 self.cv.tag_unbind(item, "<Button-%s>" % num)
614 x, y = (self.cv.canvasx(event.x)/self.xscale,
615 -self.cv.canvasy(event.y)/self.yscale)
617 self.cv.tag_bind(item, "<Button-%s>" % num, eventfun, add)
619 def _onrelease(self, item, fun, num=1, add=None):
629 self.cv.tag_unbind(item, "<Button%s-ButtonRelease>" % num)
632 x, y = (self.cv.canvasx(event.x)/self.xscale,
633 -self.cv.canvasy(event.y)/self.yscale)
635 self.cv.tag_bind(item, "<Button%s-ButtonRelease>" % num,
638 def _ondrag(self, item, fun, num=1, add=None):
648 self.cv.tag_unbind(item, "<Button%s-Motion>" % num)
652 x, y = (self.cv.canvasx(event.x)/self.xscale,
653 -self.cv.canvasy(event.y)/self.yscale)
657 self.cv.tag_bind(item, "<Button%s-Motion>" % num, eventfun, add)
659 def _onscreenclick(self, fun, num=1, add=None):
669 self.cv.unbind("<Button-%s>" % num)
672 x, y = (self.cv.canvasx(event.x)/self.xscale,
673 -self.cv.canvasy(event.y)/self.yscale)
675 self.cv.bind("<Button-%s>" % num, eventfun, add)
677 def _onkeyrelease(self, fun, key):
682 self.cv.unbind("<KeyRelease-%s>" % key, None)
686 self.cv.bind("<KeyRelease-%s>" % key, eventfun)
688 def _onkeypress(self, fun, key=None):
695 self.cv.unbind("<KeyPress>", None)
697 self.cv.unbind("<KeyPress-%s>" % key, None)
702 self.cv.bind("<KeyPress>", eventfun)
704 self.cv.bind("<KeyPress-%s>" % key, eventfun)
706 def _listen(self):
709 self.cv.focus_force()
711 def _ontimer(self, fun, t):
715 self.cv.after_idle(fun)
717 self.cv.after(t, fun)
719 def _createimage(self, image):
722 return self.cv.create_image(0, 0, image=image)
724 def _drawimage(self, item, pos, image):
729 self.cv.coords(item, (x * self.xscale, -y * self.yscale))
730 self.cv.itemconfig(item, image=image)
732 def _setbgpic(self, item, image):
737 self.cv.itemconfig(item, image=image)
738 self.cv.tag_lower(item)
740 def _type(self, item):
744 return self.cv.type(item)
746 def _pointlist(self, item):
754 cl = self.cv.coords(item)
758 def _setscrollregion(self, srx1, sry1, srx2, sry2):
759 self.cv.config(scrollregion=(srx1, sry1, srx2, sry2))
761 def _rescale(self, xscalefactor, yscalefactor):
762 items = self.cv.find_all()
764 coordinates = list(self.cv.coords(item))
771 self.cv.coords(item, *newcoordlist)
773 def _resize(self, canvwidth=None, canvheight=None, bg=None):
778 if not isinstance(self.cv, ScrolledCanvas):
779 return self.canvwidth, self.canvheight
781 return self.cv.canvwidth, self.cv.canvheight
783 self.canvwidth = canvwidth
785 self.canvheight = canvheight
786 self.cv.reset(canvwidth, canvheight, bg)
788 def _window_size(self):
791 width = self.cv.winfo_width()
793 width = self.cv['width']
794 height = self.cv.winfo_height()
796 height = self.cv['height']
799 def mainloop(self):
812 self.cv.tk.mainloop()
814 def textinput(self, title, prompt):
827 return simpledialog.askstring(title, prompt, parent=self.cv)
829 def numinput(self, title, prompt, default=None, minval=None, maxval=None):
849 parent=self.cv)
878 def __init__(self, type_, data=None):
879 self._type = type_
892 self._data = data
894 def addcomponent(self, poly, fill, outline=None):
910 if self._type != "compound":
912 % self._type)
915 self._data.append([poly, fill, outline])
920 def __init__(self, bufsize=10):
921 self.bufsize = bufsize
922 self.buffer = [[None]] * bufsize
923 self.ptr = -1
924 self.cumulate = False
925 def reset(self, bufsize=None):
927 for i in range(self.bufsize):
928 self.buffer[i] = [None]
930 self.bufsize = bufsize
931 self.buffer = [[None]] * bufsize
932 self.ptr = -1
933 def push(self, item):
934 if self.bufsize > 0:
935 if not self.cumulate:
936 self.ptr = (self.ptr + 1) % self.bufsize
937 self.buffer[self.ptr] = item
939 self.buffer[self.ptr].append(item)
940 def pop(self):
941 if self.bufsize > 0:
942 item = self.buffer[self.ptr]
946 self.buffer[self.ptr] = [None]
947 self.ptr = (self.ptr - 1) % self.bufsize
949 def nr_of_items(self):
950 return self.bufsize - self.buffer.count([None])
951 def __repr__(self):
952 return str(self.buffer) + " " + str(self.ptr)
965 def __init__(self, cv, mode=_CFG["mode"],
967 TurtleScreenBase.__init__(self, cv)
969 self._shapes = {
987 "blank" : Shape("image", self._blankimage())
990 self._bgpics = {"nopic" : ""}
992 self._mode = mode
993 self._delayvalue = delay
994 self._colormode = _CFG["colormode"]
995 self._keys = []
996 self.clear()
1005 def clear(self):
1018 self._delayvalue = _CFG["delay"]
1019 self._colormode = _CFG["colormode"]
1020 self._delete("all")
1021 self._bgpic = self._createimage("")
1022 self._bgpicname = "nopic"
1023 self._tracing = 1
1024 self._updatecounter = 0
1025 self._turtles = []
1026 self.bgcolor("white")
1028 self.onclick(None, btn)
1029 self.onkeypress(None)
1030 for key in self._keys[:]:
1031 self.onkey(None, key)
1032 self.onkeypress(None, key)
1035 def mode(self, mode=None):
1058 return self._mode
1062 self._mode = mode
1064 self._setscrollregion(-self.canvwidth//2, -self.canvheight//2,
1065 self.canvwidth//2, self.canvheight//2)
1066 self.xscale = self.yscale = 1.0
1067 self.reset()
1069 def setworldcoordinates(self, llx, lly, urx, ury):
1091 if self.mode() != "world":
1092 self.mode("world")
1095 wx, wy = self._window_size()
1096 self.screensize(wx-20, wy-20)
1097 oldxscale, oldyscale = self.xscale, self.yscale
1098 self.xscale = self.canvwidth / xspan
1099 self.yscale = self.canvheight / yspan
1100 srx1 = llx * self.xscale
1101 sry1 = -ury * self.yscale
1102 srx2 = self.canvwidth + srx1
1103 sry2 = self.canvheight + sry1
1104 self._setscrollregion(srx1, sry1, srx2, sry2)
1105 self._rescale(self.xscale/oldxscale, self.yscale/oldyscale)
1106 self.update()
1108 def register_shape(self, name, shape=None):
1134 shape = Shape("image", self._image(name))
1141 self._shapes[name] = shape
1143 def _colorstr(self, color):
1156 if self._iscolorstring(color) or color == "":
1164 if self._colormode == 1.0:
1170 def _color(self, cstr):
1179 return tuple(c * self._colormode/255 for c in cl)
1181 def colormode(self, cmode=None):
1196 return self._colormode
1198 self._colormode = float(cmode)
1200 self._colormode = int(cmode)
1202 def reset(self):
1210 for turtle in self._turtles:
1211 turtle._setmode(self._mode)
1214 def turtles(self):
1221 return self._turtles
1223 def bgcolor(self, *args):
1238 color = self._colorstr(args)
1241 color = self._bgcolor(color)
1243 color = self._color(color)
1246 def tracer(self, n=None, delay=None):
1266 return self._tracing
1267 self._tracing = int(n)
1268 self._updatecounter = 0
1270 self._delayvalue = int(delay)
1271 if self._tracing:
1272 self.update()
1274 def delay(self, delay=None):
1286 return self._delayvalue
1287 self._delayvalue = int(delay)
1289 def _incrementudc(self):
1294 if self._tracing > 0:
1295 self._updatecounter += 1
1296 self._updatecounter %= self._tracing
1298 def update(self):
1301 tracing = self._tracing
1302 self._tracing = True
1303 for t in self.turtles():
1306 self._tracing = tracing
1307 self._update()
1309 def window_width(self):
1316 return self._window_size()[0]
1318 def window_height(self):
1325 return self._window_size()[1]
1327 def getcanvas(self):
1337 return self.cv
1339 def getshapes(self):
1348 return sorted(self._shapes.keys())
1350 def onclick(self, fun, btn=1, add=None):
1365 self._onscreenclick(fun, btn, add)
1367 def onkey(self, fun, key):
1391 if key in self._keys:
1392 self._keys.remove(key)
1393 elif key not in self._keys:
1394 self._keys.append(key)
1395 self._onkeyrelease(fun, key)
1397 def onkeypress(self, fun, key=None):
1423 if key in self._keys:
1424 self._keys.remove(key)
1425 elif key is not None and key not in self._keys:
1426 self._keys.append(key)
1427 self._onkeypress(fun, key)
1429 def listen(self, xdummy=None, ydummy=None):
1439 self._listen()
1441 def ontimer(self, fun, t=0):
1460 self._ontimer(fun, t)
1462 def bgpic(self, picname=None):
1480 return self._bgpicname
1481 if picname not in self._bgpics:
1482 self._bgpics[picname] = self._image(picname)
1483 self._setbgpic(self._bgpic, self._bgpics[picname])
1484 self._bgpicname = picname
1486 def screensize(self, canvwidth=None, canvheight=None, bg=None):
1503 return self._resize(canvwidth, canvheight, bg)
1523 def __init__(self, mode=DEFAULT_MODE):
1524 self._angleOffset = self.DEFAULT_ANGLEOFFSET
1525 self._angleOrient = self.DEFAULT_ANGLEORIENT
1526 self._mode = mode
1527 self.undobuffer = None
1528 self.degrees()
1529 self._mode = None
1530 self._setmode(mode)
1531 TNavigator.reset(self)
1533 def reset(self):
1538 self._position = Vec2D(0.0, 0.0)
1539 self._orient = TNavigator.START_ORIENTATION[self._mode]
1541 def _setmode(self, mode=None):
1545 return self._mode
1548 self._mode = mode
1550 self._angleOffset = 0
1551 self._angleOrient = 1
1553 self._angleOffset = self._fullcircle/4.
1554 self._angleOrient = -1
1556 def _setDegreesPerAU(self, fullcircle):
1558 self._fullcircle = fullcircle
1559 self._degreesPerAU = 360/fullcircle
1560 if self._mode == "standard":
1561 self._angleOffset = 0
1563 self._angleOffset = fullcircle/4.
1565 def degrees(self, fullcircle=360.0):
1587 self._setDegreesPerAU(fullcircle)
1589 def radians(self):
1601 self._setDegreesPerAU(math.tau)
1603 def _go(self, distance):
1605 ende = self._position + self._orient * distance
1606 self._goto(ende)
1608 def _rotate(self, angle):
1610 angle *= self._degreesPerAU
1611 self._orient = self._orient.rotate(angle)
1613 def _goto(self, end):
1615 self._position = end
1617 def forward(self, distance):
1638 self._go(distance)
1640 def back(self, distance):
1658 self._go(-distance)
1660 def right(self, angle):
1679 self._rotate(-angle)
1681 def left(self, angle):
1700 self._rotate(angle)
1702 def pos(self):
1713 return self._position
1715 def xcor(self):
1727 return self._position[0]
1729 def ycor(self):
1741 return self._position[1]
1744 def goto(self, x, y=None):
1775 self._goto(Vec2D(*x))
1777 self._goto(Vec2D(x, y))
1779 def home(self):
1790 self.goto(0, 0)
1791 self.setheading(0)
1793 def setx(self, x):
1809 self._goto(Vec2D(x, self._position[1]))
1811 def sety(self, y):
1827 self._goto(Vec2D(self._position[0], y))
1829 def distance(self, x, y=None):
1859 return abs(pos - self._position)
1861 def towards(self, x, y=None):
1891 x, y = pos - self._position
1893 result /= self._degreesPerAU
1894 return (self._angleOffset + self._angleOrient*result) % self._fullcircle
1896 def heading(self):
1906 x, y = self._orient
1908 result /= self._degreesPerAU
1909 return (self._angleOffset + self._angleOrient*result) % self._fullcircle
1911 def setheading(self, to_angle):
1934 angle = (to_angle - self.heading())*self._angleOrient
1935 full = self._fullcircle
1937 self._rotate(angle)
1939 def circle(self, radius, extent = None, steps = None):
1969 if self.undobuffer:
1970 self.undobuffer.push(["seq"])
1971 self.undobuffer.cumulate = True
1972 speed = self.speed()
1974 extent = self._fullcircle
1976 frac = abs(extent)/self._fullcircle
1980 l = 2.0 * radius * math.sin(math.radians(w2)*self._degreesPerAU)
1983 tr = self._tracer()
1984 dl = self._delay()
1986 self._tracer(0, 0)
1988 self.speed(0)
1989 self._rotate(w2)
1991 self.speed(speed)
1992 self._go(l)
1993 self.speed(0)
1994 self._rotate(w)
1995 self._rotate(-w2)
1997 self._tracer(tr, dl)
1998 self.speed(speed)
1999 if self.undobuffer:
2000 self.undobuffer.cumulate = False
2004 def speed(self, s=0):
2006 def _tracer(self, a=None, b=None):
2008 def _delay(self, n=None):
2026 def __init__(self, resizemode=_CFG["resizemode"]):
2027 self._resizemode = resizemode # or "user" or "noresize"
2028 self.undobuffer = None
2029 TPen._reset(self)
2031 def _reset(self, pencolor=_CFG["pencolor"],
2033 self._pensize = 1
2034 self._shown = True
2035 self._pencolor = pencolor
2036 self._fillcolor = fillcolor
2037 self._drawing = True
2038 self._speed = 3
2039 self._stretchfactor = (1., 1.)
2040 self._shearfactor = 0.
2041 self._tilt = 0.
2042 self._shapetrafo = (1., 0., 0., 1.)
2043 self._outlinewidth = 1
2045 def resizemode(self, rmode=None):
2068 return self._resizemode
2071 self.pen(resizemode=rmode)
2073 def pensize(self, width=None):
2092 return self._pensize
2093 self.pen(pensize=width)
2096 def penup(self):
2106 if not self._drawing:
2108 self.pen(pendown=False)
2110 def pendown(self):
2120 if self._drawing:
2122 self.pen(pendown=True)
2124 def isdown(self):
2137 return self._drawing
2139 def speed(self, speed=None):
2168 return self._speed
2175 self.pen(speed=speed)
2177 def color(self, *args):
2217 pcolor = self._colorstr(pcolor)
2218 fcolor = self._colorstr(fcolor)
2219 self.pen(pencolor=pcolor, fillcolor=fcolor)
2221 return self._color(self._pencolor), self._color(self._fillcolor)
2223 def pencolor(self, *args):
2253 color = self._colorstr(args)
2254 if color == self._pencolor:
2256 self.pen(pencolor=color)
2258 return self._color(self._pencolor)
2260 def fillcolor(self, *args):
2289 color = self._colorstr(args)
2290 if color == self._fillcolor:
2292 self.pen(fillcolor=color)
2294 return self._color(self._fillcolor)
2296 def showturtle(self):
2307 self.pen(shown=True)
2309 def hideturtle(self):
2323 self.pen(shown=False)
2325 def isvisible(self):
2335 return self._shown
2337 def pen(self, pen=None, **pendict):
2384 _pd = {"shown" : self._shown,
2385 "pendown" : self._drawing,
2386 "pencolor" : self._pencolor,
2387 "fillcolor" : self._fillcolor,
2388 "pensize" : self._pensize,
2389 "speed" : self._speed,
2390 "resizemode" : self._resizemode,
2391 "stretchfactor" : self._stretchfactor,
2392 "shearfactor" : self._shearfactor,
2393 "outline" : self._outlinewidth,
2394 "tilt" : self._tilt
2410 if self.undobuffer:
2411 self.undobuffer.push(("pen", _p_buf))
2415 if self._drawing != p["pendown"]:
2419 p["pencolor"] = self._colorstr((p["pencolor"],))
2420 if self._pencolor != p["pencolor"]:
2423 if self._pensize != p["pensize"]:
2426 self._newLine()
2428 self._drawing = p["pendown"]
2430 self._pencolor = p["pencolor"]
2432 self._pensize = p["pensize"]
2435 p["fillcolor"] = self._colorstr((p["fillcolor"],))
2436 self._fillcolor = p["fillcolor"]
2438 self._speed = p["speed"]
2440 self._resizemode = p["resizemode"]
2445 self._stretchfactor = sf
2447 self._shearfactor = p["shearfactor"]
2449 self._outlinewidth = p["outline"]
2451 self._shown = p["shown"]
2453 self._tilt = p["tilt"]
2455 scx, scy = self._stretchfactor
2456 shf = self._shearfactor
2457 sa, ca = math.sin(self._tilt), math.cos(self._tilt)
2458 self._shapetrafo = ( scx*ca, scy*(shf*ca + sa),
2460 self._update()
2464 def _newLine(self, usePos = True):
2466 def _update(self, count=True, forced=False):
2468 def _color(self, args):
2470 def _colorstr(self, args):
2486 def __init__(self, screen, shapeIndex):
2487 self.screen = screen
2488 self._type = None
2489 self._setshape(shapeIndex)
2491 def _setshape(self, shapeIndex):
2492 screen = self.screen
2493 self.shapeIndex = shapeIndex
2494 if self._type == "polygon" == screen._shapes[shapeIndex]._type:
2496 if self._type == "image" == screen._shapes[shapeIndex]._type:
2498 if self._type in ["image", "polygon"]:
2499 screen._delete(self._item)
2500 elif self._type == "compound":
2501 for item in self._item:
2503 self._type = screen._shapes[shapeIndex]._type
2504 if self._type == "polygon":
2505 self._item = screen._createpoly()
2506 elif self._type == "image":
2507 self._item = screen._createimage(screen._shapes["blank"]._data)
2508 elif self._type == "compound":
2509 self._item = [screen._createpoly() for item in
2520 def __init__(self, canvas=None,
2525 self.screen = canvas
2529 self.screen = canvas
2533 self.screen = screen
2536 self.screen = TurtleScreen(canvas)
2537 RawTurtle.screens.append(self.screen)
2541 screen = self.screen
2542 TNavigator.__init__(self, screen.mode())
2543 TPen.__init__(self)
2544 screen._turtles.append(self)
2545 self.drawingLineItem = screen._createline()
2546 self.turtle = _TurtleImage(screen, shape)
2547 self._poly = None
2548 self._creatingPoly = False
2549 self._fillitem = self._fillpath = None
2550 self._shown = visible
2551 self._hidden_from_screen = False
2552 self.currentLineItem = screen._createline()
2553 self.currentLine = [self._position]
2554 self.items = [self.currentLineItem]
2555 self.stampItems = []
2556 self._undobuffersize = undobuffersize
2557 self.undobuffer = Tbuffer(undobuffersize)
2558 self._update()
2560 def reset(self):
2579 TNavigator.reset(self)
2580 TPen._reset(self)
2581 self._clear()
2582 self._drawturtle()
2583 self._update()
2585 def setundobuffer(self, size):
2600 self.undobuffer = None
2602 self.undobuffer = Tbuffer(size)
2604 def undobufferentries(self):
2613 if self.undobuffer is None:
2615 return self.undobuffer.nr_of_items()
2617 def _clear(self):
2619 self._fillitem = self._fillpath = None
2620 for item in self.items:
2621 self.screen._delete(item)
2622 self.currentLineItem = self.screen._createline()
2623 self.currentLine = []
2624 if self._drawing:
2625 self.currentLine.append(self._position)
2626 self.items = [self.currentLineItem]
2627 self.clearstamps()
2628 self.setundobuffer(self._undobuffersize)
2631 def clear(self):
2643 self._clear()
2644 self._update()
2646 def _update_data(self):
2647 self.screen._incrementudc()
2648 if self.screen._updatecounter != 0:
2650 if len(self.currentLine)>1:
2651 self.screen._drawline(self.currentLineItem, self.currentLine,
2652 self._pencolor, self._pensize)
2654 def _update(self):
2657 screen = self.screen
2661 self._update_data()
2662 self._drawturtle()
2666 self._update_data()
2672 def _tracer(self, flag=None, delay=None):
2691 return self.screen.tracer(flag, delay)
2693 def _color(self, args):
2694 return self.screen._color(args)
2696 def _colorstr(self, args):
2697 return self.screen._colorstr(args)
2699 def _cc(self, args):
2708 if self.screen._colormode == 1.0:
2714 def clone(self):
2726 screen = self.screen
2727 self._newLine(self._drawing)
2729 turtle = self.turtle
2730 self.screen = None
2731 self.turtle = None # too make self deepcopy-able
2733 q = deepcopy(self)
2735 self.screen = screen
2736 self.turtle = turtle
2739 q.turtle = _TurtleImage(screen, self.turtle.shapeIndex)
2742 ttype = screen._shapes[self.turtle.shapeIndex]._type
2749 screen._shapes[self.turtle.shapeIndex]._data]
2754 def shape(self, name=None):
2775 return self.turtle.shapeIndex
2776 if not name in self.screen.getshapes():
2778 self.turtle._setshape(name)
2779 self._update()
2781 def shapesize(self, stretch_wid=None, stretch_len=None, outline=None):
2803 stretch_wid, stretch_len = self._stretchfactor
2804 return stretch_wid, stretch_len, self._outlinewidth
2813 stretchfactor = self._stretchfactor[0], stretch_len
2815 stretchfactor = self._stretchfactor
2817 outline = self._outlinewidth
2818 self.pen(resizemode="user",
2821 def shearfactor(self, shear=None):
2841 return self._shearfactor
2842 self.pen(resizemode="user", shearfactor=shear)
2844 def settiltangle(self, angle):
2869 self.tiltangle(angle)
2871 def tiltangle(self, angle=None):
2903 tilt = -math.degrees(self._tilt) * self._angleOrient
2904 return (tilt / self._degreesPerAU) % self._fullcircle
2906 tilt = -angle * self._degreesPerAU * self._angleOrient
2908 self.pen(resizemode="user", tilt=tilt)
2910 def tilt(self, angle):
2927 self.tiltangle(angle + self.tiltangle())
2929 def shapetransform(self, t11=None, t12=None, t21=None, t22=None):
2950 return self._shapetrafo
2951 m11, m12, m21, m22 = self._shapetrafo
2958 self._shapetrafo = (m11, m12, m21, m22)
2963 self._stretchfactor = a11, a22
2964 self._shearfactor = a12/a22
2965 self._tilt = alfa
2966 self.pen(resizemode="user")
2969 def _polytrafo(self, poly):
2973 screen = self.screen
2974 p0, p1 = self._position
2975 e0, e1 = self._orient
2981 def get_shapepoly(self):
2993 shape = self.screen._shapes[self.turtle.shapeIndex]
2995 return self._getshapepoly(shape._data, shape._type == "compound")
2998 def _getshapepoly(self, polygon, compound=False):
3002 if self._resizemode == "user" or compound:
3003 t11, t12, t21, t22 = self._shapetrafo
3004 elif self._resizemode == "auto":
3005 l = max(1, self._pensize/5.0)
3007 elif self._resizemode == "noresize":
3011 def _drawturtle(self):
3014 screen = self.screen
3015 shape = screen._shapes[self.turtle.shapeIndex]
3017 titem = self.turtle._item
3018 if self._shown and screen._updatecounter == 0 and screen._tracing > 0:
3019 self._hidden_from_screen = False
3022 if self._resizemode == "noresize": w = 1
3023 elif self._resizemode == "auto": w = self._pensize
3024 else: w =self._outlinewidth
3025 shape = self._polytrafo(self._getshapepoly(tshape))
3026 fc, oc = self._fillcolor, self._pencolor
3030 screen._drawimage(titem, self._position, tshape)
3033 poly = self._polytrafo(self._getshapepoly(poly, True))
3034 screen._drawpoly(item, poly, fill=self._cc(fc),
3035 outline=self._cc(oc), width=self._outlinewidth, top=True)
3037 if self._hidden_from_screen:
3042 screen._drawimage(titem, self._position,
3047 self._hidden_from_screen = True
3051 def stamp(self):
3066 screen = self.screen
3067 shape = screen._shapes[self.turtle.shapeIndex]
3072 if self._resizemode == "noresize": w = 1
3073 elif self._resizemode == "auto": w = self._pensize
3074 else: w =self._outlinewidth
3075 shape = self._polytrafo(self._getshapepoly(tshape))
3076 fc, oc = self._fillcolor, self._pencolor
3081 screen._drawimage(stitem, self._position, tshape)
3089 poly = self._polytrafo(self._getshapepoly(poly, True))
3090 screen._drawpoly(item, poly, fill=self._cc(fc),
3091 outline=self._cc(oc), width=self._outlinewidth, top=True)
3092 self.stampItems.append(stitem)
3093 self.undobuffer.push(("stamp", stitem))
3096 def _clearstamp(self, stampid):
3099 if stampid in self.stampItems:
3102 self.screen._delete(subitem)
3104 self.screen._delete(stampid)
3105 self.stampItems.remove(stampid)
3109 buf = self.undobuffer
3118 def clearstamp(self, stampid):
3130 self._clearstamp(stampid)
3131 self._update()
3133 def clearstamps(self, n=None):
3152 toDelete = self.stampItems[:]
3154 toDelete = self.stampItems[:n]
3156 toDelete = self.stampItems[n:]
3158 self._clearstamp(item)
3159 self._update()
3161 def _goto(self, end):
3167 go_modes = ( self._drawing,
3168 self._pencolor,
3169 self._pensize,
3170 isinstance(self._fillpath, list))
3171 screen = self.screen
3172 undo_entry = ("go", self._position, end, go_modes,
3173 (self.currentLineItem,
3174 self.currentLine[:],
3175 screen._pointlist(self.currentLineItem),
3176 self.items[:])
3178 if self.undobuffer:
3179 self.undobuffer.push(undo_entry)
3180 start = self._position
3181 if self._speed and screen._tracing == 1:
3184 nhops = 1+int((diffsq**0.5)/(3*(1.1**self._speed)*self._speed))
3191 self._position = start + delta * n
3192 if self._drawing:
3193 screen._drawline(self.drawingLineItem,
3194 (start, self._position),
3195 self._pencolor, self._pensize, top)
3196 self._update()
3197 if self._drawing:
3198 screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)),
3199 fill="", width=self._pensize)
3201 if self._drawing: # now update currentLine
3202 self.currentLine.append(end)
3203 if isinstance(self._fillpath, list):
3204 self._fillpath.append(end)
3206 self._position = end
3207 if self._creatingPoly:
3208 self._poly.append(end)
3209 if len(self.currentLine) > 42: # 42! answer to the ultimate question
3211 self._newLine()
3212 self._update() #count=True)
3214 def _undogoto(self, entry):
3220 screen = self.screen
3221 if abs(self._position - new) > 0.5:
3224 self.currentLineItem = cLI
3225 self.currentLine = cL
3233 todelete = [i for i in self.items if (i not in items) and
3237 self.items.remove(i)
3240 if self._speed and screen._tracing == 1:
3243 nhops = 1+int((diffsq**0.5)/(3*(1.1**self._speed)*self._speed))
3250 self._position = new + delta * n
3252 screen._drawline(self.drawingLineItem,
3253 (start, self._position),
3255 self._update()
3257 screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)),
3260 self._position = old
3265 if self._creatingPoly:
3266 if len(self._poly) > 0:
3267 self._poly.pop()
3268 if self._poly == []:
3269 self._creatingPoly = False
3270 self._poly = None
3272 if self._fillpath == []:
3273 self._fillpath = None
3275 elif self._fillpath is not None:
3276 self._fillpath.pop()
3277 self._update() #count=True)
3279 def _rotate(self, angle):
3282 if self.undobuffer:
3283 self.undobuffer.push(("rot", angle, self._degreesPerAU))
3284 angle *= self._degreesPerAU
3285 neworient = self._orient.rotate(angle)
3286 tracing = self.screen._tracing
3287 if tracing == 1 and self._speed > 0:
3288 anglevel = 3.0 * self._speed
3292 self._orient = self._orient.rotate(delta)
3293 self._update()
3294 self._orient = neworient
3295 self._update()
3297 def _newLine(self, usePos=True):
3302 if len(self.currentLine) > 1:
3303 self.screen._drawline(self.currentLineItem, self.currentLine,
3304 self._pencolor, self._pensize)
3305 self.currentLineItem = self.screen._createline()
3306 self.items.append(self.currentLineItem)
3308 self.screen._drawline(self.currentLineItem, top=True)
3309 self.currentLine = []
3311 self.currentLine = [self._position]
3313 def filling(self):
3325 return isinstance(self._fillpath, list)
3327 def begin_fill(self):
3338 if not self.filling():
3339 self._fillitem = self.screen._createpoly()
3340 self.items.append(self._fillitem)
3341 self._fillpath = [self._position]
3342 self._newLine()
3343 if self.undobuffer:
3344 self.undobuffer.push(("beginfill", self._fillitem))
3345 self._update()
3348 def end_fill(self):
3359 if self.filling():
3360 if len(self._fillpath) > 2:
3361 self.screen._drawpoly(self._fillitem, self._fillpath,
3362 fill=self._fillcolor)
3363 if self.undobuffer:
3364 self.undobuffer.push(("dofill", self._fillitem))
3365 self._fillitem = self._fillpath = None
3366 self._update()
3368 def dot(self, size=None, *color):
3384 color = self._colorstr(size)
3385 size = self._pensize + max(self._pensize, 4)
3387 color = self._pencolor
3389 size = self._pensize + max(self._pensize, 4)
3392 size = self._pensize + max(self._pensize, 4)
3393 color = self._colorstr(color)
3394 if hasattr(self.screen, "_dot"):
3395 item = self.screen._dot(self._position, size, color)
3396 self.items.append(item)
3397 if self.undobuffer:
3398 self.undobuffer.push(("dot", item))
3400 pen = self.pen()
3401 if self.undobuffer:
3402 self.undobuffer.push(["seq"])
3403 self.undobuffer.cumulate = True
3405 if self.resizemode() == 'auto':
3406 self.ht()
3407 self.pendown()
3408 self.pensize(size)
3409 self.pencolor(color)
3410 self.forward(0)
3412 self.pen(pen)
3413 if self.undobuffer:
3414 self.undobuffer.cumulate = False
3416 def _write(self, txt, align, font):
3419 item, end = self.screen._write(self._position, txt, align, font,
3420 self._pencolor)
3421 self._update()
3422 self.items.append(item)
3423 if self.undobuffer:
3424 self.undobuffer.push(("wri", item))
3427 def write(self, arg, move=False, align="left", font=("Arial", 8, "normal")):
3446 if self.undobuffer:
3447 self.undobuffer.push(["seq"])
3448 self.undobuffer.cumulate = True
3449 end = self._write(str(arg), align.lower(), font)
3451 x, y = self.pos()
3452 self.setpos(end, y)
3453 if self.undobuffer:
3454 self.undobuffer.cumulate = False
3456 def begin_poly(self):
3467 self._poly = [self._position]
3468 self._creatingPoly = True
3470 def end_poly(self):
3481 self._creatingPoly = False
3483 def get_poly(self):
3493 if self._poly is not None:
3494 return tuple(self._poly)
3496 def getscreen(self):
3510 return self.screen
3512 def getturtle(self):
3527 return self
3536 def _delay(self, delay=None):
3539 return self.screen.delay(delay)
3541 def onclick(self, fun, btn=1, add=None):
3559 self.screen._onclick(self.turtle._item, fun, btn, add)
3560 self._update()
3562 def onrelease(self, fun, btn=1, add=None):
3572 ... def glow(self,x,y):
3573 ... self.fillcolor("red")
3574 ... def unglow(self,x,y):
3575 ... self.fillcolor("")
3584 self.screen._onrelease(self.turtle._item, fun, btn, add)
3585 self._update()
3587 def ondrag(self, fun, btn=1, add=None):
3605 self.screen._ondrag(self.turtle._item, fun, btn, add)
3608 def _undo(self, action, data):
3611 if self.undobuffer is None:
3615 self._rotate(-angle*degPAU/self._degreesPerAU)
3616 dummy = self.undobuffer.pop()
3619 self.clearstamp(stitem)
3621 self._undogoto(data)
3624 self.screen._delete(item)
3625 self.items.remove(item)
3628 self.screen._drawpoly(item, ((0, 0),(0, 0),(0, 0)),
3632 self._fillitem = self._fillpath = None
3633 if item in self.items:
3634 self.screen._delete(item)
3635 self.items.remove(item)
3637 TPen.pen(self, data[0])
3638 self.undobuffer.pop()
3640 def undo(self):
3657 if self.undobuffer is None:
3659 item = self.undobuffer.pop()
3665 self._undo(item[0], item[1:])
3667 self._undo(action, data)
3689 def __init__(self):
3696 _Screen._root = self._root = _Root()
3697 self._root.title(_Screen._title)
3698 self._root.ondestroy(self._destroy)
3706 self._root.setupcanvas(width, height, canvwidth, canvheight)
3707 _Screen._canvas = self._root._getcanvas()
3708 TurtleScreen.__init__(self, _Screen._canvas)
3709 self.setup(width, height, leftright, topbottom)
3711 def setup(self, width=_CFG["width"], height=_CFG["height"],
3736 if not hasattr(self._root, "set_geometry"):
3738 sw = self._root.win_width()
3739 sh = self._root.win_height()
3748 self._root.set_geometry(width, height, startx, starty)
3749 self.update()
3751 def title(self, titlestring):
3768 def _destroy(self):
3769 root = self._root
3778 def bye(self):
3784 self._destroy()
3786 def exitonclick(self):
3807 self.bye()
3808 self.onclick(exitGracefully)
3825 def __init__(self,
3831 RawTurtle.__init__(self, Turtle._screen,
3907 call. The "self" parameter is not included.
3911 # but we drop the "self" param.