golden hour

/usr/lib64/python2.7/Demo/tkinter/guido

File/Folder	Size	Actions
AttrDialog.py	14 KB
AttrDialog.pyc	18.34 KB
AttrDialog.pyo	18.34 KB
ManPage.py	6.7 KB
ManPage.pyc	6.27 KB
ManPage.pyo	6.27 KB
MimeViewer.py	4.39 KB
MimeViewer.pyc	4.83 KB
MimeViewer.pyo	4.83 KB
ShellWindow.py	4.07 KB
ShellWindow.pyc	5.47 KB
ShellWindow.pyo	5.47 KB
brownian.py	1.07 KB
brownian.pyc	1.59 KB
brownian.pyo	1.59 KB
brownian2.py	1.35 KB
brownian2.pyc	1.74 KB
brownian2.pyo	1.74 KB
canvasevents.py	6.45 KB
canvasevents.pyc	10.46 KB
canvasevents.pyo	10.46 KB
dialog.py	3.13 KB
dialog.pyc	3.11 KB
dialog.pyo	3.11 KB
electrons.py	2.27 KB
electrons.pyc	2.33 KB
electrons.pyo	2.33 KB
hanoi.py	4.54 KB
hanoi.pyc	3.82 KB
hanoi.pyo	3.82 KB
hello.py	331 B
hello.pyc	701 B
hello.pyo	701 B
imagedraw.py	509 B
imagedraw.pyc	1.13 KB
imagedraw.pyo	1.13 KB
imageview.py	205 B
imageview.pyc	570 B
imageview.pyo	570 B
kill.py	3.79 KB
kill.pyc	4.81 KB
kill.pyo	4.81 KB
listtree.py	991 B
listtree.pyc	1.5 KB
listtree.pyo	1.5 KB
mbox.py	7.3 KB
mbox.pyc	8.17 KB
mbox.pyo	8.17 KB
newmenubardemo.py	1.2 KB
newmenubardemo.pyc	1.59 KB
newmenubardemo.pyo	1.59 KB
optionmenu.py	441 B
optionmenu.pyc	594 B
optionmenu.pyo	594 B
paint.py	1.85 KB
paint.pyc	2.19 KB
paint.pyo	2.19 KB
rmt.py	4.39 KB
rmt.pyc	4.93 KB
rmt.pyo	4.93 KB
solitaire.py	17.37 KB
solitaire.pyc	20.41 KB
solitaire.pyo	20.41 KB
sortvisu.py	18.89 KB
sortvisu.pyc	23.18 KB
sortvisu.pyo	23.18 KB
ss1.py	25.57 KB
ss1.pyc	31.67 KB
ss1.pyo	31.07 KB
svkill.py	4.75 KB
svkill.pyc	5.8 KB
svkill.pyo	5.8 KB
switch.py	1.52 KB
switch.pyc	2.85 KB
switch.pyo	2.85 KB
tkman.py	8.79 KB
tkman.pyc	8.88 KB
tkman.pyo	8.88 KB
wish.py	623 B
wish.pyc	736 B
wish.pyo	736 B

Edit: canvasevents.py

#! /usr/bin/env python

from Tkinter import *
from Canvas import Oval, Group, CanvasText

# Fix a bug in Canvas.Group as distributed in Python 1.4.  The
# distributed bind() method is broken.  This is what should be used:

class Group(Group):
    def bind(self, sequence=None, command=None):
        return self.canvas.tag_bind(self.id, sequence, command)

class Object:

"""Base class for composite graphical objects.

Objects belong to a canvas, and can be moved around on the canvas.
    They also belong to at most one ``pile'' of objects, and can be
    transferred between piles (or removed from their pile).

Objects have a canonical ``x, y'' position which is moved when the
    object is moved.  Where the object is relative to this position
    depends on the object; for simple objects, it may be their center.

Objects have mouse sensitivity.  They can be clicked, dragged and
    double-clicked.  The behavior may actually determined by the pile
    they are in.

All instance attributes are public since the derived class may
    need them.

"""

def __init__(self, canvas, x=0, y=0, fill='red', text='object'):
        self.canvas = canvas
        self.x = x
        self.y = y
        self.pile = None
        self.group = Group(self.canvas)
        self.createitems(fill, text)

def __str__(self):
        return str(self.group)

def createitems(self, fill, text):
        self.__oval = Oval(self.canvas,
                           self.x-20, self.y-10, self.x+20, self.y+10,
                           fill=fill, width=3)
        self.group.addtag_withtag(self.__oval)
        self.__text = CanvasText(self.canvas,
                           self.x, self.y, text=text)
        self.group.addtag_withtag(self.__text)

def moveby(self, dx, dy):
        if dx == dy == 0:
            return
        self.group.move(dx, dy)
        self.x = self.x + dx
        self.y = self.y + dy

def moveto(self, x, y):
        self.moveby(x - self.x, y - self.y)

def transfer(self, pile):
        if self.pile:
            self.pile.delete(self)
            self.pile = None
        self.pile = pile
        if self.pile:
            self.pile.add(self)

def tkraise(self):
        self.group.tkraise()

class Bottom(Object):

"""An object to serve as the bottom of a pile."""

def createitems(self, *args):
        self.__oval = Oval(self.canvas,
                           self.x-20, self.y-10, self.x+20, self.y+10,
                           fill='gray', outline='')
        self.group.addtag_withtag(self.__oval)

class Pile:

"""A group of graphical objects."""

def __init__(self, canvas, x, y, tag=None):
        self.canvas = canvas
        self.x = x
        self.y = y
        self.objects = []
        self.bottom = Bottom(self.canvas, self.x, self.y)
        self.group = Group(self.canvas, tag=tag)
        self.group.addtag_withtag(self.bottom.group)
        self.bindhandlers()

def bindhandlers(self):
        self.group.bind('<1>', self.clickhandler)
        self.group.bind('<Double-1>', self.doubleclickhandler)

def add(self, object):
        self.objects.append(object)
        self.group.addtag_withtag(object.group)
        self.position(object)

def delete(self, object):
        object.group.dtag(self.group)
        self.objects.remove(object)

def position(self, object):
        object.tkraise()
        i = self.objects.index(object)
        object.moveto(self.x + i*4, self.y + i*8)

def clickhandler(self, event):
        pass

def doubleclickhandler(self, event):
        pass

class MovingPile(Pile):

def bindhandlers(self):
        Pile.bindhandlers(self)
        self.group.bind('<B1-Motion>', self.motionhandler)
        self.group.bind('<ButtonRelease-1>', self.releasehandler)

movethis = None

def clickhandler(self, event):
        tags = self.canvas.gettags('current')
        for i in range(len(self.objects)):
            o = self.objects[i]
            if o.group.tag in tags:
                break
        else:
            self.movethis = None
            return
        self.movethis = self.objects[i:]
        for o in self.movethis:
            o.tkraise()
        self.lastx = event.x
        self.lasty = event.y

doubleclickhandler = clickhandler

def motionhandler(self, event):
        if not self.movethis:
            return
        dx = event.x - self.lastx
        dy = event.y - self.lasty
        self.lastx = event.x
        self.lasty = event.y
        for o in self.movethis:
            o.moveby(dx, dy)

def releasehandler(self, event):
        objects = self.movethis
        if not objects:
            return
        self.movethis = None
        self.finishmove(objects)

def finishmove(self, objects):
        for o in objects:
            self.position(o)

class Pile1(MovingPile):

x = 50
    y = 50
    tag = 'p1'

def __init__(self, demo):
        self.demo = demo
        MovingPile.__init__(self, self.demo.canvas, self.x, self.y, self.tag)

def doubleclickhandler(self, event):
        try:
            o = self.objects[-1]
        except IndexError:
            return
        o.transfer(self.other())
        MovingPile.doubleclickhandler(self, event)

def other(self):
        return self.demo.p2

def finishmove(self, objects):
        o = objects[0]
        p = self.other()
        x, y = o.x, o.y
        if (x-p.x)**2 + (y-p.y)**2 < (x-self.x)**2 + (y-self.y)**2:
            for o in objects:
                o.transfer(p)
        else:
            MovingPile.finishmove(self, objects)

class Pile2(Pile1):

x = 150
    y = 50
    tag = 'p2'

def other(self):
        return self.demo.p1

class Demo:

def __init__(self, master):
        self.master = master
        self.canvas = Canvas(master,
                             width=200, height=200,
                             background='yellow',
                             relief=SUNKEN, borderwidth=2)
        self.canvas.pack(expand=1, fill=BOTH)
        self.p1 = Pile1(self)
        self.p2 = Pile2(self)
        o1 = Object(self.canvas, fill='red', text='o1')
        o2 = Object(self.canvas, fill='green', text='o2')
        o3 = Object(self.canvas, fill='light blue', text='o3')
        o1.transfer(self.p1)
        o2.transfer(self.p1)
        o3.transfer(self.p2)

# Main function, run when invoked as a stand-alone Python program.

def main():
    root = Tk()
    demo = Demo(root)
    root.protocol('WM_DELETE_WINDOW', root.quit)
    root.mainloop()

if __name__ == '__main__':
    main()