def _make_dev_fetched_state(self, form) -> QState: s = QState() s.assignProperty(form.editBtn, "enabled", True) s.assignProperty(form.deviceList, "enabled", True) s.assignProperty(form.saveBtn, "enabled", False) s.assignProperty(form.addressEdit, "enabled", False) return s
def makeState(self, parentState, animationFileName): topLevel = QState(parentState) animation = Animation() file = QFile(animationFileName) if file.open(QIODevice.ReadOnly): animation.load(file) frameCount = animation.totalFrames() previousState = None for i in range(frameCount): animation.setCurrentFrame(i) frameState = QState(topLevel) nodeCount = animation.nodeCount() for j in range(nodeCount): frameState.assignProperty(self.m_stickMan.node(j), "pos", animation.nodePos(j)) frameState.setObjectName("frame %d" % i) if previousState is None: topLevel.setInitialState(frameState) else: previousState.addTransition(previousState.propertiesAssigned, frameState) previousState = frameState previousState.addTransition(previousState.propertiesAssigned, topLevel.initialState()) return topLevel
def __init__(self, controller: Controller, menu_state: QState): super().__init__(parent=controller.stm) global ctrl ctrl = controller common = Common(controller=ctrl) self.finish = QFinalState(self) self.addTransition(self.finished, menu_state) self.addTransition(ctrl.button['back'].clicked, self.finish) menu = ctrl.menu.menu['БТП 020'] menu_state.addTransition(menu.button['Замещение торможения'].clicked, self) self.start = Start(self) self.ppm = common.Ppm(self) self.el_breaking = common.ElBreaking(self) self.speed_60 = common.Speed60(self) self.ku_215 = common.KU215(self) self.pim = common.Pim(self) self.enter = common.Enter(state='- 0 -', parent=self) self.el_breaking_on = ElBreakingOn(self) self.measure = Measure(self) self.ok = Ok(self) self.ok_measure = OkMeasure(self) self.el_breaking_off = ElBreakingOff(self) self.show_result = ShowResult(self) self.setInitialState(self.start) self.start.addTransition(self.ppm) self.ppm.addTransition(ctrl.server_updated, self.ppm) self.ppm.addTransition(self.ppm.done, self.el_breaking) self.el_breaking.addTransition(ctrl.switch['el. braking'].low_value, self.speed_60) self.speed_60.addTransition(ctrl.switch['>60 km/h'].low_value, self.ku_215) self.ku_215.addTransition(ctrl.switch['ku 215'].high_value, self.pim) self.pim.addTransition(ctrl.server_updated, self.pim) self.pim.addTransition(self.pim.done, self.enter) self.enter.addTransition( ctrl.switch_with_neutral['enter'].state_neutral, self.el_breaking_on) self.el_breaking_on.addTransition(ctrl.server_updated, self.el_breaking_on) self.el_breaking_on.addTransition(self.el_breaking_on.done, self.measure) self.measure.addTransition(ctrl.server_updated, self.measure) self.measure.addTransition(self.measure.done, self.ok) self.ok.addTransition(ctrl.switch['ok'].high_value, self.ok_measure) self.ok_measure.addTransition(ctrl.server_updated, self.ok_measure) self.ok_measure.addTransition(ctrl.switch['ok'].low_value, self.el_breaking_off) self.el_breaking_off.addTransition(ctrl.server_updated, self.el_breaking_off) self.el_breaking_off.addTransition(self.el_breaking_off.done, self.show_result)
def createState(self): mainState = QState(self.fsm) connectedState = QState(QtCore.QState.ParallelStates, mainState) processBuyState = QState(connectedState) determineBuyProcessBuyState = QState(processBuyState) waitingTRlimitProcessBuyState = QState(processBuyState) print(determineBuyProcessBuyState) determineBuyProcessBuyState.addTransition(self.sigNoBuy, waitingTRlimitProcessBuyState) determineBuyProcessBuyState.addTransition(self.sigBuy, waitingTRlimitProcessBuyState) self.test_buy() determineBuyProcessBuyState.entered.connect(self.determineBuyProcessBuyStateEntered)
def __init__(self, controller: Controller, menu_state: QState): super().__init__(parent=controller.stm) global ctrl ctrl = controller common = Common(controller=ctrl) self.finish = QFinalState(self) self.addTransition(self.finished, menu_state) self.addTransition(ctrl.button['back'].clicked, self.finish) menu = ctrl.menu.menu['БТП 020'] menu_state.addTransition(menu.button['Повышенная скорость'].clicked, self) self.start = Start(self) self.ppm = common.Ppm(self) self.el_breaking = common.ElBreaking(self) self.speed_60 = common.Speed60(self) self.ku_215 = common.KU215(self) self.pim = common.Pim(self) self.enter = common.Enter(state='- 0 -', parent=self) self.speed_on = SpeedOn(self) self.measure_fill = MeasureFill(self) self.speed_off = SpeedOff(self) self.measure_empty = MeasureEmpty(self) self.show_result = ShowResult(self) self.setInitialState(self.start) self.start.addTransition(self.ppm) self.ppm.addTransition(ctrl.server_updated, self.ppm) self.ppm.addTransition(self.ppm.done, self.ku_215) # self.el_breaking.addTransition(ctrl.switch['el. braking'].low_value, self.speed_60) # self.speed_60.addTransition(ctrl.switch['>60 km/h'].low_value, self.ku_215) self.ku_215.addTransition(ctrl.switch['ku 215'].high_value, self.pim) self.pim.addTransition(ctrl.server_updated, self.pim) self.pim.addTransition(self.pim.done, self.enter) self.enter.addTransition(ctrl.switch_with_neutral['km'].state_neutral, self.speed_on) self.speed_on.addTransition(ctrl.server_updated, self.speed_on) self.speed_on.addTransition(self.speed_on.done, self.measure_fill) self.measure_fill.addTransition(ctrl.server_updated, self.measure_fill) self.measure_fill.addTransition(self.measure_fill.done, self.speed_off) self.speed_off.addTransition(ctrl.server_updated, self.speed_off) self.speed_off.addTransition(self.speed_off.done, self.measure_empty) self.measure_empty.addTransition(ctrl.server_updated, self.measure_empty) self.measure_empty.addTransition(self.measure_empty.done, self.show_result)
def createGeometryState(w1, rect1, w2, rect2, w3, rect3, w4, rect4, parent): result = QState(parent) result.assignProperty(w1, 'geometry', rect1) result.assignProperty(w1, 'geometry', rect1) result.assignProperty(w2, 'geometry', rect2) result.assignProperty(w3, 'geometry', rect3) result.assignProperty(w4, 'geometry', rect4) return result
def __init__(self, lcd, targetVal, serial=None, template=None): super().__init__() self.defaultState = DisplayState(lcd, Color.BLACK, 0.0) self.upState = DisplayState(lcd, Color.GREEN) self.downState = DisplayState(lcd, Color.RED) self.waitState = QState() self.setTimer = QTimer() self.setTimer.setInterval(DELAY_BEFORE_SET) self.setTimer.setSingleShot(True) self.waitState.entered.connect(self.setTimer.start) self.waitState.exited.connect(self.setTimer.stop) for s in [ self.defaultState, self.upState, self.downState, self.waitState ]: self.addState(s) s.addTransition(self.raiseTarget, self.upState) s.addTransition(self.lowerTarget, self.downState) for s in [self.upState, self.downState]: s.addTransition(s.done, self.waitState) self.waitState.addTransition(self.setTimer.timeout, self.defaultState) self.setInitialState(self.defaultState) self.target = float(targetVal) if serial is not None: #self.serial = serial self.template = template serial.newDataAvailable.connect(self.defaultState.updateDisplay) self.waitState.exited.connect(self.sendTarget) self.sendToSerial.connect(serial.broadcast) self.requestTimer = QTimer() self.requestTimer.setInterval(REFRESH_PERIOD) self.requestTimer.timeout.connect(self.sendRequest) self.defaultState.entered.connect(self.requestTimer.start) self.defaultState.exited.connect(self.requestTimer.stop) self.start()
def __init__(self, controller: Controller, menu_state: QState): super().__init__(parent=controller.stm) global ctrl ctrl = controller common = Common(controller=ctrl) self.finish = QFinalState(self) self.addTransition(self.finished, menu_state) self.addTransition(ctrl.button['back'].clicked, self.finish) menu = ctrl.menu.menu['БТП 020'] menu_state.addTransition(menu.button['Время снижения'].clicked, self) self.start = Start(self) self.ppm = common.Ppm(self) self.el_breaking = common.ElBreaking(self) self.speed_60 = common.Speed60(self) self.ku_215 = common.KU215(self) self.enter = common.Enter(state='КУ', parent=self) self.handle_position_four = common.HandlePositionFour(self) self.handle_position_zero = HandlePositionZero(self) self.measure = Measure(self) self.show_result = ShowResult(self) self.setInitialState(self.start) self.start.addTransition(self.ppm) self.ppm.addTransition(ctrl.server_updated, self.ppm) self.ppm.addTransition(self.ppm.done, self.el_breaking) self.el_breaking.addTransition(ctrl.switch['el. braking'].low_value, self.speed_60) self.speed_60.addTransition(ctrl.switch['>60 km/h'].low_value, self.ku_215) self.ku_215.addTransition(ctrl.switch['ku 215'].high_value, self.enter) self.enter.addTransition(ctrl.switch_with_neutral['enter'].state_two, self.handle_position_four) self.handle_position_four.addTransition(ctrl.server_updated, self.handle_position_four) self.handle_position_four.addTransition(self.handle_position_four.done, self.handle_position_zero) self.handle_position_zero.addTransition(ctrl.server_updated, self.handle_position_zero) self.handle_position_zero.addTransition(self.handle_position_zero.done, self.measure) self.measure.addTransition(ctrl.server_updated, self.measure) self.measure.addTransition(self.measure.done, self.show_result)
def __init__(self, controller: Controller, menu_state: QState): super().__init__(parent=controller.stm) global ctrl ctrl = controller common: Common = Common(controller=ctrl) self.finish = QFinalState(self) self.addTransition(self.finished, menu_state) menu = ctrl.menu.menu['БТП 020'] self.addTransition(ctrl.button['back'].clicked, self.finish) menu_state.addTransition(menu.button['Подготовка'].clicked, self) self.start = Start(self) self.ppm = common.Ppm(self) self.install_ku = InstallKU(self) self.ku_215 = common.KU215(self) self.pim = common.Pim(self) self.tank = common.Tank(state='СБРОС', parent=self) self.el_breaking = common.ElBreaking(self) self.speed_60 = common.Speed60(self) self.set_bto = SetBTO(self) self.connect_btp = ConnectBTP(self) self.enable_menu = EnableMenu(self) self.setInitialState(self.start) self.start.addTransition(self.install_ku) self.install_ku.addTransition(ctrl.button['yes'].clicked, self.ku_215) self.ku_215.addTransition(ctrl.switch['ku 215'].high_value, self.ppm) self.ppm.addTransition(ctrl.server_updated, self.ppm) self.ppm.addTransition(self.ppm.done, self.pim) self.pim.addTransition(ctrl.server_updated, self.pim) self.pim.addTransition(self.pim.done, self.tank) self.tank.addTransition(ctrl.switch_with_neutral['tank'].state_two, self.el_breaking) self.el_breaking.addTransition(ctrl.switch['el. braking'].low_value, self.speed_60) self.speed_60.addTransition(ctrl.switch['>60 km/h'].low_value, self.set_bto) self.set_bto.addTransition(ctrl.button['yes'].clicked, self.connect_btp) self.connect_btp.addTransition(ctrl.button['yes'].clicked, self.enable_menu) self.enable_menu.addTransition(self.finish)
def __init__(self, controller: Controller, menu_state: QState): super().__init__(parent=controller.stm) global ctrl ctrl = controller common = Common(controller=ctrl) self.finish = QFinalState(self) self.addTransition(self.finished, menu_state) self.addTransition(ctrl.button['back'].clicked, self.finish) menu = ctrl.menu.menu['БТП 020'] menu_state.addTransition(menu.button['Герметичность'].clicked, self) self.start = Start(self) self.ppm = common.Ppm(self) self.el_breaking = common.ElBreaking(self) self.speed_60 = common.Speed60(self) self.ku_215 = common.KU215(self) self.enter = common.Enter(state='КУ', parent=self) self.handle_position_four = common.HandlePositionFour(self) self.check = Check(self) self.yes = Yes(self) self.no = No(self) self.setInitialState(self.start) self.start.addTransition(self.ppm) self.ppm.addTransition(ctrl.server_updated, self.ppm) self.ppm.addTransition(self.ppm.done, self.el_breaking) self.el_breaking.addTransition(ctrl.switch['el. braking'].low_value, self.speed_60) self.speed_60.addTransition(ctrl.switch['>60 km/h'].low_value, self.ku_215) self.ku_215.addTransition(ctrl.switch['ku 215'].high_value, self.enter) self.enter.addTransition(ctrl.switch_with_neutral['enter'].state_two, self.handle_position_four) self.handle_position_four.addTransition(ctrl.server_updated, self.handle_position_four) self.handle_position_four.addTransition(self.handle_position_four.done, self.check) self.check.addTransition(ctrl.button['yes'].clicked, self.yes) self.check.addTransition(ctrl.button['no'].clicked, self.no) self.yes.addTransition(self.finish) self.no.addTransition(self.finish)
def createGeometryState(self, w1, rect1, w2, rect2, w3, rect3, w4, rect4, parent): result = QState(parent) result.assignProperty(w1, 'geometry', rect1) result.assignProperty(w1, 'geometry', rect1) result.assignProperty(w2, 'geometry', rect2) result.assignProperty(w3, 'geometry', rect3) result.assignProperty(w4, 'geometry', rect4) return result
def __init__(self, controller: Controller, menu_state: QState): super().__init__(parent=controller.stm) global ctrl ctrl = controller self.finish = QFinalState(self) self.addTransition(self.finished, menu_state) self.addTransition(ctrl.button['back'].clicked, self.finish) menu = ctrl.menu.menu['БТП 020'] menu_state.addTransition(menu.button['Завершение'].clicked, self) self.start = Start(self) self.air = Air(self) self.ku_215_off = KU215Off(self) self.disconnect_bto = DisconnectBTO(self) self.report = Report(parent=self, controller=controller) self.setInitialState(self.start) self.start.addTransition(self.air) self.air.addTransition(ctrl.button['yes'].clicked, self.ku_215_off) self.ku_215_off.addTransition(ctrl.switch['ku 215'].low_value, self.disconnect_bto) self.disconnect_bto.addTransition(ctrl.button['yes'].clicked, self.report)
def __init__(self, controller: Controller, menu: QState): super().__init__(parent=controller.stm) global ctrl ctrl = controller self.finish = QFinalState(self) self.addTransition(self.finished, menu) self.reset = Reset(self) self.disable_menu = DisableMenu(self) self.report_data = ReportData(self) self.menu = Menu(self) menu.addTransition( ctrl.menu.menu['Главное меню'].button['БТП 020'].clicked, self) self.setInitialState(self.reset) self.reset.addTransition(self.disable_menu) self.disable_menu.addTransition(self.report_data) self.report_data.addTransition(ctrl.button['back'].clicked, self.finish) self.report_data.addTransition(ctrl.menu.prepare_menu.done.clicked, self.menu) self.menu.addTransition(ctrl.button['back'].clicked, self.finish) self.prepare = Prepare(controller=ctrl, menu_state=self.menu) self.auto_breaking = AutoBreaking(controller=ctrl, menu_state=self.menu) self.kvt_breaking = KvtBreaking(controller=ctrl, menu_state=self.menu) self.filling = Filling(controller=ctrl, menu_state=self.menu) self.tightness = Tightness(controller=ctrl, menu_state=self.menu) self.emptying = Emptying(controller=ctrl, menu_state=self.menu) self.substitution = Substitution(controller=ctrl, menu_state=self.menu) self.speed = Speed(controller=ctrl, menu_state=self.menu) self.ending = Ending(controller=ctrl, menu_state=self.menu) self.ending.report.addTransition(ctrl.report.exit.clicked, self.finish) self.ending.report.addTransition(ctrl.button['back'].clicked, self.finish)
def __init__(self, controller: Controller, menu_state: QState): super().__init__(parent=controller.stm) global ctrl ctrl = controller common = Common(controller=ctrl) self.finish = QFinalState(self) self.addTransition(self.finished, menu_state) self.addTransition(ctrl.button['back'].clicked, self.finish) menu = ctrl.menu.menu['БТП 020'] menu_state.addTransition(menu.button['торможение автоматическое'].clicked, self) self.start = Start(self) self.pim = common.Pim(self) self.check_1 = Check(stage=0, parent=self) self.check_2 = Check(stage=1, parent=self) self.check_3 = Check(stage=2, parent=self) self.check_4 = Check(stage=3, parent=self) self.check_5 = Check(stage=4, parent=self) self.check_6 = Check(stage=5, parent=self) self.check_7 = Check(stage=6, parent=self) self.check_8 = Check(stage=7, parent=self) self.show_result = ShowResult(parent=self) self.setInitialState(self.start) self.start.addTransition(self.pim) self.pim.addTransition(ctrl.server_updated, self.pim) self.pim.addTransition(self.pim.done, self.check_1) self.check_1.addTransition(self.check_1.finished, self.check_2) self.check_2.addTransition(self.check_2.finished, self.check_3) self.check_3.addTransition(self.check_3.finished, self.check_4) self.check_4.addTransition(self.check_4.finished, self.check_5) self.check_5.addTransition(self.check_5.finished, self.check_6) self.check_6.addTransition(self.check_6.finished, self.check_7) self.check_7.addTransition(self.check_7.finished, self.check_8) self.check_8.addTransition(self.check_8.finished, self.show_result) self.show_result.addTransition(ctrl.button['yes'].clicked, self.finish)
def __init__(self, parent=None): super().__init__(parent) self.setAttribute(Qt.WA_QuitOnClose) self.setAttribute(Qt.WA_DeleteOnClose) # create instance variables self._ui = uic.loadUi('mainwindow.ui', self) # create models self.measureModels = { 1: MeasureModel(self), 2: MeasureModel(self), } self._instrumentManager = InstrumentManager(self, self.measureModels) self.machine = QStateMachine() self.stateInitial = QState() self.stateReadyToCheck = QState() self.stateReadyToMeasure = QState() self.stateAfterMeasure = QState() self.initDialog()
def Home(self): self.items = [] for i in range(len(self.names['home'])): item = QPushButton(self) item.setText(self.names['home'][i]) item.setGeometry(395, 350, 120, 80) item.setStyleSheet( "QPushButton:hover{background-color:rgb(241, 90, 36);border:5px solid rgb(0, 97, 157);}\n" "QPushButton{color:white;background-color: rgb(50, 50, 50);border:5px solid rgb(255, 255, 255);}QPushButton:pressed{color:white;background-color: rgb(50, 50, 50);border:5px solid rgb(255, 255, 255);}\n" "") self.font.setPointSize(15) item.setFont(self.font) self.items.append(item) exec("""item.clicked.connect(partial(self.IND,i=%i))""" % (i)) self.rootState = QState() self.tiledState = QState(self.rootState) self.centeredState = QState(self.rootState) for i, item in enumerate(self.items): self.tiledState.assignProperty( item, 'pos', QPointF(((i % 6) * 5.3) * 30, ((i // 6) * 5.3) * 30)) self.centeredState.assignProperty(item, 'pos', QPointF()) self.states = QStateMachine() self.states.addState(self.rootState) self.states.setInitialState(self.rootState) self.rootState.setInitialState(self.centeredState) self.group = QParallelAnimationGroup() for i, item in enumerate(self.items): anim = QPropertyAnimation(item, b'pos') anim.setStartValue(QPoint(400, 300)) anim.setDuration(750 + i * 25) anim.setEasingCurve(QEasingCurve.InOutBack) self.group.addAnimation(anim) for u in self.items: trans = self.rootState.addTransition(u.clicked, self.tiledState) trans.addAnimation(self.group) self.states.start()
def __init__(self, blaster, *args, **kwargs): super().__init__(*args, **kwargs) self.offState = QState() self.revState = QState() self.onState = QState() for s in [self.offState, self.revState, self.onState]: self.addState(s) self.setInitialState(self.offState) self.offState.entered.connect(lambda: blaster.triggerStateChange(3)) self.offState.exited.connect(lambda: blaster.triggerStateChange(0)) self.onState.entered.connect(lambda: blaster.triggerStateChange(1)) self.onState.exited.connect(lambda: blaster.triggerStateChange(2)) self.spinUp = QSignalTransition(self.touched) self.spinUp.setTargetState(self.revState) self.spinDown = QSignalTransition(self.letGo) self.spinDown.setTargetState(self.offState) self.revState.addTransition(self.pressed, self.onState) self.onState.addTransition(self.released, self.revState) self.start()
def __init__(self, size, parent=None): super(PadNavigator, self).__init__(parent) self.form = Ui_Form() splash = SplashItem() splash.setZValue(1) pad = FlippablePad(size) flipRotation = QGraphicsRotation(pad) xRotation = QGraphicsRotation(pad) yRotation = QGraphicsRotation(pad) flipRotation.setAxis(Qt.YAxis) xRotation.setAxis(Qt.YAxis) yRotation.setAxis(Qt.XAxis) pad.setTransformations([flipRotation, xRotation, yRotation]) backItem = QGraphicsProxyWidget(pad) widget = QWidget() self.form.setupUi(widget) self.form.hostName.setFocus() backItem.setWidget(widget) backItem.setVisible(False) backItem.setFocus() backItem.setCacheMode(QGraphicsItem.ItemCoordinateCache) r = backItem.rect() backItem.setTransform(QTransform().rotate(180, Qt.YAxis).translate( -r.width() / 2, -r.height() / 2)) selectionItem = RoundRectItem(QRectF(-60, -60, 120, 120), QColor(Qt.gray), pad) selectionItem.setZValue(0.5) smoothSplashMove = QPropertyAnimation(splash) smoothSplashOpacity = QPropertyAnimation(splash) smoothSplashMove.setEasingCurve(QEasingCurve.InQuad) smoothSplashMove.setDuration(250) smoothSplashOpacity.setDuration(250) smoothXSelection = QPropertyAnimation(selectionItem) smoothYSelection = QPropertyAnimation(selectionItem) smoothXRotation = QPropertyAnimation(xRotation) smoothYRotation = QPropertyAnimation(yRotation) smoothXSelection.setDuration(125) smoothYSelection.setDuration(125) smoothXRotation.setDuration(125) smoothYRotation.setDuration(125) smoothXSelection.setEasingCurve(QEasingCurve.InOutQuad) smoothYSelection.setEasingCurve(QEasingCurve.InOutQuad) smoothXRotation.setEasingCurve(QEasingCurve.InOutQuad) smoothYRotation.setEasingCurve(QEasingCurve.InOutQuad) smoothFlipRotation = QPropertyAnimation(flipRotation) smoothFlipScale = QPropertyAnimation(pad) smoothFlipXRotation = QPropertyAnimation(xRotation) smoothFlipYRotation = QPropertyAnimation(yRotation) flipAnimation = QParallelAnimationGroup(self) smoothFlipScale.setDuration(500) smoothFlipRotation.setDuration(500) smoothFlipXRotation.setDuration(500) smoothFlipYRotation.setDuration(500) smoothFlipScale.setEasingCurve(QEasingCurve.InOutQuad) smoothFlipRotation.setEasingCurve(QEasingCurve.InOutQuad) smoothFlipXRotation.setEasingCurve(QEasingCurve.InOutQuad) smoothFlipYRotation.setEasingCurve(QEasingCurve.InOutQuad) smoothFlipScale.setKeyValueAt(0, 1.0) smoothFlipScale.setKeyValueAt(0.5, 0.7) smoothFlipScale.setKeyValueAt(1, 1.0) flipAnimation.addAnimation(smoothFlipRotation) flipAnimation.addAnimation(smoothFlipScale) flipAnimation.addAnimation(smoothFlipXRotation) flipAnimation.addAnimation(smoothFlipYRotation) setVariablesSequence = QSequentialAnimationGroup() setFillAnimation = QPropertyAnimation(pad) setBackItemVisibleAnimation = QPropertyAnimation(backItem) setSelectionItemVisibleAnimation = QPropertyAnimation(selectionItem) setFillAnimation.setDuration(0) setBackItemVisibleAnimation.setDuration(0) setSelectionItemVisibleAnimation.setDuration(0) setVariablesSequence.addPause(250) setVariablesSequence.addAnimation(setBackItemVisibleAnimation) setVariablesSequence.addAnimation(setSelectionItemVisibleAnimation) setVariablesSequence.addAnimation(setFillAnimation) flipAnimation.addAnimation(setVariablesSequence) stateMachine = QStateMachine(self) splashState = QState(stateMachine) frontState = QState(stateMachine) historyState = QHistoryState(frontState) backState = QState(stateMachine) frontState.assignProperty(pad, "fill", False) frontState.assignProperty(splash, "opacity", 0.0) frontState.assignProperty(backItem, "visible", False) frontState.assignProperty(flipRotation, "angle", 0.0) frontState.assignProperty(selectionItem, "visible", True) backState.assignProperty(pad, "fill", True) backState.assignProperty(backItem, "visible", True) backState.assignProperty(xRotation, "angle", 0.0) backState.assignProperty(yRotation, "angle", 0.0) backState.assignProperty(flipRotation, "angle", 180.0) backState.assignProperty(selectionItem, "visible", False) stateMachine.addDefaultAnimation(smoothXRotation) stateMachine.addDefaultAnimation(smoothYRotation) stateMachine.addDefaultAnimation(smoothXSelection) stateMachine.addDefaultAnimation(smoothYSelection) stateMachine.setInitialState(splashState) anyKeyTransition = QEventTransition(self, QEvent.KeyPress, splashState) anyKeyTransition.setTargetState(frontState) anyKeyTransition.addAnimation(smoothSplashMove) anyKeyTransition.addAnimation(smoothSplashOpacity) enterTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Enter, backState) returnTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Return, backState) backEnterTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Enter, frontState) backReturnTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Return, frontState) enterTransition.setTargetState(historyState) returnTransition.setTargetState(historyState) backEnterTransition.setTargetState(backState) backReturnTransition.setTargetState(backState) enterTransition.addAnimation(flipAnimation) returnTransition.addAnimation(flipAnimation) backEnterTransition.addAnimation(flipAnimation) backReturnTransition.addAnimation(flipAnimation) columns = size.width() rows = size.height() stateGrid = [] for y in range(rows): stateGrid.append([QState(frontState) for _ in range(columns)]) frontState.setInitialState(stateGrid[0][0]) selectionItem.setPos(pad.iconAt(0, 0).pos()) for y in range(rows): for x in range(columns): state = stateGrid[y][x] rightTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Right, state) leftTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Left, state) downTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Down, state) upTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Up, state) rightTransition.setTargetState(stateGrid[y][(x + 1) % columns]) leftTransition.setTargetState( stateGrid[y][((x - 1) + columns) % columns]) downTransition.setTargetState(stateGrid[(y + 1) % rows][x]) upTransition.setTargetState(stateGrid[((y - 1) + rows) % rows][x]) icon = pad.iconAt(x, y) state.assignProperty(xRotation, "angle", -icon.x() / 6.0) state.assignProperty(yRotation, "angle", icon.y() / 6.0) state.assignProperty(selectionItem, "x", icon.x()) state.assignProperty(selectionItem, "y", icon.y()) frontState.assignProperty(icon, "visible", True) backState.assignProperty(icon, "visible", False) setIconVisibleAnimation = QPropertyAnimation(icon) setIconVisibleAnimation.setDuration(0) setVariablesSequence.addAnimation(setIconVisibleAnimation) scene = QGraphicsScene(self) scene.setBackgroundBrush( QBrush(QPixmap(":/images/blue_angle_swirl.jpg"))) scene.setItemIndexMethod(QGraphicsScene.NoIndex) scene.addItem(pad) scene.setSceneRect(scene.itemsBoundingRect()) self.setScene(scene) sbr = splash.boundingRect() splash.setPos(-sbr.width() / 2, scene.sceneRect().top() - 2) frontState.assignProperty(splash, "y", splash.y() - 100.0) scene.addItem(splash) self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.setMinimumSize(50, 50) self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate) self.setCacheMode(QGraphicsView.CacheBackground) self.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform | QPainter.TextAntialiasing) if QGLFormat.hasOpenGL(): self.setViewport(QGLWidget(QGLFormat(QGL.SampleBuffers))) stateMachine.start()
tiledButton = Button(QPixmap(':/images/tile.png'), buttonParent) centeredButton = Button(QPixmap(':/images/centered.png'), buttonParent) ellipseButton.setPos(-100, -100) figure8Button.setPos(100, -100) randomButton.setPos(0, 0) tiledButton.setPos(-100, 100) centeredButton.setPos(100, 100) scene.addItem(buttonParent) buttonParent.setScale(0.75) buttonParent.setPos(200, 200) buttonParent.setZValue(65) # States. rootState = QState() ellipseState = QState(rootState) figure8State = QState(rootState) randomState = QState(rootState) tiledState = QState(rootState) centeredState = QState(rootState) # Values. for i, item in enumerate(items): # Ellipse. ellipseState.assignProperty(item, 'pos', QPointF(math.cos((i / 63.0) * 6.28) * 250, math.sin((i / 63.0) * 6.28) * 250)) # Figure 8. figure8State.assignProperty(item, 'pos',
p5 = Pixmap(QPixmap(':/help-browser.png')) p6 = Pixmap(QPixmap(':/kchart.png')) scene = QGraphicsScene(0, 0, 400, 300) scene.setBackgroundBrush(scene.palette().window()) scene.addItem(widget) scene.addItem(boxProxy) scene.addItem(p1) scene.addItem(p2) scene.addItem(p3) scene.addItem(p4) scene.addItem(p5) scene.addItem(p6) machine = QStateMachine() state1 = QState(machine) state2 = QState(machine) state3 = QState(machine) machine.setInitialState(state1) # State 1. state1.assignProperty(button, 'text', "Switch to state 2") state1.assignProperty(widget, 'geometry', QRectF(0, 0, 400, 150)) state1.assignProperty(box, 'geometry', QRect(-200, 150, 200, 150)) state1.assignProperty(p1, 'pos', QPointF(68, 185)) state1.assignProperty(p2, 'pos', QPointF(168, 185)) state1.assignProperty(p3, 'pos', QPointF(268, 185)) state1.assignProperty(p4, 'pos', QPointF(68 - 150, 48 - 150)) state1.assignProperty(p5, 'pos', QPointF(168, 48 - 150)) state1.assignProperty(p6, 'pos', QPointF(268 + 150, 48 - 150)) state1.assignProperty(p1, 'rotation', 0.0)
tiledButton = Button(QPixmap(':/images/tile.png'), buttonParent) centeredButton = Button(QPixmap(':/images/centered.png'), buttonParent) ellipseButton.setPos(-100, -100) figure8Button.setPos(100, -100) randomButton.setPos(0, 0) tiledButton.setPos(-100, 100) centeredButton.setPos(100, 100) scene.addItem(buttonParent) buttonParent.setScale(0.75) buttonParent.setPos(200, 200) buttonParent.setZValue(65) # States. rootState = QState() ellipseState = QState(rootState) figure8State = QState(rootState) randomState = QState(rootState) tiledState = QState(rootState) centeredState = QState(rootState) # Values. for i, item in enumerate(items): # Ellipse. ellipseState.assignProperty( item, 'pos', QPointF( math.cos((i / 63.0) * 6.28) * 250, math.sin((i / 63.0) * 6.28) * 250))
#tr = QScxmlSignalTransition(pb.clicked) scxml_machine = QScxml() scxml_machine.registerObject(pb, "pb") scxml_machine.registerObject(cb, "cb") scxml_machine.load("test144.scxml") #scxml_machine = QScxml.load("ExifMediaRename.scxml", ) scxml_machine.start() if 0: sm = QStateMachine() s1 = QState() s2 = QState() s2.entered.connect(toto) st = QSignalTransition(pb.clicked) st.setTargetState(s2) s1.addTransition(st) sm.addState(s1) sm.addState(s2) sm.setInitialState(s1) sm.start() sys.exit(app.exec_())
scene = QGraphicsScene(0, 0, 300, 300) scene.setBackgroundBrush(Qt.black) scene.addItem(button1) scene.addItem(button2) scene.addItem(button3) scene.addItem(button4) window = QGraphicsView(scene) window.setFrameStyle(0) window.setAlignment(Qt.AlignLeft | Qt.AlignTop) window.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) window.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) machine = QStateMachine() group = QState() timer = QTimer() timer.setInterval(1250) timer.setSingleShot(True) group.entered.connect(timer.start) state1 = createGeometryState(button1, QRect(100, 0, 50, 50), button2, QRect(150, 0, 50, 50), button3, QRect(200, 0, 50, 50), button4, QRect(250, 0, 50, 50), group) state2 = createGeometryState(button1, QRect(250, 100, 50, 50), button2, QRect(250, 150, 50, 50), button3, QRect(250, 200, 50, 50), button4, QRect(250, 250, 50, 50), group) state3 = createGeometryState(button1, QRect(150, 250, 50, 50), button2, QRect(100, 250, 50, 50), button3, QRect(50, 250, 50, 50), button4,
def __init__(self, size, parent=None): super(PadNavigator, self).__init__(parent) self.form = Ui_Form() splash = SplashItem() splash.setZValue(1) pad = FlippablePad(size) flipRotation = QGraphicsRotation(pad) xRotation = QGraphicsRotation(pad) yRotation = QGraphicsRotation(pad) flipRotation.setAxis(Qt.YAxis) xRotation.setAxis(Qt.YAxis) yRotation.setAxis(Qt.XAxis) pad.setTransformations([flipRotation, xRotation, yRotation]) backItem = QGraphicsProxyWidget(pad) widget = QWidget() self.form.setupUi(widget) self.form.hostName.setFocus() backItem.setWidget(widget) backItem.setVisible(False) backItem.setFocus() backItem.setCacheMode(QGraphicsItem.ItemCoordinateCache) r = backItem.rect() backItem.setTransform(QTransform().rotate(180, Qt.YAxis).translate(-r.width()/2, -r.height()/2)) selectionItem = RoundRectItem(QRectF(-60, -60, 120, 120), QColor(Qt.gray), pad) selectionItem.setZValue(0.5) smoothSplashMove = QPropertyAnimation(splash, b'y') smoothSplashOpacity = QPropertyAnimation(splash, b'opacity') smoothSplashMove.setEasingCurve(QEasingCurve.InQuad) smoothSplashMove.setDuration(250) smoothSplashOpacity.setDuration(250) smoothXSelection = QPropertyAnimation(selectionItem, b'x') smoothYSelection = QPropertyAnimation(selectionItem, b'y') smoothXRotation = QPropertyAnimation(xRotation, b'angle') smoothYRotation = QPropertyAnimation(yRotation, b'angle') smoothXSelection.setDuration(125) smoothYSelection.setDuration(125) smoothXRotation.setDuration(125) smoothYRotation.setDuration(125) smoothXSelection.setEasingCurve(QEasingCurve.InOutQuad) smoothYSelection.setEasingCurve(QEasingCurve.InOutQuad) smoothXRotation.setEasingCurve(QEasingCurve.InOutQuad) smoothYRotation.setEasingCurve(QEasingCurve.InOutQuad) smoothFlipRotation = QPropertyAnimation(flipRotation, b'angle') smoothFlipScale = QPropertyAnimation(pad, b'scale') smoothFlipXRotation = QPropertyAnimation(xRotation, b'angle') smoothFlipYRotation = QPropertyAnimation(yRotation, b'angle') flipAnimation = QParallelAnimationGroup(self) smoothFlipScale.setDuration(500) smoothFlipRotation.setDuration(500) smoothFlipXRotation.setDuration(500) smoothFlipYRotation.setDuration(500) smoothFlipScale.setEasingCurve(QEasingCurve.InOutQuad) smoothFlipRotation.setEasingCurve(QEasingCurve.InOutQuad) smoothFlipXRotation.setEasingCurve(QEasingCurve.InOutQuad) smoothFlipYRotation.setEasingCurve(QEasingCurve.InOutQuad) smoothFlipScale.setKeyValueAt(0, 1.0) smoothFlipScale.setKeyValueAt(0.5, 0.7) smoothFlipScale.setKeyValueAt(1, 1.0) flipAnimation.addAnimation(smoothFlipRotation) flipAnimation.addAnimation(smoothFlipScale) flipAnimation.addAnimation(smoothFlipXRotation) flipAnimation.addAnimation(smoothFlipYRotation) setVariablesSequence = QSequentialAnimationGroup() setFillAnimation = QPropertyAnimation(pad, b'fill') setBackItemVisibleAnimation = QPropertyAnimation(backItem, b'visible') setSelectionItemVisibleAnimation = QPropertyAnimation(selectionItem, b'visible') setFillAnimation.setDuration(0) setBackItemVisibleAnimation.setDuration(0) setSelectionItemVisibleAnimation.setDuration(0) setVariablesSequence.addPause(250) setVariablesSequence.addAnimation(setBackItemVisibleAnimation) setVariablesSequence.addAnimation(setSelectionItemVisibleAnimation) setVariablesSequence.addAnimation(setFillAnimation) flipAnimation.addAnimation(setVariablesSequence) stateMachine = QStateMachine(self) splashState = QState(stateMachine) frontState = QState(stateMachine) historyState = QHistoryState(frontState) backState = QState(stateMachine) frontState.assignProperty(pad, "fill", False) frontState.assignProperty(splash, "opacity", 0.0) frontState.assignProperty(backItem, "visible", False) frontState.assignProperty(flipRotation, "angle", 0.0) frontState.assignProperty(selectionItem, "visible", True) backState.assignProperty(pad, "fill", True) backState.assignProperty(backItem, "visible", True) backState.assignProperty(xRotation, "angle", 0.0) backState.assignProperty(yRotation, "angle", 0.0) backState.assignProperty(flipRotation, "angle", 180.0) backState.assignProperty(selectionItem, "visible", False) stateMachine.addDefaultAnimation(smoothXRotation) stateMachine.addDefaultAnimation(smoothYRotation) stateMachine.addDefaultAnimation(smoothXSelection) stateMachine.addDefaultAnimation(smoothYSelection) stateMachine.setInitialState(splashState) anyKeyTransition = QEventTransition(self, QEvent.KeyPress, splashState) anyKeyTransition.setTargetState(frontState) anyKeyTransition.addAnimation(smoothSplashMove) anyKeyTransition.addAnimation(smoothSplashOpacity) enterTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Enter, backState) returnTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Return, backState) backEnterTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Enter, frontState) backReturnTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Return, frontState) enterTransition.setTargetState(historyState) returnTransition.setTargetState(historyState) backEnterTransition.setTargetState(backState) backReturnTransition.setTargetState(backState) enterTransition.addAnimation(flipAnimation) returnTransition.addAnimation(flipAnimation) backEnterTransition.addAnimation(flipAnimation) backReturnTransition.addAnimation(flipAnimation) columns = size.width() rows = size.height() stateGrid = [] for y in range(rows): stateGrid.append([QState(frontState) for _ in range(columns)]) frontState.setInitialState(stateGrid[0][0]) selectionItem.setPos(pad.iconAt(0, 0).pos()) for y in range(rows): for x in range(columns): state = stateGrid[y][x] rightTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Right, state) leftTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Left, state) downTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Down, state) upTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Up, state) rightTransition.setTargetState(stateGrid[y][(x + 1) % columns]) leftTransition.setTargetState(stateGrid[y][((x - 1) + columns) % columns]) downTransition.setTargetState(stateGrid[(y + 1) % rows][x]) upTransition.setTargetState(stateGrid[((y - 1) + rows) % rows][x]) icon = pad.iconAt(x, y) state.assignProperty(xRotation, "angle", -icon.x() / 6.0) state.assignProperty(yRotation, "angle", icon.y() / 6.0) state.assignProperty(selectionItem, "x", icon.x()) state.assignProperty(selectionItem, "y", icon.y()) frontState.assignProperty(icon, "visible", True) backState.assignProperty(icon, "visible", False) setIconVisibleAnimation = QPropertyAnimation(icon, b'visible') setIconVisibleAnimation.setDuration(0) setVariablesSequence.addAnimation(setIconVisibleAnimation) scene = QGraphicsScene(self) scene.setBackgroundBrush(QBrush(QPixmap(":/images/blue_angle_swirl.jpg"))) scene.setItemIndexMethod(QGraphicsScene.NoIndex) scene.addItem(pad) scene.setSceneRect(scene.itemsBoundingRect()) self.setScene(scene) sbr = splash.boundingRect() splash.setPos(-sbr.width() / 2, scene.sceneRect().top() - 2) frontState.assignProperty(splash, "y", splash.y() - 100.0) scene.addItem(splash) self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.setMinimumSize(50, 50) self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate) self.setCacheMode(QGraphicsView.CacheBackground) self.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform | QPainter.TextAntialiasing) if QGLFormat.hasOpenGL(): self.setViewport(QGLWidget(QGLFormat(QGL.SampleBuffers))) stateMachine.start()
def __init__(self, parent): super(DrawLotteryView, self).__init__() self.pwindow = parent #获取父窗口指针 self.states = QStateMachine() sinitinfo = QState() sltypeinfo = QState() sprizeinfo = QState() svnumberwindow = QState() sdrawlottery = QState() sfinal = QState() sinitinfo.addTransition(self.on_nextstep_event, sltypeinfo) sltypeinfo.addTransition(self.on_nextstep_event, sprizeinfo) sprizeinfo.addTransition(self.on_nextstep_event, svnumberwindow) svnumberwindow.addTransition(self.on_nextstep_event, sdrawlottery) sdrawlottery.addTransition(self.on_nextstep_event, sfinal) sfinal.addTransition(self.on_final_event, sinitinfo) sinitinfo.entered.connect(self.initinfo) sltypeinfo.entered.connect(self.viewltypeinfo) sprizeinfo.entered.connect(self.viewprizeinfo) svnumberwindow.entered.connect(self.viewnumberwindow) sdrawlottery.entered.connect(self.drawlottery) sfinal.entered.connect(self.final) self.states.addState(sinitinfo) self.states.addState(sltypeinfo) self.states.addState(sprizeinfo) self.states.addState(svnumberwindow) self.states.addState(sdrawlottery) self.states.addState(sfinal) self.states.setInitialState(sinitinfo) self.states.start()
class FeedbackDisplay(QStateMachine): """CLASS: FeedbackDisplay This class wraps a QStateMachine and a QLCDNumber in the GUI so it can keep track of a target value and prevent competing display changes. SIGNALS SLOTS --------------------- -------------------- lowerTarget () (float) changeTarget raiseTarget () () sendRequest sendToSerial (str) () sendTarget targetChanged (float) """ targetChanged = pyqtSignal(float) """SIGNAL: targetChanged Emitted when the target value has changed Broadcasts: float - The new target value Connects to: TODO: (probably necessary for FPS) """ raiseTarget = pyqtSignal() """SIGNAL: raiseTarget Internal state change signal Broadcasts: none Connects to: stateMachine transition (* -> upState) """ lowerTarget = pyqtSignal() """SIGNAL: lowerTarget Internal state change signal Broadcasts: none Connects to: stateMachine transition (* -> downState) """ sendToSerial = pyqtSignal(str) """SIGNAL: sendToSerial Delivers a message to be sent over serial Broadcasts: str - The message being sent Connects to: MetroMini.broadcast """ def __init__(self, lcd, targetVal, serial=None, template=None): super().__init__() self.defaultState = DisplayState(lcd, Color.BLACK, 0.0) self.upState = DisplayState(lcd, Color.GREEN) self.downState = DisplayState(lcd, Color.RED) self.waitState = QState() self.setTimer = QTimer() self.setTimer.setInterval(DELAY_BEFORE_SET) self.setTimer.setSingleShot(True) self.waitState.entered.connect(self.setTimer.start) self.waitState.exited.connect(self.setTimer.stop) for s in [ self.defaultState, self.upState, self.downState, self.waitState ]: self.addState(s) s.addTransition(self.raiseTarget, self.upState) s.addTransition(self.lowerTarget, self.downState) for s in [self.upState, self.downState]: s.addTransition(s.done, self.waitState) self.waitState.addTransition(self.setTimer.timeout, self.defaultState) self.setInitialState(self.defaultState) self.target = float(targetVal) if serial is not None: #self.serial = serial self.template = template serial.newDataAvailable.connect(self.defaultState.updateDisplay) self.waitState.exited.connect(self.sendTarget) self.sendToSerial.connect(serial.broadcast) self.requestTimer = QTimer() self.requestTimer.setInterval(REFRESH_PERIOD) self.requestTimer.timeout.connect(self.sendRequest) self.defaultState.entered.connect(self.requestTimer.start) self.defaultState.exited.connect(self.requestTimer.stop) self.start() def getTarget(self): """METHOD: getTarget Access method for the current target value Called by: DisplayState.onEntry Arguments: none Returns: float - The current target value """ return self.target def changeTarget(self, delta): """SLOT: changeTarget Applies a numeric change to the stored target value and directs the QLCDNumber to show that change. Expects: float: The amount by which to shift the target value Connects to: QPushButton.clicked (MainWindow.fpsUpButton, MainWindow.fpsDownButton, MainWindow.psiUpButton, MainWindow.psiDownButton) Emits: raiseTarget, lowerTarget, targetChanged """ self.target += float(delta) if delta > 0: self.raiseTarget.emit() elif delta < 0: self.lowerTarget.emit() self.targetChanged.emit(self.target) def sendRequest(self): """SLOT: sendRequest Sends a serial message requesting a new value from the Metro Mini. Eliminates the need for lambda. Expects: none Connects to: (MainWindow.psiDisplay) QTimer.timeout (requestTimer) Emits: sendToSerial """ self.sendToSerial.emit("request;") def sendTarget(self): """SLOT: sendTarget Sends a serial message with a new target value to the Metro Mini. Eliminates the need for lambda. Expects: none Connects to: (MainWindow.psiDisplay) QState.exited (waitState) Called by: MainWindow.initializeSerialObjects Emits: sendToSerial """ self.sendToSerial.emit(self.template.format(self.target))
scene.setBackgroundBrush(Qt.white) scene.addItem(p1) scene.addItem(p2) scene.addItem(p3) scene.addItem(p4) window = QGraphicsView(scene) window.setFrameStyle(0) window.setAlignment(Qt.AlignLeft | Qt.AlignTop) window.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) window.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) machine = QStateMachine() machine.setGlobalRestorePolicy(QStateMachine.RestoreProperties) group = QState(machine) selectedRect = QRect(86, 86, 128, 128) idleState = QState(group) group.setInitialState(idleState) objects = [p1, p2, p3, p4] createStates(objects, selectedRect, group) createAnimations(objects, machine) machine.setInitialState(group) machine.start() window.resize(300, 300) window.show()
def _make_save_state(self, form): s = QState() s.assignProperty(form.saveBtn, "enabled", True) return s
def init_log_sm(self): self.log_state = QStateMachine() pre_system = QState() pre_event = QState() post_event = QState() self.log_state.addState(pre_system) self.log_state.addState(pre_event) self.log_state.addState(post_event) self.log_state.setInitialState(pre_system) pre_system.assignProperty(self.events, "enabled", False) pre_system.assignProperty(self.compass, "enabled", False) pre_system.assignProperty(self.exact_angle, "enabled", False) pre_event.assignProperty(self.events, "enabled", True) pre_event.assignProperty(self.compass, "enabled", False) pre_event.assignProperty(self.exact_angle, "enabled", False) post_event.assignProperty(self.compass, "enabled", True) post_event.assignProperty(self.exact_angle, "enabled", True) pre_system.addTransition( self.systems.acted, pre_event ) pre_system.addTransition(self.timeout_timer.timeout, pre_system) pre_event.addTransition(self.timeout_timer.timeout, pre_system) post_event.addTransition(self.timeout_timer.timeout, pre_system) pre_event.addTransition( self.systems.acted, pre_event ) post_event.addTransition( self.systems.acted, pre_event ) post_event.addTransition( self.events.acted, post_event ) pre_event.addTransition( self.events.acted, post_event ) pre_system.entered.connect(self.events.switch_active) pre_system.entered.connect(self.systems.switch_active) pre_event.entered.connect(self.events.switch_active) post_event.exited.connect(self.compass.clear_state) post_event.exited.connect(lambda: self.exact_angle.log_angle(False)) self.log_state.setRunning(True)
def __init__(self, stickMan, keyReceiver): self.m_stickMan = stickMan self.m_keyReceiver = keyReceiver # Create animation group to be used for all transitions. self.m_animationGroup = QParallelAnimationGroup() stickManNodeCount = self.m_stickMan.nodeCount() self._pas = [] for i in range(stickManNodeCount): pa = QPropertyAnimation(self.m_stickMan.node(i), 'pos') self._pas.append(pa) self.m_animationGroup.addAnimation(pa) # Set up intial state graph. self.m_machine = QStateMachine() self.m_machine.addDefaultAnimation(self.m_animationGroup) self.m_alive = QState(self.m_machine) self.m_alive.setObjectName('alive') # Make it blink when lightning strikes before entering dead animation. lightningBlink = QState(self.m_machine) lightningBlink.assignProperty(self.m_stickMan.scene(), 'backgroundBrush', Qt.white) lightningBlink.assignProperty(self.m_stickMan, 'penColor', Qt.black) lightningBlink.assignProperty(self.m_stickMan, 'fillColor', Qt.white) lightningBlink.assignProperty(self.m_stickMan, 'isDead', True) timer = QTimer(lightningBlink) timer.setSingleShot(True) timer.setInterval(100) lightningBlink.entered.connect(timer.start) lightningBlink.exited.connect(timer.stop) self.m_dead = QState(self.m_machine) self.m_dead.assignProperty(self.m_stickMan.scene(), 'backgroundBrush', Qt.black) self.m_dead.assignProperty(self.m_stickMan, 'penColor', Qt.white) self.m_dead.assignProperty(self.m_stickMan, 'fillColor', Qt.black) self.m_dead.setObjectName('dead') # Idle state (sets no properties). self.m_idle = QState(self.m_alive) self.m_idle.setObjectName('idle') self.m_alive.setInitialState(self.m_idle) # Lightning strikes at random. self.m_alive.addTransition(LightningStrikesTransition(lightningBlink)) lightningBlink.addTransition(timer.timeout, self.m_dead) self.m_machine.setInitialState(self.m_alive)
class StartTuto(QDialog): def __init__(self): super(StartTuto, self).__init__() QDialog.__init__(self) self.Next = 0 self.setWindowFlags(Qt.FramelessWindowHint) self.setAttribute(Qt.WA_TranslucentBackground, True) self.setWindowTitle("لنتعلم معا") self.font = QFont('abdo salem') self.font.setPointSize(20) self.font.setBold(True) self.ex = QPushButton(self) self.ex.setFont(self.font) self.ex.setGeometry(400 + 80, 450, 150, 50) self.ex.setText('خروج') self.ex.setStyleSheet( "QPushButton:hover{background-color:rgb(241, 90, 36);border:5px solid rgb(0, 97, 157);}\n" "QPushButton{color:white;background-color: rgb(50, 50, 50);border:5px solid rgb(255, 255, 255);}QPushButton:pressed{color:white;background-color: rgb(50, 50, 50);border:5px solid rgb(255, 255, 255);}\n" "") self.ex.clicked.connect(self.Exit) self.hm = QPushButton(self) self.hm.setFont(self.font) self.hm.setGeometry(200 + 80, 450, 150, 50) self.hm.setText('الرئيسية') self.hm.setStyleSheet( "QPushButton:hover{background-color:rgb(241, 90, 36);border:5px solid rgb(0, 97, 157);}\n" "QPushButton{color:white;background-color: rgb(50, 50, 50);border:5px solid rgb(255, 255, 255);}QPushButton:pressed{color:white;background-color: rgb(50, 50, 50);border:5px solid rgb(255, 255, 255);}\n" "") self.hm.clicked.connect(self.home) self.resize(925, 500) self.Ind = [ 'data', 'if', 'for', 'while', 'def', 'class', 'oop', 'exp', 'prj2', 'prj3', 'st' ] self.names = { 'home': [ 'المتغير و\n أنواع البيانات', 'الجملة الشرطية\nIF', 'حلقة التقسيم\nFOR', 'حلقة مادام\nWHILE', 'الدالة\nDEF', 'الفئة\nClass', 'البرمجة كائنية\nالتوجه OOP', 'العبارات', 'المشروع الاول\nRANGE', 'المشروع الثاني\nStr', 'ابدء' ], 'data': [ 'المتغير', 'الأحرف ', 'الأرقام ', 'القائمة', 'القاموس', 'الخطأ\nالصحيح', 'دوال \nانواع البيانات', 'الأمثلة' ], 'if': [ 'الجملة الشرطية\nIF', 'ادوات المقارنة', 'استعمالات\n ELIF و ELSE' ], 'for': ['فكرة \nFOR', 'استعمالات \nFOR', 'امثلة'], 'while': ['فكرة \nWHILE', 'استعمالات \nWHILE', 'امثلة'], 'def': [ 'دالة بسيطة', 'arg\nدالة مع', '*arg\nدالة مع', 'دالة مع\n**kwargs' ], 'class': ['فئة بسيطة\n مع متغير', 'فئة بسيطة\n مع دالة'], 'oop': ['البناء\n__init__', 'خاصية الاراثة', 'دالة\nsuper()'], 'exp': ['عبارة\nreturn', 'عبارة\nassert', 'عبارة\nyield'], 'prj2': ['المشروع'], 'prj3': ['محاكات\nCount', 'محاكات\nFind', 'تطوير\nFind'], 'st': 'exit' } self.Home() def Home(self): self.items = [] for i in range(len(self.names['home'])): item = QPushButton(self) item.setText(self.names['home'][i]) item.setGeometry(395, 350, 120, 80) item.setStyleSheet( "QPushButton:hover{background-color:rgb(241, 90, 36);border:5px solid rgb(0, 97, 157);}\n" "QPushButton{color:white;background-color: rgb(50, 50, 50);border:5px solid rgb(255, 255, 255);}QPushButton:pressed{color:white;background-color: rgb(50, 50, 50);border:5px solid rgb(255, 255, 255);}\n" "") self.font.setPointSize(15) item.setFont(self.font) self.items.append(item) exec("""item.clicked.connect(partial(self.IND,i=%i))""" % (i)) self.rootState = QState() self.tiledState = QState(self.rootState) self.centeredState = QState(self.rootState) for i, item in enumerate(self.items): self.tiledState.assignProperty( item, 'pos', QPointF(((i % 6) * 5.3) * 30, ((i // 6) * 5.3) * 30)) self.centeredState.assignProperty(item, 'pos', QPointF()) self.states = QStateMachine() self.states.addState(self.rootState) self.states.setInitialState(self.rootState) self.rootState.setInitialState(self.centeredState) self.group = QParallelAnimationGroup() for i, item in enumerate(self.items): anim = QPropertyAnimation(item, b'pos') anim.setStartValue(QPoint(400, 300)) anim.setDuration(750 + i * 25) anim.setEasingCurve(QEasingCurve.InOutBack) self.group.addAnimation(anim) for u in self.items: trans = self.rootState.addTransition(u.clicked, self.tiledState) trans.addAnimation(self.group) self.states.start() def Exit(self): open('Files/choice', 'w').write('exit') self.close() def home(self): open('Files/choice', 'w').write('home') self.close() def IND(self, i): open('Files/choice', 'a').write(str(i)) if self.Next != 2: self.Next += 1 if self.names[self.Ind[i]] != 'exit': a = self.names[self.Ind[i]] k = 0 for i in self.items[0:len(a)]: i.setText(a[k]) k += 1 for i in self.items[len(a):]: i.hide() else: self.items[-1].hide() else: self.close()
def createState(self): # state defintion mainState = QState(self.fsm) finalState = QFinalState(self.fsm) self.fsm.setInitialState(mainState) initState = QState(mainState) openState = QState(mainState) mainState.setInitialState(initState) standbyState = QState(openState) processingState = QState(openState) openState.setInitialState(standbyState) # transition defition initState.addTransition(self.sigComPortOpened, openState) openState.addTransition(self.sigComPortClosed, initState) standbyState.addTransition(self.sigPowerOn, processingState) processingState.addTransition(self.sigPowerOff, standbyState) initState.entered.connect(self.initStateEntered) openState.entered.connect(self.openStateEntered) standbyState.entered.connect(self.standbyStateEntered) processingState.entered.connect(self.processingStateEntered) # fsm start self.fsm.start() pass
def twoStateButton(name,stateMachine,action,*states): st = QStateMachine() a1,a2 = states s1,s2 = QState(),QState() icon1 = QIcon(Icons + a1[1]) icon2 = QIcon(Icons + a2[1]) s1.setObjectName(a1[0]) s2.setObjectName(a2[0]) s1.assignProperty(action, "icon", icon1) s2.assignProperty(action, "icon", icon2) s1.assignProperty(action, "text", a1[0]) s2.assignProperty(action, "text", a2[0]) s1.addTransition(action.triggered, s2) s2.addTransition(action.triggered, s1) st.addState(s1) st.addState(s2) st.setInitialState(s1) stateMachine[name] = st st.start()
def createStates(objects, selectedRect, parent): for obj in objects: state = QState(parent) state.assignProperty(obj, 'geometry', selectedRect) parent.addTransition(obj.clicked, state)
def loadState(self, dev, stateParam, stateID = ""): curExecContext = ScExecContext() curExecContext.stateMachine = self.stateMachine curHistoryState = None debug = True r = QXmlStreamReader(dev) while not r.atEnd(): r.readNext() if r.isStartElement(): logger.info("Element :<%s>", r.name()) # # <scxml> # name = r.name().lower() if name == "scxml": if stateID == "": topLevelState = curState = stateParam self.stateInfo[curState] = r.attributes().value("initial") if curState == self.stateMachine: pass # # <state> || <parallel> # elif name == "state" or name == "parallel": inRoot = False stateId = r.attributes().value("id") newState = None # # Create state # if curState is not None: logger.info("Creating state [%s] child of [%s]", stateId, curState.objectName()) type = QState.ExclusiveStates if name == "state" else QState.ParallelStates newState = QState(type, curState) # # ??? # elif stateId == stateID: topLevelState = newState = stateParam if newState is not None: self.stateInfo[newState] = r.attributes().value("initial") newState.setObjectName(stateId) # # initial state # if stateId is not "" and self.stateInfo[curState] == stateId: if curState == self.stateMachine: logger.info("Setting [%s] initial state to [%s]", self.stateMachine.objectName(), newState.objectName()) self.stateMachine.setInitialState(newState) else: logger.info("Setting [%s] initial state to [%s]", curState.objectName(), newState.objectName()) curState.setInitialState(newState) # # TODO implement src attribute management in state element # initialID = r.attributes().value("initial") self.stateByID[stateId] = newState curState = newState curExecContext.state = newState if debug: # Add entry and exit log curExecContext.script = 'logger.debug("[scxml] [debug] > Entering state: [' + stateId + ']")' curExecContext.type = ScExecContext.StateEntry curExecContext.applyScript() curExecContext.script = 'logger.debug("[scxml] [debug] < Exiting state: [' + stateId + ']")' curExecContext.type = ScExecContext.StateExit curExecContext.applyScript() # # <initial> # elif name == "initial": if curState is not None and self.stateInfo[curState] == "": logger.info("Creating state [%s] child of [%s]", stateId, curState.objectName()) newState = QState(curState) curState.setInitialState(newState) # # <history> # elif name == "history": if curState is not None: stateId = r.attributes().value("id") type = r.attributes().value("type") type = QHistoryState.ShallowHistory if type == "shallow" else QHistoryState.DeepHistory curHistoryState = QHistoryState(type) curHistoryState.setObjectName(stateId) self.stateByID[stateId] = curHistoryState # # <final> # elif name == "final": if curState is not None: stateId = r.attributes().value("id") f = QFinalState(curState) f.setObjectName(stateId) curExecContext.state = f self.statesWithFinal.add(curState) gp = curState.parentState() if gp is not None: if gp.childMode() == QState.ParallelStates: self.statesWithFinal.add() self.stateByID[stateId] = f if debug: # Add entry and exit log curExecContext.script = 'logger.debug("[scxml] [debug] > Entering final state: [' + stateId + ']")' curExecContext.type = ScExecContext.StateEntry curExecContext.applyScript() curExecContext.script = 'logger.debug("[scxml] [debug] < Exiting final state: [' + stateId + ']")' curExecContext.type = ScExecContext.StateExit curExecContext.applyScript() # # <script> # elif name == "script": txt = r.readElementText() # # The SCXML Processor MUST evaluate any <script> element that is a child # of <scxml> at document load time # if curExecContext.type == ScExecContext.Unknown and curState == topLevelState: # TODO execute script pass else: curExecContext.script += txt # # <log> # elif name == "log": curExecContext.script += 'logger.' + r.attributes().value("level") + '("[' + \ r.attributes().value("label") + '] [' + \ r.attributes().value("level") + '] ' + r.attributes().value("expr") + '")' # # <assign> # elif name == "assign": pass # # <if> # elif name == "if": pass # # <elseif> # elif name == "elseif": pass # # <else> # elif name == "else": pass # # <cancel> # elif name == "cancel": pass # # <onentry> # elif name == "onentry": curExecContext.type = ScExecContext.StateEntry curExecContext.script = "" # # <onexit> # elif name == "onexit": curExecContext.type = ScExecContext.StateExit curExecContext.script = "" # # <raise> # elif name == "raise": pass # # <send> # elif name == "send": pass # # <invoke> # elif name == "invoke": pass # # <transition> # elif name == "transition": if curHistoryState is not None: inf = ScHistoryInfo() inf.hstate = curHistoryState inf.defaultStateID = r.attributes().value("target") self.historyInfo.append(inf) else: inf = ScTransitionInfo() inf.targets = r.attributes().value("target").split() # TODO split targets curExecContext.type = ScExecContext.Transition curExecContext.script = "" if debug: curExecContext.script = 'logger.debug("[scxml] [debug] = Transitioning to: [' \ + ', '.join(inf.targets) + ']")' + '\n' curTransitions = list() inf.transitions = list() self.transitionsInf.append(inf) for pfx in r.attributes().value("event").split(' '): sigTransition = None if pfx == '': # For eventless transition create QScxmlEventlessTransition transition sigTransition = QScxmlEventlessTransition(self.stateMachine) elif pfx.startswith("q-signal:"): # For all q-signal event, add a QSxcmlSignalTransition self.signalEvents.append(pfx) # get object name (a.b.c) => a objName = pfx[pfx.index(':')+1:pfx.index('.')] # get object reference obj = self.stateMachine.registeredObjects[objName] # get signal reference for attr in pfx[pfx.index('.')+1:].split('.'): sig = getattr(obj, attr) obj = sig # create Signal transition sigTransition = QScxmlSignalTransition(sig, self.stateMachine) if sigTransition is not None: # add condition to transition sigTransition.setConditionExpression(r.attributes().value("cond")) # add transition to current state curState.addTransition(sigTransition) # append sigTransition to transition info inf.transitions.append(sigTransition) # append sigTransition to curTransitions list curTransitions.append(sigTransition) else: logger.error("Transition creation error") # # End element # elif r.isEndElement(): name = r.name().lower() # # </state> or </parallel> # if name == "state" or name == "parallel": if curState == topLevelState: return else: curState = curState.parent() curExecContext.state = curState # # </history> # elif name == "history": curHistoryState = None # # </final> # elif name == "final": curExecContext.state = curExecContext.state.parentState() # # </if> # elif name == "if": pass # # </send> </raise> # elif name == "send" or name == "raise": pass # # </onentry> </onexit> </scxml> # elif name == "onentry" or name == "onexit" or name == "scxml": curExecContext.state = curState curExecContext.type = ScExecContext.StateExit if name == "onexit" else ScExecContext.StateEntry curExecContext.applyScript() curExecContext.type = ScExecContext.Unknown curExecContext.script = "" # # </transition> # elif name == "transition": if curHistoryState is None: curExecContext.transitions = curTransitions curExecContext.type = ScExecContext.Transition curExecContext.applyScript() curExecContext.script = "" curExecContext.type = ScExecContext.Unknown
class LifeCycle(object): def __init__(self, stickMan, keyReceiver): self.m_stickMan = stickMan self.m_keyReceiver = keyReceiver # Create animation group to be used for all transitions. self.m_animationGroup = QParallelAnimationGroup() stickManNodeCount = self.m_stickMan.nodeCount() self._pas = [] for i in range(stickManNodeCount): pa = QPropertyAnimation(self.m_stickMan.node(i), 'pos') self._pas.append(pa) self.m_animationGroup.addAnimation(pa) # Set up intial state graph. self.m_machine = QStateMachine() self.m_machine.addDefaultAnimation(self.m_animationGroup) self.m_alive = QState(self.m_machine) self.m_alive.setObjectName('alive') # Make it blink when lightning strikes before entering dead animation. lightningBlink = QState(self.m_machine) lightningBlink.assignProperty(self.m_stickMan.scene(), 'backgroundBrush', Qt.white) lightningBlink.assignProperty(self.m_stickMan, 'penColor', Qt.black) lightningBlink.assignProperty(self.m_stickMan, 'fillColor', Qt.white) lightningBlink.assignProperty(self.m_stickMan, 'isDead', True) timer = QTimer(lightningBlink) timer.setSingleShot(True) timer.setInterval(100) lightningBlink.entered.connect(timer.start) lightningBlink.exited.connect(timer.stop) self.m_dead = QState(self.m_machine) self.m_dead.assignProperty(self.m_stickMan.scene(), 'backgroundBrush', Qt.black) self.m_dead.assignProperty(self.m_stickMan, 'penColor', Qt.white) self.m_dead.assignProperty(self.m_stickMan, 'fillColor', Qt.black) self.m_dead.setObjectName('dead') # Idle state (sets no properties). self.m_idle = QState(self.m_alive) self.m_idle.setObjectName('idle') self.m_alive.setInitialState(self.m_idle) # Lightning strikes at random. self.m_alive.addTransition(LightningStrikesTransition(lightningBlink)) lightningBlink.addTransition(timer.timeout, self.m_dead) self.m_machine.setInitialState(self.m_alive) def setDeathAnimation(self, fileName): deathAnimation = self.makeState(self.m_dead, fileName) self.m_dead.setInitialState(deathAnimation) def start(self): self.m_machine.start() def addActivity(self, fileName, key): state = self.makeState(self.m_alive, fileName) self.m_alive.addTransition( KeyPressTransition(self.m_keyReceiver, key, state)) def makeState(self, parentState, animationFileName): topLevel = QState(parentState) animation = Animation() file = QFile(animationFileName) if file.open(QIODevice.ReadOnly): animation.load(file) frameCount = animation.totalFrames() previousState = None for i in range(frameCount): animation.setCurrentFrame(i) frameState = QState(topLevel) nodeCount = animation.nodeCount() for j in range(nodeCount): frameState.assignProperty(self.m_stickMan.node(j), 'pos', animation.nodePos(j)) frameState.setObjectName('frame %d' % i) if previousState is None: topLevel.setInitialState(frameState) else: previousState.addTransition(previousState.propertiesAssigned, frameState) previousState = frameState previousState.addTransition(previousState.propertiesAssigned, topLevel.initialState()) return topLevel
scene = QGraphicsScene(0, 0, 300, 300) scene.setBackgroundBrush(Qt.black) scene.addItem(button1) scene.addItem(button2) scene.addItem(button3) scene.addItem(button4) window = QGraphicsView(scene) window.setFrameStyle(0) window.setAlignment(Qt.AlignLeft | Qt.AlignTop) window.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) window.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) machine = QStateMachine() group = QState() timer = QTimer() timer.setInterval(1250) timer.setSingleShot(True) group.entered.connect(timer.start) state1 = createGeometryState(button1, QRect(100, 0, 50, 50), button2, QRect(150, 0, 50, 50), button3, QRect(200, 0, 50, 50), button4, QRect(250, 0, 50, 50), group) state2 = createGeometryState(button1, QRect(250, 100, 50, 50), button2, QRect(250, 150, 50, 50), button3, QRect(250, 200, 50, 50), button4, QRect(250, 250, 50, 50), group)
def makeState(self, parentState, animationFileName): topLevel = QState(parentState) animation = Animation() file = QFile(animationFileName) if file.open(QIODevice.ReadOnly): animation.load(file) frameCount = animation.totalFrames() previousState = None for i in range(frameCount): animation.setCurrentFrame(i) frameState = QState(topLevel) nodeCount = animation.nodeCount() for j in range(nodeCount): frameState.assignProperty(self.m_stickMan.node(j), 'pos', animation.nodePos(j)) frameState.setObjectName('frame %d' % i) if previousState is None: topLevel.setInitialState(frameState) else: previousState.addTransition(previousState.propertiesAssigned, frameState) previousState = frameState previousState.addTransition(previousState.propertiesAssigned, topLevel.initialState()) return topLevel
def __init__(self, scene, x_max, y_max, back_color): scene = QGraphicsScene(0, 0, x_max, y_max) scene.setBackgroundBrush(back_color) color = [Qt.green, Qt.lightGray, Qt.darkYellow, QtGui.QColor.fromRgb(255, 85, 0)] self.anim_butt = [ QGraphicsRectWidget(color[j]) for j in range(4) ] for j in range(4): scene.addItem(self.anim_butt[j]) self.window = QGraphicsView(scene) self.window.setFrameStyle(0) self.window.setAlignment(Qt.AlignLeft | Qt.AlignTop) self.window.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.window.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.machine = QStateMachine() self.group = QState() self.timer = QTimer() self.timer.setInterval(1250) self.timer.setSingleShot(True) self.group.entered.connect(self.timer.start) # set states positions anim_state_rects = [ [QRect(x_max*xp/6, y_max*yp/4, 8, 8) for xp in range(4)] for yp in range(4) ] self.states = [ self.createGeometryState( self.anim_butt[0], anim_state_rects[0][j], self.anim_butt[1], anim_state_rects[1][j], self.anim_butt[2], anim_state_rects[2][j], self.anim_butt[3], anim_state_rects[3][j], self.group ) for j in range(4) ] self.group.setInitialState(self.states[0]) self.animationGroup = QParallelAnimationGroup() self.anim = QPropertyAnimation(self.anim_butt[3], 'geometry') self.anim.setDuration(1250) self.anim.setEasingCurve(QEasingCurve.InBack) self.animationGroup.addAnimation(self.anim) self.subGroup = QSequentialAnimationGroup(self.animationGroup) self.subGroup.addPause(100) self.anim = QPropertyAnimation(self.anim_butt[2], 'geometry') self.anim.setDuration(1000) self.anim.setEasingCurve(QEasingCurve.OutElastic) self.subGroup.addAnimation(self.anim) self.subGroup = QSequentialAnimationGroup(self.animationGroup) self.subGroup.addPause(500) self.anim = QPropertyAnimation(self.anim_butt[1], 'geometry') self.anim.setDuration(500) self.anim.setEasingCurve(QEasingCurve.OutElastic) self.subGroup.addAnimation(self.anim) self.subGroup = QSequentialAnimationGroup(self.animationGroup) self.subGroup.addPause(750) self.anim = QPropertyAnimation(self.anim_butt[0], 'geometry') self.anim.setDuration(250) self.anim.setEasingCurve(QEasingCurve.OutElastic) self.subGroup.addAnimation(self.anim) self.stateSwitcher = StateSwitcher(self.machine) self.group.addTransition(self.timer.timeout, self.stateSwitcher) for j in range(4): self.stateSwitcher.addState(self.states[j], self.animationGroup) self.machine.addState(self.group) self.machine.setInitialState(self.group) self.machine.start()
class LifeCycle(object): def __init__(self, stickMan, keyReceiver): self.m_stickMan = stickMan self.m_keyReceiver = keyReceiver # Create animation group to be used for all transitions. self.m_animationGroup = QParallelAnimationGroup() stickManNodeCount = self.m_stickMan.nodeCount() self._pas = [] for i in range(stickManNodeCount): pa = QPropertyAnimation(self.m_stickMan.node(i), b"pos") self._pas.append(pa) self.m_animationGroup.addAnimation(pa) # Set up intial state graph. self.m_machine = QStateMachine() self.m_machine.addDefaultAnimation(self.m_animationGroup) self.m_alive = QState(self.m_machine) self.m_alive.setObjectName("alive") # Make it blink when lightning strikes before entering dead animation. lightningBlink = QState(self.m_machine) lightningBlink.assignProperty(self.m_stickMan.scene(), "backgroundBrush", Qt.white) lightningBlink.assignProperty(self.m_stickMan, "penColor", Qt.black) lightningBlink.assignProperty(self.m_stickMan, "fillColor", Qt.white) lightningBlink.assignProperty(self.m_stickMan, "isDead", True) timer = QTimer(lightningBlink) timer.setSingleShot(True) timer.setInterval(100) lightningBlink.entered.connect(timer.start) lightningBlink.exited.connect(timer.stop) self.m_dead = QState(self.m_machine) self.m_dead.assignProperty(self.m_stickMan.scene(), "backgroundBrush", Qt.black) self.m_dead.assignProperty(self.m_stickMan, "penColor", Qt.white) self.m_dead.assignProperty(self.m_stickMan, "fillColor", Qt.black) self.m_dead.setObjectName("dead") # Idle state (sets no properties). self.m_idle = QState(self.m_alive) self.m_idle.setObjectName("idle") self.m_alive.setInitialState(self.m_idle) # Lightning strikes at random. self.m_alive.addTransition(LightningStrikesTransition(lightningBlink)) lightningBlink.addTransition(timer.timeout, self.m_dead) self.m_machine.setInitialState(self.m_alive) def setDeathAnimation(self, fileName): deathAnimation = self.makeState(self.m_dead, fileName) self.m_dead.setInitialState(deathAnimation) def start(self): self.m_machine.start() def addActivity(self, fileName, key): state = self.makeState(self.m_alive, fileName) self.m_alive.addTransition(KeyPressTransition(self.m_keyReceiver, key, state)) def makeState(self, parentState, animationFileName): topLevel = QState(parentState) animation = Animation() file = QFile(animationFileName) if file.open(QIODevice.ReadOnly): animation.load(file) frameCount = animation.totalFrames() previousState = None for i in range(frameCount): animation.setCurrentFrame(i) frameState = QState(topLevel) nodeCount = animation.nodeCount() for j in range(nodeCount): frameState.assignProperty(self.m_stickMan.node(j), "pos", animation.nodePos(j)) frameState.setObjectName("frame %d" % i) if previousState is None: topLevel.setInitialState(frameState) else: previousState.addTransition(previousState.propertiesAssigned, frameState) previousState = frameState previousState.addTransition(previousState.propertiesAssigned, topLevel.initialState()) return topLevel
def init_ui(self): vbox = QVBoxLayout() button1 = QPushButton('fuck1') vbox.addWidget(button1) button1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) vbox.setContentsMargins(80, 80, 80, 80) self.setLayout(vbox) machine = QStateMachine(self) s1 = QState() s1.assignProperty(button1, "text", "Outside") s2 = QState() s2.assignProperty(button1, "text", "Inside") enter_transition = QEventTransition(button1, QEvent.Enter) enter_transition.setTargetState(s2) s1.addTransition(enter_transition) leave_transition = QEventTransition(button1, QEvent.Leave) leave_transition.setTargetState(s1) s2.addTransition(leave_transition) s3 = QState() s3.assignProperty(button1, 'text', 'Pressing...') press_transition = QEventTransition(button1, QEvent.MouseButtonPress) press_transition.setTargetState(s3) s2.addTransition(press_transition) release_transition = QEventTransition(button1, QEvent.MouseButtonRelease) release_transition.setTargetState(s2) s3.addTransition(release_transition) machine.addState(s1) machine.addState(s2) machine.addState(s3) machine.setInitialState(s1) machine.start()
def __init__(self, stickMan, keyReceiver): self.m_stickMan = stickMan self.m_keyReceiver = keyReceiver # Create animation group to be used for all transitions. self.m_animationGroup = QParallelAnimationGroup() stickManNodeCount = self.m_stickMan.nodeCount() self._pas = [] for i in range(stickManNodeCount): pa = QPropertyAnimation(self.m_stickMan.node(i), b"pos") self._pas.append(pa) self.m_animationGroup.addAnimation(pa) # Set up intial state graph. self.m_machine = QStateMachine() self.m_machine.addDefaultAnimation(self.m_animationGroup) self.m_alive = QState(self.m_machine) self.m_alive.setObjectName("alive") # Make it blink when lightning strikes before entering dead animation. lightningBlink = QState(self.m_machine) lightningBlink.assignProperty(self.m_stickMan.scene(), "backgroundBrush", Qt.white) lightningBlink.assignProperty(self.m_stickMan, "penColor", Qt.black) lightningBlink.assignProperty(self.m_stickMan, "fillColor", Qt.white) lightningBlink.assignProperty(self.m_stickMan, "isDead", True) timer = QTimer(lightningBlink) timer.setSingleShot(True) timer.setInterval(100) lightningBlink.entered.connect(timer.start) lightningBlink.exited.connect(timer.stop) self.m_dead = QState(self.m_machine) self.m_dead.assignProperty(self.m_stickMan.scene(), "backgroundBrush", Qt.black) self.m_dead.assignProperty(self.m_stickMan, "penColor", Qt.white) self.m_dead.assignProperty(self.m_stickMan, "fillColor", Qt.black) self.m_dead.setObjectName("dead") # Idle state (sets no properties). self.m_idle = QState(self.m_alive) self.m_idle.setObjectName("idle") self.m_alive.setInitialState(self.m_idle) # Lightning strikes at random. self.m_alive.addTransition(LightningStrikesTransition(lightningBlink)) lightningBlink.addTransition(timer.timeout, self.m_dead) self.m_machine.setInitialState(self.m_alive)