import wx
import wx.animate
import os
import time
import multiprocessing


class processModal():
    def __init__(self, parentFrame, useProgress=None, objWithProgressAttribute=None, progressAttributeName=None):

        parentFrame.Enable(False)
        self.useProgress = useProgress
        self.objWithProgressAttribute = objWithProgressAttribute
        self.progressAttributeName = progressAttributeName

        event = multiprocessing.Event()
        _q = multiprocessing.Queue()
        self.event=event
        self._q = _q
        proc = multiprocessing.Process(target=self.openPopupInNewProcess, args=(_q, event))
        proc.start()

    def openPopupInNewProcess(self, _q, _event):
        app = wx.App(False)
        print "here1"
        self.modal = PopupModal(_q, _event, self.useProgress)
        app.MainLoop()
        print "after MainLoop"

    def UnShow(self, parentFrame):
        print 'calling set evet'
        self.event.set()
        parentFrame.Enable(True)

    def UpdateProgress(self):
        curVal = getattr(self.objWithProgressAttribute, self.progressAttributeName)
        self._q.put(curVal)


class PopupModal(wx.Frame):
    def __init__(self, _q, _event, useProgress=None, title="Busy, please wait."):
        #if parent:
        #   wx.Frame.__init__(self, parent, -1, title=title, size=(200,200), style=wx.FRAME_FLOAT_ON_PARENT | wx.CAPTION | wx.FRAME_TOOL_WINDOW)
        wx.Frame.__init__(self, None, -1, title=title, size=(200,200), style=wx.CAPTION | wx.FRAME_TOOL_WINDOW)
        self.TestPanel = wx.Panel(self, -1)
        self._event = _event
        self._q = _q
        self.Hsizer = wx.BoxSizer(wx.HORIZONTAL)
        self.Hsizer.AddStretchSpacer(1)
        ani = wx.animate.Animation(os.path.join(os.path.dirname(__file__), "Spinning_wheel_throbber.gif"))
        self.beachBall = wx.animate.AnimationCtrl(self.TestPanel, -1, ani)
        self.beachBall.SetUseWindowBackgroundColour()
        self.beachBall.Play()
        if useProgress:

            self.progressGauge = wx.Gauge(self.TestPanel, range=100)
            self.progressGauge.Show(False)

        self.Hsizer.AddF(self.beachBall, wx.SizerFlags(0).Center())

        self.Hsizer.AddStretchSpacer(1)
        self.TestPanel.SetSizerAndFit(self.Hsizer)


        updateTime = wx.Timer(self, -1)
        updateTime.Start(100, oneShot = False)
        #bind the timer to the re-enable function
        self.Bind(wx.EVT_TIMER, self.UpdateTimerFunc)
        self.Show()
        self.Refresh()
        print "after!"


    def Show(self):
        #self.CenterOnParent()
        #self.GetParent().Enable(False)
        wx.Frame.Show(self)
        self.Raise()


    def UnShow(self):
        #self.GetParent().Enable(True)
        self.Destroy()

    def UpdateTimerFunc(self):
        print "in timer"
        if self._event.is_set():
            print "after event set"
            self.UnShow()
        else:
            try:
                curVal = self._q.get(timeout=0.1)
                print "curval %s" % curVal
                self.UpdateProgress(curVal)
            except Exception as e: #multiprocessing.Queue.Empty:
                print "idling"
                print e
                pass
            #wx.Yield()
            #time.sleep(0.1)

        #self.UnShow()

        #wx.CallAfter(self.UpdateProgress, curVal)
        #self.UpdateProgress(curVal)

        #print "in UpdateTimerFunc %s" % curVal
        #wx.Yield()
        #time.sleep(0.1)


    def UpdateProgress(self, val):
        if hasattr(self, "beachBall"):
            if self.beachBall.IsShown():
                self.beachBall.Stop()
                self.beachBall.Show(False)
                self.Hsizer.Remove(self.beachBall)
                self.Hsizer.AddF(self.progressGauge, wx.SizerFlags(0).Center())
                self.TestPanel.SetSizerAndFit(self.Hsizer)
                self.progressGauge.Show(True)
        self.ctrl.SetValue(val)


import os


import time


class TestPanel(wx.Panel):
    def __init__(self, parent):

        wx.Panel.__init__(self, parent, -1)

        Hsizer = wx.BoxSizer(wx.HORIZONTAL)
        Hsizer.AddStretchSpacer(1)
        for name in GIFNames:
            ani = wx.animate.Animation(name)
            ctrl = wx.animate.AnimationCtrl(self, -1, ani)
            ctrl.SetUseWindowBackgroundColour()
            ctrl.Play()
            Hsizer.AddF(ctrl, wx.SizerFlags(0).Center())

        Hsizer.AddStretchSpacer(1)
        self.SetSizerAndFit(Hsizer)


class faker():
    PROGRESS=0
    def longTime(self, a,b, updateFunc=None):
        print "a %s, b %s" % (a, b)
        for i in range(10):
            time.sleep(1)
            self.PROGRESS+=10
            if updateFunc:
        print "calling updateFunc from faker"
                updateFunc()
            wx.Yield()
        return "fooNy"


class needsModalToPopup(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, parent=None, title="animate test", size=(800, 600))
        panel = wx.Panel(self, -1)
        sizer = wx.BoxSizer(wx.VERTICAL)
        btn = wx.Button(panel, -1, "Start long-running task")
        sizer.Add(btn)

        panel.SetSizer(sizer)
        panel.Layout()

        btn.Bind(wx.EVT_BUTTON, self.OnBlock)

    def OnBlock(self, event):
        f = faker()
        dlg = processModal(self, useProgress=None, objWithProgressAttribute=f, progressAttributeName="PROGRESS")
        print f.longTime(5, 'a', dlg.UpdateProgress)
        dlg.UnShow(self)


if __name__ == "__main__":
    app = wx.App(False)
    frame = needsModalToPopup()
    frame.Show()
    app.MainLoop()