from hgoldfish.utils import eventlet
from eventlet.green import urllib
from PyQt4.QtCore import Qt
from PyQt4.QtGui import QApplication, QTextBrowser

class TestWidget(QTextBrowser):
    def __init__(self):
        QTextBrowser.__init__(self)
        self.operations = eventlet.GreenletGroup()

    def mousePressEvent(self, event):
        if event.button() == Qt.MidButton:
            self.operations.spawn(self.getpage)
        QTextBrowser.mousePressEvent(self, event)

    def getpage(self):
        page = urllib.urlopen("http://code.google.com/p/eventlet-pyqt/").read().decode("utf-8")
        self.setHtml(page)

app = QApplication([])
w = TestWidget()
w.show()
eventlet.start_application(quitOnLastWindowClosed = True)

def submitTask(self):
    self.labelStatus.setText("正在提交任务")
    try:
        with eventlet.Timeout(30):
            self.server.submitTask(self.task)
    except eventlet.Timeout:
        self.labelStatus.setText("任务超时")
    except:
        self.labelStatus.setText("发生错误")
    else:
        self.labelStatus.setText("任务完成")

def processTasks():
    for task in self.allTasks:
        success = self.server.submitTask(task) #阻塞当前greenlet
        if success:
            self.taskModel.markFinished() #UI操作，非线程安全
        else:
            self.taskModel.markFailed()   #UI操作，非线程安全
    self.submitButton.setEnabled(True)    #UI操作，非线程安全

def on_submitButton_clicked(self):
    self.opeations.spawn(self.processTasks)
    self.submitButton.setEnabled(False)

def scanTree(self, path):
    i = 0
    for root, dirnames, filenames in os.walk(path):
        for filename in filenames:
            filepath = os.path.join(root, filename)
            if isImageFile(filepath):
                #根据用户的当前浏览位置决定是否加载图片
                self.dependsOnCurrentPosition.wait(i)
                self.loadImage(filepath)
                i += 1

class DependsOnCurrentPosition:
    def __init__(self):
        self.gate = eventlet.Event()
        self.currentPosition = 0

    def wait(self, i):
        #用户浏览到最后五个文件时就加载新图片
        while i > self.currentPosition + 5:
            try:
                self.gate.wait()
            finally:
                self.gate.reset()

    def setCurrentPosition(self, pos):
        self.currentPosition = pos
        self.gate.send(None)

def sendMessage(self, remoteAddress, message):
    while True:
        self.sendUdp(remoteAddress, message)
        try:
            answer = self.waitForUdp(remoteAddress, self.timeout)
        except eventlet.Timeout:
            continue
        else:
            return answer

def waitForUdp(self, remoteAddress, timeout):
    waiter = eventlet.Event()
    self.waiters[remoteAddress] = waiter
    try:
        with eventlet.Timeout(timeout):
            return waiter.wait()
    finally:
        del self.waiters[remoteAddress]

def handleUdp(self):
    while True:
        datagram, addr = self.serverSocket.recvfrom(1024 * 8)
        self.waiters[addr].send(datagram)

def showPage1():
    animation = create_animation(block1, "left-to-right")
    waitForFinished(animation)
    animation = create_animation(block2, "right-to-left")
    waitForFinished(animation)
    animation = create_animation(block3, "top-to-bottom")
    waitForFinished(animation)
    animation = create_animation(block4, "bottom-to-top")
    waitForFinished(animation)
    while True:
        action = waitForUserAction()
        if action == "next":
            if not checkBlock1():
                QMessageBox.information(...)
                continue
            if not checkBlock2():
                ...
            break
    showPage2()

def receiveFile(self, connection):
    self.setOperations("accept", "reject")
    action = self.waitForAction()
    if action == "rejct":
        self.setOperations(withMessage = "file rejected.")
        return
    targetFilename = callMethodInEventLoop(QFileDialog.getSaveFileName, ...)
    self.setOperations("pause", "cancel")
    t = self.operations.spawn(self.pauseAndResume, eventlet.getcurrent())
    try:
        with io.open(targetFilename, "wb") as target: #明确的资源管理
            received = 0
            total = self.parseHeader(connection).total
            while True:
                #当self.gate.close()被调用时，wait()阻塞，以此来实现暂停的功能。
                #类似的还有流控功能。
                self.gate.wait()  
                buf = connection.recv(1024)
                if not buf:
                    break
                target.write(buf)
                received += len(buf)
                self.setProgress(received, total)
    except IOError: #更加明确的异常控制
        self.setOperations(withMessage = "can not write to file. ")
    except socket.error:
        self.setOperations(withMessage = "connection aborted."
    except eventlet.SystemExceptions:
        self.setOpreations(withMessage = "canceled.")
    finally: #附属的Greenlet生存周期非常明确。
        t.kill()

def pauseAndResume(self, greenlet):
    while True:
        action = self.waitForAction()
        if action == "resume":
            self.setOperations("pause", "cancel")
            self.gate.close()
        elif action == "pause":
            self.setOperations("resume", "cancel")
            self.gate.open()
        else:
            greenlet.kill()

t = self.operations.spawn(self.showProgress)
try:
    self.server.submitTask(self.task)
except socket.error:
    eventlet.exc_clear()
    callMethodInEventLoop(QMessageBox.information, self, u"提交任务时出错", u"网络错误。")
finally:
    t.kill()