AndrewShkrob/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Move arrow animation into parallel animation.

Browse source
This commit is contained in:
Daria Volvenkova 2016-08-03 17:51:00 +03:00
parent 5543117f5b
commit dcfa52b2ae
14 changed files with 250 additions and 100 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

111
drape_frontend/animation/parallel_animation.cpp
View file

@ -1,5 +1,7 @@
#include "parallel_animation.hpp"
#include "animation_system.hpp"
namespace df
{
@ -7,6 +9,26 @@ ParallelAnimation::ParallelAnimation()
: Animation(true /* couldBeInterrupted */, true /* couldBeBlended */)
{}
string ParallelAnimation::GetCustomType() const
{
return m_customType;
}
void ParallelAnimation::SetCustomType(string const & type)
{
m_customType = type;
}
Animation::TAnimObjects const & ParallelAnimation::GetObjects() const
{
return m_objects;
}
bool ParallelAnimation::HasObject(TObject object) const
{
return m_objects.find(object) != m_objects.end();
}
Animation::TObjectProperties const & ParallelAnimation::GetProperties(TObject object) const
{
ASSERT(HasObject(object), ());
@ -17,20 +39,66 @@ bool ParallelAnimation::HasProperty(TObject object, TProperty property) const
{
if (!HasObject(object))
return false;
TObjectProperties properties = GetProperties(object);
TObjectProperties const & properties = GetProperties(object);
return properties.find(property) != properties.end();
}
void ParallelAnimation::AddAnimation(drape_ptr<Animation> animation)
bool ParallelAnimation::HasTargetProperty(TObject object, TProperty property) const
{
TAnimObjects const & objects = animation->GetObjects();
m_objects.insert(objects.begin(), objects.end());
for (auto const & object : objects)
ASSERT(!m_animations.empty(), ());
for (auto const & anim : m_animations)
{
TObjectProperties const & properties = animation->GetProperties(object);
m_properties[object].insert(properties.begin(), properties.end());
if (anim->HasTargetProperty(object, property))
return true;
}
m_animations.push_back(move(animation));
return false;
}
void ParallelAnimation::SetMaxDuration(double maxDuration)
{
for (auto const & anim : m_animations)
anim->SetMaxDuration(maxDuration);
}
double ParallelAnimation::GetDuration() const
{
double duration = 0.0;
for (auto const & anim : m_animations)
duration = max(duration, anim->GetDuration());
return duration;
}
bool ParallelAnimation::IsFinished() const
{
return m_animations.empty();
}
bool ParallelAnimation::GetProperty(TObject object, TProperty property, PropertyValue & value) const
{
ASSERT(!m_animations.empty(), ());
for (auto const & anim : m_animations)
{
if (anim->HasProperty(object, property))
return anim->GetProperty(object, property, value);
}
return false;
}
bool ParallelAnimation::GetTargetProperty(TObject object, TProperty property, PropertyValue & value) const
{
ASSERT(!m_animations.empty(), ());
for (auto const & anim : m_animations)
{
if (anim->HasProperty(object, property))
return anim->GetTargetProperty(object, property, value);
}
return false;
}
void ParallelAnimation::AddAnimation(drape_ptr<Animation> && animation)
{
m_animations.emplace_back(move(animation));
ObtainObjectProperties();
}
void ParallelAnimation::OnStart()
@ -54,7 +122,9 @@ void ParallelAnimation::Advance(double elapsedSeconds)
if ((*iter)->IsFinished())
{
(*iter)->OnFinish();
AnimationSystem::Instance().SaveAnimationResult(*(*iter));
iter = m_animations.erase(iter);
ObtainObjectProperties();
}
else
{
@ -66,8 +136,33 @@ void ParallelAnimation::Advance(double elapsedSeconds)
void ParallelAnimation::Finish()
{
for (auto & anim : m_animations)
{
anim->Finish();
AnimationSystem::Instance().SaveAnimationResult(*anim);
}
m_animations.clear();
ObtainObjectProperties();
Animation::Finish();
}
void ParallelAnimation::ObtainObjectProperties()
{
m_objects.clear();
m_properties.clear();
if (m_animations.empty())
return;
for (auto const & anim : m_animations)
{
TAnimObjects const & objects = anim->GetObjects();
m_objects.insert(objects.begin(), objects.end());
for (auto const & object : objects)
{
TObjectProperties const & properties = anim->GetProperties(object);
m_properties[object].insert(properties.begin(), properties.end());
}
}
}
} // namespace df

28
drape_frontend/animation/parallel_animation.hpp
View file

@ -14,31 +14,39 @@ public:
Animation::Type GetType() const override { return Animation::Parallel; }
TAnimObjects const & GetObjects() const override
{
return m_objects;
}
bool HasObject(TObject object) const override
{
return m_objects.find(object) != m_objects.end();
}
TAnimObjects const & GetObjects() const override;
bool HasObject(TObject object) const override;
TObjectProperties const & GetProperties(TObject object) const override;
bool HasProperty(TObject object, TProperty property) const override;
bool HasTargetProperty(TObject object, TProperty property) const override;
void AddAnimation(drape_ptr<Animation> animation);
string GetCustomType() const override;
void SetCustomType(string const & type);
void AddAnimation(drape_ptr<Animation> && animation);
void OnStart() override;
void OnFinish() override;
void SetMaxDuration(double maxDuration) override;
double GetDuration() const override;
bool IsFinished() const override;
void Advance(double elapsedSeconds) override;
void Finish() override;
bool GetProperty(TObject object, TProperty property, PropertyValue & value) const override;
bool GetTargetProperty(TObject object, TProperty property, PropertyValue & value) const override;
private:
void ObtainObjectProperties();
list<drape_ptr<Animation>> m_animations;
TAnimObjects m_objects;
map<TObject, TObjectProperties> m_properties;
string m_customType;
};
} // namespace df

6
drape_frontend/animation/sequence_animation.cpp
View file

@ -41,6 +41,8 @@ Animation::TObjectProperties const & SequenceAnimation::GetProperties(TObject ob
bool SequenceAnimation::HasProperty(TObject object, TProperty property) const
{
if (!HasObject(object))
return false;
ASSERT(!m_animations.empty(), ());
return m_animations.front()->HasProperty(object, property);
}
@ -94,9 +96,9 @@ bool SequenceAnimation::GetTargetProperty(TObject object, TProperty property, Pr
return false;
}
void SequenceAnimation::AddAnimation(drape_ptr<Animation> animation)
void SequenceAnimation::AddAnimation(drape_ptr<Animation> && animation)
{
m_animations.push_back(move(animation));
m_animations.emplace_back(move(animation));
if (m_animations.size() == 1)
ObtainObjectProperties();
}

2
drape_frontend/animation/sequence_animation.hpp
View file

@ -30,7 +30,7 @@ public:
bool GetProperty(TObject object, TProperty property, PropertyValue &value) const override;
bool GetTargetProperty(TObject object, TProperty property, PropertyValue &value) const override;
void AddAnimation(drape_ptr<Animation> animation);
void AddAnimation(drape_ptr<Animation> && animation);
void OnStart() override;
void OnFinish() override;

4
drape_frontend/animation_system.cpp
View file

@ -159,7 +159,7 @@ AnimationSystem & AnimationSystem::Instance()
return animSystem;
}
void AnimationSystem::CombineAnimation(drape_ptr<Animation> animation)
void AnimationSystem::CombineAnimation(drape_ptr<Animation> && animation)
{
#ifdef DEBUG_ANIMATIONS
LOG(LINFO, ("Combine animation", animation->GetType()));
@ -233,7 +233,7 @@ void AnimationSystem::CombineAnimation(drape_ptr<Animation> animation)
PushAnimation(move(animation));
}
void AnimationSystem::PushAnimation(drape_ptr<Animation> animation)
void AnimationSystem::PushAnimation(drape_ptr<Animation> && animation)
{
#ifdef DEBUG_ANIMATIONS
LOG(LINFO, ("Push animation", animation->GetType()));

4
drape_frontend/animation_system.hpp
View file

@ -30,8 +30,8 @@ public:
bool AnimationExists(Animation::TObject object) const;
bool HasAnimations() const;
void CombineAnimation(drape_ptr<Animation> animation);
void PushAnimation(drape_ptr<Animation> animation);
void CombineAnimation(drape_ptr<Animation> && animation);
void PushAnimation(drape_ptr<Animation> && animation);
void FinishAnimations(Animation::Type type, bool rewind, bool finishAll);
void FinishAnimations(Animation::Type type, string const & customType, bool rewind, bool finishAll);

22
drape_frontend/frontend_renderer.cpp
View file

@ -1609,30 +1609,32 @@ void FrontendRenderer::PositionChanged(m2::PointD const & position)
m_userPositionChangedFn(position);
}
void FrontendRenderer::ChangeModelView(m2::PointD const & center, int zoomLevel)
void FrontendRenderer::ChangeModelView(m2::PointD const & center, int zoomLevel, TAnimationCreator parallelAnimCreator)
{
AddUserEvent(make_unique_dp<SetCenterEvent>(center, zoomLevel, true));
AddUserEvent(make_unique_dp<SetCenterEvent>(center, zoomLevel, true, parallelAnimCreator));
}
void FrontendRenderer::ChangeModelView(double azimuth)
void FrontendRenderer::ChangeModelView(double azimuth, TAnimationCreator parallelAnimCreator)
{
AddUserEvent(make_unique_dp<RotateEvent>(azimuth));
AddUserEvent(make_unique_dp<RotateEvent>(azimuth, parallelAnimCreator));
}
void FrontendRenderer::ChangeModelView(m2::RectD const & rect)
void FrontendRenderer::ChangeModelView(m2::RectD const & rect, TAnimationCreator parallelAnimCreator)
{
AddUserEvent(make_unique_dp<SetRectEvent>(rect, true, kDoNotChangeZoom, true));
AddUserEvent(make_unique_dp<SetRectEvent>(rect, true, kDoNotChangeZoom, true, parallelAnimCreator));
}
void FrontendRenderer::ChangeModelView(m2::PointD const & userPos, double azimuth,
m2::PointD const & pxZero, int preferredZoomLevel)
m2::PointD const & pxZero, int preferredZoomLevel,
TAnimationCreator parallelAnimCreator)
{
AddUserEvent(make_unique_dp<FollowAndRotateEvent>(userPos, pxZero, azimuth, preferredZoomLevel, true));
AddUserEvent(make_unique_dp<FollowAndRotateEvent>(userPos, pxZero, azimuth, preferredZoomLevel, true, parallelAnimCreator));
}
void FrontendRenderer::ChangeModelView(double autoScale, m2::PointD const & userPos, double azimuth, m2::PointD const & pxZero)
void FrontendRenderer::ChangeModelView(double autoScale, m2::PointD const & userPos, double azimuth, m2::PointD const & pxZero,
TAnimationCreator parallelAnimCreator)
{
AddUserEvent(make_unique_dp<FollowAndRotateEvent>(userPos, pxZero, azimuth, autoScale));
AddUserEvent(make_unique_dp<FollowAndRotateEvent>(userPos, pxZero, azimuth, autoScale, parallelAnimCreator));
}
ScreenBase const & FrontendRenderer::ProcessEvents(bool & modelViewChanged, bool & viewportChanged)

11
drape_frontend/frontend_renderer.hpp
View file

@ -140,12 +140,13 @@ public:
/// MyPositionController::Listener
void PositionChanged(m2::PointD const & position) override;
void ChangeModelView(m2::PointD const & center, int zoomLevel) override;
void ChangeModelView(double azimuth) override;
void ChangeModelView(m2::RectD const & rect) override;
void ChangeModelView(m2::PointD const & center, int zoomLevel, TAnimationCreator parallelAnimCreator) override;
void ChangeModelView(double azimuth, TAnimationCreator parallelAnimCreator) override;
void ChangeModelView(m2::RectD const & rect, TAnimationCreator parallelAnimCreator) override;
void ChangeModelView(m2::PointD const & userPos, double azimuth,
m2::PointD const & pxZero, int preferredZoomLevel) override;
void ChangeModelView(double autoScale, m2::PointD const & userPos, double azimuth, m2::PointD const & pxZero) override;
m2::PointD const & pxZero, int preferredZoomLevel, TAnimationCreator parallelAnimCreator) override;
void ChangeModelView(double autoScale, m2::PointD const & userPos, double azimuth, m2::PointD const & pxZero,
TAnimationCreator parallelAnimCreator) override;
protected:
void AcceptMessage(ref_ptr<Message> message) override;

17
drape_frontend/my_position_controller.cpp
View file

@ -640,32 +640,32 @@ void MyPositionController::OnCompassTapped()
void MyPositionController::ChangeModelView(m2::PointD const & center, int zoomLevel)
{
if (m_listener)
m_listener->ChangeModelView(center, zoomLevel);
m_listener->ChangeModelView(center, zoomLevel, m_animCreator);
}
void MyPositionController::ChangeModelView(double azimuth)
{
if (m_listener)
m_listener->ChangeModelView(azimuth);
m_listener->ChangeModelView(azimuth, m_animCreator);
}
void MyPositionController::ChangeModelView(m2::RectD const & rect)
{
if (m_listener)
m_listener->ChangeModelView(rect);
m_listener->ChangeModelView(rect, m_animCreator);
}
void MyPositionController::ChangeModelView(m2::PointD const & userPos, double azimuth,
m2::PointD const & pxZero, int zoomLevel)
{
if (m_listener)
m_listener->ChangeModelView(userPos, azimuth, pxZero, zoomLevel);
m_listener->ChangeModelView(userPos, azimuth, pxZero, zoomLevel, m_animCreator);
}
void MyPositionController::ChangeModelView(double autoScale, m2::PointD const & userPos, double azimuth, m2::PointD const & pxZero)
{
if (m_listener)
m_listener->ChangeModelView(autoScale, userPos, azimuth, pxZero);
m_listener->ChangeModelView(autoScale, userPos, azimuth, pxZero, m_animCreator);
}
void MyPositionController::UpdateViewport(int zoomLevel)
@ -741,10 +741,11 @@ void MyPositionController::CreateAnim(m2::PointD const & oldPos, double oldAzimu
{
if (IsModeChangeViewport())
{
m_animCreator = [this, oldPos, oldAzimut, moveDuration](double correctedDuration)
m_animCreator = [this, oldPos, oldAzimut, moveDuration](double correctedDuration) -> drape_ptr<Animation>
{
AnimationSystem::Instance().CombineAnimation(make_unique_dp<ArrowAnimation>(oldPos, m_position,
correctedDuration > 0.0 ? correctedDuration : moveDuration, oldAzimut, m_drawDirection));
return make_unique_dp<ArrowAnimation>(oldPos, m_position,
correctedDuration > 0.0 ? correctedDuration : moveDuration,
oldAzimut, m_drawDirection);
};
m_oldPosition = oldPos;
m_oldDrawDirection = oldAzimut;

13
drape_frontend/my_position_controller.hpp
View file

@ -15,7 +15,9 @@
namespace df
{
class Animation;
using TAnimationCreator = function<drape_ptr<Animation>(double)>;
class MyPositionController
{
@ -26,16 +28,16 @@ public:
virtual ~Listener() {}
virtual void PositionChanged(m2::PointD const & position) = 0;
/// Show map with center in "center" point and current zoom
virtual void ChangeModelView(m2::PointD const & center, int zoomLevel) = 0;
virtual void ChangeModelView(m2::PointD const & center, int zoomLevel, TAnimationCreator parallelAnimCreator) = 0;
/// Change azimuth of current ModelView
virtual void ChangeModelView(double azimuth) = 0;
virtual void ChangeModelView(double azimuth, TAnimationCreator parallelAnimCreator) = 0;
/// Somehow show map that "rect" will see
virtual void ChangeModelView(m2::RectD const & rect) = 0;
virtual void ChangeModelView(m2::RectD const & rect, TAnimationCreator parallelAnimCreator) = 0;
/// Show map where "usePos" (mercator) placed in "pxZero" on screen and map rotated around "userPos"
virtual void ChangeModelView(m2::PointD const & userPos, double azimuth, m2::PointD const & pxZero,
int zoomLevel) = 0;
int zoomLevel, TAnimationCreator parallelAnimCreator) = 0;
virtual void ChangeModelView(double autoScale,
m2::PointD const & userPos, double azimuth, m2::PointD const & pxZero) = 0;
m2::PointD const & userPos, double azimuth, m2::PointD const & pxZero, TAnimationCreator parallelAnimCreator) = 0;
};
MyPositionController(location::EMyPositionMode initMode, double timeInBackground,
@ -167,7 +169,6 @@ private:
bool m_isDirtyAutoZoom;
bool m_isPendingAnimation;
using TAnimationCreator = function<void(double)>;
TAnimationCreator m_animCreator;
bool m_isPositionAssigned;

2
drape_frontend/screen_animations.cpp
View file

@ -12,6 +12,8 @@ namespace df
string const kPrettyMoveAnim = "PrettyMove";
string const kPrettyFollowAnim = "PrettyFollow";
string const kParallelFollowAnim = "ParallelFollow";
string const kParallelLinearAnim = "ParallelLinear";
drape_ptr<SequenceAnimation> GetPrettyMoveAnimation(ScreenBase const & startScreen, ScreenBase const & endScreen)
{

2
drape_frontend/screen_animations.hpp
View file

@ -9,6 +9,8 @@ namespace df
extern string const kPrettyMoveAnim;
extern string const kPrettyFollowAnim;
extern string const kParallelFollowAnim;
extern string const kParallelLinearAnim;
class SequenceAnimation;
class MapLinearAnimation;

86
drape_frontend/user_event_stream.cpp
View file

@ -1,7 +1,8 @@
#include "drape_frontend/user_event_stream.hpp"
#include "drape_frontend/animation/follow_animation.hpp"
#include "drape_frontend/animation/linear_animation.hpp"
#include "drape_frontend/animation/scale_animation.hpp"
#include "drape_frontend/animation/follow_animation.hpp"
#include "drape_frontend/animation/parallel_animation.hpp"
#include "drape_frontend/animation/sequence_animation.hpp"
#include "drape_frontend/animation_constants.hpp"
#include "drape_frontend/animation_system.hpp"
@ -192,14 +193,16 @@ ScreenBase const & UserEventStream::ProcessEvents(bool & modelViewChanged, bool
{
ref_ptr<SetRectEvent> rectEvent = make_ref(e);
breakAnim = SetRect(rectEvent->GetRect(), rectEvent->GetZoom(),
rectEvent->GetApplyRotation(), rectEvent->IsAnim());
rectEvent->GetApplyRotation(), rectEvent->IsAnim(),
rectEvent->GetParallelAnimCreator());
TouchCancel(m_touches);
}
break;
case UserEvent::SetCenter:
{
ref_ptr<SetCenterEvent> centerEvent = make_ref(e);
breakAnim = SetCenter(centerEvent->GetCenter(), centerEvent->GetZoom(), centerEvent->IsAnim());
breakAnim = SetCenter(centerEvent->GetCenter(), centerEvent->GetZoom(), centerEvent->IsAnim(),
centerEvent->GetParallelAnimCreator());
TouchCancel(m_touches);
}
break;
@ -218,13 +221,14 @@ ScreenBase const & UserEventStream::ProcessEvents(bool & modelViewChanged, bool
m2::PointD pt = screen.PixelRectIn3d().Center();
breakAnim = SetFollowAndRotate(screen.PtoG(screen.P3dtoP(pt)), pt,
rotateEvent->GetTargetAzimuth(), kDoNotChangeZoom, kDoNotAutoZoom,
true /* isAnim */, false /* isAutoScale */);
true /* isAnim */, false /* isAutoScale */,
rotateEvent->GetParallelAnimCreator());
}
else
{
m2::AnyRectD dstRect = GetTargetRect();
dstRect.SetAngle(rotateEvent->GetTargetAzimuth());
breakAnim = SetRect(dstRect, true);
breakAnim = SetRect(dstRect, true, rotateEvent->GetParallelAnimCreator());
}
}
break;
@ -233,7 +237,8 @@ ScreenBase const & UserEventStream::ProcessEvents(bool & modelViewChanged, bool
ref_ptr<FollowAndRotateEvent> followEvent = make_ref(e);
breakAnim = SetFollowAndRotate(followEvent->GetUserPos(), followEvent->GetPixelZero(),
followEvent->GetAzimuth(), followEvent->GetPreferredZoomLelel(),
followEvent->GetAutoScale(), followEvent->IsAnim(), followEvent->IsAutoScale());
followEvent->GetAutoScale(), followEvent->IsAnim(), followEvent->IsAutoScale(),
followEvent->GetParallelAnimCreator());
}
break;
case UserEvent::AutoPerspective:
@ -335,7 +340,7 @@ bool UserEventStream::SetScale(m2::PointD const & pxScaleCenter, double factor,
return true;
}
bool UserEventStream::SetCenter(m2::PointD const & center, int zoom, bool isAnim)
bool UserEventStream::SetCenter(m2::PointD const & center, int zoom, bool isAnim, TAnimationCreator parallelAnimCreator)
{
ScreenBase screen = GetCurrentScreen();
if (zoom == kDoNotChangeZoom)
@ -351,27 +356,21 @@ bool UserEventStream::SetCenter(m2::PointD const & center, int zoom, bool isAnim
ShrinkAndScaleInto(screen, df::GetWorldRect());
return SetScreen(screen, isAnim);
return SetScreen(screen, isAnim, parallelAnimCreator);
}
bool UserEventStream::SetRect(m2::RectD rect, int zoom, bool applyRotation, bool isAnim)
bool UserEventStream::SetRect(m2::RectD rect, int zoom, bool applyRotation, bool isAnim, TAnimationCreator parallelAnimCreator)
{
CheckMinGlobalRect(rect, kDefault3dScale);
CheckMinMaxVisibleScale(rect, zoom, kDefault3dScale);
m2::AnyRectD targetRect = applyRotation ? ToRotated(m_navigator, rect) : m2::AnyRectD(rect);
return SetRect(targetRect, isAnim);
return SetRect(targetRect, isAnim, parallelAnimCreator);
}
bool UserEventStream::SetScreen(ScreenBase const & endScreen, bool isAnim)
bool UserEventStream::SetScreen(ScreenBase const & endScreen, bool isAnim, TAnimationCreator parallelAnimCreator)
{
if (isAnim)
{
auto onStartHandler = [this](ref_ptr<Animation> animation)
{
if (m_listener)
m_listener->OnAnimationStarted(animation);
};
ScreenBase const & screen = GetCurrentScreen();
drape_ptr<Animation> anim = GetRectAnimation(screen, endScreen);
@ -386,8 +385,18 @@ bool UserEventStream::SetScreen(ScreenBase const & endScreen, bool isAnim)
if (anim != nullptr)
{
anim->SetOnStartAction(onStartHandler);
m_animationSystem.CombineAnimation(move(anim));
if (parallelAnimCreator != nullptr)
{
drape_ptr<ParallelAnimation> parallelAnim = make_unique_dp<ParallelAnimation>();
parallelAnim->SetCustomType(kParallelLinearAnim);
parallelAnim->AddAnimation(parallelAnimCreator(anim->GetDuration()));
parallelAnim->AddAnimation(move(anim));
m_animationSystem.CombineAnimation(move(parallelAnim));
}
else
{
m_animationSystem.CombineAnimation(move(anim));
}
return false;
}
}
@ -397,13 +406,13 @@ bool UserEventStream::SetScreen(ScreenBase const & endScreen, bool isAnim)
return true;
}
bool UserEventStream::SetRect(m2::AnyRectD const & rect, bool isAnim)
bool UserEventStream::SetRect(m2::AnyRectD const & rect, bool isAnim, TAnimationCreator parallelAnimCreator)
{
ScreenBase tmp = GetCurrentScreen();
tmp.SetFromRects(rect, tmp.PixelRectIn3d());
tmp.MatchGandP3d(rect.GlobalCenter(), tmp.PixelRectIn3d().Center());
return SetScreen(tmp, isAnim);
return SetScreen(tmp, isAnim, parallelAnimCreator);
}
bool UserEventStream::InterruptFollowAnimations(bool force)
@ -413,15 +422,16 @@ bool UserEventStream::InterruptFollowAnimations(bool force)
if (followAnim == nullptr)
followAnim = m_animationSystem.FindAnimation<SequenceAnimation>(Animation::Sequence, kPrettyFollowAnim.c_str());
if (followAnim == nullptr)
followAnim = m_animationSystem.FindAnimation<SequenceAnimation>(Animation::Parallel, kParallelFollowAnim.c_str());
if (followAnim == nullptr)
followAnim = m_animationSystem.FindAnimation<SequenceAnimation>(Animation::Parallel, kParallelLinearAnim.c_str());
if (followAnim != nullptr)
{
if (force || followAnim->CouldBeInterrupted())
{
bool const isFollowAnim = followAnim->GetType() == Animation::MapFollow;
ResetAnimations(followAnim->GetType());
if (isFollowAnim)
ResetAnimations(Animation::Arrow);
}
ResetAnimations(followAnim->GetType(), followAnim->GetCustomType());
else
{
return false;
@ -432,7 +442,7 @@ bool UserEventStream::InterruptFollowAnimations(bool force)
bool UserEventStream::SetFollowAndRotate(m2::PointD const & userPos, m2::PointD const & pixelPos,
double azimuth, int preferredZoomLevel, double autoScale,
bool isAnim, bool isAutoScale)
bool isAnim, bool isAutoScale, TAnimationCreator parallelAnimCreator)
{
// Reset current follow-and-rotate animation if possible.
if (isAnim && !InterruptFollowAnimations(false /* force */))
@ -456,12 +466,6 @@ bool UserEventStream::SetFollowAndRotate(m2::PointD const & userPos, m2::PointD
if (isAnim)
{
auto onStartHandler = [this](ref_ptr<Animation> animation)
{
if (m_listener)
m_listener->OnAnimationStarted(animation);
};
drape_ptr<Animation> anim;
double const moveDuration = PositionInterpolator::GetMoveDuration(currentScreen.GetOrg(), screen.GetOrg(),
currentScreen.PixelRectIn3d(),
@ -483,8 +487,18 @@ bool UserEventStream::SetFollowAndRotate(m2::PointD const & userPos, m2::PointD
anim->SetCouldBeBlended(false);
}
anim->SetOnStartAction(onStartHandler);
m_animationSystem.CombineAnimation(move(anim));
if (parallelAnimCreator != nullptr)
{
drape_ptr<ParallelAnimation> parallelAnim = make_unique_dp<ParallelAnimation>();
parallelAnim->SetCustomType(kParallelFollowAnim);
parallelAnim->AddAnimation(parallelAnimCreator(anim->GetDuration()));
parallelAnim->AddAnimation(move(anim));
m_animationSystem.CombineAnimation(move(parallelAnim));
}
else
{
m_animationSystem.CombineAnimation(move(anim));
}
return false;
}

42
drape_frontend/user_event_stream.hpp
View file

@ -23,6 +23,8 @@ namespace df
int const kDoNotChangeZoom = -1;
double const kDoNotAutoZoom = -1.0;
using TAnimationCreator = function<drape_ptr<Animation>(double)>;
class UserEvent
{
public:
@ -134,10 +136,12 @@ private:
class SetCenterEvent : public UserEvent
{
public:
SetCenterEvent(m2::PointD const & center, int zoom, bool isAnim)
SetCenterEvent(m2::PointD const & center, int zoom, bool isAnim,
TAnimationCreator parallelAnimCreator = nullptr)
: m_center(center)
, m_zoom(zoom)
, m_isAnim(isAnim)
, m_parallelAnimCreator(parallelAnimCreator)
{
}
@ -146,21 +150,25 @@ public:
m2::PointD const & GetCenter() const { return m_center; }
int GetZoom() const { return m_zoom; }
bool IsAnim() const { return m_isAnim; }
TAnimationCreator const & GetParallelAnimCreator() const { return m_parallelAnimCreator; }
private:
m2::PointD m_center; // center point in mercator
int m_zoom; // if zoom == -1, then zoom level will'n change
bool m_isAnim;
TAnimationCreator m_parallelAnimCreator;
};
class SetRectEvent : public UserEvent
{
public:
SetRectEvent(m2::RectD const & rect, bool rotate, int zoom, bool isAnim)
SetRectEvent(m2::RectD const & rect, bool rotate, int zoom, bool isAnim,
TAnimationCreator parallelAnimCreator = nullptr)
: m_rect(rect)
, m_applyRotation(rotate)
, m_zoom(zoom)
, m_isAnim(isAnim)
, m_parallelAnimCreator(parallelAnimCreator)
{
}
@ -170,12 +178,14 @@ public:
bool GetApplyRotation() const { return m_applyRotation; }
int GetZoom() const { return m_zoom; }
bool IsAnim() const { return m_isAnim; }
TAnimationCreator const & GetParallelAnimCreator() const { return m_parallelAnimCreator; }
private:
m2::RectD m_rect; // destination mercator rect
bool m_applyRotation; // if true, current rotation will be apply to m_rect
int m_zoom; // if zoom == -1, then zoom level will'n change
bool m_isAnim;
TAnimationCreator m_parallelAnimCreator;
};
class SetAnyRectEvent : public UserEvent
@ -200,7 +210,7 @@ class FollowAndRotateEvent : public UserEvent
{
public:
FollowAndRotateEvent(m2::PointD const & userPos, m2::PointD const & pixelZero,
double azimuth, double autoScale)
double azimuth, double autoScale, TAnimationCreator parallelAnimCreator = nullptr)
: m_userPos(userPos)
, m_pixelZero(pixelZero)
, m_azimuth(azimuth)
@ -208,12 +218,13 @@ public:
, m_autoScale(autoScale)
, m_isAutoScale(true)
, m_isAnim(true)
, m_parallelAnimCreator(parallelAnimCreator)
{
}
FollowAndRotateEvent(m2::PointD const & userPos, m2::PointD const & pixelZero,
double azimuth, int preferredZoomLevel,
bool isAnim)
bool isAnim, TAnimationCreator parallelAnimCreator = nullptr)
: m_userPos(userPos)
, m_pixelZero(pixelZero)
, m_azimuth(azimuth)
@ -221,6 +232,7 @@ public:
, m_autoScale(kDoNotAutoZoom)
, m_isAutoScale(false)
, m_isAnim(isAnim)
, m_parallelAnimCreator(parallelAnimCreator)
{}
EEventType GetType() const override { return UserEvent::FollowAndRotate; }
@ -232,6 +244,7 @@ public:
double GetAutoScale() const { return m_autoScale; }
bool IsAutoScale() const { return m_isAutoScale; }
bool IsAnim() const { return m_isAnim; }
TAnimationCreator const & GetParallelAnimCreator() const { return m_parallelAnimCreator; }
private:
m2::PointD m_userPos;
@ -241,6 +254,7 @@ private:
double m_autoScale;
bool m_isAutoScale;
bool m_isAnim;
TAnimationCreator m_parallelAnimCreator;
};
class SetAutoPerspectiveEvent : public UserEvent
@ -261,16 +275,19 @@ private:
class RotateEvent : public UserEvent
{
public:
RotateEvent(double targetAzimut)
RotateEvent(double targetAzimut, TAnimationCreator parallelAnimCreator = nullptr)
: m_targetAzimut(targetAzimut)
, m_parallelAnimCreator(parallelAnimCreator)
{}
EEventType GetType() const override { return UserEvent::Rotate; }
double GetTargetAzimuth() const { return m_targetAzimut; }
TAnimationCreator const & GetParallelAnimCreator() const { return m_parallelAnimCreator; }
private:
double m_targetAzimut;
TAnimationCreator m_parallelAnimCreator;
};
class ResizeEvent : public UserEvent
@ -357,13 +374,18 @@ public:
private:
bool SetScale(m2::PointD const & pxScaleCenter, double factor, bool isAnim);
bool SetCenter(m2::PointD const & center, int zoom, bool isAnim);
bool SetRect(m2::RectD rect, int zoom, bool applyRotation, bool isAnim);
bool SetRect(m2::AnyRectD const & rect, bool isAnim);
bool SetScreen(ScreenBase const & screen, bool isAnim);
bool SetCenter(m2::PointD const & center, int zoom, bool isAnim,
TAnimationCreator parallelAnimCreator = nullptr);
bool SetRect(m2::RectD rect, int zoom, bool applyRotation, bool isAnim,
TAnimationCreator parallelAnimCreator = nullptr);
bool SetRect(m2::AnyRectD const & rect, bool isAnim,
TAnimationCreator parallelAnimCreator = nullptr);
bool SetScreen(ScreenBase const & screen, bool isAnim,
TAnimationCreator parallelAnimCreator = nullptr);
bool SetFollowAndRotate(m2::PointD const & userPos, m2::PointD const & pixelPos,
double azimuth, int preferredZoomLevel, double autoScale,
bool isAnim, bool isAutoScale);
bool isAnim, bool isAutoScale,
TAnimationCreator parallelAnimCreator = nullptr);
void SetAutoPerspective(bool isAutoPerspective);
m2::AnyRectD GetCurrentRect() const;