void CMainWindow::startingAnimation()
{
setWindowFlags(Qt::Window | Qt::FramelessWindowHint); //FramelessWindowHint wymagane do przezroczystego t³a
setAttribute(Qt::WA_TranslucentBackground, true);
QRect screenRect = QApplication::desktop()->screenGeometry();
QSequentialAnimationGroup *group = new QSequentialAnimationGroup(this);
QPropertyAnimation* fadeIn = new QPropertyAnimation(this, "windowOpacity", this);
fadeIn->setDuration(2000);
fadeIn->setStartValue(0.0);
fadeIn->setEndValue(1.0);
group->addAnimation(fadeIn);
QParallelAnimationGroup *moveGroup = new QParallelAnimationGroup(this);
QPropertyAnimation* imageRight = new QPropertyAnimation(pandemicImage, "geometry", this);
imageRight->setStartValue(pandemicImage->geometry());
imageRight->setEndValue(pandemicImage->geometry().translated(screenRect.width() - pandemicImage->geometry().right(), 0));
imageRight->setDuration(1000);
imageRight->setEasingCurve(QEasingCurve::InOutCubic);
moveGroup->addAnimation(imageRight);
QPropertyAnimation* menuLeft = new QPropertyAnimation(menu, "geometry", this);
menuLeft->setStartValue(menu->geometry());
menuLeft->setEndValue(QRect(0,0, screenRect.width()-pandemicImage->width()+1, menu->height()));
menuLeft->setDuration(1000);
menuLeft->setEasingCurve(QEasingCurve::InOutCubic);
moveGroup->addAnimation(menuLeft);
group->addAnimation(moveGroup);
group->start();
connect(group, &QSequentialAnimationGroup::finished, [this]() {
content->setObjectName("body");
});
}
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 QocViewWidget::rebuildChart()
{
QPushButton *pb = qobject_cast<QPushButton *>(sender());
// QParallelAnimationGroup *group = new QParallelAnimationGroup();
QSequentialAnimationGroup *group = new QSequentialAnimationGroup();
if (pb)
{
pb->setEnabled(false);
connect(group, SIGNAL(finished()), this, SLOT(animationFinished()));
connect(this, SIGNAL(animationEnded(bool)), pb, SLOT(setEnabled(bool)));
}
QList<QocAbstractChartItem *> items = m_chart->items(QocAbstractChart::ChartLayer);
foreach(QocAbstractChartItem *item, items)
{
QocAbstractValueItem *i = qobject_cast<QocAbstractValueItem *>(item);
if ( i )
{
QPropertyAnimation *anim = new QPropertyAnimation(i, "value", group);
anim->setStartValue(0);
anim->setEndValue(i->value());
anim->setDuration(2000/items.size());
group->addAnimation(anim);
// i->blockSignals(true);
i->setValue(0);
// i->blockSignals(false);
}
}
void DockModeWindow::setPrepareAddedToWindowManager() {
m_prepareAddedToWm = true;
if (G_LIKELY(s_dockGlow == 0)) {
QString path(Settings::LunaSettings()->lunaSystemResourcesPath.c_str());
path.append("/dockmode/dock-loading-glow.png");
s_dockGlow = new QPixmap(path);
if(s_dockGlow)
s_dockGlowRefCount++;
if (!s_dockGlow || s_dockGlow->isNull()) {
g_critical("%s: Failed to load image '%s'", __PRETTY_FUNCTION__, qPrintable(path));
}
} else {
s_dockGlowRefCount++;
}
ApplicationDescription* appDesc = static_cast<Window*>(this)->appDescription();
int size = Settings::LunaSettings()->splashIconSize;
m_icon.load(appDesc->splashIconName().c_str());
if (!m_icon.isNull()) {
// scale splash icon to fit the devices screen dimensions
m_icon = m_icon.scaled(size, size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
}
else {
// just use the launcher icon
m_icon = appDesc->getDefaultLaunchPoint()->icon();
int newWidth = qMin((int)(m_icon.width()*1.5), size);
int newHeight = qMin((int)(m_icon.height()*1.5), size);
m_icon = m_icon.scaled(newWidth, newHeight, Qt::KeepAspectRatio, Qt::SmoothTransformation);
}
// set up the pulsing animation
QPropertyAnimation* pulseIn = new QPropertyAnimation(this, "pulseOpacity");
pulseIn->setDuration(AS(cardLoadingPulseDuration));
pulseIn->setEasingCurve(AS_CURVE(cardLoadingPulseCurve));
pulseIn->setEndValue(1.0);
QPropertyAnimation* pulseOut = new QPropertyAnimation(this, "pulseOpacity");
pulseOut->setDuration(AS(cardLoadingPulseDuration));
pulseOut->setEasingCurve(AS_CURVE(cardLoadingPulseCurve));
pulseOut->setEndValue(0.0);
QSequentialAnimationGroup* pulseGroup = new QSequentialAnimationGroup;
pulseGroup->addAnimation(pulseIn);
pulseGroup->addAnimation(pulseOut);
pulseGroup->setLoopCount(-1);
m_pulseAnimation.addPause(AS(cardLoadingTimeBeforeShowingPulsing));
m_pulseAnimation.addAnimation(pulseGroup);
m_loadingOverlayEnabled = true;
m_pulseAnimation.start();
update();
}
void AVLTree::Find(int x, bool showProgress)
{
if (showProgress)
{
QSequentialAnimationGroup *group = new QSequentialAnimationGroup;
Find(root, x, group);
group->start(QAbstractAnimation::DeleteWhenStopped);
}
else
{
Find(root, x, NULL);
}
}
void AVLTree::Delete(int x, bool showProgress)
{
if (showProgress)
{
QSequentialAnimationGroup *group = new QSequentialAnimationGroup;
Delete(root, x, group);
group->start(QAbstractAnimation::DeleteWhenStopped);
}
else
{
Delete(root, x, NULL);
getPosAnim()->start(QAbstractAnimation::DeleteWhenStopped);
getEdgeAnim()->start(QAbstractAnimation::DeleteWhenStopped);
}
}
void MWidgetSlideAnimationPrivate::init()
{
Q_Q(MWidgetSlideAnimation);
direction = MWidgetSlideAnimation::In;
QSequentialAnimationGroup *delayedAnimation = new QSequentialAnimationGroup;
delay = new QPauseAnimation;
positionAnimation = new QPropertyAnimation;
positionAnimation->setPropertyName("pos");
delayedAnimation->addAnimation(delay);
delayedAnimation->addAnimation(positionAnimation);
q->addAnimation(delayedAnimation);
q->connect(delay, SIGNAL(finished()), SLOT(_q_onDelayFinished()));
}
void Unite::animationDeplacement(vector<Case *> chemin ) {
this->setSelected(false);
float decalageX,decalageY;
Case* caseActu=chemin[0];
QSequentialAnimationGroup *group = new QSequentialAnimationGroup();
QSequentialAnimationGroup *animPm = new QSequentialAnimationGroup();
QParallelAnimationGroup *groupPara = new QParallelAnimationGroup();
QPointF OS = offset();
int anim;
int j=1;
for (unsigned int i=1;i<chemin.size(); i++) {
QPropertyAnimation *animation = new QPropertyAnimation(this, "offset");
animation->setDuration(200);
decalageX = (chemin[i]->getX()-caseActu->getX())*SIZE;
decalageY = (chemin[i]->getY()-caseActu->getY())*SIZE;
if (decalageX>0)
anim=30;
else if (decalageX<0)
anim=20;
else if (decalageY<0)
anim=10;
else if (decalageY>0)
anim=0;
QPropertyAnimation *animPix = new QPropertyAnimation(this, "pixmap");
animPix->setDuration(200);
animPix->setStartValue(anim);
animPix->setEndValue(anim+7);
animPm->addAnimation(animPix);
animation->setStartValue(OS);
OS=QPointF(OS.x()+decalageX,OS.y()+decalageY);
animation->setEndValue(OS);
group->addAnimation(animation);
j++;
caseActu=chemin[i];
}
groupPara->addAnimation(group);
groupPara->addAnimation(animPm);
groupPara->start();
this->setSelected(true);
}
void AVLTree::LevelOrder()
{
QSequentialAnimationGroup *group = new QSequentialAnimationGroup;
QQueue<TreeNode*> q;
q.push_back(root);
while (!q.empty())
{
TreeNode *node = q.front();
q.pop_front();
if (node == NULL) continue;
group->addAnimation(node->getPopAnim());
q.push_back(node->Lson);
q.push_back(node->Rson);
}
group->start(QAbstractAnimation::DeleteWhenStopped);
}
void Sprite::start(int loops)
{
if(loops<0)loops=0;
QMapIterator<QString, AnimationLine*> i(lines);
QParallelAnimationGroup *pgroup = new QParallelAnimationGroup;
while (i.hasNext()) {
i.next();
AnimationLine * line = i.value();
const QByteArray &name = i.key().toLocal8Bit();
QSequentialAnimationGroup *sgroup = new QSequentialAnimationGroup;
QMapIterator<int,qreal> j(line->frames);
while(j.hasNext())
{
j.next();
QPropertyAnimation *trans = new QPropertyAnimation(this,name);
trans->setStartValue(j.value());
trans->setEasingCurve(line->easings[j.key()]);
if(j.hasNext())
{
trans->setEndValue(j.peekNext().value());
trans->setDuration(j.peekNext().key()-j.key());
}
else
{
trans->setEndValue(j.value());
trans->setDuration(total_time - j.key());
}
sgroup->addAnimation(trans);
}
QPropertyAnimation *trans = new QPropertyAnimation(this,name);
trans->setEndValue(line->frames[0]);
trans->setDuration(resetTime);
sgroup->addAnimation(trans);
pgroup->addAnimation(sgroup);
}
if(--loops)connect(pgroup,SIGNAL(finished()),this,SLOT(start(int)));
else connect(pgroup,SIGNAL(finished()),this,SLOT(deleteLater()));
void Creator::TestToLogIn()
{
singleWindow->show();
QParallelAnimationGroup* parallelWindow = WindowToMenuAnimation(TestWindow , singleWindow , TestState , SingleState );
QParallelAnimationGroup* parallel = new QParallelAnimationGroup;
parallel->addAnimation(parallelWindow);
QSequentialAnimationGroup* sequential = new QSequentialAnimationGroup;
sequential->addAnimation(parallel);
sequential->start();
sleep(1000);
for ( int i = 0 ; i < 10 ; i++ ){
testwidget->but[i]->setProperty("pos",QPointF(testwidget->but[9]->x(),testwidget->but[9]->y()));
}
TestWindow->close();
}
void IndicatorItem::doAnimation() {
QSequentialAnimationGroup *group = new QSequentialAnimationGroup(this);
QPropertyAnimation *animation = new QPropertyAnimation(this, "finish");
animation->setEndValue(real_finish);
animation->setEasingCurve(QEasingCurve::OutCubic);
animation->setDuration(500);
QPropertyAnimation *pause = new QPropertyAnimation(this, "opacity");
pause->setEndValue(0);
pause->setEasingCurve(QEasingCurve::InQuart);
pause->setDuration(600);
group->addAnimation(animation);
group->addAnimation(pause);
group->start(QAbstractAnimation::DeleteWhenStopped);
connect(group, &QSequentialAnimationGroup::finished, this, &IndicatorItem::deleteLater);
}
void TFutureProgressPrivate::_q_FadeAway()
{
Q_Q(TFutureProgress);
FaderWidget->raise();
QSequentialAnimationGroup *Group = new QSequentialAnimationGroup(q);
QPropertyAnimation *Animation = new QPropertyAnimation(FaderWidget, "Opacity");
Animation->setDuration(600);
Animation->setEndValue(1.0);
Group->addAnimation(Animation);
Animation = new QPropertyAnimation(q, "maximumHeight");
Animation->setDuration(120);
Animation->setEasingCurve(QEasingCurve::InCurve);
Animation->setStartValue(q->sizeHint().height());
Animation->setEndValue(0.0);
Group->addAnimation(Animation);
Group->start(QAbstractAnimation::DeleteWhenStopped);
QObject::connect(Group, SIGNAL(finished()), q, SIGNAL(RemoveMe()));
}
Tank::Tank(QObject *parent)
: QGLSceneNode(parent)
, m_texture(0)
{
QSequentialAnimationGroup *seq = new QSequentialAnimationGroup(this);
QGraphicsScale3D *scale = new QGraphicsScale3D(this);
addTransform(scale);
QPropertyAnimation *anim = new QPropertyAnimation(scale, "scale");
anim->setDuration(10000);
anim->setStartValue(QVector3D(1.0f, 0.1f, 1.0f));
anim->setEndValue(QVector3D(1.0f, 1.2f, 1.0f));
anim->setEasingCurve(QEasingCurve(QEasingCurve::InOutQuad));
seq->addAnimation(anim);
seq->addPause(2000);
anim = new QPropertyAnimation(scale, "scale");
anim->setDuration(10000);
anim->setStartValue(QVector3D(1.0f, 1.2f, 1.0f));
anim->setEndValue(QVector3D(1.0f, 0.1f, 1.0f));
anim->setEasingCurve(QEasingCurve(QEasingCurve::InOutQuad));
seq->addAnimation(anim);
seq->setLoopCount(-1);
seq->start();
addNode(tankObject());
QGLMaterial *mat = qCreateFluid();
m_texture = mat->texture();
setMaterial(mat);
}
void Creator::LogInToTest(QString user_name)
{
testwidget->SetUserName(user_name);
testwidget->upDateScores();
TestWindow->show();
QParallelAnimationGroup* parallelWindow = WindowAnimation(LogInWindow , TestWindow , LogState , TestState);
QParallelAnimationGroup* parallelButton = ButtonAnimation(testwidget->but, 10);
QParallelAnimationGroup* parallel = new QParallelAnimationGroup;
parallel->addAnimation(parallelWindow);
QSequentialAnimationGroup* sequential = new QSequentialAnimationGroup;
sequential->addAnimation(parallel);
sequential->addPause(0);
sequential->addAnimation(parallelButton);
sequential->start();
sleep(1000);
LogInWindow->close();
}
void FutureProgressPrivate::fadeAway()
{
m_isFading = true;
QGraphicsOpacityEffect *opacityEffect = new QGraphicsOpacityEffect;
opacityEffect->setOpacity(1.);
m_q->setGraphicsEffect(opacityEffect);
QSequentialAnimationGroup *group = new QSequentialAnimationGroup(this);
QPropertyAnimation *animation = new QPropertyAnimation(opacityEffect, "opacity");
animation->setDuration(StyleHelper::progressFadeAnimationDuration);
animation->setEndValue(0.);
group->addAnimation(animation);
animation = new QPropertyAnimation(m_q, "maximumHeight");
animation->setDuration(120);
animation->setEasingCurve(QEasingCurve::InCurve);
animation->setStartValue(m_q->sizeHint().height());
animation->setEndValue(0.0);
group->addAnimation(animation);
connect(group, &QAbstractAnimation::finished, m_q, &FutureProgress::removeMe);
group->start(QAbstractAnimation::DeleteWhenStopped);
emit m_q->fadeStarted();
}
void ContactsViewDelegate::startAlertAnimation()
{
if (!m_alertAnimation)
{
QSequentialAnimationGroup *ag = new QSequentialAnimationGroup(this);
m_alertAnimation = ag;
QPropertyAnimation *aIn = new QPropertyAnimation(this, "alertOpacity");
aIn->setEndValue(qreal(1));
aIn->setEasingCurve(QEasingCurve::OutQuad);
aIn->setDuration(750);
QPropertyAnimation *aOut = new QPropertyAnimation(this, "alertOpacity");
aOut->setEndValue(qreal(0.2));
aOut->setEasingCurve(QEasingCurve::InQuad);
aOut->setDuration(750);
ag->addAnimation(aIn);
ag->addPause(150);
ag->addAnimation(aOut);
ag->setLoopCount(-1);
ag->start();
}
}
//! [0]
PadNavigator::PadNavigator(const QSize &size, QWidget *parent)
: QGraphicsView(parent)
{
//! [0]
//! [1]
// Splash item
SplashItem *splash = new SplashItem;
splash->setZValue(1);
//! [1]
//! [2]
// Pad item
FlippablePad *pad = new FlippablePad(size);
QGraphicsRotation *flipRotation = new QGraphicsRotation(pad);
QGraphicsRotation *xRotation = new QGraphicsRotation(pad);
QGraphicsRotation *yRotation = new QGraphicsRotation(pad);
flipRotation->setAxis(Qt::YAxis);
xRotation->setAxis(Qt::YAxis);
yRotation->setAxis(Qt::XAxis);
pad->setTransformations(QList<QGraphicsTransform *>()
<< flipRotation
<< xRotation << yRotation);
//! [2]
//! [3]
// Back (proxy widget) item
QGraphicsProxyWidget *backItem = new QGraphicsProxyWidget(pad);
QWidget *widget = new QWidget;
form.setupUi(widget);
form.hostName->setFocus();
backItem->setWidget(widget);
backItem->setVisible(false);
backItem->setFocus();
backItem->setCacheMode(QGraphicsItem::ItemCoordinateCache);
const QRectF r = backItem->rect();
backItem->setTransform(QTransform()
.rotate(180, Qt::YAxis)
.translate(-r.width()/2, -r.height()/2));
//! [3]
//! [4]
// Selection item
RoundRectItem *selectionItem = new RoundRectItem(QRectF(-60, -60, 120, 120), Qt::gray, pad);
selectionItem->setZValue(0.5);
//! [4]
//! [5]
// Splash animations
QPropertyAnimation *smoothSplashMove = new QPropertyAnimation(splash, "y");
QPropertyAnimation *smoothSplashOpacity = new QPropertyAnimation(splash, "opacity");
smoothSplashMove->setEasingCurve(QEasingCurve::InQuad);
smoothSplashMove->setDuration(250);
smoothSplashOpacity->setDuration(250);
//! [5]
//! [6]
// Selection animation
QPropertyAnimation *smoothXSelection = new QPropertyAnimation(selectionItem, "x");
QPropertyAnimation *smoothYSelection = new QPropertyAnimation(selectionItem, "y");
QPropertyAnimation *smoothXRotation = new QPropertyAnimation(xRotation, "angle");
QPropertyAnimation *smoothYRotation = new QPropertyAnimation(yRotation, "angle");
smoothXSelection->setDuration(125);
smoothYSelection->setDuration(125);
smoothXRotation->setDuration(125);
smoothYRotation->setDuration(125);
smoothXSelection->setEasingCurve(QEasingCurve::InOutQuad);
smoothYSelection->setEasingCurve(QEasingCurve::InOutQuad);
smoothXRotation->setEasingCurve(QEasingCurve::InOutQuad);
smoothYRotation->setEasingCurve(QEasingCurve::InOutQuad);
//! [6]
//! [7]
// Flip animation setup
QPropertyAnimation *smoothFlipRotation = new QPropertyAnimation(flipRotation, "angle");
QPropertyAnimation *smoothFlipScale = new QPropertyAnimation(pad, "scale");
QPropertyAnimation *smoothFlipXRotation = new QPropertyAnimation(xRotation, "angle");
QPropertyAnimation *smoothFlipYRotation = new QPropertyAnimation(yRotation, "angle");
QParallelAnimationGroup *flipAnimation = new QParallelAnimationGroup(this);
smoothFlipScale->setDuration(500);
smoothFlipRotation->setDuration(500);
smoothFlipXRotation->setDuration(500);
smoothFlipYRotation->setDuration(500);
smoothFlipScale->setEasingCurve(QEasingCurve::InOutQuad);
smoothFlipRotation->setEasingCurve(QEasingCurve::InOutQuad);
smoothFlipXRotation->setEasingCurve(QEasingCurve::InOutQuad);
smoothFlipYRotation->setEasingCurve(QEasingCurve::InOutQuad);
smoothFlipScale->setKeyValueAt(0, qvariant_cast<qreal>(1.0));
smoothFlipScale->setKeyValueAt(0.5, qvariant_cast<qreal>(0.7));
smoothFlipScale->setKeyValueAt(1, qvariant_cast<qreal>(1.0));
flipAnimation->addAnimation(smoothFlipRotation);
flipAnimation->addAnimation(smoothFlipScale);
flipAnimation->addAnimation(smoothFlipXRotation);
flipAnimation->addAnimation(smoothFlipYRotation);
//! [7]
//! [8]
// Flip animation delayed property assignment
QSequentialAnimationGroup *setVariablesSequence = new QSequentialAnimationGroup;
QPropertyAnimation *setFillAnimation = new QPropertyAnimation(pad, "fill");
QPropertyAnimation *setBackItemVisibleAnimation = new QPropertyAnimation(backItem, "visible");
QPropertyAnimation *setSelectionItemVisibleAnimation = new QPropertyAnimation(selectionItem, "visible");
setFillAnimation->setDuration(0);
setBackItemVisibleAnimation->setDuration(0);
setSelectionItemVisibleAnimation->setDuration(0);
setVariablesSequence->addPause(250);
setVariablesSequence->addAnimation(setBackItemVisibleAnimation);
setVariablesSequence->addAnimation(setSelectionItemVisibleAnimation);
setVariablesSequence->addAnimation(setFillAnimation);
flipAnimation->addAnimation(setVariablesSequence);
//! [8]
//! [9]
// Build the state machine
QStateMachine *stateMachine = new QStateMachine(this);
QState *splashState = new QState(stateMachine);
QState *frontState = new QState(stateMachine);
QHistoryState *historyState = new QHistoryState(frontState);
QState *backState = new QState(stateMachine);
//! [9]
//! [10]
frontState->assignProperty(pad, "fill", false);
frontState->assignProperty(splash, "opacity", 0.0);
frontState->assignProperty(backItem, "visible", false);
frontState->assignProperty(flipRotation, "angle", qvariant_cast<qreal>(0.0));
frontState->assignProperty(selectionItem, "visible", true);
backState->assignProperty(pad, "fill", true);
backState->assignProperty(backItem, "visible", true);
backState->assignProperty(xRotation, "angle", qvariant_cast<qreal>(0.0));
backState->assignProperty(yRotation, "angle", qvariant_cast<qreal>(0.0));
backState->assignProperty(flipRotation, "angle", qvariant_cast<qreal>(180.0));
backState->assignProperty(selectionItem, "visible", false);
stateMachine->addDefaultAnimation(smoothXRotation);
stateMachine->addDefaultAnimation(smoothYRotation);
stateMachine->addDefaultAnimation(smoothXSelection);
stateMachine->addDefaultAnimation(smoothYSelection);
stateMachine->setInitialState(splashState);
//! [10]
//! [11]
// Transitions
QEventTransition *anyKeyTransition = new QEventTransition(this, QEvent::KeyPress, splashState);
anyKeyTransition->setTargetState(frontState);
anyKeyTransition->addAnimation(smoothSplashMove);
anyKeyTransition->addAnimation(smoothSplashOpacity);
//! [11]
//! [12]
QKeyEventTransition *enterTransition = new QKeyEventTransition(this, QEvent::KeyPress,
Qt::Key_Enter, backState);
QKeyEventTransition *returnTransition = new QKeyEventTransition(this, QEvent::KeyPress,
Qt::Key_Return, backState);
QKeyEventTransition *backEnterTransition = new QKeyEventTransition(this, QEvent::KeyPress,
Qt::Key_Enter, frontState);
QKeyEventTransition *backReturnTransition = new QKeyEventTransition(this, QEvent::KeyPress,
Qt::Key_Return, frontState);
enterTransition->setTargetState(historyState);
returnTransition->setTargetState(historyState);
backEnterTransition->setTargetState(backState);
backReturnTransition->setTargetState(backState);
enterTransition->addAnimation(flipAnimation);
returnTransition->addAnimation(flipAnimation);
backEnterTransition->addAnimation(flipAnimation);
backReturnTransition->addAnimation(flipAnimation);
//! [12]
//! [13]
// Create substates for each icon; store in temporary grid.
int columns = size.width();
int rows = size.height();
QVector< QVector< QState * > > stateGrid;
stateGrid.resize(rows);
for (int y = 0; y < rows; ++y) {
stateGrid[y].resize(columns);
for (int x = 0; x < columns; ++x)
stateGrid[y][x] = new QState(frontState);
}
frontState->setInitialState(stateGrid[0][0]);
selectionItem->setPos(pad->iconAt(0, 0)->pos());
//! [13]
//! [14]
// Enable key navigation using state transitions
for (int y = 0; y < rows; ++y) {
for (int x = 0; x < columns; ++x) {
QState *state = stateGrid[y][x];
QKeyEventTransition *rightTransition = new QKeyEventTransition(this, QEvent::KeyPress,
Qt::Key_Right, state);
QKeyEventTransition *leftTransition = new QKeyEventTransition(this, QEvent::KeyPress,
Qt::Key_Left, state);
QKeyEventTransition *downTransition = new QKeyEventTransition(this, QEvent::KeyPress,
Qt::Key_Down, state);
QKeyEventTransition *upTransition = new QKeyEventTransition(this, QEvent::KeyPress,
Qt::Key_Up, state);
rightTransition->setTargetState(stateGrid[y][(x + 1) % columns]);
leftTransition->setTargetState(stateGrid[y][((x - 1) + columns) % columns]);
downTransition->setTargetState(stateGrid[(y + 1) % rows][x]);
upTransition->setTargetState(stateGrid[((y - 1) + rows) % rows][x]);
//! [14]
//! [15]
RoundRectItem *icon = pad->iconAt(x, y);
state->assignProperty(xRotation, "angle", -icon->x() / 6.0);
state->assignProperty(yRotation, "angle", icon->y() / 6.0);
state->assignProperty(selectionItem, "x", icon->x());
state->assignProperty(selectionItem, "y", icon->y());
frontState->assignProperty(icon, "visible", true);
backState->assignProperty(icon, "visible", false);
QPropertyAnimation *setIconVisibleAnimation = new QPropertyAnimation(icon, "visible");
setIconVisibleAnimation->setDuration(0);
setVariablesSequence->addAnimation(setIconVisibleAnimation);
}
}
//! [15]
//! [16]
// Scene
QGraphicsScene *scene = new QGraphicsScene(this);
scene->setBackgroundBrush(QPixmap(":/images/blue_angle_swirl.jpg"));
scene->setItemIndexMethod(QGraphicsScene::NoIndex);
scene->addItem(pad);
scene->setSceneRect(scene->itemsBoundingRect());
setScene(scene);
//! [16]
//! [17]
// Adjust splash item to scene contents
const QRectF sbr = splash->boundingRect();
splash->setPos(-sbr.width() / 2, scene->sceneRect().top() - 2);
frontState->assignProperty(splash, "y", splash->y() - 100.0);
scene->addItem(splash);
//! [17]
//! [18]
// View
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setMinimumSize(50, 50);
setViewportUpdateMode(FullViewportUpdate);
setCacheMode(CacheBackground);
setRenderHints(QPainter::Antialiasing
| QPainter::SmoothPixmapTransform
| QPainter::TextAntialiasing);
#ifndef QT_NO_OPENGL
setViewport(new QOpenGLWidget);
#endif
stateMachine->start();
//! [18]
}
void Barbel::Scene::initScene()
{
//Setup Framegraph
if (m_frameGraph == Q_NULLPTR)
m_frameGraph = new Qt3D::QFrameGraph();
if (m_forwardRenderer == Q_NULLPTR)
m_forwardRenderer = new Qt3D::QForwardRenderer();
m_forwardRenderer->setClearColor(Qt::black);
m_frameGraph->setActiveFrameGraph(m_forwardRenderer);
m_rootEntity->addComponent(m_frameGraph);
//Test Objects
Barbel::Player *player = new Barbel::Player(m_rootEntity);
player->setTranslation(QVector3D(0.0f, 0.0f, 0.0f));
setActiveCamera(player->camera());
activeCamera()->lens()->setAspectRatio(m_cameraAspectRatio);
QVector3D startPostion(0.0f, 0.0f, 0.0f);
QVector3D secondPosition(10.0f, 10.0f, 10.0f);
QVector3D thirdPosition(-10.0f, 0.0f, 10.0f);
QVector3D startAngles(0.0f, 0.0f, 0.0f);
QVector3D secondAngles(45.0f, 150.0f, 0.0f);
QVector3D thirdAngles(0.0f, 200.0f, 0.0f);
QVector3D finalAngles(0.0f, 360.0f, 0.0f);
QSequentialAnimationGroup *animationGroup = new QSequentialAnimationGroup(this);
QParallelAnimationGroup *parallelAnimationGroup1 = new QParallelAnimationGroup(this);
QPropertyAnimation *animation = new QPropertyAnimation(player, "translation", this);
animation->setDuration(5000);
animation->setStartValue(startPostion);
animation->setEndValue(secondPosition);
parallelAnimationGroup1->addAnimation(animation);
QPropertyAnimation *rotationAnimation = new QPropertyAnimation(player, "rotation", this);
rotationAnimation->setDuration(5000);
rotationAnimation->setStartValue(startAngles);
rotationAnimation->setEndValue(secondAngles);
parallelAnimationGroup1->addAnimation(rotationAnimation);
animationGroup->addAnimation(parallelAnimationGroup1);
QParallelAnimationGroup *parallelAnimationGroup2 = new QParallelAnimationGroup(this);
animation = new QPropertyAnimation(player, "translation", this);
animation->setDuration(5000);
animation->setStartValue(secondPosition);
animation->setEndValue(thirdPosition);
parallelAnimationGroup2->addAnimation(animation);
rotationAnimation = new QPropertyAnimation(player, "rotation", this);
rotationAnimation->setDuration(5000);
rotationAnimation->setStartValue(secondAngles);
rotationAnimation->setEndValue(thirdAngles);
parallelAnimationGroup2->addAnimation(rotationAnimation);
animationGroup->addAnimation(parallelAnimationGroup2);
QParallelAnimationGroup *parallelAnimationGroup3 = new QParallelAnimationGroup(this);
animation = new QPropertyAnimation(player, "translation", this);
animation->setDuration(5000);
animation->setStartValue(thirdPosition);
animation->setEndValue(startPostion);
parallelAnimationGroup3->addAnimation(animation);
rotationAnimation = new QPropertyAnimation(player, "rotation", this);
rotationAnimation->setDuration(5000);
rotationAnimation->setStartValue(thirdAngles);
rotationAnimation->setEndValue(finalAngles);
parallelAnimationGroup3->addAnimation(rotationAnimation);
animationGroup->addAnimation(parallelAnimationGroup3);
animationGroup->setLoopCount(-1);
animationGroup->start();
//Test Cubes
Qt3D::QPhongMaterial *phongMaterial1 = new Qt3D::QPhongMaterial();
phongMaterial1->setDiffuse(QColor(94, 141, 25));
phongMaterial1->setSpecular(Qt::white);
Qt3D::QPhongMaterial *phongMaterial2 = new Qt3D::QPhongMaterial();
phongMaterial2->setDiffuse(QColor(129, 23, 71));
phongMaterial2->setSpecular(Qt::white);
for (int z = -5; z < 5; z++) {
for (int y = -5; y < 5; y++) {
for (int x = -5; x < 5; x++) {
float xSize = (rand() % 10000) / 10000.0;
float ySize = (rand() % 10000) / 10000.0;
float zSize = (rand() % 10000) / 10000.0;
Barbel::TestCube *cube = new TestCube(QVector3D(x, y, z), QVector3D(xSize, ySize, zSize), m_rootEntity);
if (y % 2)
cube->addComponent(phongMaterial1);
else
cube->addComponent(phongMaterial2);
}
}
}
}
void GlanceShower::Start ()
{
if (!TabWidget_)
{
qWarning () << Q_FUNC_INFO
<< "no tab widget set";
return;
}
int count = TabWidget_->count ();
if (count < 2)
return;
QSequentialAnimationGroup *animGroup = new QSequentialAnimationGroup;
int sqr = std::sqrt ((double)count);
int rows = sqr;
int cols = sqr;
if (rows * cols < count)
++cols;
if (rows * cols < count)
++rows;
QRect screenGeom = QApplication::desktop ()->
screenGeometry (Core::Instance ().GetReallyMainWindow ());
int width = screenGeom.width ();
int height = screenGeom.height ();
int singleW = width / cols;
int singleH = height / rows;
int wW = singleW * 4 / 5;
int wH = singleH * 4 / 5;
qreal scaleFactor = 0;
QSize sSize;
int animLength = 500 / (sqr);
QProgressDialog pg;
pg.setMinimumDuration (1000);
pg.setRange (0, count);
for (int row = 0; row < rows; ++row)
for (int column = 0;
column < cols && column + row * cols < count;
++column)
{
int idx = column + row * cols;
pg.setValue (idx);
QWidget *w = TabWidget_->widget (idx);
if (!sSize.isValid ())
sSize = w->size () / 2;
if (sSize != w->size ())
w->resize (sSize * 2);
if (!scaleFactor)
scaleFactor = std::min (static_cast<qreal> (wW) / sSize.width (),
static_cast<qreal> (wH) / sSize.height ());
QPixmap pixmap (sSize * 2);
w->render (&pixmap);
pixmap = pixmap.scaled (sSize,
Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
{
QPainter p (&pixmap);
QPen pen (Qt::black);
pen.setWidth (2 / scaleFactor + 1);
p.setPen (pen);
p.drawRect (QRect (QPoint (0, 0), sSize));
}
GlanceItem *item = new GlanceItem (pixmap);
item->SetIndex (idx);
connect (item,
SIGNAL (clicked (int)),
this,
SLOT (handleClicked (int)));
Scene_->addItem (item);
item->setTransformOriginPoint (sSize.width () / 2, sSize.height () / 2);
item->setScale (scaleFactor);
item->SetIdealScale (scaleFactor);
item->setOpacity (0);
item->moveBy (column * singleW, row * singleH);
QParallelAnimationGroup *pair = new QParallelAnimationGroup;
QPropertyAnimation *posAnim = new QPropertyAnimation (item, "Pos");
posAnim->setDuration (animLength);
posAnim->setStartValue (QPointF (0, 0));
posAnim->setEndValue (QPointF (column * singleW, row * singleH));
posAnim->setEasingCurve (QEasingCurve::OutSine);
pair->addAnimation (posAnim);
QPropertyAnimation *opacityAnim = new QPropertyAnimation (item, "Opacity");
opacityAnim->setDuration (animLength);
opacityAnim->setStartValue (0.);
opacityAnim->setEndValue (1.);
pair->addAnimation (opacityAnim);
animGroup->addAnimation (pair);
}
setScene (Scene_);
setGeometry (screenGeom);
animGroup->start ();
show ();
}
void init()
{
Q_Q(KFlipWidget);
flipRotation = new QGraphicsRotation(q);
xRotation = new QGraphicsRotation(q);
yRotation = new QGraphicsRotation(q);
flipRotation->setAxis(Qt::YAxis);
xRotation->setAxis(Qt::YAxis);
yRotation->setAxis(Qt::XAxis);
q->setTransformations(QList<QGraphicsTransform *>() << flipRotation << xRotation << yRotation);
front = new KWidget(q);
back = new KWidget(q);
QSizeF s = q->size();
back->setTransform(QTransform().rotate(180, Qt::YAxis).translate(-s.width(), 0));
smoothFlipRotation = new QPropertyAnimation(flipRotation, "angle");
smoothFlipScale = new QPropertyAnimation(q, "scale");
smoothFlipXRotation = new QPropertyAnimation(xRotation, "angle");
smoothFlipYRotation = new QPropertyAnimation(yRotation, "angle");
flipAnimation = new QParallelAnimationGroup(q);
smoothFlipScale->setDuration(500);
smoothFlipRotation->setDuration(500);
smoothFlipXRotation->setDuration(500);
smoothFlipYRotation->setDuration(500);
smoothFlipScale->setEasingCurve(QEasingCurve::InOutQuad);
smoothFlipRotation->setEasingCurve(QEasingCurve::InOutQuad);
smoothFlipXRotation->setEasingCurve(QEasingCurve::InOutQuad);
smoothFlipYRotation->setEasingCurve(QEasingCurve::InOutQuad);
smoothFlipScale->setKeyValueAt(0, qVariantValue<qreal>(1.0));
smoothFlipScale->setKeyValueAt(0.5, qVariantValue<qreal>(0.7));
smoothFlipScale->setKeyValueAt(1, qVariantValue<qreal>(1.0));
flipAnimation->addAnimation(smoothFlipRotation);
flipAnimation->addAnimation(smoothFlipScale);
flipAnimation->addAnimation(smoothFlipXRotation);
flipAnimation->addAnimation(smoothFlipYRotation);
// Flip animation delayed property assignment
QSequentialAnimationGroup *setVariablesSequence = new QSequentialAnimationGroup;
QPropertyAnimation *setBackItemVisibleAnimation = new QPropertyAnimation(back, "visible");
QPropertyAnimation *setSelectionItemVisibleAnimation = new QPropertyAnimation(front, "visible");
setBackItemVisibleAnimation->setDuration(0);
setSelectionItemVisibleAnimation->setDuration(0);
setVariablesSequence->addPause(250);
setVariablesSequence->addAnimation(setBackItemVisibleAnimation);
setVariablesSequence->addAnimation(setSelectionItemVisibleAnimation);
flipAnimation->addAnimation(setVariablesSequence);
// Build the state machine
stateMachine = new QStateMachine(q);
frontState = new QState(stateMachine);
backState = new QState(stateMachine);
frontState->assignProperty(back, "visible", false);
frontState->assignProperty(flipRotation, "angle", qVariantValue<qreal>(0.0));
frontState->assignProperty(front, "visible", true);
backState->assignProperty(back, "visible", true);
backState->assignProperty(xRotation, "angle", qVariantValue<qreal>(0.0));
backState->assignProperty(yRotation, "angle", qVariantValue<qreal>(0.0));
backState->assignProperty(flipRotation, "angle", qVariantValue<qreal>(180.0));
backState->assignProperty(front, "visible", false);
stateMachine->setInitialState(frontState);
frontTransition = new QSignalTransition(q, SIGNAL(activeBack()), frontState);
backTransition = new QSignalTransition(q, SIGNAL(activeFront()), backState);
frontTransition->addAnimation(flipAnimation);
backTransition->addAnimation(flipAnimation);
frontTransition->setTargetState(backState);
backTransition->setTargetState(frontState);
bool bok = QObject::connect(flipAnimation, SIGNAL(stateChanged(QAbstractAnimation::State,QAbstractAnimation::State)), q, SLOT(on_animation_stateChanged(QAbstractAnimation::State,QAbstractAnimation::State)));
bool bok1 = QObject::connect(flipAnimation, SIGNAL(stateChanged(QAbstractAnimation::State,QAbstractAnimation::State)), q, SLOT(on_animation_stateChanged(QAbstractAnimation::State,QAbstractAnimation::State)));
stateMachine->start();
}
void slideShowEngine::start()
{
int x,y;
QPixmap pix;
QModelIndex index;
QVariant val;
node itemNode;
QPropertyAnimation *enterAnimation,*displayAnimation,*exitAnimation;
Pixmap *item;
effect e;
QParallelAnimationGroup *parallelAnim;
QSequentialAnimationGroup *seqAnim;
if(m_groupAnimation->state()==QAbstractAnimation::Paused)
resume();
if(m_groupAnimation->state()==QAbstractAnimation::Running)
return;
QList <QGraphicsView *> views=m_scene->views();
m_size=views.at(0)->size();
m_scene->clear();
for(int i=0;i<m_sequence->rowCount();i++)
{
index=m_sequence->index(i);
if(index.isValid())
{
m_scene->setSceneRect(0.0,0.0,qreal(m_size.width()),qreal(m_size.height())); // come fare per full screen size?
qDebug() << "index valid";
val=index.data(Qt::UserRole);
itemNode=val.value<node>();
qDebug() << "pix:" << itemNode.nodeName();
pix=itemNode.nodePixmap();
if(pix.width()>m_size.width() || pix.height()>m_size.height())
pix=pix.scaled(m_size,Qt::KeepAspectRatio,Qt::SmoothTransformation);
item = new Pixmap(pix);
m_PixmapList.append(item); // serve questa lista?
if(m_size.width()>pix.width())
{
x=(m_size.width()-pix.width())/2;
}
else
{
x=0;
}
if(m_size.height()>pix.height())
{
y=(m_size.height()-pix.height())/2;
}
else
{
y=0;
}
item->setPos(qreal(x), qreal(y));
qDebug() <<qreal(m_sequence->rowCount()-i);
item->setZValue(qreal(m_sequence->rowCount()-i));
//m_scene->addItem(item);
e=itemNode.enterEffect();
enterAnimation = new QPropertyAnimation(item, e.effectType().toAscii());
itemNode.setEnterAnimation(enterAnimation,item);
connect(enterAnimation,SIGNAL(finished()),this,SLOT(animEnterFinished()));
e=itemNode.displayEffect();
displayAnimation = new QPropertyAnimation(item, e.effectType().toAscii());
itemNode.setDisplayAnimation(displayAnimation,item);
connect(displayAnimation,SIGNAL(finished()),this,SLOT(animDisplayFinished()));
e=itemNode.exitEffect();
exitAnimation = new QPropertyAnimation(item, e.effectType().toAscii());
itemNode.setExitAnimation(exitAnimation,item);
connect(exitAnimation,SIGNAL(finished()),this,SLOT(animExitFinished()));
//parallelAnim= new QParallelAnimationGroup;
//parallelAnim->addAnimation(exitAnimation);
seqAnim = new QSequentialAnimationGroup;
seqAnim->addAnimation(enterAnimation);
seqAnim->addAnimation(displayAnimation);
seqAnim->addAnimation(exitAnimation);
qDebug() << "add all animation";
m_groupAnimation->addAnimation(seqAnim);
connect(m_groupAnimation,SIGNAL(finished()),this,SLOT(endOfSlideShow()));
//group->addAnimation(animation4);
} // end index is valid
} // end for
qDebug() << "start group";
m_currentSlideIndex=0;
m_scene->addItem(m_PixmapList.at(m_currentSlideIndex));
m_groupAnimation->start();
//m_timerId=startTimer(2);
//m_slideShowClock.restart();
int width=640;
int height=480;
int bitrate=1000000;
int gop = 20;
// Create the encoder
//QVideoEncoder encoder;
//encoder.createFile("test.avi",width,height,bitrate,gop);
}
void AVLTree::PostOrder()
{
QSequentialAnimationGroup *group = new QSequentialAnimationGroup;
PostOrder(root, group);
group->start(QAbstractAnimation::DeleteWhenStopped);
}
