#!/usr/bin/python

import sys
import Image
import wx
import wx.aui
import operator
# import ImageWin

# ImageSequence?

imgs = []

def pilImage_to_wxBitmap(pilImage):
    """convert pil Image to wx Bitmap with Alpha"""
    
    # http://jehiah.cz/archive/pil-to-wxbitmap, except that
    #   it gave me 0xff for alpha which was pointless...
    image = wx.EmptyImage(*pilImage.size)
    # RGB/RGBA are one byte per channel...
    image.SetData(pilImage.convert("RGB").tostring())
    # image.SetAlphaData(pilImage.convert("RGBA").tostring()[3::4])
    image.SetAlphaData(chr(128) * operator.mul(*pilImage.size))
    # adjust?
    image.AdjustChannels(1.0,1.0,1.0,0.8)
    # DrawBitmap wants a bitmap...
    bitmap = wx.BitmapFromImage(image)
    return bitmap


class TestPanel(wx.Panel):
    def __init__(self, parent, imgs):
        self.imgs = imgs
        self.bitmaps = [pilImage_to_wxBitmap(img) for img in self.imgs]
        wx.Panel.__init__(self, parent, -1)
        self.Bind(wx.EVT_PAINT, self.OnPaint)
        self.Bind(wx.EVT_CHAR, self.OnChar)
        self.x_offset = []
        self.y_offset = []
        self.forward = True
        for offset in range(len(self.bitmaps)):
            self.x_offset.append(offset * 50)
            self.y_offset.append(offset * 50)

    def OnChar(self, evt):
        # needs focus...
        # wx.WXK_RETURN
        wxk = evt.GetKeyCode()
        if wxk == ord("q"):
            print zip(self.x_offset, self.y_offset)
            sys.exit()
        elif wxk == wx.WXK_UP:
            self.y_offset[1] -= 1
        elif wxk == wx.WXK_DOWN:
            self.y_offset[1] += 1
        elif wxk == wx.WXK_LEFT:
            self.x_offset[1] -= 1
        elif wxk == wx.WXK_RIGHT:
            self.x_offset[1] += 1
        elif wxk == ord(" "):
            self.forward = not self.forward
        else:
            print "key:", wxk
        self.OnPaint(None)

    def OnPaint(self, evt):
        pdc = wx.BufferedDC(wx.PaintDC(self))

        # dc = wx.GCDC(pdc)

        if False:
            # paint a background to show the alpha manipulation
            pdc.SetBackground(wx.Brush("BLUE"))
            pdc.Clear()
            pdc.SetBrush(wx.Brush("WHITE", wx.CROSSDIAG_HATCH))
            windowsize = self.GetSizeTuple()
            print windowsize
            pdc.DrawRectangle(0, 0, windowsize[0], windowsize[1])
        else:
            pdc.SetBackground(wx.Brush("WHITE"))
            pdc.Clear()

            
        x_shift = min(self.x_offset)
        y_shift = min(self.y_offset)
        work = zip(self.x_offset, self.y_offset, self.bitmaps)
        if not self.forward:
            work.reverse()
        for x_offset, y_offset, bitmap in work:
            # handle clipping...
            pdc.DrawBitmap(bitmap, 
                           x_offset - x_shift, 
                           y_offset - y_shift, 
                           True)


        # penclr   = wx.Colour(0, 0, 0, wx.ALPHA_OPAQUE)
        # brushclr = wx.Colour(0, 0, 0, 128)   # half transparent
        # pdc.SetPen(wx.Pen(penclr))
        # pdc.SetBrush(wx.Brush(brushclr))
        # pdc.SetBackground(wx.Brush(brushclr))

        # print dir(pdc)
        # pdc.SetBackgroundMode(wx.TRANSPARENT)

    def not_doing_this(self):
        rect = wx.Rect(0,0, 100, 100)
        for RGB, pos in [((178,  34,  34), ( 50,  90)),
                         (( 35, 142,  35), (110, 150)),
                         ((  0,   0, 139), (170,  90))
                         ]:
            r, g, b = RGB
            penclr   = wx.Colour(r, g, b, wx.ALPHA_OPAQUE)
            brushclr = wx.Colour(r, g, b, 128)   # half transparent
            dc.SetPen(wx.Pen(penclr))
            dc.SetBrush(wx.Brush(brushclr))
            rect.SetPosition(pos)
            dc.DrawRoundedRectangleRect(rect, 8)

def display_blended(paths):
    global imgs
    imgs = [Image.open(path) for path in paths]
    #for img in imgs:
    #    print img.mode

    wxstuff()

#     dib = ImageWin.Dib()
#     hwnd = ImageWin.HWND(widget.winfo_id())
#     dib.draw(hwnd, xy)


class MyApp(wx.App):
    def OnInit(self):
        self.frame = wx.Frame(None)
        # self.nb = wx.Notebook(self.frame, -1, style=wx.CLIP_CHILDREN)
        # print dir(self.frame)
        self.tp = TestPanel(self.frame, imgs)
        self.frame.Show()
        self.mgr = wx.aui.AuiManager()
        self.mgr.SetManagedWindow(self.frame)
        # self.mgr.AddPane(self.frame, wx.aui.AuiPaneInfo().CenterPane().Name("Notebook"))
        self.mgr.Update()
        self.tp.SetFocus() # otherwise we need a click to get it

        return True

def wxstuff():
    app = MyApp(False)
    app.MainLoop()


if __name__ == "__main__":
    display_blended(sys.argv[1:])


# http://sandbox.manning.com/thread.jspa?messageID=59056
# >>> import wx
# >>> frame = wx.GetTopLevelParent(shell)
# >>> frame.SetTransparent(200) 
# returns false...


# http://www.zetcode.com/wxpython/events/