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();
}
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
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();
}
}
GcChartWindow::GcChartWindow(QWidget *parent) : GcWindow(parent) {
//
// Default layout
//
setContentsMargins(0,0,0,0);
// Main layout
_layout = new QStackedLayout();
setLayout(_layout);
_mainWidget = new QWidget(this);
_mainWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
_blank = new QWidget(this);
_blank->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
_layout->addWidget(_blank);
_layout->addWidget(_mainWidget);
_layout->setCurrentWidget(_mainWidget);
_mainLayout = new QGridLayout();
_mainLayout->setContentsMargins(2,2,2,2);
// reveal widget
_revealControls = new QWidget();
_revealControls->setFixedHeight(50);
_revealControls->setStyleSheet("background-color: rgba(100%, 100%, 100%, 100%)");
_revealControls->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
_revealAnim = new QPropertyAnimation(_revealControls, "pos");
_revealAnim->setDuration(200);
_revealAnim->setEasingCurve(QEasingCurve(QEasingCurve::InSine));
_revealAnim->setKeyValueAt(0,QPoint(2,-50));
_revealAnim->setKeyValueAt(0.5,QPoint(2,-5));
_revealAnim->setKeyValueAt(1,QPoint(2,0));
_unrevealAnim = new QPropertyAnimation(_revealControls, "pos");
_unrevealAnim->setDuration(150);
_unrevealAnim->setEasingCurve(QEasingCurve(QEasingCurve::InSine));
_unrevealAnim->setKeyValueAt(0,QPoint(2,0));
_unrevealAnim->setKeyValueAt(0.5,QPoint(2,-5));
_unrevealAnim->setKeyValueAt(1,QPoint(2,-50));
_unrevealTimer = new QTimer();
connect(_unrevealTimer, SIGNAL(timeout()), this, SLOT(hideRevealControls()));
_revealControls->hide();
_mainLayout->addWidget(_revealControls,0,0, Qt::AlignTop);
_mainWidget->setLayout(_mainLayout);
}
void Ut_MSceneWindowScroller::testApplyScrolling()
{
// the scrolling is actually performed by the scene manager in response
// to the scroller signals. We can't test the scrolling funcionality here
// but just that the signal is emitted
QSignalSpy spy(scroller, SIGNAL(sceneWindowDislocationRequest(MSceneWindow*, const QPointF&)));
// when asking for an empty offset, the signal is not emitted
scroller->applyScrolling(sceneWindow, QPoint(), 0, QEasingCurve());
QVERIFY (spy.count() == 0);
// otherwise the signal is emitted
scroller->applyScrolling(sceneWindow, QPoint(0, -1000), 0, QEasingCurve());
QVERIFY (spy.count() == 1);
}
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;
}
}
QcMapGestureArea::QcMapGestureArea(QcMapItem * map)
: QQuickItem(map),
m_map(map),
m_enabled(true),
m_accepted_gestures(PinchGesture | PanGesture | FlickGesture),
m_prevent_stealing(false),
m_pan_enabled(true)
{
// qInfo();
m_flick.m_enabled = true;
m_flick.m_max_velocity = QML_MAP_FLICK_DEFAULT_MAX_VELOCITY;
m_flick.m_deceleration = QML_MAP_FLICK_DEFAULT_DECELERATION;
m_flick.m_animation = new QcGeoCoordinateAnimation(this);
m_flick.m_animation->setTargetObject(m_map);
m_flick.m_animation->setProperty(QStringLiteral("center"));
m_flick.m_animation->setEasing(QEasingCurve(QEasingCurve::OutQuad));
connect(m_flick.m_animation, &QQuickAbstractAnimation::stopped,
this, &QcMapGestureArea::handle_flick_animation_stopped);
m_touch_point_state = TouchPoints0;
m_pinch_state = PinchInactive;
m_flick_state = FlickInactive;
m_press_timer.setSingleShot(true);
m_press_timer.setInterval(MINIMUM_PRESS_AND_HOLD_TIME);
connect(&m_press_timer, &QTimer::timeout,
this, &QcMapGestureArea::handle_press_timer_timeout);
m_press_time.invalidate();
m_double_press_time.invalidate();
}
MessageListView::MessageListView(QWidget *parent) :
QTableView(parent)
{
this->horizontalHeader()->hide();
this->verticalHeader()->hide();
this->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
this->verticalHeader()->setDefaultSectionSize(60);
this->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
this->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
this->setShowGrid(false);
this->setSelectionMode(QAbstractItemView::NoSelection);
/*
* 添加滑屏操作
*/
this->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
QScroller *scroller = QScroller::scroller(this->viewport());
QScrollerProperties prop = scroller->scrollerProperties();
prop.setScrollMetric(QScrollerProperties::AxisLockThreshold, 0.66);
prop.setScrollMetric(QScrollerProperties::ScrollingCurve, QEasingCurve(QEasingCurve::OutExpo));
prop.setScrollMetric(QScrollerProperties::DecelerationFactor, 0.05);
prop.setScrollMetric(QScrollerProperties::MaximumVelocity, 0);
prop.setScrollMetric(QScrollerProperties::OvershootDragResistanceFactor, 0.33);
prop.setScrollMetric(QScrollerProperties::OvershootScrollDistanceFactor, 0.33);
prop.setScrollMetric(QScrollerProperties::SnapPositionRatio, 0.93);
prop.setScrollMetric(QScrollerProperties::DragStartDistance, 0.001);
prop.setScrollMetric(QScrollerProperties::SnapPositionRatio,0.5);
scroller->setScrollerProperties(prop);
scroller->grabGesture(this, QScroller::TouchGesture);
scroller->grabGesture(this, QScroller::LeftMouseButtonGesture);
}
// Test getting and setting easing properties via the metaobject system.
void tst_QEasingCurve::properties()
{
tst_QEasingProperties obj;
QEasingCurve inOutBack(QEasingCurve::InOutBack);
qreal overshoot = 1.5;
inOutBack.setOvershoot(overshoot);
qreal amplitude = inOutBack.amplitude();
qreal period = inOutBack.period();
obj.setEasing(inOutBack);
QEasingCurve easing = qVariantValue<QEasingCurve>(obj.property("easing"));
QCOMPARE(easing.type(), QEasingCurve::InOutBack);
QCOMPARE(easing.overshoot(), overshoot);
QCOMPARE(easing.amplitude(), amplitude);
QCOMPARE(easing.period(), period);
QEasingCurve linear(QEasingCurve::Linear);
overshoot = linear.overshoot();
amplitude = linear.amplitude();
period = linear.period();
obj.setProperty("easing",
qVariantFromValue(QEasingCurve(QEasingCurve::Linear)));
easing = qVariantValue<QEasingCurve>(obj.property("easing"));
QCOMPARE(easing.type(), QEasingCurve::Linear);
QCOMPARE(easing.overshoot(), overshoot);
QCOMPARE(easing.amplitude(), amplitude);
QCOMPARE(easing.period(), period);
}
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();
}
}
Cube *CubeBuilder::newCube(const QVector3D &loc) const
{
Cube *c = new Cube(loc);
initialize(c);
qreal d = 4000.0f;
qreal d3 = d / 3.0f;
// Animate movement from left to right
c->r = new QPropertyAnimation(c, "range");
c->r->setStartValue(-1.3f);
c->r->setEndValue(1.3f);
c->startx = ix * d3 * 3.0f;
c->r->setDuration(d * 4.0f);
c->r->setLoopCount(-1);
c->r->setEasingCurve(QEasingCurve(QEasingCurve::CosineCurve));
c->animGroup = new QSequentialAnimationGroup(c);
// Animate movement from bottom to top
QPropertyAnimation *a_up = new QPropertyAnimation(c, "altitude", c->animGroup);
a_up->setEndValue(loc.y());
a_up->setStartValue(loc.y() + amplitudes[ix]);
a_up->setDuration(d / speeds[ix]);
a_up->setLoopCount(1);
a_up->setEasingCurve(QEasingCurve(QEasingCurve::InQuad));
// Animate movement from top to bottom
QPropertyAnimation *a_down = new QPropertyAnimation(c, "altitude", c->animGroup);
a_down->setEndValue(loc.y() + amplitudes[ix]);
a_down->setStartValue(loc.y());
a_down->setDuration(d / speeds[ix]);
a_down->setLoopCount(1);
a_down->setEasingCurve(QEasingCurve(QEasingCurve::OutQuad));
c->animGroup->addAnimation(a_up);
c->animGroup->addAnimation(a_down);
c->animGroup->setLoopCount(-1);
// Animate rotation
c->rtn = new QPropertyAnimation(c, "rotation");
c->rtn->setStartValue(c->rot);
c->rtn->setEndValue(359.0f);
c->rtn->setDuration(d * 2.0f);
c->rtn->setLoopCount(-1);
c->rtn->setDuration(d / 2);
ix = (ix + 1) % 3;
return c;
}
/*!
\internal
*/
void QDeclarativeGeoMapGestureArea::setMap(QGeoMap *map)
{
if (map_ || !map)
return;
map_ = map;
pan_.animation_ = new QPropertyAnimation(map_->mapController(), "center", this);
pan_.animation_->setEasingCurve(QEasingCurve(QEasingCurve::OutQuad));
connect(pan_.animation_, SIGNAL(finished()), this, SLOT(endFlick()));
connect(this, SIGNAL(movementStopped()),
map_, SLOT(cameraStopped()));
}
static VALUE
cVariantAnimation_easingCurve_set(VALUE v_self, VALUE v_easing)
{
const RPP::QObject<QVariantAnimation> self = v_self;
const RPP::QEasingCurve easing(v_easing, RPP::UNSAFE);
if (easing.isNil())
self->setEasingCurve(QEasingCurve());
else
self->setEasingCurve(*easing);
return v_easing;
}
void EasingGraph::setEasingName(const QString &newName)
{
if (easingName() != newName) {
if (!m_availableNames.contains(newName)) return;
m_curveFunction = QEasingCurve(m_availableNames.value(newName));
emit easingNameChanged();
emit easingExtremesChanged();
emit easingShapeChanged();
update();
}
}
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;
}
Qgs3DAnimationSettings Qgs3DAnimationWidget::animation() const
{
Qgs3DAnimationSettings animSettings;
animSettings.setEasingCurve( QEasingCurve( ( QEasingCurve::Type ) cboInterpolation->currentIndex() ) );
Qgs3DAnimationSettings::Keyframes keyframes;
for ( int i = 1; i < cboKeyframe->count(); ++i )
{
Qgs3DAnimationSettings::Keyframe kf;
kf = cboKeyframe->itemData( i, Qt::UserRole + 1 ).value<Qgs3DAnimationSettings::Keyframe>();
keyframes << kf;
}
animSettings.setKeyframes( keyframes );
return animSettings;
}
void ContentPane::initAnimations()
{
this->openAnimation = std::unique_ptr<QPropertyAnimation>(new QPropertyAnimation());
this->closeAnimation = std::unique_ptr<QPropertyAnimation>(new QPropertyAnimation());
// TODO: Currently these animations only animate maximumHeight. This leads to
// different behaviour depending on whether the Accordion Widget is placed
// inside a QScollWidget or not. Maybe we also need to animate minimumHeight
// as well to get the same effect.
this->openAnimation->setTargetObject(this->container);
this->openAnimation->setPropertyName("maximumHeight");
this->closeAnimation->setTargetObject(this->container);
this->closeAnimation->setPropertyName("maximumHeight");
this->openAnimation->setDuration(300);
this->closeAnimation->setDuration(300);
this->openAnimation->setStartValue(0);
this->closeAnimation->setStartValue(this->containerAnimationMaxHeight);
this->openAnimation->setEndValue(this->containerAnimationMaxHeight);
this->closeAnimation->setEndValue(0);
this->openAnimation->setEasingCurve(
QEasingCurve(QEasingCurve::Type::Linear));
this->closeAnimation->setEasingCurve(
QEasingCurve(QEasingCurve::Type::Linear));
}
void Qgs3DAnimationSettings::readXml( const QDomElement &elem )
{
mEasingCurve = QEasingCurve( ( QEasingCurve::Type ) elem.attribute( QStringLiteral( "interpolation" ), QStringLiteral( "0" ) ).toInt() );
mKeyframes.clear();
QDomElement elemKeyframes = elem.firstChildElement( QStringLiteral( "keyframes" ) );
QDomElement elemKeyframe = elemKeyframes.firstChildElement( QStringLiteral( "keyframe" ) );
while ( !elemKeyframe.isNull() )
{
Keyframe kf;
kf.time = elemKeyframe.attribute( QStringLiteral( "time" ) ).toFloat();
kf.point.set( elemKeyframe.attribute( QStringLiteral( "x" ) ).toDouble(),
elemKeyframe.attribute( QStringLiteral( "y" ) ).toDouble(),
elemKeyframe.attribute( QStringLiteral( "z" ) ).toDouble() );
kf.dist = elemKeyframe.attribute( QStringLiteral( "dist" ) ).toFloat();
kf.pitch = elemKeyframe.attribute( QStringLiteral( "pitch" ) ).toFloat();
kf.yaw = elemKeyframe.attribute( QStringLiteral( "yaw" ) ).toFloat();
mKeyframes.append( kf );
elemKeyframe = elemKeyframe.nextSiblingElement( QStringLiteral( "keyframe" ) );
}
}
KNMusicBackendMpvThread::KNMusicBackendMpvThread(QObject *parent) :
KNMusicStandardBackendThread(parent),
m_volumeCurve(QEasingCurve(QEasingCurve::OutQuad)),
m_filePath(QString()),
m_totalDuration(-1),
m_duration(-1),
m_startPosition(-1),
m_endPosition(-1),
m_mpvHandle(nullptr),
m_state(MusicUtil::Stopped),
m_volumeSize(100)
{
//Initial the locale settings.
setlocale(LC_NUMERIC, "C");
//Create the mpv handle.
m_mpvHandle=mpv_create();
//Check out the mpv handle.
if(!m_mpvHandle)
{
//Cannot create an instance for mpv.
return;
}
//Set mpv options.
// No mouse handling.
mpv_set_option_string(m_mpvHandle, "input-cursor", "no");
// No cursor-autohide.
mpv_set_option_string(m_mpvHandle, "cursor-autohide", "no");
mpv_set_option_string(m_mpvHandle, "no-video", NULL);
// get updates when these properties change
mpv_observe_property(m_mpvHandle, 0, "time-pos", MPV_FORMAT_DOUBLE);
// setup callback event handling
mpv_set_wakeup_callback(m_mpvHandle,
KNMusicBackendMpvThread::instanceWakeUp,
this);
//Initialize the mpv handler.
mpv_initialize(m_mpvHandle);
}
QtViewportInteractionEngine::QtViewportInteractionEngine(const QQuickWebView* viewport, QQuickWebPage* content)
: m_viewport(viewport)
, m_content(content)
, m_suspendCount(0)
, m_scaleAnimation(new ScaleAnimation(this))
, m_pinchStartScale(-1)
{
reset();
QScrollerProperties properties = scroller()->scrollerProperties();
// The QtPanGestureRecognizer is responsible for recognizing the gesture
// thus we need to disable the drag start distance.
properties.setScrollMetric(QScrollerProperties::DragStartDistance, 0.0);
// Set some default QScroller constrains to mimic the physics engine of the N9 browser.
properties.setScrollMetric(QScrollerProperties::AxisLockThreshold, 0.66);
properties.setScrollMetric(QScrollerProperties::ScrollingCurve, QEasingCurve(QEasingCurve::OutExpo));
properties.setScrollMetric(QScrollerProperties::DecelerationFactor, 0.05);
properties.setScrollMetric(QScrollerProperties::MaximumVelocity, 0.635);
properties.setScrollMetric(QScrollerProperties::OvershootDragResistanceFactor, 0.33);
properties.setScrollMetric(QScrollerProperties::OvershootScrollDistanceFactor, 0.33);
scroller()->setScrollerProperties(properties);
connect(m_content, SIGNAL(widthChanged()), this, SLOT(itemSizeChanged()), Qt::DirectConnection);
connect(m_content, SIGNAL(heightChanged()), this, SLOT(itemSizeChanged()), Qt::DirectConnection);
connect(m_scaleAnimation, SIGNAL(valueChanged(QVariant)),
SLOT(scaleAnimationValueChanged(QVariant)), Qt::DirectConnection);
connect(m_scaleAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)),
SLOT(scaleAnimationStateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), Qt::DirectConnection);
connect(scroller(), SIGNAL(stateChanged(QScroller::State)),
SLOT(scrollStateChanged(QScroller::State)), Qt::DirectConnection);
}
Op(Type t, int l, qreal v, qreal v2, int o,
const QDeclarativeTimeLineCallback &ev = QDeclarativeTimeLineCallback(), const QEasingCurve &es = QEasingCurve())
: type(t), length(l), value(v), value2(v2), order(o), event(ev),
easing(es) {}
KNMusicAlbumDetail::KNMusicAlbumDetail(QWidget *parent, KNMusicTab *tab) :
QWidget(parent),
m_currentIndex(QModelIndex()),
m_inCurve(QEasingCurve(QEasingCurve::OutCubic)),
m_animeStartRect(QRect()),
m_albumContent(new KNMouseUnclickableWidget(this)),
m_albumArt(new KNMusicAlbumTitle(this)),
m_rightShadow(new KNSideShadowWidget(KNSideShadowWidget::RightShadow,
this)),
m_leftShadow(new KNSideShadowWidget(KNSideShadowWidget::LeftShadow,
this)),
m_albumTitle(new KNScrollLabel(this)),
m_albumDetails(new KNScrollLabel(this)),
m_albumListView(new KNMusicAlbumListView(this, tab)),
m_libraryModel(nullptr),
m_expandAnime(new QSequentialAnimationGroup(this)),
m_expandStep1(new QParallelAnimationGroup(this)),
m_expandStep2(new QParallelAnimationGroup(this)),
m_foldAnime(new QParallelAnimationGroup(this)),
m_showAlbumArt(new QParallelAnimationGroup(this)),
m_hideAlbumArt(new QParallelAnimationGroup(this)),
m_flyAwayAnime(new QParallelAnimationGroup(this)),
m_albumArtIn1(generateAnime(m_albumArt)),
m_albumContentIn1(generateAnime(m_albumContent)),
m_albumArtIn2(generateAnime(m_albumArt)),
m_albumContentIn2(generateAnime(m_albumContent)),
m_albumArtOut(generateAnime(m_albumArt)),
m_albumContentOut(generateAnime(m_albumContent)),
m_albumArtFlyAway(generateAnime(m_albumArt)),
m_albumContentFlyAway(generateAnime(m_albumContent)),
m_showAlbumArtLabel(generateAnime(m_albumArt)),
m_showAlbumContent(generateAnime(m_albumContent)),
m_hideAlbumArtLabel(generateAnime(m_albumArt)),
m_hideAlbumContent(generateAnime(m_albumContent)),
m_iconSize(0),
m_panelSize(0),
m_backgroundAnime(true),
m_pressed(false)
{
//Set properties.
setAutoFillBackground(true);
setFocusPolicy(Qt::WheelFocus);
//Set the background color.
QPalette pal=palette();
pal.setColor(QPalette::Base, QColor(0,0,0,0));
pal.setColor(QPalette::Window, QColor(0,0,0,0));
setPalette(pal);
//Configure the album content.
m_albumContent->setAutoFillBackground(true);
m_albumContent->setFocusPolicy(Qt::StrongFocus);
QPalette contentPalette=m_albumContent->palette();
contentPalette.setColor(QPalette::Window, QColor(255,255,255,240));
m_albumContent->setPalette(contentPalette);
//Configure the album title label.
m_albumTitle->setObjectName("MusicAlbumTitleLabel");
m_albumTitle->setGlowRadius(4.0);
knTheme->registerWidget(m_albumTitle);
// Set the font.
QFont captionFont=m_albumTitle->font();
captionFont.setBold(true);
captionFont.setPixelSize(21);
m_albumTitle->setFont(captionFont);
//Configure the album artist label.
m_albumDetails->setObjectName("MusicAlbumDetailLabel");
m_albumDetails->setGlowRadius(4.0);
knTheme->registerWidget(m_albumDetails);
//Link signals.
connect(m_expandAnime, &QSequentialAnimationGroup::finished,
this, &KNMusicAlbumDetail::onActionExpandFinished);
connect(m_albumContentIn1, &QPropertyAnimation::valueChanged,
this, &KNMusicAlbumDetail::onActionExpandStep1);
connect(m_expandStep1, &QParallelAnimationGroup::finished,
this, &KNMusicAlbumDetail::onActionExpandStep1InFinished);
connect(m_albumContentIn2, &QPropertyAnimation::valueChanged,
this, &KNMusicAlbumDetail::onActionContentMove);
connect(m_foldAnime, &QParallelAnimationGroup::finished,
this, &KNMusicAlbumDetail::onActionFoldFinished);
connect(m_albumArtOut, &QPropertyAnimation::valueChanged,
this, &KNMusicAlbumDetail::onActionFold);
connect(m_flyAwayAnime, &QParallelAnimationGroup::finished,
this, &KNMusicAlbumDetail::onActionFlyAwayFinished);
connect(m_albumArtFlyAway, &QPropertyAnimation::valueChanged,
this, &KNMusicAlbumDetail::onActionFlyAway);
connect(m_showAlbumContent, &QPropertyAnimation::valueChanged,
this, &KNMusicAlbumDetail::onActionContentMove);
connect(m_hideAlbumContent, &QPropertyAnimation::valueChanged,
this, &KNMusicAlbumDetail::onActionContentMove);
//Configure the animation groups.
m_expandStep1->addAnimation(m_albumArtIn1);
m_expandStep1->addAnimation(m_albumContentIn1);
m_expandAnime->addAnimation(m_expandStep1);
m_expandStep2->addAnimation(m_albumArtIn2);
m_expandStep2->addAnimation(m_albumContentIn2);
m_expandAnime->addAnimation(m_expandStep2);
m_foldAnime->addAnimation(m_albumArtOut);
m_foldAnime->addAnimation(m_albumContentOut);
m_flyAwayAnime->addAnimation(m_albumArtFlyAway);
m_flyAwayAnime->addAnimation(m_albumContentFlyAway);
m_showAlbumArt->addAnimation(m_showAlbumArtLabel);
m_showAlbumArt->addAnimation(m_showAlbumContent);
m_hideAlbumArt->addAnimation(m_hideAlbumArtLabel);
m_hideAlbumArt->addAnimation(m_hideAlbumContent);
//Initial the content layout for album content.
QBoxLayout *contentLayout=new QBoxLayout(QBoxLayout::TopToBottom,
m_albumContent);
contentLayout->setContentsMargins(0,0,0,0);
contentLayout->setSpacing(0);
m_albumContent->setLayout(contentLayout);
//Initial the caption layout for the title and detail label.
QBoxLayout *captionLayout=new QBoxLayout(QBoxLayout::TopToBottom,
contentLayout->widget());
captionLayout->setContentsMargins(21,21,21,14);
captionLayout->setSpacing(0);
contentLayout->addLayout(captionLayout);
//Add widget to caption layout.
captionLayout->addWidget(m_albumTitle);
captionLayout->addWidget(m_albumDetails);
//Add the tree view to content layout.
contentLayout->addWidget(m_albumListView, 1);
}
RocketStorageSelectionDialog::RocketStorageSelectionDialog(RocketPlugin *plugin, MeshmoonStorage *storage, const QStringList &suffixFilters,
bool allowChangingFolder, MeshmoonStorageItem &startDirectory, QWidget *parent) :
QDialog(parent),
plugin_(plugin),
storage_(storage),
suffixFilters_(suffixFilters),
allowChangingFolder_(allowChangingFolder),
startDirectory_(startDirectory),
currentFolder_(0)
{
// Setup UI
ui_.setupUi(this);
ui_.scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
ui_.lineEditFilter->installEventFilter(this);
ui_.buttonSelect->setAutoDefault(false);
ui_.buttonCancel->setAutoDefault(false);
view_ = new RocketStorageListWidget(this, plugin_);
view_->SetPreviewFileOnMouse(true);
view_->setSelectionMode(QAbstractItemView::SingleSelection);
QVBoxLayout *l = new QVBoxLayout(ui_.scrollAreaWidgetContents);
l->setSpacing(0);
l->setContentsMargins(0,0,0,0);
l->addWidget(view_);
ui_.scrollAreaWidgetContents->setLayout(l);
// Connections
connect(view_, SIGNAL(itemClicked(QListWidgetItem*)), SLOT(OnItemClicked(QListWidgetItem*)));
connect(view_, SIGNAL(itemDoubleClicked(QListWidgetItem*)), SLOT(OnItemDoubleClicked(QListWidgetItem*)));
connect(ui_.buttonSelect, SIGNAL(clicked()), SLOT(OnSelect()), Qt::QueuedConnection);
connect(ui_.buttonCancel, SIGNAL(clicked()), SLOT(reject()), Qt::QueuedConnection);
connect(this, SIGNAL(rejected()), SLOT(OnCancel()));
connect(ui_.lineEditFilter, SIGNAL(textChanged(const QString&)), SLOT(OnFilterChanged(const QString&)));
// Dialog setup
setAttribute(Qt::WA_DeleteOnClose, true);
setWindowModality(parent != 0 ? Qt::WindowModal : Qt::ApplicationModal);
setWindowFlags(parent != 0 ? Qt::Tool : Qt::SplashScreen);
setWindowTitle(parent != 0 ? "Meshmoon Storage Picker" : "");
setModal(true);
// Center to main window or to parent window.
if (!parent)
{
plugin_->Notifications()->DimForeground();
plugin_->Notifications()->CenterToMainWindow(this);
}
else
plugin_->Notifications()->CenterToWindow(parent, this);
// Show and activate
show();
setFocus(Qt::ActiveWindowFocusReason);
activateWindow();
// If this is a splash dialog animate opacity
if (!parent)
{
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();
}
if (!plugin_ || !storage_)
{
view_->addItem(new QListWidgetItem("Failed to list storage content"));
return;
}
if (storage_->RootDirectory().IsNull())
view_->addItem(new QListWidgetItem("Loading..."));
MeshmoonStorageAuthenticationMonitor *auth = storage_->Authenticate();
connect(auth, SIGNAL(Completed()), SLOT(OnStorageAuthCompleted()), Qt::QueuedConnection);
connect(auth, SIGNAL(Canceled()), SLOT(reject()), Qt::QueuedConnection);
connect(auth, SIGNAL(Failed(const QString&)), SLOT(reject()), Qt::QueuedConnection);
}
