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;
}
/*!
Adds a transition associated with the given \a signal of the given \a sender
object, and returns the new QSignalTransition object. The transition has
this state as the source, and the given \a target as the target state.
*/
QSignalTransition *QState::addTransition(QObject *sender, const char *signal,
QAbstractState *target)
{
if (!sender) {
qWarning("QState::addTransition: sender cannot be null");
return 0;
}
if (!signal) {
qWarning("QState::addTransition: signal cannot be null");
return 0;
}
if (!target) {
qWarning("QState::addTransition: cannot add transition to null state");
return 0;
}
int offset = (*signal == '0'+QSIGNAL_CODE) ? 1 : 0;
const QMetaObject *meta = sender->metaObject();
if (meta->indexOfSignal(signal+offset) == -1) {
if (meta->indexOfSignal(QMetaObject::normalizedSignature(signal+offset)) == -1) {
qWarning("QState::addTransition: no such signal %s::%s",
meta->className(), signal+offset);
return 0;
}
}
QSignalTransition *trans = new QSignalTransition(sender, signal);
trans->setTargetState(target);
addTransition(trans);
return trans;
}
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();
}
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 UIAnimation::prepare()
{
/* Prepare animation-machine: */
m_pAnimationMachine = new QStateMachine(this);
/* Create 'start' state: */
m_pStateStart = new QState(m_pAnimationMachine);
connect(m_pStateStart, SIGNAL(propertiesAssigned()), this, SIGNAL(sigStateEnteredStart()));
/* Create 'final' state: */
m_pStateFinal = new QState(m_pAnimationMachine);
connect(m_pStateFinal, SIGNAL(propertiesAssigned()), this, SIGNAL(sigStateEnteredFinal()));
/* Prepare 'forward' animation: */
m_pForwardAnimation = new QPropertyAnimation(parent(), m_pszPropertyName, m_pAnimationMachine);
m_pForwardAnimation->setEasingCurve(QEasingCurve(QEasingCurve::InOutCubic));
m_pForwardAnimation->setDuration(m_iAnimationDuration);
/* Prepare 'reverse' animation: */
m_pReverseAnimation = new QPropertyAnimation(parent(), m_pszPropertyName, m_pAnimationMachine);
m_pReverseAnimation->setEasingCurve(QEasingCurve(QEasingCurve::InOutCubic));
m_pReverseAnimation->setDuration(m_iAnimationDuration);
/* Prepare state-transitions: */
QSignalTransition *pStartToFinal = m_pStateStart->addTransition(parent(), m_pszSignalForward, m_pStateFinal);
pStartToFinal->addAnimation(m_pForwardAnimation);
QSignalTransition *pFinalToStart = m_pStateFinal->addTransition(parent(), m_pszSignalReverse, m_pStateStart);
pFinalToStart->addAnimation(m_pReverseAnimation);
/* Fetch animation-borders: */
update();
/* Choose initial state: */
m_pAnimationMachine->setInitialState(!m_fReverse ? m_pStateStart : m_pStateFinal);
/* Start animation-machine: */
m_pAnimationMachine->start();
}
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();
}
}
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();
}
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;
}
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);
}
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();
}
/*
* 功能：
* 构造函数，初始化有限状态机并run之。
* 参数：
* 无
* 返回值：
* 无
*/
SlidingScreen::SlidingScreen(QGraphicsView *parent, bool isOneDirection):
QGraphicsView(parent), m_isOneDirection(isOneDirection)
{
m_enable = false;
m_enableSliding = true;
m_pressPos.setX(0);
m_pressPos.setY(0);
m_releasePos.setX(0);
m_releasePos.setY(0);
p_frame1 = new QFrame();
p_frame2 = new QFrame();
p_frame3 = new QFrame();
p_layout1 = new QStackedLayout();
p_layout2 = new QStackedLayout();
p_layout3 = new QStackedLayout();
m_layOut[0] = p_layout1;
m_layOut[1] = p_layout2;
m_layOut[2] = p_layout3;
/****初始化窗体指针缓存，索引缓存，索引缓存长度*********/
p_widgetBuf = new QVector<QWidget*>(BUF_LEN, nullptr);
p_indexBuf = new QVector<int>();
p_frame1->resize(DESKTOP_WIDTH,DESKTOP_HEIGHT);
p_frame2->resize(DESKTOP_WIDTH,DESKTOP_HEIGHT);
p_frame3->resize(DESKTOP_WIDTH,DESKTOP_HEIGHT);
p_frame1->setLayout(p_layout1);
p_frame2->setLayout(p_layout2);
p_frame3->setLayout(p_layout3);
/**************动画类实例化**********************/
p_group = new QParallelAnimationGroup;
p_frame1Animation = new QPropertyAnimation(p_frame1, "pos");
p_frame2Animation = new QPropertyAnimation(p_frame2, "pos");
p_frame3Animation = new QPropertyAnimation(p_frame3, "pos");
p_frame1Animation->setDuration(1200);
p_frame2Animation->setDuration(1200);
p_frame3Animation->setDuration(1200);
p_frame1Animation->setEasingCurve(QEasingCurve::InOutQuad);
p_frame2Animation->setEasingCurve(QEasingCurve::InOutQuad);
p_frame3Animation->setEasingCurve(QEasingCurve::InOutQuad);
p_group->addAnimation(p_frame1Animation);
p_group->addAnimation(p_frame2Animation);
p_group->addAnimation(p_frame3Animation);
connect(p_group, SIGNAL(finished()), this, SLOT(slotAnimationFinish()));
/***********************状态机实例化*******************************/
p_stateMachine = new QStateMachine(this);
p_startState = new QState();
p_leftState1 = new QState(p_startState);
p_leftState2 = new QState(p_startState);
p_leftState3 = new QState(p_startState);
p_rightState1 = new QState(p_startState);
p_rightState2 = new QState(p_startState);
p_rightState3 = new QState(p_startState);
p_upState1 = new QState(p_startState);
p_upState2 = new QState(p_startState);
p_upState3 = new QState(p_startState);
p_downState1 = new QState(p_startState);
p_downState2 = new QState(p_startState);
p_downState3 = new QState(p_startState);
/*********************move to left state*************************************/
p_leftState1->assignProperty(p_frame1, "visible", true);
p_leftState1->assignProperty(p_frame2, "visible", true);
p_leftState1->assignProperty(p_frame3, "visible", false);
p_leftState1->assignProperty(p_frame1, "pos", QPointF(0, DESKTOP_HEIGHT));
p_leftState1->assignProperty(p_frame2, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_leftState1->assignProperty(p_frame3, "pos", QPointF(2*DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_leftState1->assignProperty(p_frame1, "objectName", QString("1")); //存放当前显示的frame索引号
p_leftState2->assignProperty(p_frame2, "visible", true);
p_leftState2->assignProperty(p_frame3, "visible", true);
p_leftState2->assignProperty(p_frame1, "visible", false);
p_leftState2->assignProperty(p_frame2, "pos", QPointF(0, DESKTOP_HEIGHT));
p_leftState2->assignProperty(p_frame3, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_leftState2->assignProperty(p_frame1, "pos", QPointF(DESKTOP_WIDTH*2, DESKTOP_HEIGHT));
p_leftState2->assignProperty(p_frame1, "objectName", QString("2"));
p_leftState3->assignProperty(p_frame3, "visible", true);
p_leftState3->assignProperty(p_frame1, "visible", true);
p_leftState3->assignProperty(p_frame2, "visible", false);
p_leftState3->assignProperty(p_frame3, "pos", QPointF(0, DESKTOP_HEIGHT));
p_leftState3->assignProperty(p_frame1, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_leftState3->assignProperty(p_frame2, "pos", QPointF(DESKTOP_WIDTH*2, DESKTOP_HEIGHT));
p_leftState3->assignProperty(p_frame1, "objectName", QString("0"));
/***************move to right state*********************************/
p_rightState1->assignProperty(p_frame1, "visible", false);
p_rightState1->assignProperty(p_frame2, "visible", true);
p_rightState1->assignProperty(p_frame3, "visible", true);
p_rightState1->assignProperty(p_frame1, "pos", QPointF(0, DESKTOP_HEIGHT));
p_rightState1->assignProperty(p_frame2, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_rightState1->assignProperty(p_frame3, "pos", QPointF(DESKTOP_WIDTH*2, DESKTOP_HEIGHT));
p_rightState1->assignProperty(p_frame1, "objectName", QString("1"));
p_rightState2->assignProperty(p_frame2, "visible", false);
p_rightState2->assignProperty(p_frame3, "visible", true);
p_rightState2->assignProperty(p_frame1, "visible", true);
p_rightState2->assignProperty(p_frame2, "pos", QPointF(0, DESKTOP_HEIGHT));
p_rightState2->assignProperty(p_frame3, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_rightState2->assignProperty(p_frame1, "pos", QPointF(DESKTOP_WIDTH*2, DESKTOP_HEIGHT));
p_rightState2->assignProperty(p_frame1, "objectName", QString("2"));
p_rightState3->assignProperty(p_frame3, "visible", false);
p_rightState3->assignProperty(p_frame1, "visible", true);
p_rightState3->assignProperty(p_frame2, "visible", true);
p_rightState3->assignProperty(p_frame3, "pos", QPointF(0, DESKTOP_HEIGHT));
p_rightState3->assignProperty(p_frame1, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_rightState3->assignProperty(p_frame2, "pos", QPointF(DESKTOP_WIDTH*2, DESKTOP_HEIGHT));
p_rightState3->assignProperty(p_frame1, "objectName", QString("0"));
/***********************move to up state******************************************/
p_upState1->assignProperty(p_frame1, "visible", true);
p_upState1->assignProperty(p_frame2, "visible", true);
p_upState1->assignProperty(p_frame3, "visible", false);
p_upState1->assignProperty(p_frame1, "pos", QPointF(DESKTOP_WIDTH, 0));
p_upState1->assignProperty(p_frame2, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_upState1->assignProperty(p_frame3, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT*2));
p_upState1->assignProperty(p_frame1, "objectName", QString("1"));
p_upState2->assignProperty(p_frame2, "visible", true);
p_upState2->assignProperty(p_frame3, "visible", true);
p_upState2->assignProperty(p_frame1, "visible", false);
p_upState2->assignProperty(p_frame2, "pos", QPointF(DESKTOP_WIDTH, 0));
p_upState2->assignProperty(p_frame3, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_upState2->assignProperty(p_frame1, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT*2));
p_upState2->assignProperty(p_frame1, "objectName", QString("2"));
p_upState3->assignProperty(p_frame3, "visible", true);
p_upState3->assignProperty(p_frame1, "visible", true);
p_upState3->assignProperty(p_frame2, "visible", false);
p_upState3->assignProperty(p_frame3, "pos", QPointF(DESKTOP_WIDTH, 0));
p_upState3->assignProperty(p_frame1, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_upState3->assignProperty(p_frame2, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT*2));
p_upState3->assignProperty(p_frame1, "objectName", QString("0"));
/*************************move to down state *************************************/
p_downState1->assignProperty(p_frame1, "visible", false);
p_downState1->assignProperty(p_frame2, "visible", true);
p_downState1->assignProperty(p_frame3, "visible", true);
p_downState1->assignProperty(p_frame1, "pos", QPointF(DESKTOP_WIDTH, 0));
p_downState1->assignProperty(p_frame2, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_downState1->assignProperty(p_frame3, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT*2));
p_downState1->assignProperty(p_frame1, "objectName", QString("1"));
p_downState2->assignProperty(p_frame2, "visible", false);
p_downState2->assignProperty(p_frame3, "visible", true);
p_downState2->assignProperty(p_frame1, "visible", true);
p_downState2->assignProperty(p_frame2, "pos", QPointF(DESKTOP_WIDTH, 0));
p_downState2->assignProperty(p_frame3, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_downState2->assignProperty(p_frame1, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT*2));
p_downState2->assignProperty(p_frame1, "objectName", QString("2"));
p_downState3->assignProperty(p_frame3, "visible", false);
p_downState3->assignProperty(p_frame1, "visible", true);
p_downState3->assignProperty(p_frame2, "visible", true);
p_downState3->assignProperty(p_frame3, "pos", QPointF(DESKTOP_WIDTH, 0));
p_downState3->assignProperty(p_frame1, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT));
p_downState3->assignProperty(p_frame2, "pos", QPointF(DESKTOP_WIDTH, DESKTOP_HEIGHT*2));
p_downState3->assignProperty(p_frame1, "objectName", QString("0"));
/*************************收到向右滑动信号*********************绑定状态切换转换和动画效果***/
QSignalTransition *rightTransition = p_rightState1->addTransition(this, SIGNAL(sigMoveRight()), p_rightState3);
rightTransition->addAnimation(p_group);
rightTransition = p_rightState2->addTransition(this, SIGNAL(sigMoveRight()), p_rightState1);
rightTransition->addAnimation(p_group);
rightTransition = p_rightState3->addTransition(this, SIGNAL(sigMoveRight()), p_rightState2);
rightTransition->addAnimation(p_group);
rightTransition = p_leftState1->addTransition(this, SIGNAL(sigMoveRight()), p_rightState3);
rightTransition->addAnimation(p_group);
rightTransition = p_leftState2->addTransition(this, SIGNAL(sigMoveRight()), p_rightState1);
rightTransition->addAnimation(p_group);
rightTransition = p_leftState3->addTransition(this, SIGNAL(sigMoveRight()), p_rightState2);
rightTransition->addAnimation(p_group);
p_upState1->addTransition(this, SIGNAL(sigMoveRight()), p_rightState1);
p_upState2->addTransition(this, SIGNAL(sigMoveRight()), p_rightState2);
p_upState3->addTransition(this, SIGNAL(sigMoveRight()), p_rightState3);
p_downState1->addTransition(this, SIGNAL(sigMoveRight()), p_rightState1);
p_downState2->addTransition(this, SIGNAL(sigMoveRight()), p_rightState2);
p_downState3->addTransition(this, SIGNAL(sigMoveRight()), p_rightState3);
/*************************收到向左滑动信号*********************绑定状态切换转换和动画效果***/
QSignalTransition *leftTransition = p_leftState1->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState2);
leftTransition->addAnimation(p_group);
leftTransition = p_leftState2->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState3);
leftTransition->addAnimation(p_group);
leftTransition = p_leftState3->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState1);
leftTransition->addAnimation(p_group);
leftTransition = p_rightState1->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState2);
leftTransition->addAnimation(p_group);
leftTransition = p_rightState2->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState3);
leftTransition->addAnimation(p_group);
leftTransition = p_rightState3->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState1);
leftTransition->addAnimation(p_group);
p_upState1->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState1);
p_upState2->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState2);
p_upState3->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState3);
p_downState1->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState1);
p_downState2->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState2);
p_downState3->addTransition(this, SIGNAL(sigMoveLeft()), p_leftState3);
/*************************收到向上滑动信号*********************绑定状态切换转换和动画效果***/
QSignalTransition *upTransition = p_upState1->addTransition(this, SIGNAL(sigMoveUp()), p_upState2);
upTransition->addAnimation(p_group);
upTransition = p_upState2->addTransition(this, SIGNAL(sigMoveUp()), p_upState3);
upTransition->addAnimation(p_group);
upTransition = p_upState3->addTransition(this, SIGNAL(sigMoveUp()), p_upState1);
upTransition->addAnimation(p_group);
upTransition = p_downState1->addTransition(this, SIGNAL(sigMoveUp()), p_upState2);
upTransition->addAnimation(p_group);
upTransition = p_downState2->addTransition(this, SIGNAL(sigMoveUp()), p_upState3);
upTransition->addAnimation(p_group);
upTransition = p_downState3->addTransition(this, SIGNAL(sigMoveUp()), p_upState1);
upTransition->addAnimation(p_group);
p_leftState1->addTransition(this, SIGNAL(sigMoveUp()), p_upState1);
p_leftState2->addTransition(this, SIGNAL(sigMoveUp()), p_upState2);
p_leftState3->addTransition(this, SIGNAL(sigMoveUp()), p_upState3);
p_rightState1->addTransition(this, SIGNAL(sigMoveUp()), p_upState1);
p_rightState2->addTransition(this, SIGNAL(sigMoveUp()), p_upState2);
p_rightState3->addTransition(this, SIGNAL(sigMoveUp()), p_upState3);
/*************************收到向下滑动信号*********************绑定状态切换转换和动画效果***/
QSignalTransition *downTransition = p_downState1->addTransition(this, SIGNAL(sigMoveDown()), p_downState3);
downTransition->addAnimation(p_group);
downTransition = p_downState2->addTransition(this, SIGNAL(sigMoveDown()), p_downState1);
downTransition->addAnimation(p_group);
downTransition = p_downState3->addTransition(this, SIGNAL(sigMoveDown()), p_downState2);
downTransition->addAnimation(p_group);
downTransition = p_upState1->addTransition(this, SIGNAL(sigMoveDown()), p_downState3);
downTransition->addAnimation(p_group);
downTransition = p_upState2->addTransition(this, SIGNAL(sigMoveDown()), p_downState1);
downTransition->addAnimation(p_group);
downTransition = p_upState3->addTransition(this, SIGNAL(sigMoveDown()), p_downState2);
downTransition->addAnimation(p_group);
p_leftState1->addTransition(this, SIGNAL(sigMoveDown()), p_downState1);
p_leftState2->addTransition(this, SIGNAL(sigMoveDown()), p_downState2);
p_leftState3->addTransition(this, SIGNAL(sigMoveDown()), p_downState3);
p_rightState1->addTransition(this, SIGNAL(sigMoveDown()), p_downState1);
p_rightState2->addTransition(this, SIGNAL(sigMoveDown()), p_downState2);
p_rightState3->addTransition(this, SIGNAL(sigMoveDown()), p_downState3);
/**************************收到恢复初始状态信号*******************************************/
p_leftState1->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
p_leftState2->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
p_leftState3->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
p_rightState1->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
p_rightState2->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
p_rightState3->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
p_upState1->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
p_upState2->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
p_upState3->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
p_downState1->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
p_downState2->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
p_downState3->addTransition(this, SIGNAL(sigInitState()), p_leftState1);
/************************初始化状态机和场景并关联之***********************************/
p_scene = new QGraphicsScene(this);
p_scene->addWidget(p_frame1);
p_scene->addWidget(p_frame2);
p_scene->addWidget(p_frame3);
p_scene->setSceneRect(DESKTOP_WIDTH,DESKTOP_HEIGHT, DESKTOP_WIDTH, DESKTOP_HEIGHT);
setScene(p_scene);
p_startState->setInitialState(p_leftState1);
m_isXDirection = true;
m_currentWidgetIndex = 1; //这个值跟初始状态当前显示索引有关
m_currentFrameIndexl = 1;
p_stateMachine->addState(p_startState);
p_stateMachine->setInitialState(p_startState);
p_stateMachine->start();
connect(p_frame1, SIGNAL(objectNameChanged(QString)), this, SLOT(slotSendCurrentWidgetPointer(QString)));
}
// 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();
}
}
int main(int argv, char **args)
{
QApplication app(argv, args);
QWidget *button;
{
//![0]
QStateMachine machine;
machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
QState *s1 = new QState();
s1->assignProperty(object, "fooBar", 1.0);
machine.addState(s1);
machine.setInitialState(s1);
QState *s2 = new QState();
machine.addState(s2);
//![0]
}
{
//![2]
QStateMachine machine;
machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
QState *s1 = new QState();
s1->assignProperty(object, "fooBar", 1.0);
machine.addState(s1);
machine.setInitialState(s1);
QState *s2 = new QState(s1);
s2->assignProperty(object, "fooBar", 2.0);
s1->setInitialState(s2);
QState *s3 = new QState(s1);
//![2]
}
{
//![3]
QState *s1 = new QState();
QState *s2 = new QState();
s1->assignProperty(button, "geometry", QRectF(0, 0, 50, 50));
s2->assignProperty(button, "geometry", QRectF(0, 0, 100, 100));
s1->addTransition(button, SIGNAL(clicked()), s2);
//![3]
}
{
//![4]
QState *s1 = new QState();
QState *s2 = new QState();
s1->assignProperty(button, "geometry", QRectF(0, 0, 50, 50));
s2->assignProperty(button, "geometry", QRectF(0, 0, 100, 100));
QSignalTransition *transition = s1->addTransition(button, SIGNAL(clicked()), s2);
transition->addAnimation(new QPropertyAnimation(button, "geometry"));
//![4]
}
{
QMainWindow *mainWindow = 0;
//![5]
QMessageBox *messageBox = new QMessageBox(mainWindow);
messageBox->addButton(QMessageBox::Ok);
messageBox->setText("Button geometry has been set!");
messageBox->setIcon(QMessageBox::Information);
QState *s1 = new QState();
QState *s2 = new QState();
s2->assignProperty(button, "geometry", QRectF(0, 0, 50, 50));
connect(s2, SIGNAL(entered()), messageBox, SLOT(exec()));
s1->addTransition(button, SIGNAL(clicked()), s2);
//![5]
}
{
QMainWindow *mainWindow = 0;
//![6]
QMessageBox *messageBox = new QMessageBox(mainWindow);
messageBox->addButton(QMessageBox::Ok);
messageBox->setText("Button geometry has been set!");
messageBox->setIcon(QMessageBox::Information);
QState *s1 = new QState();
QState *s2 = new QState();
s2->assignProperty(button, "geometry", QRectF(0, 0, 50, 50));
QState *s3 = new QState();
connect(s3, SIGNAL(entered()), messageBox, SLOT(exec()));
s1->addTransition(button, SIGNAL(clicked()), s2);
s2->addTransition(s2, SIGNAL(propertiesAssigned()), s3);
//![6]
}
{
//![7]
QState *s1 = new QState();
QState *s2 = new QState();
s2->assignProperty(object, "fooBar", 2.0);
s1->addTransition(s2);
QStateMachine machine;
machine.setInitialState(s1);
machine.addDefaultAnimation(new QPropertyAnimation(object, "fooBar"));
//![7]
}
return app.exec();
}
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();
}
