void LinkSelectionItem::appear(const QPointF& animStartPos, const QRectF& linkRect)
{
QGraphicsBlurEffect* blur = new QGraphicsBlurEffect();
blur->setBlurHints(QGraphicsBlurEffect::PerformanceHint);
blur->setBlurRadius(15);
setGraphicsEffect(blur);
QPropertyAnimation* rectAnimation = new QPropertyAnimation(this, "rect");
rectAnimation->setDuration(s_appearAnimDuration);
rectAnimation->setStartValue(QRectF(animStartPos, QSize(3, 3)));
rectAnimation->setEndValue(linkRect);
rectAnimation->setEasingCurve(QEasingCurve::OutExpo);
QPropertyAnimation* opacityAnimation = new QPropertyAnimation(this, "opacity");
opacityAnimation->setDuration(s_disappearAnimDuration);
opacityAnimation->setStartValue(s_linkOpacity);
opacityAnimation->setEndValue(0.0);
opacityAnimation->setEasingCurve(QEasingCurve::InExpo);
m_linkSelectiogroup.addAnimation(rectAnimation);
m_linkSelectiogroup.addAnimation(opacityAnimation);
m_linkSelectiogroup.start();
}
void KItemListViewAnimation::start(QGraphicsWidget* widget, AnimationType type, const QVariant& endValue)
{
stop(widget, type);
QPropertyAnimation* propertyAnim = nullptr;
const int animationDuration = widget->style()->styleHint(QStyle::SH_Widget_Animate) ? 200 : 1;
switch (type) {
case MovingAnimation: {
const QPointF newPos = endValue.toPointF();
if (newPos == widget->pos()) {
return;
}
propertyAnim = new QPropertyAnimation(widget, "pos");
propertyAnim->setDuration(animationDuration);
propertyAnim->setEndValue(newPos);
break;
}
case CreateAnimation: {
propertyAnim = new QPropertyAnimation(widget, "opacity");
propertyAnim->setEasingCurve(QEasingCurve::InQuart);
propertyAnim->setDuration(animationDuration);
propertyAnim->setStartValue(0.0);
propertyAnim->setEndValue(1.0);
break;
}
case DeleteAnimation: {
propertyAnim = new QPropertyAnimation(widget, "opacity");
propertyAnim->setEasingCurve(QEasingCurve::OutQuart);
propertyAnim->setDuration(animationDuration);
propertyAnim->setStartValue(1.0);
propertyAnim->setEndValue(0.0);
break;
}
case ResizeAnimation: {
const QSizeF newSize = endValue.toSizeF();
if (newSize == widget->size()) {
return;
}
propertyAnim = new QPropertyAnimation(widget, "size");
propertyAnim->setDuration(animationDuration);
propertyAnim->setEndValue(newSize);
break;
}
default:
break;
}
Q_ASSERT(propertyAnim);
connect(propertyAnim, &QPropertyAnimation::finished, this, &KItemListViewAnimation::slotFinished);
m_animation[type].insert(widget, propertyAnim);
propertyAnim->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 HideBlock::showBlock()
{
if(block->isVisible())
{
btnTitle->setIcon(QIcon(":/img/down.png"));
QPropertyAnimation *animation = new QPropertyAnimation(block,"maximumHeight");
animation->setDuration(350);
animation->setEasingCurve(QEasingCurve::OutCirc);
animation->setStartValue(blockHeight);
animation->setEndValue(0);
animation->start();
connect(animation,SIGNAL(finished()),block,SLOT(hide()));
}
else
{
block->show();
btnTitle->setIcon(QIcon(":/img/up.png"));
QPropertyAnimation *animation = new QPropertyAnimation(block,"maximumHeight");
animation->setDuration(500);
animation->setEasingCurve(QEasingCurve::InCirc);
animation->setStartValue(0);
animation->setEndValue(blockHeight+10000);
animation->start();
}
}
/**
* @brief Shows or hides the right menu with an animation
* according to the value of \ref _rightMenuHidden attribute.
*/
void MainWindow::on_showHidePushButton_clicked()
{
QPropertyAnimation * animation = new QPropertyAnimation(ui->rightMenuWidget, "maximumWidth");
animation->setDuration(1000);
animation->setStartValue(ui->rightMenuWidget->maximumWidth());
if(!_rightMenuHidden) {
ui->showHidePushButton->setIcon(QIcon(":/icons/2left"));
animation->setEndValue(0);
animation->setEasingCurve(QEasingCurve::InBack);
_rightMenuHidden = true;
}
else {
animation->setEndValue(314);
animation->setEasingCurve(QEasingCurve::OutBack);
ui->showHidePushButton->setIcon(QIcon(":/icons/2right"));
_rightMenuHidden = false;
}
animation->start(QPropertyAnimation::DeleteWhenStopped);
}
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 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 QtMaemo6MenuProxy::hideWindow() {
const MWidgetFadeAnimationStyle *fadeOutStyle =
static_cast<const MWidgetFadeAnimationStyle *>(QtMaemo6StylePrivate::mStyle(QStyle::State_Active,
"MWidgetFadeAnimationStyle", "Out"));
QRect startGeometry = m_menu->geometry();
QRect finalGeometry = startGeometry;
finalGeometry.moveTo(finalGeometry.x(), finalGeometry.y() - finalGeometry.height());
QParallelAnimationGroup* animationGroup = new QParallelAnimationGroup();
QPropertyAnimation *widgetFadeOut = new QPropertyAnimation(animationGroup);
widgetFadeOut->setTargetObject(m_menu);
widgetFadeOut->setPropertyName("geometry");
widgetFadeOut->setDuration(fadeOutStyle->duration());
widgetFadeOut->setEasingCurve(fadeOutStyle->easingCurve());
widgetFadeOut->setStartValue(startGeometry);
widgetFadeOut->setEndValue(finalGeometry);
QPalette startPalette = m_appArea->palette();
QPalette finalPalette = startPalette;
startPalette.setBrush(QPalette::Window, QBrush(QColor(0, 0, 0, 0)));
QPropertyAnimation *backgroundFadeOut = new QPropertyAnimation(animationGroup);
backgroundFadeOut->setTargetObject(m_appArea);
backgroundFadeOut->setPropertyName("palette");
backgroundFadeOut->setDuration(fadeOutStyle->duration());
backgroundFadeOut->setEasingCurve(fadeOutStyle->easingCurve());
backgroundFadeOut->setStartValue(startPalette);
backgroundFadeOut->setEndValue(finalPalette);
connect(animationGroup, SIGNAL(finished()), this, SLOT(close()));
animationGroup->start(QAbstractAnimation::DeleteWhenStopped);
}
void UnseenEpisodeWidget::animateNextEpisode()
{
_currentWidget->setEnabled(false);
_nextWidget = _makeWidget();
if (_nextWidget) {
layout()->addWidget(_nextWidget);
_currentWidget->setMinimumWidth(_currentWidget->width());
_nextWidget->setMinimumWidth(_currentWidget->width());
QPoint finalPos = _currentWidget->pos();
int duration = 600;
QPropertyAnimation *slideOut = new QPropertyAnimation(_currentWidget, "pos", this);
slideOut->setDuration(duration);
slideOut->setStartValue(finalPos);
slideOut->setEndValue(QPoint(finalPos.x() - _currentWidget->width(), finalPos.y()));
slideOut->setEasingCurve(QEasingCurve::OutQuart);
QPropertyAnimation *slideIn = new QPropertyAnimation(_nextWidget, "pos", this);
slideIn->setDuration(duration);
slideIn->setStartValue(QPoint(finalPos.x() + _currentWidget->width(), finalPos.y()));
slideIn->setEndValue(finalPos);
slideIn->setEasingCurve(QEasingCurve::OutQuart);
QParallelAnimationGroup *group = new QParallelAnimationGroup(_currentWidget);
group->addAnimation(slideOut);
group->addAnimation(slideIn);
group->start(QAbstractAnimation::DeleteWhenStopped);
group->connect(group, SIGNAL(finished()), this, SLOT(setupNewCurrent()));
}
}
void ReticleItem::startAt(const QPoint& pos)
{
if (m_animation)
m_animation->stop();
setPos(pos.x(), pos.y());
setVisible(true);
setOpacity(1);
setScale(1);
QPropertyAnimation* opacityAnimation = new QPropertyAnimation(this, "opacity");
opacityAnimation->setDuration(AS(reticleDuration));
opacityAnimation->setStartValue(1.0);
opacityAnimation->setEndValue(0.0);
opacityAnimation->setEasingCurve(AS_CURVE(reticleCurve));
QPropertyAnimation* scaleAnimation = new QPropertyAnimation(this, "scale");
scaleAnimation->setDuration(AS(reticleDuration));
scaleAnimation->setStartValue(1.0);
scaleAnimation->setEndValue(1.5);
scaleAnimation->setEasingCurve(AS_CURVE(reticleCurve));
QParallelAnimationGroup* reticleAnimation = new QParallelAnimationGroup;
reticleAnimation->addAnimation(opacityAnimation);
reticleAnimation->addAnimation(scaleAnimation);
QPropertyAnimation* visibility = new QPropertyAnimation(this, "visible");
visibility->setEndValue(false);
visibility->setDuration(0);
m_animation = new QSequentialAnimationGroup;
m_animation->addAnimation(reticleAnimation);
m_animation->addAnimation(visibility);
m_animation->start(QAbstractAnimation::DeleteWhenStopped);
}
void
StatsGauge::setValue( int v )
{
if ( maximum() == 0 || v == 0 )
return;
if ( v == m_targetValue )
return;
m_targetValue = v;
{
QPropertyAnimation* a = new QPropertyAnimation( (QProgressBar*)this, "value" );
a->setEasingCurve( QEasingCurve( QEasingCurve::OutQuad ) );
a->setStartValue( value() > 0 ? value() : 1 );
a->setEndValue( v );
a->setDuration( 2000 );
connect( a, SIGNAL( finished() ), a, SLOT( deleteLater() ) );
a->start();
}
{
QPropertyAnimation* a = new QPropertyAnimation( (QProgressBar*)this, "percentage" );
a->setEasingCurve( QEasingCurve( QEasingCurve::OutQuad ) );
a->setStartValue( (float)0 );
a->setEndValue( (float)v / (float)maximum() );
a->setDuration( 2000 );
connect( a, SIGNAL( finished() ), a, SLOT( deleteLater() ) );
a->start();
}
}
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 DProgressFrame::slideUsbSeclect() {
if (m_Active) {
return;
}
else {
m_Active=true;
}
this->layout()->setEnabled(false);
m_TopShadow->show();
m_ProcessLabel->setPixmap(QPixmap(""));
emit changedUsbSeclet();
int offsetx=frameRect().width(); //inherited from mother
int offsety=frameRect().height();//inherited from mother
m_SecondWidget->setGeometry(0, 0, offsetx, offsety);
offsetx=0;
//offsety=offsety;
//re-position the next widget outside/aside of the display area
QPoint pnext=m_SecondWidget->pos();
QPoint pnow=m_FirstWidget->pos();
m_FirstWidget->move(pnow.x(), pnow.y()- offsety + 64+ 36);
m_SecondWidget->move(pnext.x(), pnext.y() + 64+ 36);
//make it visible/show
m_SecondWidget->show();
m_SecondWidget->raise();
m_TopShadow->raise();
//animate both, the now and next widget to the side, using movie framework
QPropertyAnimation *animnow = new QPropertyAnimation(m_FirstWidget, "pos");
animnow->setDuration(m_Speed);
animnow->setEasingCurve(QEasingCurve::OutBack);
animnow->setStartValue(QPoint(pnow.x(), pnow.y()));
animnow->setEndValue(QPoint(offsetx+pnow.x(), -offsety+pnow.y() + 64 + 36));
QPropertyAnimation *animnext = new QPropertyAnimation(m_SecondWidget, "pos");
animnext->setDuration(m_Speed);
animnext->setEasingCurve(QEasingCurve::OutBack);
animnext->setStartValue(QPoint(pnext.x(), offsety+pnext.y()));
animnext->setEndValue(QPoint(pnext.x(), pnext.y() + 64+ 36));
m_AnimGroup = new QParallelAnimationGroup;
m_AnimGroup->addAnimation(animnow);
m_AnimGroup->addAnimation(animnext);
connect(m_AnimGroup, SIGNAL(finished()),this,SLOT(slideUsbDone()));
m_Active=true;
m_AnimGroup->start();
}
void DeckHandler::adjustDrawSize()
{
if(drawAnimating)
{
QTimer::singleShot(ANIMATION_TIME+50, this, SLOT(adjustDrawSize()));
return;
}
int rowHeight = ui->drawListWidget->sizeHintForRow(0);
int rows = drawCardList.count();
int height = rows*rowHeight + 2*ui->drawListWidget->frameWidth();
int maxHeight = (ui->drawListWidget->height()+ui->enemyHandListWidget->height())*4/5;
if(height>maxHeight) height = maxHeight;
QPropertyAnimation *animation = new QPropertyAnimation(ui->drawListWidget, "minimumHeight");
animation->setDuration(ANIMATION_TIME);
animation->setStartValue(ui->drawListWidget->minimumHeight());
animation->setEndValue(height);
animation->setEasingCurve(QEasingCurve::OutBounce);
animation->start();
QPropertyAnimation *animation2 = new QPropertyAnimation(ui->drawListWidget, "maximumHeight");
animation2->setDuration(ANIMATION_TIME);
animation2->setStartValue(ui->drawListWidget->maximumHeight());
animation2->setEndValue(height);
animation2->setEasingCurve(QEasingCurve::OutBounce);
animation2->start();
this->drawAnimating = true;
connect(animation, SIGNAL(finished()),
this, SLOT(clearDrawAnimating()));
}
void AbstractClipItem::closeAnimation()
{
#if QT_VERSION >= 0x040600
if (!isEnabled()) return;
setEnabled(false);
setFlag(QGraphicsItem::ItemIsSelectable, false);
if (!(KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects)) {
// animation disabled
deleteLater();
return;
}
QPropertyAnimation *closeAnimation = new QPropertyAnimation(this, "rect");
QPropertyAnimation *closeAnimation2 = new QPropertyAnimation(this, "opacity");
closeAnimation->setDuration(200);
closeAnimation2->setDuration(200);
QRectF r = rect();
QRectF r2 = r;
r2.setLeft(r.left() + r.width() / 2);
r2.setTop(r.top() + r.height() / 2);
r2.setWidth(1);
r2.setHeight(1);
closeAnimation->setStartValue(r);
closeAnimation->setEndValue(r2);
closeAnimation->setEasingCurve(QEasingCurve::InQuad);
closeAnimation2->setStartValue(1.0);
closeAnimation2->setEndValue(0.0);
QParallelAnimationGroup *group = new QParallelAnimationGroup;
connect(group, SIGNAL(finished()), this, SLOT(deleteLater()));
group->addAnimation(closeAnimation);
group->addAnimation(closeAnimation2);
group->start(QAbstractAnimation::DeleteWhenStopped);
#endif
}
void View::articleClicked() {
Button *btn = dynamic_cast<Button*>(sender());
if (!btn)
return;
QPropertyAnimation *animation = new QPropertyAnimation(btn, "geometry");
animation->setDuration(750);
animation->setEasingCurve(QEasingCurve::OutExpo);
if (btn->isFront()) {
btn->setZValue(1);
animation->setStartValue(btn->geometry());
animation->setEndValue(btn->gridGeometry());
connect(animation, SIGNAL(finished()), btn, SLOT(setBack()));
animation->start();
//_actButton = NULL;
} else {
if (_actButton != NULL && _actButton != btn) {
delete animation;
return;
}
btn->setFront();
btn->setGridGeometry(btn->geometry());
animation->setStartValue(btn->geometry());
unsigned int w = size().width() / 17;
unsigned int h = (size().height() - _topBar->size().height()) / 15;
animation->setEndValue(QRectF(w, h + _topBar->size().height(), 15 * w, 13 * h));
animation->start();
_actButton = btn;
}
btn->setEnabled(false);
connect(animation, SIGNAL(finished()), animation, SLOT(deleteLater()));
connect(animation, SIGNAL(finished()), this, SLOT(animationFinished()));
}
void QWidgetAnimator::animate(QWidget *widget, const QRect &_final_geometry, bool animate)
{
QRect r = widget->geometry();
if (r.right() < 0 || r.bottom() < 0)
r = QRect();
animate = animate && !r.isNull() && !_final_geometry.isNull();
// might make the wigdet go away by sending it to negative space
const QRect final_geometry = _final_geometry.isValid() || widget->isWindow() ? _final_geometry :
QRect(QPoint(-500 - widget->width(), -500 - widget->height()), widget->size());
#ifndef QT_NO_ANIMATION
AnimationMap::const_iterator it = m_animation_map.constFind(widget);
if (it != m_animation_map.constEnd() && (*it)->endValue().toRect() == final_geometry)
return;
QPropertyAnimation *anim = new QPropertyAnimation(widget, "geometry", widget);
anim->setDuration(animate ? 200 : 0);
anim->setEasingCurve(QEasingCurve::InOutQuad);
anim->setEndValue(final_geometry);
m_animation_map[widget] = anim;
connect(anim, SIGNAL(finished()), SLOT(animationFinished()));
anim->start(QPropertyAnimation::DeleteWhenStopped);
#else
//we do it in one shot
widget->setGeometry(final_geometry);
#ifndef QT_NO_MAINWINDOW
m_mainWindowLayout->animationFinished(widget);
#endif //QT_NO_MAINWINDOW
#endif //QT_NO_ANIMATION
}
Widget::Widget(const char* wname) : m_settings(wname)//, m_shortcutGrabber(this, m_settings)
{
setWindowFlags(Qt::ToolTip);
setAttribute(Qt::WA_TranslucentBackground);
setWindowOpacity(m_settings.get("gui/opacity").toInt() / 100.0);
QPropertyAnimation* anim = new QPropertyAnimation(this);
anim->setTargetObject(this);
m_animation.addAnimation(anim);
anim->setEasingCurve(QEasingCurve::Type(m_settings.get("gui/in_animation").toInt()));
connect(anim, SIGNAL(finished()), this, SLOT(reverseTrigger()));
connectForPosition(m_settings.get("gui/position").toString());
connect(&m_visible, SIGNAL(timeout()), this, SLOT(reverseStart()));
m_visible.setSingleShot(true);
QHBoxLayout* l = new QHBoxLayout;
l->setSizeConstraint(QLayout::SetNoConstraint);
l->setMargin(0);
l->setContentsMargins(0, 0, 0, 0);
setLayout(l);
l->addWidget(m_contentView["icon"] = new QLabel);
l->addWidget(m_contentView["title"] = new QLabel);
l->addWidget(m_contentView["text"] = new QLabel);
m_contentView["title"]->setOpenExternalLinks(true);
m_contentView["text"]->setOpenExternalLinks(true);
setContextMenuPolicy(Qt::CustomContextMenu);
connect(this, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(onHide()));
// Let the event loop run
QTimer::singleShot(30, this, SLOT(init()));
}
QAbstractAnimation *CardItem::getGoBackAnimation(bool doFade, bool smoothTransition, int duration) {
m_animationMutex.lock();
if (m_currentAnimation != NULL) {
m_currentAnimation->stop();
delete m_currentAnimation;
m_currentAnimation = NULL;
}
QPropertyAnimation *goback = new QPropertyAnimation(this, "pos");
goback->setEndValue(home_pos);
goback->setEasingCurve(QEasingCurve::OutQuad);
goback->setDuration(duration);
if (doFade) {
QParallelAnimationGroup *group = new QParallelAnimationGroup;
QPropertyAnimation *disappear = new QPropertyAnimation(this, "opacity");
double middleOpacity = qMax(opacity(), m_opacityAtHome);
if (middleOpacity == 0) middleOpacity = 1.0;
disappear->setEndValue(m_opacityAtHome);
if (!smoothTransition) {
disappear->setKeyValueAt(0.2, middleOpacity);
disappear->setKeyValueAt(0.8, middleOpacity);
disappear->setDuration(duration);
}
group->addAnimation(goback);
group->addAnimation(disappear);
m_currentAnimation = group;
} else {
m_currentAnimation = goback;
}
m_animationMutex.unlock();
connect(m_currentAnimation, SIGNAL(finished()), this, SIGNAL(movement_animation_finished()));
return m_currentAnimation;
}
int MPF::showHelp()
{
QGraphicsOpacityEffect* opacityEffect = new QGraphicsOpacityEffect(this);
helpTextEdit->setGraphicsEffect(opacityEffect);
//helpTextEdit->setText("");
QPropertyAnimation* anim = new QPropertyAnimation(this);
if(helpTextEdit->isHidden())
{
opacityEffect->setOpacity(1);
anim->setEndValue(0);
helpPushButton->setText(trUtf8("&Hide Help"));
helpTextEdit->show();
fullHelpPushButton->show();
}
else
{
opacityEffect->setOpacity(0);
anim->setEndValue(1);
helpPushButton->setText(trUtf8("&Show Help"));
helpTextEdit->hide();
fullHelpPushButton->hide();
}
anim->setTargetObject(opacityEffect);
anim->setPropertyName("opacity");
anim->setDuration(3000);
anim->setStartValue(opacityEffect->opacity());
anim->setEasingCurve(QEasingCurve::InBounce);
anim->start(QAbstractAnimation::DeleteWhenStopped);
return 0;
}
void Item::move ( const QPointF& pos, qreal tileSize, bool animated )
{
if ( !animated || Settings::animationSpeed() == Settings::EnumAnimationSpeed::Instant )
{
setPos ( pos );
}
else
{
int duration = 0;
switch ( Settings::animationSpeed() )
{
case Settings::EnumAnimationSpeed::Fast:
duration = fastAnimationDuration;
break;
case Settings::EnumAnimationSpeed::Normal:
duration = normalAnimationDuration;
break;
case Settings::EnumAnimationSpeed::Slow:
duration = slowAnimationDuration;
break;
default:
break;
}
duration *= qSqrt ( QPointF ( this->pos() - pos ).manhattanLength() / tileSize );
QPropertyAnimation* anim = new QPropertyAnimation ( this, "pos" );
anim->setDuration ( duration );
anim->setEasingCurve ( QEasingCurve::InOutCubic );
anim->setEndValue ( pos );
anim->start ( QAbstractAnimation::DeleteWhenStopped );
}
}
void RocketStorageAuthDialog::Show()
{
if (isVisible())
return;
show();
setFocus(Qt::ActiveWindowFocusReason);
activateWindow();
setWindowOpacity(0.0);
QPropertyAnimation *showAnim = new QPropertyAnimation(this, "windowOpacity", this);
showAnim->setStartValue(0.0);
showAnim->setEndValue(1.0);
showAnim->setDuration(300);
showAnim->setEasingCurve(QEasingCurve(QEasingCurve::InOutQuad));
showAnim->start();
plugin_->Notifications()->CenterToMainWindow(this);
if (!plugin_->Notifications()->IsForegroundDimmed())
{
plugin_->Notifications()->DimForeground();
restoreForeground_ = true;
}
}
void Widget::startBounce()
{
if (!m_settings.get("gui/bounce").toBool()) {
return;
}
doneBounce();
QPropertyAnimation* anim = new QPropertyAnimation(this);
anim->setTargetObject(this);
m_animation.addAnimation(anim);
anim->setEasingCurve(QEasingCurve::OutQuad);
anim->setDuration(m_settings.get("gui/bounce_duration").toInt() * 0.25f);
anim->setStartValue(0);
QString position = m_messageQueue.front().data["pos"]->toString();
if (position == "top_center" || position == "tc" ||
position == "bottom_center" || position == "bc" ||
position == "center" || position == "c")
anim->setEndValue(height());
else
anim->setEndValue(40);
tmpBouncePos = pos();
anim->start();
connect(anim, SIGNAL(valueChanged(QVariant)), this, SLOT(updateBounceAnimation(QVariant)));
connect(anim, SIGNAL(finished()), this, SLOT(unbounce()));
}
void RocketStorageInfoDialog::Open()
{
if (isVisible())
return;
show();
setFocus(Qt::ActiveWindowFocusReason);
activateWindow();
setWindowOpacity(0.0);
QPropertyAnimation *showAnim = new QPropertyAnimation(this, "windowOpacity", this);
showAnim->setStartValue(0.0);
showAnim->setEndValue(1.0);
showAnim->setDuration(300);
showAnim->setEasingCurve(QEasingCurve(QEasingCurve::InOutQuad));
showAnim->start();
plugin_->Notifications()->CenterToMainWindow(this);
plugin_->Notifications()->DimForeground();
// If input mode is enabled, focus the input field and
// select the text so user can start writing.
if (ui.lineEditInput->isVisible())
{
ui.lineEditInput->setFocus(Qt::MouseFocusReason);
ui.lineEditInput->selectAll();
}
}
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 CardItem::goBack(bool kieru){
if(home_pos == pos()){
if(kieru)
setOpacity(0.0);
return;
}
QPropertyAnimation *goback = new QPropertyAnimation(this, "pos");
goback->setEndValue(home_pos);
goback->setEasingCurve(QEasingCurve::OutBounce);
if(kieru){
QParallelAnimationGroup *group = new QParallelAnimationGroup;
QPropertyAnimation *disappear = new QPropertyAnimation(this, "opacity");
disappear->setKeyValueAt(0.9, 1.0);
disappear->setEndValue(0.0);
goback->setDuration(1000);
disappear->setDuration(1000);
group->addAnimation(goback);
group->addAnimation(disappear);
group->start(QParallelAnimationGroup::DeleteWhenStopped);
}else
goback->start(QPropertyAnimation::DeleteWhenStopped);
}
void DialogController::closeDialog()
{
QWidget *dialog = m_dialog;
m_dialog = nullptr;
m_widget = nullptr;
if(!dialog)
return;
QRect geom = dialog->geometry();
int w = geom.width() + m_dialogOffsetLeft;
QPropertyAnimation *animation = new QPropertyAnimation(dialog, "geometry");
animation->setStartValue(visibleGeometry(dialog));
animation->setEndValue(hiddenGeometry(dialog));
animation->setDuration(300);
animation->setEasingCurve(QEasingCurve::OutExpo);
animation->start();
connect(animation, &QPropertyAnimation::finished, [=]{
animation->deleteLater();
dialog->close();
dialog->deleteLater();
});
emit dialogClosed();
}
int MPF::animateWidget(QWidget* widget, bool hide, int effect)
{
if(!widget)
{
return 1;
}
if(effect == FADING)
{
QGraphicsOpacityEffect* opacityEffect = new QGraphicsOpacityEffect(this);
opacityEffect->setOpacity(0);
widget->setGraphicsEffect(opacityEffect);
QPropertyAnimation* anim = new QPropertyAnimation(this);
anim->setTargetObject(opacityEffect);
anim->setPropertyName("opacity");
anim->setDuration(3000);
anim->setStartValue(opacityEffect->opacity());
anim->setEndValue(1);
anim->setEasingCurve(QEasingCurve::OutQuad);
anim->start(QAbstractAnimation::DeleteWhenStopped);
}
return 0;
}
void LogoScene::setupLogo()
{
Qneed* background = new Qneed(this, get_window());
background->loadImage(":images/logo/logo_background.png");
set_background(background);
logo = new Qneed(this, get_window());
logo->loadImage(":images/logo/logo.png");
logo->setPos(307, 240);
OnemoreButton* one = new OnemoreButton(this,get_window());
one->setPos(400, 553);
one->hide();
QGraphicsOpacityEffect* opacityEffect = new QGraphicsOpacityEffect();
opacityEffect->setOpacity(0.0);
logo->setGraphicsEffect(opacityEffect);
QPropertyAnimation * animation = new QPropertyAnimation();
animation->setTargetObject(opacityEffect);
animation->setPropertyName("opacity");
animation->setDuration(2000);
animation->setStartValue(0.0);
animation->setEndValue(1.0);
animation->setEasingCurve(QEasingCurve::OutQuad);
connect(animation, SIGNAL(finished()), this, SLOT(goinit()));
animation->start();
}
void Item::resize ( const QSize& size, bool animated )
{
if ( !animated || Settings::animationSpeed() == Settings::EnumAnimationSpeed::Instant )
{
setRenderSize ( size );
}
else
{
int duration = 0;
switch ( Settings::animationSpeed() )
{
case Settings::EnumAnimationSpeed::Fast:
duration = fastAnimationDuration;
break;
case Settings::EnumAnimationSpeed::Normal:
duration = normalAnimationDuration;
break;
case Settings::EnumAnimationSpeed::Slow:
duration = slowAnimationDuration;
break;
default:
break;
}
QPropertyAnimation* anim = new QPropertyAnimation ( this, "renderSize" );
anim->setDuration ( duration );
anim->setEasingCurve ( QEasingCurve::InOutCubic );
anim->setEndValue ( size );
anim->start ( QAbstractAnimation::DeleteWhenStopped );
}
}