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

[core] restore old logic for follow mode in routing

Browse source
This commit is contained in:
ExMix 2014-10-03 19:59:24 +03:00 • committed by Alex Zolotarev
parent 8e7b437136
commit 75b67819ba
6 changed files with 95 additions and 115 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
map/framework.cpp
View file

@ -962,6 +962,7 @@ void Framework::StartRotate(RotateEvent const & e)
{
m_navigator.StartRotate(e.Angle(), ElapsedSeconds());
m_renderPolicy->StartRotate(e.Angle(), ElapsedSeconds());
GetLocationState()->ScaleStarted();
}
}
@ -980,6 +981,7 @@ void Framework::StopRotate(RotateEvent const & e)
{
m_navigator.StopRotate(e.Angle(), ElapsedSeconds());
GetLocationState()->Rotated();
GetLocationState()->ScaleEnded();
m_renderPolicy->StopRotate(e.Angle(), ElapsedSeconds());
UpdateUserViewportChanged();
@ -999,7 +1001,7 @@ void Framework::Move(double azDir, double factor)
void Framework::ScaleToPoint(ScaleToPointEvent const & e)
{
m2::PointD pt = m_navigator.ShiftPoint(e.Pt());
m_informationDisplay.locationState()->ScaleCorrection(pt);
GetLocationState()->ScaleCorrection(pt);
m_animController->AddTask(m_navigator.ScaleToPointAnim(pt, e.ScaleFactor(), 0.25));
@ -1014,7 +1016,9 @@ void Framework::ScaleDefault(bool enlarge)
void Framework::Scale(double scale)
{
m_animController->AddTask(m_navigator.ScaleAnim(scale));
m2::PointD center = GetPixelCenter();
GetLocationState()->ScaleCorrection(center);
m_animController->AddTask(m_navigator.ScaleToPointAnim(center, scale, 0.25));
Invalidate();
UpdateUserViewportChanged();
@ -1036,8 +1040,7 @@ void Framework::CalcScalePoints(ScaleEvent const & e, m2::PointD & pt1, m2::Poin
bool Framework::CanRotate() const
{
return m_renderPolicy &&
m_renderPolicy->DoSupportRotation() &&
GetLocationState()->IsRotationAllowed();
m_renderPolicy->DoSupportRotation();
}
void Framework::StartScale(ScaleEvent const & e)
@ -1045,7 +1048,8 @@ void Framework::StartScale(ScaleEvent const & e)
m2::PointD pt1, pt2;
CalcScalePoints(e, pt1, pt2);
m_navigator.StartScale(pt1, pt2, ElapsedSeconds(), GetLocationState()->IsRotationAllowed());
GetLocationState()->ScaleStarted();
m_navigator.StartScale(pt1, pt2, ElapsedSeconds());
if (m_renderPolicy)
m_renderPolicy->StartScale();
}
@ -1075,6 +1079,8 @@ void Framework::StopScale(ScaleEvent const & e)
m_renderPolicy->StopScale();
UpdateUserViewportChanged();
}
GetLocationState()->ScaleEnded();
}
//@}

170
map/location_state.cpp
View file

@ -62,13 +62,15 @@ class RotateAndFollowAnim : public anim::Task
{
public:
RotateAndFollowAnim(Framework * fw, m2::PointD const & srcPos,
double srcAngle, m2::PointD const & srcPixelBinding)
double srcAngle,
m2::PointD const & srcPixelBinding,
m2::PointD const & dstPixelbinding)
: m_fw(fw)
{
m_angleAnim.reset(new anim::SafeAngleInterpolation(srcAngle, srcAngle, 1.0));
m_posAnim.reset(new anim::SafeSegmentInterpolation(srcPos, srcPos, 1.0));
m2::PointD invertedPxBinding(InvertPxBinding(srcPixelBinding));
m_pxBindingAnim.reset(new anim::SafeSegmentInterpolation(invertedPxBinding, invertedPxBinding, 1.0));
m_pxBindingAnim.reset(new anim::SafeSegmentInterpolation(InvertPxBinding(srcPixelBinding),
InvertPxBinding(dstPixelbinding), 1.0));
}
void SetDestinationParams(m2::PointD const & dstPos, double dstAngle)
@ -87,12 +89,6 @@ public:
m_posAnim->ResetDestParams(dstPos, posSpeed);
}
void SetDestinationPxBinding(m2::PointD const & pxBinding)
{
ASSERT(m_pxBindingAnim != nullptr, ());
m_pxBindingAnim->ResetDestParams(InvertPxBinding(pxBinding), 0.5);
}
virtual void OnStep(double ts)
{
ASSERT(m_angleAnim != nullptr, ());
@ -119,6 +115,12 @@ public:
m_pxBindingAnim->IsRunning();
}
void SetPxBinding(m2::PointD const & pt)
{
m_pxBindingAnim->Reset(pt, pt, 0.1);
UpdateViewport();
}
private:
void UpdateViewport()
{
@ -173,6 +175,7 @@ private:
return false;
}
private:
m2::PointD InvertPxBinding(m2::PointD const & px) const
{
m2::RectD const & pixelRect = m_fw->GetNavigator().Screen().PixelRect();
@ -196,7 +199,7 @@ State::Params::Params()
State::State(Params const & p)
: TBase(p),
m_modeInfo(UnknownPosition),
m_modeInfo(Follow),
m_errorRadius(0),
m_position(0, 0),
m_drawDirection(0.0),
@ -246,13 +249,11 @@ void State::SwitchToNextMode()
newMode = PendingPosition;
break;
case PendingPosition:
{
newMode = UnknownPosition;
m_afterPendingMode = Follow;
break;
}
newMode = UnknownPosition;
m_afterPendingMode = Follow;
break;
case NotFollow:
newMode = Follow;
newMode = Follow;
break;
case Follow:
if (IsRotationActive())
@ -275,8 +276,6 @@ void State::SwitchToNextMode()
newMode = IsRotationActive() ? RotateAndFollow : Follow;
SetModeInfo(ChangeMode(m_modeInfo, newMode));
if (newMode > NotFollow)
SetCurrentPixelBinding(GetModeDefaultPixelBinding(newMode));
}
void State::StartRoutingMode()
@ -285,17 +284,16 @@ void State::StartRoutingMode()
ASSERT(IsModeHasPosition(), ());
State::Mode newMode = IsRotationActive() ? RotateAndFollow : Follow;
SetModeInfo(ChangeMode(IncludeModeBit(m_modeInfo, RoutingSessionBit), newMode));
SetCurrentPixelBinding(GetModeDefaultPixelBinding(GetMode()));
}
void State::StopRoutingMode()
{
SetModeInfo(ExcludeModeBit(m_modeInfo, RoutingSessionBit));
SetCurrentPixelBinding(GetModeDefaultPixelBinding(GetMode()));
}
void State::TurnOff()
{
StopLocationFollow();
SetModeInfo(UnknownPosition);
setIsVisible(false);
invalidate();
@ -313,10 +311,7 @@ void State::OnLocationUpdate(location::GpsInfo const & info)
setIsVisible(true);
if (GetMode() == PendingPosition)
{
SetModeInfo(ChangeMode(m_modeInfo, m_afterPendingMode));
SetCurrentPixelBinding(GetModeDefaultPixelBinding(m_afterPendingMode));
}
else
AnimateFollow();
@ -374,7 +369,12 @@ void State::RemovePositionChangedListener(int slotID)
void State::InvalidatePosition()
{
m_afterPendingMode = GetMode();
SetModeInfo(ChangeMode(m_modeInfo, PendingPosition));
if (m_afterPendingMode != UnknownPosition)
{
SetModeInfo(ChangeMode(m_modeInfo, UnknownPosition));
SetModeInfo(ChangeMode(m_modeInfo, PendingPosition));
}
setIsVisible(false);
invalidate();
}
@ -535,7 +535,7 @@ void State::CacheArrow(graphics::DisplayList * dl, const string & iconName)
bool State::IsRotationActive() const
{
return m_framework->GetNavigator().DoSupportRotation() && IsDirectionKnown();
return m_framework->GetNavigator().DoSupportRotation() && TestModeBit(m_modeInfo, KnownDirectionBit);
}
bool State::IsDirectionKnown() const
@ -548,21 +548,6 @@ bool State::IsInRouting() const
return TestModeBit(m_modeInfo, RoutingSessionBit);
}
m2::PointD const & State::GetCurrentPixelBinding() const
{
return m_dstPixelBinding;
}
void State::SetCurrentPixelBinding(m2::PointD const & pxBinding)
{
m_dstPixelBinding = pxBinding;
if (m_animTask)
{
RotateAndFollowAnim * anim = static_cast<RotateAndFollowAnim *>(m_animTask.get());
anim->SetDestinationPxBinding(pxBinding);
}
}
m2::PointD const State::GetModeDefaultPixelBinding(State::Mode mode) const
{
switch (mode)
@ -580,15 +565,21 @@ bool State::FollowCompass()
RotateAndFollowAnim * task = static_cast<RotateAndFollowAnim *>(m_animTask.get());
task->SetDestinationParams(Position(), -m_drawDirection);
return true;
return true;
}
void State::CreateAnimTask()
{
CreateAnimTask(m_framework->GtoP(Position()),
GetModeDefaultPixelBinding(GetMode()));
}
void State::CreateAnimTask(const m2::PointD & srcPx, const m2::PointD & dstPx)
{
EndAnimation();
m_animTask.reset(new RotateAndFollowAnim(m_framework, Position(),
m_framework->GetNavigator().Screen().GetAngle(),
GetCurrentPixelBinding()));
srcPx, dstPx));
m_framework->GetAnimController()->AddTask(m_animTask);
}
@ -614,6 +605,14 @@ void State::SetModeInfo(uint16_t modeInfo)
}
}
void State::StopAllAnimations()
{
EndAnimation();
m_framework->GetAnimator().StopRotation();
m_framework->GetAnimator().StopChangeViewport();
m_framework->GetAnimator().StopMoveScreen();
}
m2::PointD const State::GetRaFModeDefaultPxBind() const
{
m2::RectD const & pixelRect = m_framework->GetNavigator().Screen().PixelRect();
@ -621,19 +620,13 @@ m2::PointD const State::GetRaFModeDefaultPxBind() const
pixelRect.maxY() - POSITION_Y_OFFSET * visualScale());
}
void State::StopCompassFollowing(Mode mode, bool resetPxBinding)
void State::StopCompassFollowing()
{
if (GetMode() != RotateAndFollow)
return;
EndAnimation();
SetModeInfo(ChangeMode(m_modeInfo, mode));
if (resetPxBinding)
SetCurrentPixelBinding(GetModeDefaultPixelBinding(GetMode()));
m_framework->GetAnimator().StopRotation();
m_framework->GetAnimator().StopChangeViewport();
m_framework->GetAnimator().StopMoveScreen();
StopAllAnimations();
SetModeInfo(ChangeMode(m_modeInfo, Follow));
}
void State::StopLocationFollow()
@ -641,8 +634,8 @@ void State::StopLocationFollow()
StopCompassFollowing();
if (GetMode() > NotFollow)
{
StopAllAnimations();
SetModeInfo(ChangeMode(m_modeInfo, NotFollow));
SetCurrentPixelBinding(GetModeDefaultPixelBinding(GetMode()));
}
}
@ -650,86 +643,70 @@ void State::DragStarted()
{
m_dragModeInfo = m_modeInfo;
m_afterPendingMode = NotFollow;
StopLocationFollow();
}
void State::Draged()
{
if (!IsModeChangeViewport())
return;
StopCompassFollowing(NotFollow, false);
SetModeInfo(ChangeMode(m_modeInfo, NotFollow));
}
void State::Draged(){}
void State::DragEnded()
{
// reset GPS centering mode if we have dragged far from current location
ScreenBase const & s = m_framework->GetNavigator().Screen();
m2::PointD const pxBinding = GetCurrentPixelBinding();
m2::PointD const defaultPxBinding = GetModeDefaultPixelBinding(ExcludeAllBits(m_dragModeInfo));
m2::PointD const pxPosition = s.GtoP(Position());
SetCurrentPixelBinding(pxPosition);
if (ExcludeAllBits(m_dragModeInfo) > NotFollow &&
pxBinding == defaultPxBinding &&
pxBinding.Length(pxPosition) < s.GetMinPixelRectSize() / 5.0)
defaultPxBinding.Length(pxPosition) < s.GetMinPixelRectSize() / 5.0)
{
SetModeInfo(m_dragModeInfo);
SetCurrentPixelBinding(pxBinding);
}
else if (IsInRouting() && s.PixelRect().IsPointInside(pxPosition))
{
SetModeInfo(ChangeMode(m_modeInfo, IsRotationActive() ? RotateAndFollow : Follow));
}
m_dragModeInfo = 0;
}
void State::ScaleStarted()
{
m_scaleModeInfo = m_modeInfo;
}
void State::ScaleCorrection(m2::PointD & pt)
{
if (GetMode() == Follow)
pt = m_framework->GetPixelCenter();
if (IsModeChangeViewport() || ExcludeAllBits(m_scaleModeInfo) > NotFollow)
pt = m_framework->GtoP(Position());
}
void State::ScaleCorrection(m2::PointD & pt1, m2::PointD & pt2)
{
if (GetMode() == Follow)
if (IsModeChangeViewport() || ExcludeAllBits(m_scaleModeInfo) > NotFollow)
{
m2::PointD const ptC = (pt1 + pt2) / 2;
m2::PointD const ptDiff = m_framework->GetPixelCenter() - ptC;
m2::PointD const ptDiff = m_framework->GtoP(Position()) - ptC;
pt1 += ptDiff;
pt2 += ptDiff;
}
}
bool State::IsRotationAllowed() const
void State::ScaleEnded()
{
return !(IsInRouting() && GetMode() == RotateAndFollow);
m_scaleModeInfo = 0;
}
void State::Rotated()
{
m_afterPendingMode = NotFollow;
ASSERT(IsRotationAllowed(), ());
StopCompassFollowing(NotFollow);
EndAnimation();
if (GetMode() == RotateAndFollow)
SetModeInfo(ChangeMode(m_modeInfo, NotFollow));
}
void State::OnSize(m2::RectD const & oldPixelRect)
void State::OnSize(m2::RectD const & /*oldPixelRect*/)
{
if (!IsModeChangeViewport())
return;
m2::PointD const & currentPxOffset = GetCurrentPixelBinding() - oldPixelRect.Center();
double oldHalfW = oldPixelRect.SizeX() / 2.0;
double oldHalfH = oldPixelRect.SizeY() / 2.0;
double wPart = currentPxOffset.x / oldHalfW;
double hPart = currentPxOffset.y / oldHalfH;
m2::RectD const & newPixelRect = m_framework->GetNavigator().Screen().PixelRect();
m2::PointD const newCenter = newPixelRect.Center();
double newHalfW = newPixelRect.SizeX() / 2.0;
double newHalfH = newPixelRect.SizeY() / 2.0;
SetCurrentPixelBinding(newCenter + m2::PointD(wPart * newHalfW, hPart * newHalfH));
if (GetMode() == RotateAndFollow)
{
EndAnimation();
m2::PointD pxBind = GetModeDefaultPixelBinding(GetMode());
CreateAnimTask(m_framework->GtoP(Position()), pxBind);
}
}
namespace
@ -778,10 +755,7 @@ void State::AnimateStateTransition(Mode oldMode, Mode newMode)
{
ASSERT(ValidateTransition(oldMode, newMode), ("from", oldMode, "to", newMode));
if (oldMode == RotateAndFollow)
EndAnimation();
if (oldMode == Follow)
m_framework->GetAnimator().StopMoveScreen();
StopAllAnimations();
if (oldMode == PendingPosition && newMode == Follow)
{

16
map/location_state.hpp
View file

@ -71,7 +71,7 @@ namespace location
void InvalidatePosition();
void TurnOff();
void StopCompassFollowing(Mode mode = Follow, bool resetPxBinding = true);
void StopCompassFollowing();
void StopLocationFollow();
/// @name User input notification block
@ -80,10 +80,11 @@ namespace location
void Draged();
void DragEnded();
void ScaleStarted();
void ScaleCorrection(m2::PointD & pt);
void ScaleCorrection(m2::PointD & pt1, m2::PointD & pt2);
void ScaleEnded();
bool IsRotationAllowed() const;
void Rotated();
//@}
@ -124,13 +125,12 @@ namespace location
bool IsDirectionKnown() const;
bool IsInRouting() const;
m2::PointD const & GetCurrentPixelBinding() const;
void SetCurrentPixelBinding(m2::PointD const & pxBinding);
m2::PointD const GetModeDefaultPixelBinding(Mode mode) const;
m2::PointD const GetRaFModeDefaultPxBind() const;
void SetModeInfo(uint16_t modeInfo);
m2::PointD const GetRaFModeDefaultPxBind() const;
void StopAllAnimations();
private:
// Mode bits
@ -141,7 +141,8 @@ namespace location
static uint16_t const s_cacheRadius = 500.0f;
uint16_t m_modeInfo; // combination of Mode enum and "Mode bits"
uint16_t m_dragModeInfo;
uint16_t m_dragModeInfo = 0;
uint16_t m_scaleModeInfo = 0;
Framework * m_framework;
double m_errorRadius; //< error radius in mercator
@ -149,8 +150,6 @@ namespace location
double m_drawDirection;
Mode m_afterPendingMode;
m2::PointD m_dstPixelBinding;
typedef map<int, TStateModeListener> TModeListeners;
typedef map<int, TPositionListener> TPositionListeners;
@ -172,6 +171,7 @@ namespace location
shared_ptr<anim::Task> m_animTask;
bool FollowCompass();
void CreateAnimTask();
void CreateAnimTask(m2::PointD const & srcPx, m2::PointD const & dstPx);
void EndAnimation();
//@}
};

2
map/map_tests/navigator_test.cpp
View file

@ -40,7 +40,7 @@ UNIT_TEST(Navigator_Scale2Points)
TEST_EQUAL(screen.ClipRect(), m2::RectD(0, 0, 8, 4), ());
navigator.StartScale(screen.GtoP(m2::PointD(1, 1)),
screen.GtoP(m2::PointD(7, 1)), 0, true);
screen.GtoP(m2::PointD(7, 1)), 0);
navigator.StopScale(screen.GtoP(m2::PointD(1, 1)),
screen.GtoP(m2::PointD(4, 1)), 1);
TEST_EQUAL(screen.ClipRect(), m2::RectD(-1, -1, 15, 7), ());

4
map/navigator.cpp
View file

@ -385,13 +385,13 @@ bool Navigator::InAction() const
return m_InAction;
}
void Navigator::StartScale(m2::PointD const & pt1, m2::PointD const & pt2, double /*timeInSec*/, bool isRotationAllowed)
void Navigator::StartScale(m2::PointD const & pt1, m2::PointD const & pt2, double /*timeInSec*/)
{
m_StartScreen = m_Screen;
m_StartPt1 = m_LastPt1 = pt1;
m_StartPt2 = m_LastPt2 = pt2;
m_DoCheckRotationThreshold = m_DoSupportRotation && isRotationAllowed;
m_DoCheckRotationThreshold = m_DoSupportRotation;
m_IsRotatingDuringScale = false;
m_InAction = true;
}

2
map/navigator.hpp
View file

@ -47,7 +47,7 @@ public:
void DoRotate(double Angle, double timeInSec);
void StopRotate(double Angle, double timeInSec);
void StartScale(m2::PointD const & pt1, m2::PointD const & pt2, double timeInSec, bool isRotationAllowed);
void StartScale(m2::PointD const & pt1, m2::PointD const & pt2, double timeInSec);
void DoScale(m2::PointD const & org, m2::PointD const & p1, m2::PointD const & p2);
void DoScale(m2::PointD const & pt1, m2::PointD const & pt2, double timeInSec);
void StopScale(m2::PointD const & pt1, m2::PointD const & pt2, double timeInSec);