"""

images.py

This module, writtn by Kenneth Lambert, supports simple image processing.  
The Image class represents either an image loaded from a GIF file or a 
blank image.  

To instantiate an image from a file, enter

image = Image(aGifFileName)                   

To instantiate a blank image, enter

image = Image(aWidth, aHeight)

Image methods:

draw()                          Displays the image in a window 
getWidth()  -> anInt            The width in pixels
getHeight() -> anInt            The height in pixels
getPixel(x, y)  -> (r, g, b)    The RGB values of pixel at x, y
setPixel(x, y, (r, g, b))       Resets pixel at x, y to (r, g, b)
save()                          Saves the image to the current file name
save(aFileName)                 Saves the image to fileName

LICENSE: This is open-source software released under the terms of the
GPL (http://www.gnu.org/licenses/gpl.html).
"""

import Tkinter
import os, os.path
tk = Tkinter
import PIL.Image
import PIL.ImageTk
Pimg = PIL.Image
Pimgtk = PIL.ImageTk

import exceptions

_root = None

class ImageView(tk.Canvas):
    def __init__(self, image,
                 title = "New Image",
                 autoflush=False):
        master = tk.Toplevel(_root)
        master.protocol("WM_DELETE_WINDOW", self.close)
        tk.Canvas.__init__(self, master,
                           width = image.getWidth(),
                           height = image.getHeight())
        self.master.title(title)
        self.pack()
        master.resizable(0,0)
        self.image = image
        self.height = image.getHeight()
        self.width = image.getWidth()
        self.autoflush = autoflush
        self.closed = False

    def close(self):
        """Close the window"""
        self.closed = True
        self.master.destroy()
        self.image.canvas = None
        _root.quit()

    def isClosed(self):
        return self.closed

    def getHeight(self):
        """Return the height of the window"""
        return self.height

    def getWidth(self):
        """Return the width of the window"""
        return self.width

class Image:
        
    def __init__(self, *args):
        self.canvas = None
        if len(args) == 1:
            name = args[0]
            if type(name) != str:
                raise Exception, 'Must be a file name'
            if not os.path.exists(args[0]):
                raise Exception, 'File not in current directory'
            self.image = Pimg.open(args[0])
            self.filename = args[0]
            box = self.image.getbbox()
            self.width = box[2]
            self.height = box[3]
        else: # arguments are width and height
            self.width, self.height = args
            self.image = Pimg.new(mode = "RGB",
                                  size = (self.width, self.height))
            self.filename = ""
            		
    def getWidth(self):
        """Returns the width of the image in pixels"""
        return self.width

    def getHeight(self):
        """Returns the height of the image in pixels"""
        return self.height

    def getPixel(self, x, y):
        """Returns a tuple (r,g,b) with the RGB color values for pixel (x,y)
        r,g,b are in range(256)

        """
        return self.image.getpixel((x, y))

    def setPixel(self, x, y, color):
        """Sets pixel (x,y) to the color given by RGB values r, g, and b.
        r,g,b should be in range(256)

        """
        self.image.putpixel((x, y), color)

    def draw(self):
        """Creates and opens a window on an image.
        The user must close the window to return control to
        the caller."""
        if not self.canvas:
            self.canvas = ImageView(self,
                                    self.filename)
        self.photoImage = Pimgtk.PhotoImage(self.image)
        self.canvas.create_image(self.width / 2,
                                 self.height / 2,
                                 image = self.photoImage)
        _root.mainloop()

    def save(self, filename = ""):
        """Saves the image to filename.  If no file name
        is provided, uses the image's file name if there
        is one; otherwise, simply returns.
        If the .gif extension is not present, it is added.
        """
        if filename == "":
            return
        else:
            self.filename = filename
        #path, name = os.path.split(filename)
        #ext = name.split(".")[-1]
        #if ext != "gif":
        #filename += ".gif"
        self.filename = filename
        self.image.save(self.filename)

    def clone(self):
        new = Image(self.width, self.height)
        new.image = self.image.copy()
        return new

    def __str__(self):
        rep = ""
        if self.filename:
            rep += ("File name: " + self.filename + "\n")
        rep += ("Width:  " + str(self.width) + \
                "\nHeight: " + str(self.height))
        return rep
    		
_root = tk.Tk()
_root.withdraw()



  

   
