def testBasic(self):
'''QStateMachine.configuration converting QSet to python set'''
machine = QStateMachine()
s1 = QState()
machine.addState(s1)
machine.setInitialState(s1)
machine.start()
QTimer.singleShot(100, self.app.quit)
self.app.exec_()
configuration = machine.configuration()
self.assert_(isinstance(configuration, set))
self.assert_(s1 in configuration)
def testBasic(self):
self.machine = QStateMachine()
s1 = QState()
s2 = QState()
s3 = QFinalState()
QObject.connect(self.machine, SIGNAL("started()"), self.cb)
self.anim = QParallelAnimationGroup()
self.machine.addState(s1)
self.machine.addState(s2)
self.machine.addState(s3)
self.machine.setInitialState(s1)
self.machine.addDefaultAnimation(self.anim)
self.machine.start()
QTimer.singleShot(100, self.app.quit)
self.app.exec_()
def testCase(self):
check = QCheckBox()
check.setTristate(True)
s1 = QState()
s2 = QState()
t1 = CheckedTransition(check)
t1.setTargetState(s2)
s1.addTransition(t1)
machine = QStateMachine()
machine.addState(s1)
machine.addState(s2)
machine.setInitialState(s1)
machine.start()
check.stateChanged[int].emit(1)
check.show()
self.app.exec_()
self.assert_(t1.eventTested)
def _make_simple_machine(self, conn,
button=None, action=None, label=None):
"""
Creates a statemachine associated with the passed controls.
:param conn: the connection instance that defines this machine.
:type conn: AbstractLEAPConnection
:param button: the switch button.
:type button: QPushButton
:param action: the actionh that controls connection switch in a menu.
:type action: QAction
:param label: the label that displays the connection state
:type label: QLabel
:returns: a state machine
:rtype: QStateMachine
"""
machine = QStateMachine()
states = self._make_states(conn, button, action, label)
# transitions:
states[_OFF].addTransition(
conn.qtsigs.do_connect_signal,
states[_CON])
# * Clicking the buttons or actions transitions to the
# intermediate stage.
if button:
states[_OFF].addTransition(
button.clicked,
states[_CON])
states[_ON].addTransition(
button.clicked,
states[_DIS])
if action:
states[_OFF].addTransition(
action.triggered,
states[_CON])
states[_ON].addTransition(
action.triggered,
states[_DIS])
# * We transition to the completed stages when
# we receive the matching signal from the underlying
# conductor.
states[_CON].addTransition(
conn.qtsigs.connected_signal,
states[_ON])
states[_DIS].addTransition(
conn.qtsigs.disconnected_signal,
states[_OFF])
# * If we receive the connection_died, we transition
# from on directly to the off state
states[_ON].addTransition(
conn.qtsigs.connection_died_signal,
states[_OFF])
# XXX adding this---------------------
states[_ON].addTransition(
conn.qtsigs.do_disconnect_signal,
states[_DIS])
# * If we receive the connection_aborted, we transition
# from connecting to the off state
states[_CON].addTransition(
conn.qtsigs.connection_aborted_signal,
states[_OFF])
# * Connection died can in some cases also be
# triggered while we are in CONNECTING
# state. I should be avoided, since connection_aborted
# is clearer (and reserve connection_died
# for transitions from on->off
states[_CON].addTransition(
conn.qtsigs.connection_died_signal,
states[_OFF])
# adding states to the machine
for state in states.itervalues():
machine.addState(state)
machine.setInitialState(states[_OFF])
machine.conn = conn
return machine
from PySide.QtCore import QStateMachine, QState mach = QStateMachine() state = QState(mach) print(state.machine())
