def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
machine = QStateMachine(self)
s11 = QState()
s11.setObjectName('s11')
s11.assignProperty(self.lineEdit, 'text', u'Состояние 1')
s12 = QState()
s12.setObjectName('s12')
s12.assignProperty(self.lineEdit, 'text', u'Состояние 2')
s13 = QState()
s13.setObjectName('s13')
s13.assignProperty(self.lineEdit, 'text', u'Состояние 3')
# s11.entered.connect(self.s11entered)
s11.addTransition(self.ChangeState.clicked, s12)
s12.addTransition(self.ChangeState.clicked, s13)
s13.addTransition(self.ChangeState.clicked, s11)
machine.addState(s11)
machine.addState(s12)
machine.addState(s13)
machine.setInitialState(s11)
machine.start()
def buildStateMachine(app, stateMachineData):
''' A helper function that builds a QStateMachine from data, returning an operational QStateMachine
'''
def getState(sm, name, states):
try:
states[name]
except KeyError:
states[name] = QState(sm)
return states[name]
sm = QStateMachine(app)
(graph, initialState) = stateMachineData
states = dict()
for (T, begin, end) in graph:
t = T(app)
t.setTargetState(getState(sm, end, states))
getState(sm, begin, states).addTransition(t)
sm.setInitialState(getState(sm, initialState, states))
return sm
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_()
class QStateMachineTest(UsesQCoreApplication):
def cb(self, *args):
self.assertEqual(self.machine.defaultAnimations(), [self.anim])
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 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
def __init__(self, parent=None):
QStateMachine.__init__(self, parent)
# events
self.events = Events(parent)
self.create_events()
from PySide.QtCore import QStateMachine, QState mach = QStateMachine() state = QState(mach) print(state.machine())
from PySide.QtGui import QPushButton, QLabel
from PySide.QtCore import QStateMachine, QState
switch = QPushButton("Switch")
notification = QLabel("Flip the switch")
onState = QState()
offState = QState()
offState.addTransition(switch, "clicked()", onState)
onState.addTransition(switch, "clicked()", offState)
offState.assignProperty(notification, "text", "Off")
onState.assignProperty(notification, "text", "On")
machine = QStateMachine()
machine.addState(onState)
machine.addState(offState)
machine.setInitialState(offState)
machine.start()
switch.show()
notification.show()
