def _processPendingEvents(): """Process pending application events.""" # Quit the event loop when it becomes idle. QTimer.singleShot(0, papp.quit) papp.exec_()
def waitForSignal(sender, senderSignal, timeoutMs, expectedSignalParams=None): """ Wait up to timeoutMs after calling sender() for senderSignal to be emitted. It returns True if the senderSignal was emitted; otherwise, it returns False. If expectedSignalParams is not None, it is compared against the parameters emitted by the senderSignal. This function was inspired by http://stackoverflow.com/questions/2629055/qtestlib-qnetworkrequest-not-executed/2630114#2630114. """ # Create a single-shot timer. Could use QTimer.singleShot(), # but can't cancel this / disconnect it. timer = QTimer() timer.setSingleShot(True) # Create a slot which receives a senderSignal with any number # of arguments. Check the arguments against their expected # values, if requested, storing the result in senderSignalArgsWrong[0]. # (I can't use senderSignalArgsWrong = True/False, since # non-local variables cannot be assigned in another scope). senderSignalArgsWrong = [] def senderSignalSlot(*args): # If the senderSignal args should be checked and they # don't match, then they're wrong. In all other cases, # they're right. senderSignalArgsWrong.append( (expectedSignalParams is not None) and (expectedSignalParams != args) ) # We received the requested signal, so exit the event loop. papp.quit() # Connect both signals to a slot which quits the event loop. senderSignal.connect(senderSignalSlot) timer.timeout.connect(papp.quit) # Start the sender and the timer and at the beginning of the event loop. # Just calling sender() may cause signals emitted in sender # not to reach their connected slots. QTimer.singleShot(0, sender) timer.start(timeoutMs) # Catch any exceptions which the EventLoop would otherwise catch # and not re-raise. ex = [] def excepthook(type_, value, traceback): ex.append(value) if PRINT_EXEC_TRACKBACK: oeh(type_, value, traceback) oeh = sys.excepthook sys.excepthook = excepthook # Wait for an emitted signal. papp.exec_() # If an exception occurred in the event loop, re-raise it. if ex: raise ex[0] # Clean up: don't allow the timer to call app.quit after this # function exits, which would produce "interesting" behavior. ret = timer.isActive() timer.stop() # Stopping the timer may not cancel timeout signals in the # event queue. Disconnect the signal to be sure that loop # will never receive a timeout after the function exits. # Likewise, disconnect the senderSignal for the same reason. senderSignal.disconnect(senderSignalSlot) timer.timeout.disconnect(papp.quit) # Restore the old exception hook sys.excepthook = oeh return ret and senderSignalArgsWrong and (not senderSignalArgsWrong[0])