class SignaltoSignalTest(UsesQCoreApplication):
def setUp(self):
UsesQCoreApplication.setUp(self)
self.receiver = ExtQObject()
self.timeline = QTimeLine(100)
def tearDown(self):
del self.timeline
del self.receiver
UsesQCoreApplication.tearDown(self)
def testSignaltoSignal(self):
self.timeline.setUpdateInterval(10)
self.timeline.finished.connect(self.app.quit)
self.timeline.valueChanged.connect(self.receiver.signalbetween)
self.receiver.signalbetween.connect(self.receiver.foo)
self.timeline.start()
self.app.exec_()
self.assert_(self.receiver.counter > 1)
class NativeSignalsTest(UsesQCoreApplication):
def setUp(self):
UsesQCoreApplication.setUp(self)
self.called = False
self.timeline = QTimeLine(100)
def tearDown(self):
del self.called
del self.timeline
UsesQCoreApplication.tearDown(self)
def testSignalWithIntArgument(self):
def valueChangedSlot(value):
self.called = True
self.assertEqual(type(value), float)
self.app.quit()
self.timeline.valueChanged.connect(valueChangedSlot)
self.timeline.start()
self.app.exec_()
self.assert_(self.called)
def testSignalWithoutArguments(self):
def finishedSlot():
self.called = True
self.app.quit()
self.timeline.finished.connect(finishedSlot)
self.timeline.start()
self.app.exec_()
self.assert_(self.called)
class SignaltoSignalTest(UsesQCoreApplication):
def setUp(self):
UsesQCoreApplication.setUp(self)
self.receiver = ExtQObject()
self.timeline = QTimeLine(100)
def tearDown(self):
del self.timeline
del self.receiver
UsesQCoreApplication.tearDown(self)
def testSignaltoSignal(self):
self.timeline.setUpdateInterval(10)
self.timeline.finished.connect(self.app.quit)
self.timeline.valueChanged.connect(self.receiver.signalbetween)
self.receiver.signalbetween.connect(self.receiver.foo)
self.timeline.start()
self.app.exec_()
self.assert_(self.receiver.counter > 1)
class FaderWidget(QWidget):
def __init__(self, old_widget, new_widget):
QWidget.__init__(self, new_widget)
self.old_pixmap = QPixmap(new_widget.size())
old_widget.render(self.old_pixmap)
self.pixmap_opacity = 1.0
self.timeline = QTimeLine()
self.timeline.valueChanged.connect(self.animate)
self.timeline.finished.connect(self.close)
self.timeline.setDuration(333)
self.timeline.start()
self.resize(new_widget.size())
self.show()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setOpacity(self.pixmap_opacity)
painter.drawPixmap(0, 0, self.old_pixmap)
painter.end()
def animate(self, value):
self.pixmap_opacity = 1.0 - value
self.repaint()
def testWithArgs(self):
"""Connect python signals to QTimeLine.setCurrentTime(int)"""
timeline = QTimeLine()
dummy = Dummy()
QObject.connect(dummy, SIGNAL("dummy(int)"), timeline, SLOT("setCurrentTime(int)"))
current = timeline.currentTime()
dummy.emit(SIGNAL("dummy(int)"), current + 42)
self.assertEqual(timeline.currentTime(), current + 42)
def testWithArgs(self):
'''Connect python signals to QTimeLine.setCurrentTime(int)'''
timeline = QTimeLine()
dummy = Dummy()
QObject.connect(dummy, SIGNAL('dummy(int)'),
timeline, SLOT('setCurrentTime(int)'))
current = timeline.currentTime()
dummy.emit(SIGNAL('dummy(int)'), current+42)
self.assertEqual(timeline.currentTime(), current+42)
def config_animate_to(t,item,x,y):
# used to animate an item in specific ways
animation = QGraphicsItemAnimation()
# create a timeline (1 sec here)
timeline = QTimeLine(100)
timeline.setFrameRange(0,200) # 200 steps
#item should at 'x,y' by time 't's
animation.setPosAt(t,QPointF(x,y))
animation.setItem(item) # animate this item
animation.setTimeLine(timeline) # with this duration/steps
return animation
def testWithoutArgs(self):
"""Connect python signal to QTimeLine.toggleDirection()"""
timeline = QTimeLine()
dummy = Dummy()
QObject.connect(dummy, SIGNAL("dummy()"), timeline, SLOT("toggleDirection()"))
orig_dir = timeline.direction()
dummy.emit(SIGNAL("dummy()"))
new_dir = timeline.direction()
if orig_dir == QTimeLine.Forward:
self.assertEqual(new_dir, QTimeLine.Backward)
else:
self.assertEqual(new_dir, QTimeLine.Forward)
def testWithoutArgs(self):
'''Connect python signal to QTimeLine.toggleDirection()'''
timeline = QTimeLine()
dummy = Dummy()
QObject.connect(dummy, SIGNAL('dummy()'),
timeline, SLOT('toggleDirection()'))
orig_dir = timeline.direction()
dummy.emit(SIGNAL('dummy()'))
new_dir = timeline.direction()
if orig_dir == QTimeLine.Forward:
self.assertEqual(new_dir, QTimeLine.Backward)
else:
self.assertEqual(new_dir, QTimeLine.Forward)
def __init__(self, old_widget, new_widget):
QWidget.__init__(self, new_widget)
self.old_pixmap = QPixmap(new_widget.size())
old_widget.render(self.old_pixmap)
self.pixmap_opacity = 1.0
self.timeline = QTimeLine()
self.timeline.valueChanged.connect(self.animate)
self.timeline.finished.connect(self.close)
self.timeline.setDuration(333)
self.timeline.start()
self.resize(new_widget.size())
self.show()
def testWithoutArgs(self):
"""Connect QProcess.started() to QTimeLine.togglePaused()"""
process = QProcess()
timeline = QTimeLine()
QObject.connect(process, SIGNAL("finished(int, QProcess::ExitStatus)"), timeline, SLOT("toggleDirection()"))
orig_dir = timeline.direction()
process.start(sys.executable, ["-c", '"print 42"'])
process.waitForFinished()
new_dir = timeline.direction()
if orig_dir == QTimeLine.Forward:
self.assertEqual(new_dir, QTimeLine.Backward)
else:
self.assertEqual(new_dir, QTimeLine.Forward)
def testWithoutArgs(self):
'''Connect QProcess.started() to QTimeLine.togglePaused()'''
process = QProcess()
timeline = QTimeLine()
QObject.connect(process, SIGNAL('finished(int, QProcess::ExitStatus)'),
timeline, SLOT('toggleDirection()'))
orig_dir = timeline.direction()
process.start(sys.executable, ['-c', '"print 42"'])
process.waitForFinished()
new_dir = timeline.direction()
if orig_dir == QTimeLine.Forward:
self.assertEqual(new_dir, QTimeLine.Backward)
else:
self.assertEqual(new_dir, QTimeLine.Forward)
class NativeSignalsTest(UsesQCoreApplication):
def setUp(self):
UsesQCoreApplication.setUp(self)
self.called = False
self.timeline = QTimeLine(100)
def tearDown(self):
del self.called
del self.timeline
UsesQCoreApplication.tearDown(self)
def testSignalWithIntArgument(self):
def valueChangedSlot(value):
self.called = True
self.assertEqual(type(value), float)
self.app.quit()
self.timeline.valueChanged.connect(valueChangedSlot)
self.timeline.start()
self.app.exec_()
self.assert_(self.called)
def testSignalWithoutArguments(self):
def finishedSlot():
self.called = True
self.app.quit()
self.timeline.finished.connect(finishedSlot)
self.timeline.start()
self.app.exec_()
self.assert_(self.called)
def __init__(self):
CallbackRegister.__init__(self)
QObject.__init__(self)
self.callbacks_tail = []
self.time_line = QTimeLine()
# print 'pido el logger'
Logger.getLoggerFor(self.__class__)
# print 'pedi el logger %s' % self.__class__.logger
self.condition = None
QtCore.QObject.connect(self.time_line,
QtCore.SIGNAL("frameChanged(int)"),
self.execRegisteredCallback)
QtCore.QObject.connect(self.time_line,
QtCore.SIGNAL("finished()"),
self.finish)
def setUp(self):
UsesQCoreApplication.setUp(self)
self.receiver = ExtQObject()
self.timeline = QTimeLine(100)
def setUp(self):
UsesQCoreApplication.setUp(self)
self.receiver = ExtQObject()
self.timeline = QTimeLine(100)
def setUp(self):
UsesQCoreApplication.setUp(self)
self.called = False
self.timeline = QTimeLine(100)
def setUp(self):
UsesQCoreApplication.setUp(self)
self.called = False
self.timeline = QTimeLine(100)
class HumanEvent(CallbackRegister,QObject):
logger = None
def __init__(self):
CallbackRegister.__init__(self)
QObject.__init__(self)
self.callbacks_tail = []
self.time_line = QTimeLine()
# print 'pido el logger'
Logger.getLoggerFor(self.__class__)
# print 'pedi el logger %s' % self.__class__.logger
self.condition = None
QtCore.QObject.connect(self.time_line,
QtCore.SIGNAL("frameChanged(int)"),
self.execRegisteredCallback)
QtCore.QObject.connect(self.time_line,
QtCore.SIGNAL("finished()"),
self.finish)
def registerCallback(self,objct,name_method,params,stack=False,parent_stack=False):
key = CallbackRegister.registerCallback(self,objct,name_method,params,stack,parent_stack)
self.logger.debug('Registered callback %s object %s : method %s : params len %s : stack %s : parent_stack %s ' % (key,
objct.__class__.__name__,
name_method,
len(params),
stack,
parent_stack))
self.callbacks_tail.append(key)
return key
def fire(self):
calls_len = len(self.callbacks_tail)
if calls_len == 0:
self.finish()
return
d = calls_len*300
self.time_line.setDuration(d)
self.time_line.setFrameRange(0 , calls_len)
# print 'El end frame es %s la duracion es %s' % ( self.time_line.endFrame(),self.time_line.duration())
if self.time_line.state() == QTimeLine.Running:
self.logger.warning('Starting timeline started, %s' % self.__class__.__name__)
self.time_line.stop()
if self.time_line.state() == QTimeLine.NotRunning:
self.logger.debug('Starting time line object %s' % self.__class__.__name__)
logger_core = Logger.getInstance()
try :
self.time_line.start()
except Exception as e:
traceback.print_exc(file=logger_core.last_traceback)
logger_core.last_traceback.seek(0)
self.logger.fatal("Exception firing human event \n%s" % logger_core.last_traceback.getvalue())
Jaime.instance.finishWork()
else:
self.logger.error('Trying to start running time line on object %s ' % self.__class__.__name__)
def execRegisteredCallback(self,pos):
if pos > len(self.callbacks_tail):
raise Exception('Inexistent callback index on %s [%s] max is %s' % (self.__class__.__name__,
pos,
len(self.callbacks_tail) ) )
else:
pos = pos-1
key = self.callbacks_tail[pos]
self.logger.debug('execRegisteredCallback %s %s %s' % (self.__class__.__name__,
pos,
key))
ret = getattr(self,key)()
if len(self.call_register[key]) > 3 and self.call_register[key][3] :
self.returns_stack.append(ret)
if len(self.call_register[key]) > 4 and self.call_register[key][4] :
self.parent().returns_stack.append(ret)
return ret
def finish(self):
# print 'llamo al finish'
self.logger.debug('sending finished signal %s' % self.__class__.__name__ )
self.emit(QtCore.SIGNAL('finished()'))
def loadLinkCallback(self,link):
self.logger.info('loadLinkCallback %s' % link)
Jaime.instance.view.load(QUrl(link))
@classmethod
def programAttachJavascript(cls,css,java):
he = cls()
he.logger.info('programAttachJavascript with css selector %s' % css)
he.registerCallback(he,'attachJavascript',[css,java])
return he
@classmethod
def testUi(cls,css,must_match=None,child_css=None,attrs={}):
he = cls()
he.registerCallback(RouteNode,'elementXY',[css,must_match,child_css,attrs],stack=False,parent_stack=True)
return he
def attachJavascript(self,css,java):
print 'Attaching javascript %s' % css
frame = Jaime.instance.page.mainFrame()
els = frame.findAllElements(css)
for i in range(els.count()):
el = els.at(i)
el.evaluateJavaScript(java)
self.logger.info('attachJavascript with css selector %s on elem with id %s' % (css,
el.attribute('id')) )
def doSaveImageUnderMouse(self,filename):
l = len(self.returns_stack)
if not (l and isinstance(self.returns_stack[l-1],QPoint) ) :
return
pos = self.returns_stack.pop()
# print 'saving image under pos %s' % pos
frame = Jaime.instance.page.frameAt(pos)
htc = frame.hitTestContent(pos)
if not htc.isNull():
pix = htc.pixmap()
# print 'pixmap size %s' % pix.size()
if not pix.save(filename,'JPEG'):
# print 'no guardo'
self.logger.error("Error while saving image under the mouse")
else:
self.logger.info("Image under the mouse was saved successfully")
else:
self.logger.error("There isn't image under the mouse")
@classmethod
def saveImageUnderMouse(cls,filename):
he = cls()
he.logger.info('doSaveImageUnderMouse' )
he.registerCallback(MouseHumanEvent,'getMousePos',[],stack=True)
he.registerCallback(he,'doSaveImageUnderMouse',[filename])
return he
@classmethod
def loadLink(cls,link):
he = cls()
he.logger.info('programLoadLink %s' % link )
he.registerCallback(he,'loadLinkCallback',[link])
return he
@classmethod
def loadLink(cls,link):
he = cls()
he.logger.info('programLoadLink %s' % link )
he.registerCallback(he,'loadLinkCallback',[link])
return he
def makeTimeCallback(self):
pass
@classmethod
def makeTime(cls):
he = cls()
he.registerCallback(he,'makeTimeCallback',[])
return he
