#! /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()