void DockPanel::initShowHideAnimation()
{
QStateMachine * machine = new QStateMachine(this);
QState * showState = new QState(machine);
showState->assignProperty(this,"y", 0);
QState * hideState = new QState(machine);
//y should change with DockMode changed
connect(this, &DockPanel::startHide, [=]{
hideState->assignProperty(this,"y", m_dockModeData->getDockHeight());
});
machine->setInitialState(showState);
QPropertyAnimation *showAnimation = new QPropertyAnimation(this, "y");
showAnimation->setDuration(SHOW_ANIMATION_DURATION);
showAnimation->setEasingCurve(SHOW_EASINGCURVE);
connect(showAnimation,&QPropertyAnimation::finished,this,&DockPanel::onShowPanelFinished);
QPropertyAnimation *hideAnimation = new QPropertyAnimation(this, "y");
hideAnimation->setDuration(HIDE_ANIMATION_DURATION);
hideAnimation->setEasingCurve(HIDE_EASINGCURVE);
connect(hideAnimation,&QPropertyAnimation::finished,this,&DockPanel::onHidePanelFinished);
QSignalTransition *st = showState->addTransition(this,SIGNAL(startHide()), hideState);
st->addAnimation(hideAnimation);
QSignalTransition *ht = hideState->addTransition(this,SIGNAL(startShow()),showState);
ht->addAnimation(showAnimation);
machine->start();
}
void DiscountPage::setupItemAnimations()
{
QState *smallState = new QState();
QState *bigState = new QState();
for (int i = 0; i < this->m_itemList.size(); i++) {
smallState->assignProperty(this->m_itemList[i],"scale", 0);
bigState->assignProperty(this->m_itemList[i],"scale",1);
}
QSequentialAnimationGroup *showItemGroup = new QSequentialAnimationGroup(this);
for (int i = 0; i < this->m_itemList.size(); i++) {
QPropertyAnimation *anim = new QPropertyAnimation(this->m_itemList[i], "scale", this);
anim->setDuration(300);
anim->setEasingCurve(QEasingCurve::OutBack);
showItemGroup->addAnimation(anim);
}
QSignalTransition *trans = smallState->addTransition(this, SIGNAL(start()), bigState);
trans->addAnimation(showItemGroup);
connect(showItemGroup,SIGNAL(finished()),this,SLOT(startSelect()));
trans = bigState->addTransition(this,SIGNAL(quitPage()),smallState);
connect(smallState,SIGNAL(entered()),this,SLOT(closeSelect()));
QStateMachine *states = new QStateMachine(this);
states->addState(smallState);
states->addState(bigState);
states->setInitialState(smallState);
states->start();
}
QGraphicsItem *CarouselGraphicsWidget::addItem(QGraphicsWidget *p)
{
scene()->addItem(p);
icons.append(p);
// Set the speed of the animation (it has to be set on the objects in the scene)
QPropertyAnimation *anim = new QPropertyAnimation(p, "geometry");
anim->setDuration(500);
animationGroup->addAnimation(anim);
QState *newState = new QState(machine);
QState *lastState = states.at(states.size()-1);
if (states.size() == 0) {
machine->setInitialState(newState);
} else {
// Link this new state to the next state
QSignalTransition *transition;
transition = lastState->addTransition(this, SIGNAL(m_next()), newState);
transition->addAnimation(animationGroup);
// Link the next state to this new state
transition = newState->addTransition(this, SIGNAL(m_back()), lastState);
transition->addAnimation(animationGroup);
}
states.append(newState);
// NB: Don't update the scene yet. See resizeEvent comment
return p;
}
UIGChooserItem::UIGChooserItem(UIGChooserItem *pParent, bool fTemporary)
: m_fRoot(!pParent)
, m_fTemporary(fTemporary)
, m_pParent(pParent)
, m_iPreviousMinimumWidthHint(0)
, m_iPreviousMinimumHeightHint(0)
, m_dragTokenPlace(DragToken_Off)
, m_fHovered(false)
, m_pHighlightMachine(0)
, m_pForwardAnimation(0)
, m_pBackwardAnimation(0)
, m_iAnimationDuration(400)
, m_iDefaultDarkness(100)
, m_iHighlightDarkness(90)
, m_iAnimationDarkness(m_iDefaultDarkness)
, m_iDragTokenDarkness(110)
{
/* Basic item setup: */
setOwnedByLayout(false);
setAcceptDrops(true);
setFocusPolicy(Qt::NoFocus);
setFlag(QGraphicsItem::ItemIsSelectable, false);
setAcceptHoverEvents(!isRoot());
/* Non-root item? */
if (!isRoot())
{
/* Create state machine: */
m_pHighlightMachine = new QStateMachine(this);
/* Create 'default' state: */
QState *pStateDefault = new QState(m_pHighlightMachine);
/* Create 'highlighted' state: */
QState *pStateHighlighted = new QState(m_pHighlightMachine);
/* Forward animation: */
m_pForwardAnimation = new QPropertyAnimation(this, "animationDarkness", this);
m_pForwardAnimation->setDuration(m_iAnimationDuration);
m_pForwardAnimation->setStartValue(m_iDefaultDarkness);
m_pForwardAnimation->setEndValue(m_iHighlightDarkness);
/* Backward animation: */
m_pBackwardAnimation = new QPropertyAnimation(this, "animationDarkness", this);
m_pBackwardAnimation->setDuration(m_iAnimationDuration);
m_pBackwardAnimation->setStartValue(m_iHighlightDarkness);
m_pBackwardAnimation->setEndValue(m_iDefaultDarkness);
/* Add state transitions: */
QSignalTransition *pDefaultToHighlighted = pStateDefault->addTransition(this, SIGNAL(sigHoverEnter()), pStateHighlighted);
pDefaultToHighlighted->addAnimation(m_pForwardAnimation);
QSignalTransition *pHighlightedToDefault = pStateHighlighted->addTransition(this, SIGNAL(sigHoverLeave()), pStateDefault);
pHighlightedToDefault->addAnimation(m_pBackwardAnimation);
/* Initial state is 'default': */
m_pHighlightMachine->setInitialState(pStateDefault);
/* Start state-machine: */
m_pHighlightMachine->start();
}
}
explicit Foo(QObject * parent = 0) :
QObject(parent),
m_state1(&m_stateMachine),
m_state2(&m_stateMachine)
{
m_stateMachine.setInitialState(&m_state1);
m_state1.addTransition(this, SIGNAL(sigGoToStateTwo()), &m_state2);
m_state2.addTransition(this, SIGNAL(sigGoToStateOne()), &m_state1);
}
//! [3]
Q_DECL_EXPORT int main(int argc, char **argv)
{
Application app(argc, argv);
Factorial factorial;
// Create the state machine
QStateMachine machine;
//! [3]
//! [4]
// Create the 'compute' state as child of the state machine
QState *compute = new QState(&machine);
// Initialize the 'fac', 'x' and 'xorig' properties of the Factorial object whenever the compute state is entered
compute->assignProperty(&factorial, "fac", 1);
compute->assignProperty(&factorial, "x", 6);
compute->assignProperty(&factorial, "xorig", 6);
/**
* Add the custom transition to the compute state.
* Note: This transition has the compute state as source and target state.
*/
compute->addTransition(new FactorialLoopTransition(&factorial));
//! [4]
//! [5]
// Create a final state
QFinalState *done = new QFinalState(&machine);
// Add a custom transition with the 'compute' state as source state and the 'done' state as target state
FactorialDoneTransition *doneTransition = new FactorialDoneTransition(&factorial);
doneTransition->setTargetState(done);
compute->addTransition(doneTransition);
//! [5]
//! [6]
// Set the 'compute' state as initial state of the state machine
machine.setInitialState(compute);
// Load the UI description from main.qml
QmlDocument *qml = QmlDocument::create("asset:///main.qml");
// Make the Factorial and StateMachine object available to the UI as context properties
qml->setContextProperty("_factorial", &factorial);
qml->setContextProperty("_machine", &machine);
// Create the application scene
AbstractPane *appPage = qml->createRootObject<AbstractPane>();
Application::instance()->setScene(appPage);
return Application::exec();
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow),
stateMachine(new QStateMachine(this)),
lastSelectDir(OP_DIR)
{
ui->setupUi(this);
ui->listWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
//Setting states
QState *runningState = new QState();
QState *stopState = new QState();
stopState->addTransition(this,SIGNAL(started()),runningState);
runningState->addTransition(this,SIGNAL(finished()),stopState);
runningState->assignProperty(ui->addButton,"enabled","false");
runningState->assignProperty(ui->clearAllButton,"enabled","false");
runningState->assignProperty(ui->removeButton,"enabled","false");
stopState->assignProperty(ui->addButton,"enabled","true");
stopState->assignProperty(ui->clearAllButton,"enabled","true");
stopState->assignProperty(ui->removeButton,"enabled","true");
connect(runningState,&QState::entered,[&]{
qDebug()<<QTime::currentTime()<<"start convert";
});
connect(runningState,&QState::exited,[&]{
qDebug()<<QTime::currentTime()<<"stop convert";
});
connect(runningState,&QState::exited,[&]{
ui->progressBar->setValue(100);
QMessageBox::information(
this,
tr("Nook HD+ Manga Converter"),
tr("All job completed!") );
});
stateMachine->addState(stopState);
stateMachine->addState(runningState);
stateMachine->setInitialState(stopState);
connect(ui->convertButton,&QPushButton::clicked,this,&MainWindow::convert);
connect(ui->addButton,&QPushButton::clicked,this,&MainWindow::addBook);
connect(ui->clearAllButton,&QPushButton::clicked,ui->listWidget,&QListWidget::clear);
connect(ui->removeButton,&QPushButton::clicked,[&]{qDeleteAll(ui->listWidget->selectedItems());});
connect(this,&MainWindow::completed,ui->progressBar,&QProgressBar::setValue);
stateMachine->start();
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
QString n = "(?:[0-1]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])";
ipValidator = new QRegExpValidator(QRegExp("^" + n + "\\." + n + "\\." + n + "\\." + n + "$"));
intValidator = new QRegExpValidator(QRegExp("[0-9]+"));
hexValidator = new QRegExpValidator(QRegExp("[0-9a-fA-F]+"));
base64Validator = new QRegExpValidator(QRegExp("^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$"));
setIpValidator();
machine = new QStateMachine(this);
QState *ipToInt = new QState();
QState *intToHex = new QState();
QState *hexToBase64 = new QState();
QState *base64ToHex = new QState();
QState *hexToInt = new QState();
QState *intToIp = new QState();
ipToInt->addTransition(ui->pushButton, SIGNAL(clicked()), intToHex);
intToHex->addTransition(ui->pushButton, SIGNAL(clicked()), hexToBase64);
hexToBase64->addTransition(ui->pushButton, SIGNAL(clicked()), base64ToHex);
base64ToHex->addTransition(ui->pushButton, SIGNAL(clicked()), hexToInt);
hexToInt->addTransition(ui->pushButton, SIGNAL(clicked()), intToIp);
intToIp->addTransition(ui->pushButton, SIGNAL(clicked()), ipToInt);
QObject::connect(ipToInt, SIGNAL(exited()), this, SLOT(convertIpToInt()));
QObject::connect(intToHex, SIGNAL(exited()), this, SLOT(convertIntToHex()));
QObject::connect(hexToBase64, SIGNAL(exited()), this, SLOT(convertHexToBase64()));
QObject::connect(base64ToHex, SIGNAL(exited()), this, SLOT(convertBase64ToHex()));
QObject::connect(hexToInt, SIGNAL(exited()), this, SLOT(convertHexToInt()));
QObject::connect(intToIp, SIGNAL(exited()), this, SLOT(convertIntToIp()));
machine->addState(ipToInt);
machine->addState(intToHex);
machine->addState(hexToBase64);
machine->addState(base64ToHex);
machine->addState(hexToInt);
machine->addState(intToIp);
machine->setInitialState(ipToInt);
machine->start();
}
bool AbstractTransition::initialize() {
logger->info(QString("%1 initialize").arg(toString()));
if (sourceState == NULL) {
logger->warning(QString("%1 transition initialization failed: couldn't find source state \"%2\"").arg(toString()).arg(sourceStateId));
return false;
}
if (targetState == NULL) {
logger->warning(QString("%1 transition initialization failed: couldn't find target state \"%2\"").arg(toString()).arg(targetStateId));
return false;
}
// cast abstract state
QState* state = dynamic_cast<QState*>(sourceState->getDelegate());
if (state == NULL) {
logger->warning(QString("%1 transition initialization failed: source delegate is not of type QState").arg(toString()));
return false;
}
logger->info(QString("%1 add transition from \"%2\" to \"%3\"").arg(toString()).arg(sourceState->getId()).arg(targetState->getId()));
setTargetState(targetState->getDelegate());
state->addTransition(this);
return true;
}
//! [4]
int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
QStateMachine machine;
QState *group = new QState(QState::ParallelStates);
group->setObjectName("group");
//! [4]
//! [5]
Pinger *pinger = new Pinger(group);
pinger->setObjectName("pinger");
pinger->addTransition(new PongTransition());
QState *ponger = new QState(group);
ponger->setObjectName("ponger");
ponger->addTransition(new PingTransition());
//! [5]
//! [6]
machine.addState(group);
machine.setInitialState(group);
machine.start();
return app.exec();
}
UIGraphicsZoomButton::UIGraphicsZoomButton(QIGraphicsWidget *pParent, const QIcon &icon, int iDirection)
: UIGraphicsButton(pParent, icon)
, m_iIndent(4)
, m_iDirection(iDirection)
, m_iAnimationDuration(200)
, m_pStateMachine(0)
, m_pForwardAnimation(0)
, m_pBackwardAnimation(0)
, m_fStateDefault(true)
{
/* Setup: */
setAcceptHoverEvents(true);
/* Create state machine: */
m_pStateMachine = new QStateMachine(this);
/* Create 'default' state: */
QState *pStateDefault = new QState(m_pStateMachine);
pStateDefault->assignProperty(this, "stateDefault", true);
/* Create 'zoomed' state: */
QState *pStateZoomed = new QState(m_pStateMachine);
pStateZoomed->assignProperty(this, "stateDefault", false);
/* Initial state is 'default': */
m_pStateMachine->setInitialState(pStateDefault);
/* Zoom animation: */
m_pForwardAnimation = new QPropertyAnimation(this, "geometry", this);
m_pForwardAnimation->setDuration(m_iAnimationDuration);
/* Unzoom animation: */
m_pBackwardAnimation = new QPropertyAnimation(this, "geometry", this);
m_pBackwardAnimation->setDuration(m_iAnimationDuration);
/* Add state transitions: */
QSignalTransition *pDefaultToZoomed = pStateDefault->addTransition(this, SIGNAL(sigHoverEnter()), pStateZoomed);
pDefaultToZoomed->addAnimation(m_pForwardAnimation);
QSignalTransition *pZoomedToDefault = pStateZoomed->addTransition(this, SIGNAL(sigHoverLeave()), pStateDefault);
pZoomedToDefault->addAnimation(m_pBackwardAnimation);
/* Start state-machine: */
m_pStateMachine->start();
}
//! [0]
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QPushButton button;
QStateMachine machine;
//! [0]
//! [1]
QState *off = new QState();
off->assignProperty(&button, "text", "Off");
off->setObjectName("off");
QState *on = new QState();
on->setObjectName("on");
on->assignProperty(&button, "text", "On");
//! [1]
//! [2]
off->addTransition(&button, SIGNAL(clicked()), on);
on->addTransition(&button, SIGNAL(clicked()), off);
//! [2]
//! [3]
machine.addState(off);
machine.addState(on);
//! [3]
//! [4]
machine.setInitialState(off);
machine.start();
//! [4]
//! [5]
#if defined(Q_OS_SYMBIAN)
button.showMaximized();
#elif defined(Q_WS_MAEMO_5) || defined(Q_WS_SIMULATOR)
button.show();
#else
button.resize(100, 50);
button.show();
#endif
return app.exec();
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
// Загружаем интерфейс пользователя из формы и устанавливаем действия в меню
ui->setupUi(this);
connect(ui->action_start, SIGNAL(triggered()), ui->startButton, SLOT(click()));
connect(ui->action_exit, SIGNAL(triggered()), this, SLOT(close()));
connect(ui->action_Qt, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
connect(ui->action_help, SIGNAL(triggered()), this, SLOT(showHelp()));
connect(ui->action_about, SIGNAL(triggered()), this, SLOT(showAbout()));
connect(ui->action_tech, SIGNAL(triggered()), this, SLOT(showTz()));
// Заводим машину состояний
QStateMachine *animation = new QStateMachine(this);
QState *idle = new QState();
QState *animating = new QState();
animating->assignProperty(ui->startButton,"text", tr("&Стоп"));
animating->assignProperty(ui->startButton,"icon", QIcon(":/icons/control-stop-square.png"));
animating->assignProperty(ui->action_start,"text",tr("О&становить анимацию"));
animating->assignProperty(ui->action_start,"icon", QIcon(":/icons/control-stop-square.png"));
idle->assignProperty(ui->startButton,"text", tr("Пу&ск"));
idle->assignProperty(ui->startButton,"icon", QIcon(":/icons/control.png"));
idle->assignProperty(ui->action_start,"text",tr("Запу&стить анимацию"));
idle->assignProperty(ui->action_start,"icon", QIcon(":/icons/control.png"));
QSignalTransition *startTransition = new QSignalTransition(ui->startButton, SIGNAL(clicked()), idle);
startTransition->setTargetState(animating);
QSignalTransition *stopTransition = new QSignalTransition(ui->startButton, SIGNAL(clicked()), animating);
stopTransition->setTargetState(idle);
QSignalTransition *doneTransition = new QSignalTransition(ui->widget, SIGNAL(animationStopped()), animating);
doneTransition->setTargetState(idle);
connect(startTransition, SIGNAL(triggered()), ui->widget, SLOT(startAnimation()));
connect(stopTransition, SIGNAL(triggered()), ui->widget, SLOT(stopAnimation()));
idle->addTransition(startTransition);
animating->addTransition(stopTransition);
animating->addTransition(doneTransition);
animation->addState(idle);
animation->addState(animating);
animation->setInitialState(idle);
animation->start();
// В Linux мячик иногда сразу не отображается...
ui->widget->updateGL();
}
void UIGDetailsElement::prepareElement()
{
/* Initialization: */
m_nameFont = font();
m_nameFont.setWeight(QFont::Bold);
m_textFont = font();
/* Create highlight machine: */
m_pHighlightMachine = new QStateMachine(this);
/* Create 'default' state: */
QState *pStateDefault = new QState(m_pHighlightMachine);
/* Create 'highlighted' state: */
QState *pStateHighlighted = new QState(m_pHighlightMachine);
/* Forward animation: */
m_pForwardAnimation = new QPropertyAnimation(this, "animationDarkness", this);
m_pForwardAnimation->setDuration(m_iAnimationDuration);
m_pForwardAnimation->setStartValue(m_iDefaultDarkness);
m_pForwardAnimation->setEndValue(m_iHighlightDarkness);
/* Backward animation: */
m_pBackwardAnimation = new QPropertyAnimation(this, "animationDarkness", this);
m_pBackwardAnimation->setDuration(m_iAnimationDuration);
m_pBackwardAnimation->setStartValue(m_iHighlightDarkness);
m_pBackwardAnimation->setEndValue(m_iDefaultDarkness);
/* Add state transitions: */
QSignalTransition *pDefaultToHighlighted = pStateDefault->addTransition(this, SIGNAL(sigHoverEnter()), pStateHighlighted);
pDefaultToHighlighted->addAnimation(m_pForwardAnimation);
QSignalTransition *pHighlightedToDefault = pStateHighlighted->addTransition(this, SIGNAL(sigHoverLeave()), pStateDefault);
pHighlightedToDefault->addAnimation(m_pBackwardAnimation);
/* Initial state is 'default': */
m_pHighlightMachine->setInitialState(pStateDefault);
/* Start state-machine: */
m_pHighlightMachine->start();
connect(this, SIGNAL(sigToggleElement(DetailsElementType, bool)), model(), SLOT(sltToggleElements(DetailsElementType, bool)));
connect(this, SIGNAL(sigLinkClicked(const QString&, const QString&, const QString&)),
model(), SIGNAL(sigLinkClicked(const QString&, const QString&, const QString&)));
}
QStateMachine* UIAnimationFramework::installPropertyAnimation(QWidget *pTarget, const char *pszPropertyName,
const char *pszValuePropertyNameStart, const char *pszValuePropertyNameFinal,
const char *pSignalForward, const char *pSignalBackward,
bool fReversive /*= false*/, int iAnimationDuration /*= 300*/)
{
/* State-machine: */
QStateMachine *pStateMachine = new QStateMachine(pTarget);
/* State-machine 'start' state: */
QState *pStateStart = new QState(pStateMachine);
/* State-machine 'final' state: */
QState *pStateFinal = new QState(pStateMachine);
/* State-machine 'forward' animation: */
QPropertyAnimation *pForwardAnimation = new QPropertyAnimation(pTarget, pszPropertyName, pStateMachine);
pForwardAnimation->setEasingCurve(QEasingCurve(QEasingCurve::InOutCubic));
pForwardAnimation->setDuration(iAnimationDuration);
pForwardAnimation->setStartValue(pTarget->property(pszValuePropertyNameStart));
pForwardAnimation->setEndValue(pTarget->property(pszValuePropertyNameFinal));
/* State-machine 'backward' animation: */
QPropertyAnimation *pBackwardAnimation = new QPropertyAnimation(pTarget, pszPropertyName, pStateMachine);
pBackwardAnimation->setEasingCurve(QEasingCurve(QEasingCurve::InOutCubic));
pBackwardAnimation->setDuration(iAnimationDuration);
pBackwardAnimation->setStartValue(pTarget->property(pszValuePropertyNameFinal));
pBackwardAnimation->setEndValue(pTarget->property(pszValuePropertyNameStart));
/* State-machine state transitions: */
QSignalTransition *pDefaultToHovered = pStateStart->addTransition(pTarget, pSignalForward, pStateFinal);
pDefaultToHovered->addAnimation(pForwardAnimation);
QSignalTransition *pHoveredToDefault = pStateFinal->addTransition(pTarget, pSignalBackward, pStateStart);
pHoveredToDefault->addAnimation(pBackwardAnimation);
/* Initial state is 'start': */
pStateMachine->setInitialState(!fReversive ? pStateStart : pStateFinal);
/* Start hover-machine: */
pStateMachine->start();
/* Return machine: */
return pStateMachine;
}
//! [0]
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QPushButton button;
QStateMachine machine;
//! [0]
//! [1]
QState *off = new QState();
off->assignProperty(&button, "text", "Off");
off->setObjectName("off");
QState *on = new QState();
on->setObjectName("on");
on->assignProperty(&button, "text", "On");
//! [1]
//! [2]
off->addTransition(&button, SIGNAL(clicked()), on);
on->addTransition(&button, SIGNAL(clicked()), off);
//! [2]
//! [3]
machine.addState(off);
machine.addState(on);
//! [3]
//! [4]
machine.setInitialState(off);
machine.start();
//! [4]
//! [5]
button.resize(100, 50);
button.show();
return app.exec();
}
Rect::Rect(QGraphicsItem *parent) : m_x(0), m_y(0), QGraphicsRectItem(parent) {
this->setRect(m_x, m_y, 100, 100);
this->setAcceptDrops(true);
QObject::connect(this, SIGNAL(rectChange()), this, SLOT(slRectChange()));
this->m_rectUpAn = new QPropertyAnimation(this, "rect"); // the animation will change rect and emit rectChange signal
this->m_rectDownAn = new QPropertyAnimation(this, "rect");
this->m_rectUpAn->setDuration(150);
this->m_rectUpAn->setStartValue(this->rect()); // animation start point
this->m_rectUpAn->setKeyValueAt(0.7, QRectF(-6, -6, 120, 120)); // animation end point
this->m_rectUpAn->setEndValue(QRectF(-3, -3, 110, 110));
this->m_rectDownAn->setDuration(150);;
this->m_rectDownAn->setStartValue(this->rect());
this->m_rectDownAn->setEndValue(QRectF(0, 0, 100, 100));
this->m_mainStatus = new QStateMachine(this);
QState *rectDragStart = new QState(this->m_mainStatus);
QState *rectDragEnd = new QState(this->m_mainStatus);
QSignalTransition *transition = rectDragStart->addTransition(this, SIGNAL(rectDragStart()), rectDragEnd);
transition->addAnimation(this->m_rectUpAn);
transition = rectDragEnd->addTransition(this, SIGNAL(rectDragEnd()), rectDragStart);
transition->addAnimation(this->m_rectDownAn);
this->m_mainStatus->addState(rectDragStart);
this->m_mainStatus->addState(rectDragEnd);
this->m_mainStatus->setInitialState(rectDragStart);
this->m_mainStatus->start();
this->setFlag(QGraphicsItem::ItemIsMovable, true);
this->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
this->setFlag(QGraphicsItem::ItemIsFocusable, true);
this->setFlag(QGraphicsItem::ItemAcceptsInputMethod, true);
}
void ViewMachine::setup(LayoutUpdater *updater)
{
if (not updater) {
qCritical() << __PRETTY_FUNCTION__
<< "No updater specified. Aborting setup.";
return;
}
setChildMode(QState::ExclusiveStates);
QState *main = 0;
QState *symbols0 = 0;
QState *symbols1 = 0;
// addState makes state machine to be a parent of passed state,
// so we don't have to care about deleting states explicitly.
addState(main = new QState);
addState(symbols0 = new QState);
addState(symbols1 = new QState);
setInitialState(main);
main->setObjectName(main_state);
symbols0->setObjectName(symbols0_state);
symbols1->setObjectName(symbols1_state);
main->addTransition(updater, SIGNAL(symKeyReleased()), symbols0);
connect(main, SIGNAL(entered()),
updater, SLOT(switchToMainView()));
symbols0->addTransition(updater, SIGNAL(symKeyReleased()), main);
symbols0->addTransition(updater, SIGNAL(symSwitcherReleased()), symbols1);
connect(symbols0, SIGNAL(entered()),
updater, SLOT(switchToPrimarySymView()));
symbols1->addTransition(updater, SIGNAL(symKeyReleased()), main);
symbols1->addTransition(updater, SIGNAL(symSwitcherReleased()), symbols0);
connect(symbols1, SIGNAL(entered()),
updater, SLOT(switchToSecondarySymView()));
// Defer to first main loop iteration:
QTimer::singleShot(0, this, SLOT(start()));
}
/*
* InvokeState
*/
InvokeState::InvokeState(const QString& stateId, const QString& binding, const QString& parentStateId) :
AbstractComplexState(stateId, parentStateId),
binding(binding),
communicationPlugin(Application::getInstance()->getCommunicationPluginLoader().getCommunicationPlugin(binding)),
invocationActive(false) {
if (communicationPlugin != NULL) {
communicationPlugin->successCallback = std::bind(&InvokeState::success, this, std::placeholders::_1);
communicationPlugin->errorCallback = std::bind(&InvokeState::error, this, std::placeholders::_1);
}
QState* stateInvoke = new QState(delegate);
QFinalState* stateFinal = new QFinalState(delegate);
InternalTransition* transitionFinal = new InternalTransition("done." + uuid);
transitionFinal->setTargetState(stateFinal);
stateInvoke->addTransition(transitionFinal);
delegate->setInitialState(stateInvoke);
endpoint = Value::Object();
}
void TMainWind::init()
{
setCentralWidget(m_canvas = new TCanvas);
QLabel* statusLabel = new QLabel;
statusBar()->addPermanentWidget(statusLabel);
QStateMachine* machine = new QStateMachine(this);
QState* creation = new QState;
QState* bending = new QState; // transformation
QState* painting = new QState;
QState* extrusion = new QState;
creation->assignProperty(m_canvas, "mode", TCanvas::Creation);
creation->assignProperty(statusLabel, "text", tr("Mode: Creation"));
creation->addTransition(m_canvas, SIGNAL(creationFinished()), painting);
bending->assignProperty(m_canvas, "mode", TCanvas::Bending);
bending->assignProperty(statusLabel, "text", tr("Mode: Bending"));
bending->addTransition(m_canvas, SIGNAL(bendingFinished()), painting);
painting->assignProperty(m_canvas, "mode", TCanvas::Painting);
painting->assignProperty(statusLabel, "text", tr("Mode: Painting"));
painting->addTransition(m_canvas, SIGNAL(toEdit()), extrusion);
extrusion->assignProperty(m_canvas, "mode", TCanvas::Extrusion);
extrusion->assignProperty(statusLabel, "text", tr("Mode: Extrusion"));
extrusion->addTransition(m_canvas, SIGNAL(extrusionFinished()), painting);
bending->addTransition(m_canvas, SIGNAL(restart()), creation);
painting->addTransition(m_canvas, SIGNAL(restart()), creation);
extrusion->addTransition(m_canvas, SIGNAL(restart()), creation);
machine->addState(creation);
machine->addState(bending);
machine->addState(painting);
machine->addState(extrusion);
machine->setInitialState(creation);
machine->start();
}
ExampleView::ExampleView(QWidget* parent)
: QFrame(parent)
{
_score = 0;
setAcceptDrops(true);
setFocusPolicy(Qt::StrongFocus);
resetMatrix();
_fgPixmap = nullptr;
if (preferences.getBool(PREF_UI_CANVAS_FG_USECOLOR))
_fgColor = preferences.getColor(PREF_UI_CANVAS_FG_COLOR);
else {
_fgPixmap = new QPixmap(preferences.getString(PREF_UI_CANVAS_FG_WALLPAPER));
if (_fgPixmap == 0 || _fgPixmap->isNull())
qDebug("no valid pixmap %s", qPrintable(preferences.getString(PREF_UI_CANVAS_FG_WALLPAPER)));
}
// setup drag canvas state
sm = new QStateMachine(this);
QState* stateActive = new QState;
QState* s1 = new QState(stateActive);
s1->setObjectName("example-normal");
s1->assignProperty(this, "cursor", QCursor(Qt::ArrowCursor));
QState* s = new QState(stateActive);
s->setObjectName("example-drag");
s->assignProperty(this, "cursor", QCursor(Qt::SizeAllCursor));
QEventTransition* cl = new QEventTransition(this, QEvent::MouseButtonRelease);
cl->setTargetState(s1);
s->addTransition(cl);
s1->addTransition(new DragTransitionExampleView(this));
sm->addState(stateActive);
stateActive->setInitialState(s1);
sm->setInitialState(stateActive);
sm->start();
}
UIGraphicsRotatorButton::UIGraphicsRotatorButton(QIGraphicsWidget *pParent,
const QString &strPropertyName,
bool fToggled,
bool fReflected /* = false */,
int iAnimationDuration /* = 300 */)
: UIGraphicsButton(pParent, UIIconPool::iconSet(":/expanding_collapsing_16px.png"))
, m_fReflected(fReflected)
, m_state(fToggled ? UIGraphicsRotatorButtonState_Rotated : UIGraphicsRotatorButtonState_Default)
, m_pAnimationMachine(0)
, m_iAnimationDuration(iAnimationDuration)
, m_pForwardButtonAnimation(0)
, m_pBackwardButtonAnimation(0)
, m_pForwardSubordinateAnimation(0)
, m_pBackwardSubordinateAnimation(0)
{
/* Configure: */
setAutoHandleButtonClick(true);
/* Create state machine: */
m_pAnimationMachine = new QStateMachine(this);
/* Create 'default' state: */
QState *pStateDefault = new QState(m_pAnimationMachine);
pStateDefault->assignProperty(this, "state", QVariant::fromValue(UIGraphicsRotatorButtonState_Default));
pStateDefault->assignProperty(this, "rotation", m_fReflected ? 180 : 0);
/* Create 'animating' state: */
QState *pStateAnimating = new QState(m_pAnimationMachine);
pStateAnimating->assignProperty(this, "state", QVariant::fromValue(UIGraphicsRotatorButtonState_Animating));
/* Create 'rotated' state: */
QState *pStateRotated = new QState(m_pAnimationMachine);
pStateRotated->assignProperty(this, "state", QVariant::fromValue(UIGraphicsRotatorButtonState_Rotated));
pStateRotated->assignProperty(this, "rotation", 90);
/* Forward button animation: */
m_pForwardButtonAnimation = new QPropertyAnimation(this, "rotation", this);
m_pForwardButtonAnimation->setDuration(m_iAnimationDuration);
m_pForwardButtonAnimation->setStartValue(m_fReflected ? 180 : 0);
m_pForwardButtonAnimation->setEndValue(90);
/* Backward button animation: */
m_pBackwardButtonAnimation = new QPropertyAnimation(this, "rotation", this);
m_pBackwardButtonAnimation->setDuration(m_iAnimationDuration);
m_pBackwardButtonAnimation->setStartValue(90);
m_pBackwardButtonAnimation->setEndValue(m_fReflected ? 180 : 0);
/* Forward subordinate animation: */
m_pForwardSubordinateAnimation = new QPropertyAnimation(pParent, strPropertyName.toLatin1(), this);
m_pForwardSubordinateAnimation->setDuration(m_iAnimationDuration);
m_pForwardSubordinateAnimation->setEasingCurve(QEasingCurve::InCubic);
/* Backward subordinate animation: */
m_pBackwardSubordinateAnimation = new QPropertyAnimation(pParent, strPropertyName.toLatin1(), this);
m_pBackwardSubordinateAnimation->setDuration(m_iAnimationDuration);
m_pBackwardSubordinateAnimation->setEasingCurve(QEasingCurve::InCubic);
/* Default => Animating: */
QSignalTransition *pDefaultToAnimating = pStateDefault->addTransition(this, SIGNAL(sigToAnimating()), pStateAnimating);
pDefaultToAnimating->addAnimation(m_pForwardButtonAnimation);
pDefaultToAnimating->addAnimation(m_pForwardSubordinateAnimation);
/* Animating => Rotated: */
connect(m_pForwardButtonAnimation, SIGNAL(finished()), this, SIGNAL(sigToRotated()), Qt::QueuedConnection);
pStateAnimating->addTransition(this, SIGNAL(sigToRotated()), pStateRotated);
/* Rotated => Animating: */
QSignalTransition *pRotatedToAnimating = pStateRotated->addTransition(this, SIGNAL(sigToAnimating()), pStateAnimating);
pRotatedToAnimating->addAnimation(m_pBackwardButtonAnimation);
pRotatedToAnimating->addAnimation(m_pBackwardSubordinateAnimation);
/* Animating => Default: */
connect(m_pBackwardButtonAnimation, SIGNAL(finished()), this, SIGNAL(sigToDefault()), Qt::QueuedConnection);
pStateAnimating->addTransition(this, SIGNAL(sigToDefault()), pStateDefault);
/* Default => Rotated: */
pStateDefault->addTransition(this, SIGNAL(sigToRotated()), pStateRotated);
/* Rotated => Default: */
pStateRotated->addTransition(this, SIGNAL(sigToDefault()), pStateDefault);
/* Initial state is 'default': */
m_pAnimationMachine->setInitialState(!fToggled ? pStateDefault : pStateRotated);
/* Start state-machine: */
m_pAnimationMachine->start();
/* Refresh: */
refresh();
}
MoveEventState::MoveEventState(const ToolPalette& stateMachine,
const Path<ScenarioModel>& scenarioPath,
iscore::CommandStack& stack,
iscore::ObjectLocker& locker,
QState* parent):
StateBase{scenarioPath, parent},
m_dispatcher{stack}
{
this->setObjectName("MoveEventState");
using namespace Scenario::Command ;
auto finalState = new QFinalState{this};
QState* mainState = new QState{this};
{
QState* pressed = new QState{mainState};
QState* released = new QState{mainState};
QState* moving = new QState{mainState};
// General setup
mainState->setInitialState(pressed);
released->addTransition(finalState);
make_transition<MoveOnAnything_Transition>(
pressed, moving, *this);
make_transition<ReleaseOnAnything_Transition>(
pressed, finalState);
make_transition<MoveOnAnything_Transition>(
moving, moving, *this);
make_transition<ReleaseOnAnything_Transition>(
moving, released);
// What happens in each state.
QObject::connect(moving, &QState::entered, [&] ()
{
Id<EventModel> evId{clickedEvent};
if(!bool(evId) && bool(clickedState))
{
auto& scenar = m_scenarioPath.find();
evId = scenar.state(clickedState).eventId();
}
m_dispatcher.submitCommand(
Path<ScenarioModel>{m_scenarioPath},
evId,
currentPoint.date,
stateMachine.editionSettings().expandMode());
});
QObject::connect(released, &QState::entered, [&] ()
{
m_dispatcher.commit();
});
}
QState* rollbackState = new QState{this};
make_transition<Cancel_Transition>(mainState, rollbackState);
rollbackState->addTransition(finalState);
QObject::connect(rollbackState, &QState::entered, [&] ()
{
m_dispatcher.rollback();
});
setInitialState(mainState);
}
// NB: resizeEvent should just change the positions & sizes. However,
// moving the first to last state transitions every time an item is
// added is a pain. This means that setGeometry on this widget must
// only be called after all items have been added.
void CarouselGraphicsWidget::resizeEvent(QResizeEvent *event)
{
QSize size = event->size();
// TODO view changes size, should we really be changeing the scene size?
scene()->setSceneRect(0, 0, size.width(), size.height());
// Use icons with same aspect ratio as VGA.
int tw = size.width();
int th = size.height();
if (tw > th*640/480) tw = th*640/480;
if (th > tw*480/640) th = tw*480/640;
int iw = tw / 2;
int ih = th / 2;
int isw = tw * 3 / 16;
int ish = th * 3 / 16;
int w = (size.width() - iw/2 - isw/2) / 2;
int h = (size.height() - ih/2 - ish/2) / 2;
int cx = size.width()/2;
int cy = (size.height() - ish)/2;
int num_objects = icons.size();
for (int i=0; i<num_objects; ++i) {
float angle = 2.0*PI*i / num_objects;
QRect r;
// When the icon is at the bottom of the screen (i=0), make it larger.
// Though it would look nicer if the size was based on the 'depth', this
// would involve a lot of scaling and then likely hit performance.
if (i == 0)
r.setRect(-iw/2, -ih/2, iw, ih);
else
r.setRect(-isw/2, -ish/2, isw, ish);
r.translate(cx, cy);
r.translate(w*sin(angle), h*cos(angle));
for (int j=0; j<num_objects; ++j) {
QState *state = states.at((i+j) % num_objects);
QObject *o = icons.at((num_objects-j) % num_objects);
// Set the position & make only the item at the bottom
// of the widget clickable
state->assignProperty(o, "geometry", r);
state->assignProperty(o, "enabled", i==0);
state->assignProperty(o, "focus", i==0);
}
}
if (states.size() > 1) {
QSignalTransition *transition;
QState *firstState = states.at(0);
QState *lastState = states.at(states.size()-1);
// Link to the next state - special case
transition = lastState->addTransition(this, SIGNAL(m_next()), firstState);
transition->addAnimation(animationGroup);
// Link to the previous state - special case
transition = firstState->addTransition(this, SIGNAL(m_back()), lastState);
transition->addAnimation(animationGroup);
machine->start();
}
}
void Protocol::prepareStateMachine(){
qDebug() << "Protocol: Initialising Protocol State";
QStateMachine *machine = new QStateMachine(this);
/**
* Main states are connected, disconnected and done, we start disconnected
* and turn to connected when the socket is operational.
* All the other states are part of the connected state
*/
QState *disconnected = new QState();
QState *connected = new QState();
QFinalState *done = new QFinalState();
/**
* When first connected, we need to know the protocol version,
* then request authentication. We then either turn to the authenticated
* state or flee to *done
*/
QState *waitingproto = new QState(connected);
QState *waitingauthrequest = new QState(connected);
QState *waitingauthstatus = new QState(connected);
QState *authenticated = new QState(connected);
connected->setInitialState(waitingproto);
/**
* When authenticated, the user must provide some information about himself
* (nickname, status, planet picture, user picture, attack picture)
* Then the user can request to join the chat room, get the list of games and users
* join a game or create a game
* In the chat room, the user sends and receives messages, and can eventually exit
*/
QState *waitinguserdetails = new QState(authenticated);
QState *waitingcommand = new QState(authenticated);
QState *inchat = new QState(authenticated);
QState *waitinggamecreation = new QState(authenticated);
QState *waitinggamelist = new QState(authenticated);
QState *waitinguserlist = new QState(authenticated);
QState *joinedgame = new QState(authenticated);
authenticated->setInitialState(waitinguserdetails);
/**
* When entering the game, we wait for the users to show up
* then receive the game map
* we then wait for the game to unpause, and the game progresses till
* there's a winner or cancellation
*/
QState *waitinguser = new QState(joinedgame);
QState *waitingmap = new QState(joinedgame);
QState *paused = new QState(joinedgame);
QState *ingame = new QState(joinedgame);
joinedgame->setInitialState(waitinguser);
qDebug() << "Protocol: Connecting Protocol Signals";
disconnected->addTransition(this, SIGNAL(connected()), connected);
connected->addTransition(this, SIGNAL(closed()), done);
waitingproto->addTransition(this, SIGNAL(protocol(QString)), waitingauthrequest);
waitingauthrequest->addTransition(this, SIGNAL(authrequest(QString,QString)), waitingauthstatus);
waitingauthstatus->addTransition(this, SIGNAL(authenticated()), authenticated);
waitingauthstatus->addTransition(this, SIGNAL(protocolError(QString)), done);
machine->addState(disconnected);
machine->addState(connected);
machine->setInitialState(disconnected);
qDebug() << "Protocol: Starting State Machine";
machine->start();
}
MoveConstraintState::MoveConstraintState(const ToolPalette& stateMachine,
const Path<ScenarioModel>& scenarioPath,
iscore::CommandStack& stack,
iscore::ObjectLocker& locker,
QState* parent):
StateBase{scenarioPath, parent},
m_dispatcher{stack}
{
this->setObjectName("MoveConstraintState");
using namespace Scenario::Command ;
auto finalState = new QFinalState{this};
QState* mainState = new QState{this};
{
QState* pressed = new QState{mainState};
QState* released = new QState{mainState};
QState* moving = new QState{mainState};
// General setup
mainState->setInitialState(pressed);
released->addTransition(finalState);
auto t_pressed =
make_transition<MoveOnAnything_Transition>(
pressed, moving , *this);
connect(t_pressed, &QAbstractTransition::triggered, [&] ()
{
auto& scenar = m_scenarioPath.find();
m_constraintInitialStartDate= scenar.constraints.at(clickedConstraint).startDate();
m_constraintInitialClickDate = currentPoint.date;
});
make_transition<ReleaseOnAnything_Transition>(
pressed, finalState);
make_transition<MoveOnAnything_Transition>(
moving , moving , *this);
make_transition<ReleaseOnAnything_Transition>(
moving , released);
QObject::connect(moving, &QState::entered, [&] ()
{
m_dispatcher.submitCommand(
Path<ScenarioModel>{m_scenarioPath},
clickedConstraint,
m_constraintInitialStartDate + (currentPoint.date - m_constraintInitialClickDate),
currentPoint.y);
});
QObject::connect(released, &QState::entered, [&] ()
{
m_dispatcher.commit();
});
}
QState* rollbackState = new QState{this};
make_transition<Cancel_Transition>(mainState, rollbackState);
rollbackState->addTransition(finalState);
QObject::connect(rollbackState, &QState::entered, [&] ()
{
m_dispatcher.rollback();
});
setInitialState(mainState);
}
SmoozikSimplestClientWindow::SmoozikSimplestClientWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::SmoozikSimplestClientWindow)
{
ui->setupUi(this);
// Initialize SmoozikManager
smoozikManager = new SmoozikManager(APIKEY, SECRET, SmoozikManager::XML, false, this);
smoozikPlaylist = new SmoozikPlaylist;
connect(smoozikManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(processNetworkReply(QNetworkReply*)));
// Initialize music directory
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
_dirName = QDesktopServices::storageLocation(QDesktopServices::MusicLocation);
#else
_dirName = QStandardPaths::writableLocation(QStandardPaths::MusicLocation);
#endif
// Initialize playlist filler
ui->setupUi(this);
smoozikPlaylistFillerThread = new QThread();
smoozikPlaylistFiller = new SmoozikPlaylistFiller(smoozikPlaylist);
smoozikPlaylistFiller->moveToThread(smoozikPlaylistFillerThread);
connect(smoozikPlaylistFiller, SIGNAL(trackFound(QString,QString,QString,QString,uint)), this, SLOT(addTrackToPlaylist(QString,QString,QString,QString,uint)));
connect(smoozikPlaylistFiller, SIGNAL(tracksRetrieved()), this, SIGNAL(tracksRetrieved()));
connect(smoozikPlaylistFiller, SIGNAL(noTrackRetrieved()), this, SLOT(noTrackRetrievedMessage()));
connect(smoozikPlaylistFiller, SIGNAL(maxPlaylistSizeReached()), this, SLOT(maxPlaylistSizeReachedMessage()));
connect(smoozikPlaylistFillerThread, SIGNAL(started()), smoozikPlaylistFiller, SLOT(fillPlaylist()));
connect(smoozikPlaylistFiller, SIGNAL(finished()), smoozikPlaylistFillerThread, SLOT(quit()), Qt::DirectConnection);
// Initialize player
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
player = new Phonon::MediaObject(this);
Phonon::AudioOutput *audioOutput = new Phonon::AudioOutput(Phonon::MusicCategory, this);
Phonon::createPath(player, audioOutput);
connect(player, SIGNAL(currentSourceChanged(Phonon::MediaSource)), this, SLOT(updateTrackLabels()));
connect(player, SIGNAL(stateChanged(Phonon::State,Phonon::State)), this, SLOT(playerStateChanged()));
#else
player = new QMediaPlayer(this);
player->setPlaylist(new QMediaPlaylist(player));
player->playlist()->setPlaybackMode(QMediaPlaylist::Sequential);
connect(player, SIGNAL(currentMediaChanged(QMediaContent)), this, SLOT(updateTrackLabels()));
connect(player, SIGNAL(stateChanged(QMediaPlayer::State)), this, SLOT(playerStateChanged()));
#endif
connect(ui->playButton, SIGNAL(clicked()), player, SLOT(play()));
connect(ui->pauseButton, SIGNAL(clicked()), player, SLOT(pause()));
connect(this, SIGNAL(currentTrackSet()), this, SLOT(updateTrackLabels()));
connect(this, SIGNAL(nextTrackSet()), this, SLOT(updateTrackLabels()));
// Initialize main state machine which controls what is displayed
QStateMachine *mainStateMachine = new QStateMachine(this);
QState *mainState = new QState(mainStateMachine);
QState *loginState = new QState(mainState);
QState *startPartyState = new QState(mainState);
QState *connectedState = new QState(mainState);
QState *retrieveTracksState = new QState(connectedState);
QState *sendPlaylistState = new QState(connectedState);
QState *getTopTracksState = new QState(connectedState);
QState *partyState = new QState(connectedState);
QState *waitingState = new QState(partyState);
QState *sendCurrentTrackState = new QState(partyState);
QState *sendNextTrackState = new QState(partyState);
QStateMachine *playerStateMachine = new QStateMachine(this);
QState *playerState = new QState(playerStateMachine);
QState *playingState = new QState(playerState);
QState *pausedState = new QState(playerState);
// Define state initial states and transitions
mainStateMachine->setInitialState(mainState);
mainState->setInitialState(loginState);
connectedState->setInitialState(retrieveTracksState);
partyState->setInitialState(waitingState);
playerStateMachine->setInitialState(playerState);
playerState->setInitialState(pausedState);
mainState->addTransition(this, SIGNAL(disconnected()), loginState);
loginState->addTransition(this, SIGNAL(loggedIn()), startPartyState);
startPartyState->addTransition(this, SIGNAL(partyStarted()), connectedState);
connectedState->addTransition(ui->changePlaylistButton, SIGNAL(clicked()), retrieveTracksState);
retrieveTracksState->addTransition(this, SIGNAL(tracksRetrieved()), sendPlaylistState);
sendPlaylistState->addTransition(this, SIGNAL(playlistSent()), getTopTracksState);
getTopTracksState->addTransition(this, SIGNAL(currentTrackSet()), sendCurrentTrackState);
sendCurrentTrackState->addTransition(this, SIGNAL(currentTrackSent()), getTopTracksState);
getTopTracksState->addTransition(this, SIGNAL(nextTrackSet()), sendNextTrackState);
sendNextTrackState->addTransition(this, SIGNAL(nextTrackSent()), waitingState);
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
waitingState->addTransition(player, SIGNAL(currentSourceChanged(Phonon::MediaSource)), sendCurrentTrackState);
#else
waitingState->addTransition(player, SIGNAL(currentMediaChanged(QMediaContent)), sendCurrentTrackState);
#endif
playerState->addTransition(this, SIGNAL(playing()), playingState);
playerState->addTransition(this, SIGNAL(paused()), pausedState);
// Define state properties
loginState->assignProperty(this, "state", Login);
loginState->assignProperty(ui->stackedWidget, "currentIndex", ui->stackedWidget->indexOf(ui->loginPage));
loginState->assignProperty(ui->loginButton, "enabled", true);
loginState->assignProperty(ui->disconnectButton, "visible", false);
loginState->assignProperty(ui->changePlaylistButton, "visible", false);
loginState->assignProperty(ui->usernameLineEdit, "enabled", true);
loginState->assignProperty(ui->passwordLineEdit, "enabled", true);
loginState->assignProperty(ui->loginStateLabel, "text", QString());
startPartyState->assignProperty(this, "state", StartParty);
startPartyState->assignProperty(ui->loginStateLabel, "text", tr("Starting party..."));
startPartyState->assignProperty(ui->disconnectButton, "visible", false);
startPartyState->assignProperty(ui->changePlaylistButton, "visible", false);
connectedState->assignProperty(ui->disconnectButton, "visible", true);
retrieveTracksState->assignProperty(ui->stackedWidget, "currentIndex", ui->stackedWidget->indexOf(ui->loadingPage));
retrieveTracksState->assignProperty(ui->loginStateLabel, "text", tr("Connected"));
retrieveTracksState->assignProperty(ui->loadingLabel, "text", tr("Retrieving tracks..."));
retrieveTracksState->assignProperty(ui->changePlaylistButton, "visible", false);
sendPlaylistState->assignProperty(this, "state", SendPlaylist);
sendPlaylistState->assignProperty(ui->loadingLabel, "text", tr("Sending playlist..."));
sendPlaylistState->assignProperty(ui->changePlaylistButton, "visible", true);
getTopTracksState->assignProperty(this, "state", GetTopTracks);
getTopTracksState->assignProperty(ui->loadingLabel, "text", tr("Get top tracks..."));
getTopTracksState->assignProperty(ui->nextButton, "enabled", false);
getTopTracksState->assignProperty(ui->changePlaylistButton, "visible", true);
partyState->assignProperty(ui->stackedWidget, "currentIndex", ui->stackedWidget->indexOf(ui->playerPage));
partyState->assignProperty(ui->changePlaylistButton, "visible", true);
sendCurrentTrackState->assignProperty(this, "state", SendCurrentTrack);
sendCurrentTrackState->assignProperty(ui->nextButton, "enabled", false);
sendNextTrackState->assignProperty(this, "state", SendNextTrack);
sendNextTrackState->assignProperty(ui->nextButton, "enabled", false);
waitingState->assignProperty(ui->nextButton, "enabled", true);
playingState->assignProperty(ui->playButton, "visible", false);
playingState->assignProperty(ui->pauseButton, "visible", true);
pausedState->assignProperty(ui->playButton, "visible", true);
pausedState->assignProperty(ui->pauseButton, "visible", false);
// Connect states and actions
connect(startPartyState, SIGNAL(entered()), this, SLOT(startParty()));
connect(retrieveTracksState, SIGNAL(entered()), this, SLOT(retrieveTracksDialog()));
connect(sendPlaylistState, SIGNAL(entered()), this, SLOT(sendPlaylist()));
connect(getTopTracksState, SIGNAL(entered()), this, SLOT(getTopTracks()));
connect(sendCurrentTrackState, SIGNAL(entered()), this, SLOT(sendCurrentTrack()));
connect(sendNextTrackState, SIGNAL(entered()), this, SLOT(sendNextTrack()));
// Connect gui and actions
connect(ui->usernameLineEdit, SIGNAL(returnPressed()), this, SLOT(submitLogin()));
connect(ui->passwordLineEdit, SIGNAL(returnPressed()), this, SLOT(submitLogin()));
connect(ui->loginButton, SIGNAL(clicked()), this, SLOT(submitLogin()));
connect(ui->nextButton, SIGNAL(clicked()), this, SLOT(nextTrack()));
connect(ui->disconnectButton, SIGNAL(clicked()), this, SLOT(disconnect()));
// Start state machine
mainStateMachine->start();
playerStateMachine->start();
}
ScenarioCreation_FromEvent::ScenarioCreation_FromEvent(
const ScenarioStateMachine& stateMachine,
ObjectPath &&scenarioPath,
iscore::CommandStack& stack,
QState* parent):
ScenarioCreationState{stateMachine, stack, std::move(scenarioPath), parent}
{
using namespace Scenario::Command;
auto finalState = new QFinalState{this};
connect(finalState, &QState::entered, [&] ()
{
clearCreatedIds();
});
QState* mainState = new QState{this};
mainState->setObjectName("Main state");
{
auto pressed = new QState{mainState};
auto released = new QState{mainState};
auto move_nothing = new StrongQState<ScenarioElement::Nothing + Modifier::Move_tag::value>{mainState};
auto move_state = new StrongQState<ScenarioElement::State + Modifier::Move_tag::value>{mainState};
auto move_event = new StrongQState<ScenarioElement::Event + Modifier::Move_tag::value>{mainState};
auto move_timenode = new StrongQState<ScenarioElement::TimeNode + Modifier::Move_tag::value>{mainState};
pressed->setObjectName("Pressed");
released->setObjectName("Released");
move_nothing->setObjectName("Move on Nothing");
move_state->setObjectName("Move on State");
move_event->setObjectName("Move on Event");
move_timenode->setObjectName("Move on TimeNode");
// General setup
mainState->setInitialState(pressed);
released->addTransition(finalState);
// Release
make_transition<ReleaseOnAnything_Transition>(mainState, released);
// Pressed -> ...
make_transition<MoveOnNothing_Transition>(pressed, move_nothing, *this);
/// MoveOnNothing -> ...
// MoveOnNothing -> MoveOnNothing.
make_transition<MoveOnNothing_Transition>(move_nothing, move_nothing, *this);
// MoveOnNothing -> MoveOnState.
add_transition(move_nothing, move_state,
[&] () { rollback(); createToState(); });
// MoveOnNothing -> MoveOnEvent.
add_transition(move_nothing, move_event,
[&] () { rollback(); createToEvent(); });
// MoveOnNothing -> MoveOnTimeNode
add_transition(move_nothing, move_timenode,
[&] () { rollback(); createToTimeNode(); });
/// MoveOnState -> ...
// MoveOnState -> MoveOnNothing
add_transition(move_state, move_nothing,
[&] () { rollback(); createToNothing(); });
// MoveOnState -> MoveOnState
// We don't do anything, the constraint should not move.
// MoveOnState -> MoveOnEvent
add_transition(move_state, move_event,
[&] () { rollback(); createToEvent(); });
// MoveOnState -> MoveOnTimeNode
add_transition(move_state, move_timenode,
[&] () { rollback(); createToTimeNode(); });
/// MoveOnEvent -> ...
// MoveOnEvent -> MoveOnNothing
add_transition(move_event, move_nothing,
[&] () { rollback(); createToNothing(); });
// MoveOnEvent -> MoveOnState
add_transition(move_event, move_state,
[&] () { rollback(); createToState(); });
// MoveOnEvent -> MoveOnEvent
make_transition<MoveOnEvent_Transition>(move_event, move_event, *this);
// MoveOnEvent -> MoveOnTimeNode
add_transition(move_event, move_timenode,
[&] () { rollback(); createToTimeNode(); });
/// MoveOnTimeNode -> ...
// MoveOnTimeNode -> MoveOnNothing
add_transition(move_timenode, move_nothing,
[&] () { rollback(); createToNothing(); });
// MoveOnTimeNode -> MoveOnState
add_transition(move_timenode, move_state,
[&] () { rollback(); createToState(); });
// MoveOnTimeNode -> MoveOnEvent
add_transition(move_timenode, move_event,
[&] () { rollback(); createToEvent(); });
// MoveOnTimeNode -> MoveOnTimeNode
make_transition<MoveOnTimeNode_Transition>(move_timenode , move_timenode , *this);
// What happens in each state.
QObject::connect(pressed, &QState::entered,
[&] ()
{
m_clickedPoint = currentPoint;
// Create a simple state where we are
createInitialState();
//createToNothing();
});
QObject::connect(move_nothing, &QState::entered, [&] ()
{
// Move the timenode
m_dispatcher.submitCommand<MoveNewEvent>(
ObjectPath{m_scenarioPath},
createdConstraints.last(), // TODO CheckMe
createdEvents.last(),// TODO CheckMe
currentPoint.date,
currentPoint.y,
!stateMachine.isShiftPressed());
});
QObject::connect(move_timenode , &QState::entered, [&] ()
{
// TODO why ?
m_dispatcher.submitCommand<MoveNewState>(
ObjectPath{m_scenarioPath},
createdStates.last(),
currentPoint.y);
});
QObject::connect(move_event, &QState::entered, [&] ()
{
m_dispatcher.submitCommand<MoveNewState>(
ObjectPath{m_scenarioPath},
createdStates.last(),
currentPoint.y);
});
QObject::connect(released, &QState::entered, [&] ()
{
m_dispatcher.commit<Scenario::Command::CreationMetaCommand>();
});
}
QState* rollbackState = new QState{this};
rollbackState->setObjectName("Rollback");
make_transition<Cancel_Transition>(mainState, rollbackState);
rollbackState->addTransition(finalState);
QObject::connect(rollbackState, &QState::entered, [&] ()
{
rollback();
});
setInitialState(mainState);
}
Creation_FromState::Creation_FromState(
const ToolPalette& stateMachine,
const Path<ScenarioModel>& scenarioPath,
iscore::CommandStack& stack,
QState* parent):
CreationState{stateMachine, stack, std::move(scenarioPath), parent}
{
using namespace Scenario::Command;
auto finalState = new QFinalState{this};
connect(finalState, &QState::entered, [&] ()
{
clearCreatedIds();
});
QState* mainState = new QState{this};
{
auto pressed = new QState{mainState};
auto released = new QState{mainState};
auto move_nothing = new StrongQState<ScenarioElement::Nothing + Modifier::Move_tag::value>{mainState};
auto move_state = new StrongQState<ScenarioElement::State + Modifier::Move_tag::value>{mainState};
auto move_event = new StrongQState<ScenarioElement::Event + Modifier::Move_tag::value>{mainState};
auto move_timenode = new StrongQState<ScenarioElement::TimeNode + Modifier::Move_tag::value>{mainState};
// General setup
mainState->setInitialState(pressed);
released->addTransition(finalState);
// Release
make_transition<ReleaseOnAnything_Transition>(mainState, released);
// Pressed -> ...
make_transition<MoveOnNothing_Transition>(pressed, move_state, *this);
make_transition<MoveOnNothing_Transition>(pressed, move_nothing, *this);
/// MoveOnNothing -> ...
// MoveOnNothing -> MoveOnNothing.
make_transition<MoveOnNothing_Transition>(move_nothing, move_nothing, *this);
// MoveOnNothing -> MoveOnState.
add_transition(move_nothing, move_state,
[&] () { rollback(); createToState(); });
// MoveOnNothing -> MoveOnEvent.
add_transition(move_nothing, move_event,
[&] () { rollback(); createToEvent(); });
// MoveOnNothing -> MoveOnTimeNode
add_transition(move_nothing, move_timenode,
[&] () { rollback(); createToTimeNode(); });
/// MoveOnState -> ...
// MoveOnState -> MoveOnNothing
add_transition(move_state, move_nothing,
[&] () { rollback(); createToNothing(); });
// MoveOnState -> MoveOnState
// We don't do anything, the constraint should not move.
// MoveOnState -> MoveOnEvent
add_transition(move_state, move_event,
[&] () { rollback(); createToEvent(); });
// MoveOnState -> MoveOnTimeNode
add_transition(move_state, move_timenode,
[&] () { rollback(); createToTimeNode(); });
/// MoveOnEvent -> ...
// MoveOnEvent -> MoveOnNothing
add_transition(move_event, move_nothing,
[&] () { rollback(); createToNothing(); });
// MoveOnEvent -> MoveOnState
add_transition(move_event, move_state,
[&] () {
if(m_parentSM.model().state(clickedState).eventId() != m_parentSM.model().state(hoveredState).eventId())
{
rollback();
createToState();
}
});
// MoveOnEvent -> MoveOnEvent
make_transition<MoveOnEvent_Transition>(move_event, move_event, *this);
// MoveOnEvent -> MoveOnTimeNode
add_transition(move_event, move_timenode,
[&] () { rollback(); createToTimeNode(); });
/// MoveOnTimeNode -> ...
// MoveOnTimeNode -> MoveOnNothing
add_transition(move_timenode, move_nothing,
[&] () { rollback(); createToNothing(); });
// MoveOnTimeNode -> MoveOnState
add_transition(move_timenode, move_state,
[&] () { rollback(); createToState(); });
// MoveOnTimeNode -> MoveOnEvent
add_transition(move_timenode, move_event,
[&] () { rollback(); createToEvent(); });
// MoveOnTimeNode -> MoveOnTimeNode
make_transition<MoveOnTimeNode_Transition>(move_timenode , move_timenode , *this);
// What happens in each state.
QObject::connect(pressed, &QState::entered,
[&] ()
{
m_clickedPoint = currentPoint;
createToNothing();
});
QObject::connect(move_nothing, &QState::entered, [&] ()
{
if(createdConstraints.empty() || createdEvents.empty())
{
rollback();
return;
}
if(m_parentSM.editionSettings().sequence())
{
const auto& st = m_parentSM.model().state(clickedState);
currentPoint.y = st.heightPercentage();
}
m_dispatcher.submitCommand<MoveNewEvent>(
Path<ScenarioModel>{m_scenarioPath},
createdConstraints.last(),
createdEvents.last(),
currentPoint.date,
currentPoint.y,
stateMachine.editionSettings().sequence());
});
QObject::connect(move_event, &QState::entered, [&] ()
{
if(createdStates.empty())
{
rollback();
return;
}
m_dispatcher.submitCommand<MoveNewState>(
Path<ScenarioModel>{m_scenarioPath},
createdStates.last(),
currentPoint.y);
});
QObject::connect(move_timenode, &QState::entered, [&] ()
{
if(createdStates.empty())
{
rollback();
return;
}
m_dispatcher.submitCommand<MoveNewState>(
Path<ScenarioModel>{m_scenarioPath},
createdStates.last(),
currentPoint.y);
});
QObject::connect(released, &QState::entered, [&] ()
{
this->makeSnapshot();
m_dispatcher.commit<Scenario::Command::CreationMetaCommand>();
});
}
QState* rollbackState = new QState{this};
make_transition<Cancel_Transition>(mainState, rollbackState);
rollbackState->addTransition(finalState);
QObject::connect(rollbackState, &QState::entered, [&] ()
{
rollback();
});
setInitialState(mainState);
}
void StateMachineMgr::buildStateMachine(QLayout* layout,bool bIsEntryLane)
{
if(bIsEntryLane)
{
buildEntryWindows(layout);
}
else
{
buildExitWindows(layout);
}
//设备查看状态
QState * devShowState = new MtcLaneState(&m_machine, m_devTable);
//初始化状态
QState * initState = new MtcLaneState(&m_machine, m_pFormLoadParam);
//参数加载成功状态
QState * loadSuccess = new MtcLaneState(&m_machine,m_pFormMsg);
//加载参数成功时页面显示设置
loadSuccess->assignProperty(m_pFormMsg, "message", tr("请放置身份卡\n按『上/下班』键登录"));
loadSuccess->assignProperty(m_pFormMsg, "title", tr(""));
//选择程序操作：退出程序、重启程序、关闭计算机、重启计算机
QState *exitState = new MtcLaneState(&m_machine,m_pTableWidget);
//工班选择状态
QState * shiftState = new MtcLaneState(&m_machine, m_pTableWidget);
//选择票号修改状态
QState *IdTKstate=new MtcLaneState(&m_machine,m_pTableWidget);
//修改票号页面状态
QState *IdInform=new MtcLaneState(&m_machine,getInformWidget());
//确认票号状态
QState *confirmInvState = new MtcLaneState(&m_machine, m_pFormMsg);
//正常上班状态
QState* ordState = new MtcLaneState(&m_machine, m_pOrdWidget);
//提示切换雨棚灯状态
QState * turnOnLightState = new MtcLaneState(&m_machine, m_pFormMsg);
turnOnLightState->assignProperty(m_pFormMsg, "message", tr("请按【雨棚开关】键\n将雨棚灯切换至绿灯"));
//设备状态确认->初始化状态
devShowState->addTransition(new TranConfirmDev(initState));
//初始化状态->参数加载成功状态
LoadParamTransition *tLoadParam = new LoadParamTransition(initState,SIGNAL(entered()));
tLoadParam->setTargetState(loadSuccess);
initState->addTransition(tLoadParam);
//加载成功状态->选择程序退出状态
TranExitApp *exitTrans = new TranExitApp(exitState);
loadSuccess->addTransition(exitTrans);
//加载成功状态->闯关tran->加载成功状态
addRushTranLogOut(loadSuccess);
//选择程序退出状态->执行退出操作
TranSelectExitApp *exitAppTrans = new TranSelectExitApp(loadSuccess);
exitState->addTransition(exitAppTrans);
//退出程序操作，返回初始化界面
TranQuitSelect *quitselTrans = new TranQuitSelect(loadSuccess);
exitState->addTransition(quitselTrans);
//选择工班时出现闯关
addRushTranLogOut(shiftState);
//上班后出现闯关
QHistoryState* rushState = new QHistoryState(ordState);
TranRushLogin* tranLogin = new TranRushLogin(getDeviceFactory()->getIOBoard(), SIGNAL(InputChanged(quint32,quint8)));
tranLogin->setTargetState(rushState);
ordState->addTransition(tranLogin);
//上班后收费员按F12键，切换菜单
QHistoryState* showLogState = new QHistoryState(ordState);
TranChangeVpr* tranVpr = new TranChangeVpr(showLogState);
ordState->addTransition(tranVpr);
//建立上班后子状态机
m_pOrdWidget->initStateMachine(ordState, loadSuccess);
//加载参数成功->用户验证身份
TranShift *tShowPassword = new TranShift(shiftState);
loadSuccess->addTransition(tShowPassword);
//打开雨棚灯状态闯关
addRushTranLogOut(turnOnLightState);
//打开雨棚灯状态->正常上班状态
TranTurnOnCanLight* tOrd = new TranTurnOnCanLight(ordState);
turnOnLightState->addTransition(tOrd);
//确认卡盒卡ID操作，模拟实现
TranCardBox *tGotoLight = new TranCardBox(turnOnLightState);
//入口没有票号处理
if(getLaneInfo()->isEntryLane())
{
shiftState->addTransition(new TranEntryConfirmShift(turnOnLightState));
}
else
{
//下班时票号操作
QState *logOutIdState=new MtcLaneState(&m_machine,m_pTableWidget);
QState *logOutInform=new MtcLaneState(&m_machine,getInformWidget());
loadSuccess->addTransition(new TranShowInvoiceMenu(logOutIdState));
logOutIdState->addTransition(new TranModifyInvoice(logOutInform));
logOutIdState->addTransition(new TranChangeUpInvoice(logOutInform));
logOutInform->addTransition(new TranFinInvoice(loadSuccess));
logOutIdState->addTransition(new TranRtInvConfirm(loadSuccess));
logOutInform->addTransition(new TranRtInvConfirm(loadSuccess));
//确认班次，用户从班次中选择一个班次上班，班次记录到LaneInfo
TranConfirmShift *tConfirm = new TranConfirmShift(confirmInvState);
shiftState->addTransition(tConfirm);
//修改票号时出现闯关
addRushTranLogOut(IdTKstate);
//修改票号时出现闯关
addRushTranLogOut(IdInform);
//确认票号状态闯关
addRushTranLogOut(confirmInvState);
//选择票号处理菜单，包括票据换上、修改票号
TranShowInvoiceMenu * tMessIDTick = new TranShowInvoiceMenu(IdTKstate);
confirmInvState->addTransition(tMessIDTick);
//显示插入票号页面
TranChangeUpInvoice *tInsertTK=new TranChangeUpInvoice(IdInform);//跳转到票号输入页面
IdTKstate->addTransition(tInsertTK);
//显示修改票号页面
TranModifyInvoice *tInformTK=new TranModifyInvoice(IdInform);
IdTKstate->addTransition(tInformTK);
//完成票号操作，跳转票号确认状态
TranFinInvoice *tShowInform=new TranFinInvoice(confirmInvState); //从页面输入和修改跳转到票号页面
IdInform->addTransition(tShowInform);
//输入修改票号跳转
TranRtInvConfirm *treturntable=new TranRtInvConfirm(confirmInvState);
IdInform->addTransition(treturntable);
IdTKstate->addTransition(new TranRtInvConfirm(confirmInvState));
//显示确认卡盒卡界面
confirmInvState->addTransition(tGotoLight);
}
//返回等待上班状态
shiftState->addTransition(new SpecialKeySignalTransition(loadSuccess, KeyEsc, KC_Func));
confirmInvState->addTransition(new SpecialKeySignalTransition(loadSuccess, KeyEsc, KC_Func));
//跳转到功能页面
m_machine.setInitialState(devShowState);
m_machine.start();
//上班前功能界面
loadSuccess->addTransition(new TranLogOutFunc(loadSuccess));
QTimer::singleShot(1000, this, SLOT(beginInitState()));
}