*
*/
-// INTERNAL INCLUDES
+// CLASS HEADER
+#include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.h>
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/animation/constraints.h>
+#include <dali/public-api/common/stage.h>
#include <dali/public-api/events/mouse-wheel-event.h>
+#include <dali/public-api/events/touch-event.h>
+#include <dali/public-api/object/type-registry.h>
+#include <dali/integration-api/debug.h>
+// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-constraints.h>
#include <dali-toolkit/public-api/controls/scrollable/scroll-component-impl.h>
-#include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.h>
#include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-effect-impl.h>
#include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-overshoot-indicator-impl.h>
-#include <dali/integration-api/debug.h>
//#define ENABLED_SCROLL_STATE_LOGGING
#endif
// TODO: Change to two class system:
-// 1. DraggableActor (is an actor which can be dragged anywhere/scaled/rotated, can be set to range using the ruler)
+// 1. DraggableActor (is an actor which can be dragged anywhere, can be set to range using the ruler)
// 2. ScrollView (contains a draggable actor that can a) be dragged in the negative X, and Y domain, b) has a hitArea for touches)
-// TODO: Rotation
-// TODO: Asymetrical scaling
// TODO: external components (page and status overlays).
// TODO: Orientation.
// TODO: upgrade Vector2/3 to support returning Unit vectors, normals, & cross product (dot product is already provided)
{
const int DEFAULT_REFRESH_INTERVAL_MILLISECONDS = 50; ///< Refresh rate TODO: Animation should have an update signal (and see item-view-impl)
-const float FLICK_SPEED_THRESHOLD = 500.0f; ///< Flick threshold in pixels/ms
+const Vector2 DEFAULT_MIN_FLICK_DISTANCE(30.0f, 30.0f); ///< minimum distance for pan before flick allowed
+const float DEFAULT_MIN_FLICK_SPEED_THRESHOLD(500.0f); ///< Minimum pan speed required for flick in pixels/s
const float FREE_FLICK_SPEED_THRESHOLD = 200.0f; ///< Free-Flick threshold in pixels/ms
const float AUTOLOCK_AXIS_MINIMUM_DISTANCE2 = 100.0f; ///< Auto-lock axis after minimum distance squared.
const float FLICK_ORTHO_ANGLE_RANGE = 75.0f; ///< degrees. (if >45, then supports diagonal flicking)
const unsigned int MAXIMUM_NUMBER_OF_VALUES = 5; ///< Number of values to use for weighted pan calculation.
const Vector2 DEFAULT_MOUSE_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION = Vector2(0.17f, 0.1f); ///< The step of horizontal scroll distance in the proportion of stage size for each mouse wheel event received.
const unsigned long MINIMUM_TIME_BETWEEN_DOWN_AND_UP_FOR_RESET( 150u );
-const float DEFAULT_OVERSHOOT_ANIMATION_DURATION = 0.35f; // time in seconds
-const Vector2 OVERSCROLL_CLAMP(1.0f, 1.0f); // maximum overscroll allowed in pixels when overshoot indicator is being used
const float TOUCH_DOWN_TIMER_INTERVAL = 100.0f;
const float DEFAULT_SCROLL_UPDATE_DISTANCE( 30.0f ); ///< Default distance to travel in pixels for scroll update signal
// Helpers ////////////////////////////////////////////////////////////////////////////////////////
-// TODO: GetAngle for Vector2 can be moved.
-// GetAngle for Vector3 needs to be measured against a normal/plane.
-
-/**
- * @param[in] vector The 3D vector to be measured
- * @return angle in radians from 0 to 2PI
- */
-float GetAngle(const Vector3& vector)
-{
- return atan2(vector.y, vector.x) + Math::PI;
-}
-
-/**
- * @param[in] vector The 2D vector to be measured
- * @return angle in radians from 0 to 2PI
- */
-float GetAngle(const Vector2& vector)
-{
- return atan2(vector.y, vector.x) + Math::PI;
-}
-
/**
* Find the vector (distance) from (a) to (b)
* in domain (start) to (end)
* Generates position property based on current position + gesture displacement.
* Or generates position property based on positionX/Y.
* Note: This is the position prior to any clamping at scroll boundaries.
- * TODO: Scale & Rotation Transforms.
*/
struct InternalPrePositionConstraint
{
- InternalPrePositionConstraint(const Vector2& initialPanMask,
+ InternalPrePositionConstraint(const Vector2& initialPanPosition,
+ const Vector2& initialPanMask,
bool axisAutoLock,
float axisAutoLockGradient,
ScrollView::LockAxis initialLockAxis,
const Vector2& maxOvershoot,
const RulerDomain& domainX, const RulerDomain& domainY)
- : mInitialPanMask(initialPanMask),
+ : mLocalStart(initialPanPosition),
+ mInitialPanMask(initialPanMask),
mDomainMin( -domainX.min, -domainY.min ),
mDomainMax( -domainX.max, -domainY.max ),
mMaxOvershoot(maxOvershoot),
Vector3 operator()(const Vector3& current,
const PropertyInput& gesturePositionProperty,
- const PropertyInput& gestureDisplacementProperty,
const PropertyInput& sizeProperty)
{
Vector3 scrollPostPosition = current;
if(!mWasPanning)
{
- mLocalStart = gesturePositionProperty.GetVector2() - gestureDisplacementProperty.GetVector2();
mPrePosition = current;
mCurrentPanMask = mInitialPanMask;
mWasPanning = true;
};
/**
- * When panning, this constraint updates the X property, otherwise
- * it has no effect on the X property.
- */
-float InternalXConstraint(const float& current,
- const PropertyInput& scrollPosition)
-{
- return scrollPosition.GetVector3().x;
-}
-
-/**
- * When panning, this constraint updates the Y property, otherwise
- * it has no effect on the Y property.
- */
-float InternalYConstraint(const float& current,
- const PropertyInput& scrollPosition)
-{
- return scrollPosition.GetVector3().y;
-}
-
-/**
* Internal Position-Delta Property Constraint.
*
* Generates position-delta property based on scroll-position + scroll-offset properties.
: ScrollBase(),
mTouchDownTime(0u),
mGestureStackDepth(0),
- mRotationDelta(0.0f),
mScrollStateFlags(0),
- mScrollPreRotation(0.0f),
- mScrollPostRotation(0.0f),
mMinTouchesForPanning(1),
mMaxTouchesForPanning(1),
mLockAxis(LockPossible),
mSnapOvershootAlphaFunction(AlphaFunctions::EaseOut),
mSnapDuration(Toolkit::ScrollView::DEFAULT_SLOW_SNAP_ANIMATION_DURATION),
mSnapAlphaFunction(AlphaFunctions::EaseOut),
+ mMinFlickDistance(DEFAULT_MIN_FLICK_DISTANCE),
+ mFlickSpeedThreshold(DEFAULT_MIN_FLICK_SPEED_THRESHOLD),
mFlickDuration(Toolkit::ScrollView::DEFAULT_FAST_SNAP_ANIMATION_DURATION),
mFlickAlphaFunction(AlphaFunctions::EaseOut),
mAxisAutoLockGradient(Toolkit::ScrollView::DEFAULT_AXIS_AUTO_LOCK_GRADIENT),
RegisterProperties();
mScrollPostPosition = mScrollPrePosition = Vector3::ZERO;
- mScrollPostScale = mScrollPreScale = Vector3::ONE;
- mScrollPostRotation = mScrollPreRotation = 0.0f;
mMouseWheelScrollDistanceStep = Stage::GetCurrent().GetSize() * DEFAULT_MOUSE_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION;
// By default we'll allow the user to freely drag the scroll view,
// while disabling the other rulers.
RulerPtr ruler = new DefaultRuler();
- RulerPtr rulerDisabled = new DefaultRuler();
- rulerDisabled->Disable();
mRulerX = ruler;
mRulerY = ruler;
- mRulerScaleX = rulerDisabled;
- mRulerScaleY = rulerDisabled;
- mRulerRotation = rulerDisabled;
EnableScrollComponent(Toolkit::Scrollable::OvershootIndicator);
domainChanged = true;
min.y = 0.0f;
max.y = 0.0f;
- canScrollHorizontal = false;
+ canScrollVertical = false;
}
// avoid setting properties if possible, otherwise this will cause an entire update as well as triggering constraints using each property we update
}
}
-void ScrollView::SetRulerScaleX(RulerPtr ruler)
-{
- mRulerScaleX = ruler;
- UpdateMainInternalConstraint();
-}
-
-void ScrollView::SetRulerScaleY(RulerPtr ruler)
-{
- mRulerScaleY = ruler;
- UpdateMainInternalConstraint();
-}
-
-void ScrollView::SetRulerRotation(RulerPtr ruler)
-{
- mRulerRotation = ruler;
- UpdateMainInternalConstraint();
-}
-
void ScrollView::SetScrollSensitive(bool sensitive)
{
Actor self = Self();
Self().SetProperty(mPropertyWrap, enable);
}
-int ScrollView::GetRefreshInterval() const
-{
- return mScrollUpdateDistance;
-}
-
-void ScrollView::SetRefreshInterval(int milliseconds)
-{
- mScrollUpdateDistance = milliseconds;
-}
-
int ScrollView::GetScrollUpdateDistance() const
{
return mScrollUpdateDistance;
mFlickSpeedCoefficient = speed;
}
+Vector2 ScrollView::GetMinimumDistanceForFlick() const
+{
+ return mMinFlickDistance;
+}
+
+void ScrollView::SetMinimumDistanceForFlick( const Vector2& distance )
+{
+ mMinFlickDistance = distance;
+}
+
+float ScrollView::GetMinimumSpeedForFlick() const
+{
+ return mFlickSpeedThreshold;
+}
+
+void ScrollView::SetMinimumSpeedForFlick( float speed )
+{
+ mFlickSpeedThreshold = speed;
+}
+
float ScrollView::GetMaxFlickSpeed() const
{
return mMaxFlickSpeed;
mScrollPrePosition = position;
}
-Vector3 ScrollView::GetCurrentScrollScale() const
-{
- // in case animation is currently taking place.
- return GetPropertyScale();
-}
-
Vector3 ScrollView::GetDomainSize() const
{
Vector3 size = Self().GetCurrentSize();
return domainSize;
}
-void ScrollView::TransformTo(const Vector3& position, const Vector3& scale, float rotation,
+void ScrollView::TransformTo(const Vector3& position,
DirectionBias horizontalBias, DirectionBias verticalBias)
{
- TransformTo(position, scale, rotation, mSnapDuration, horizontalBias, verticalBias);
+ TransformTo(position, mSnapDuration, mSnapAlphaFunction, horizontalBias, verticalBias);
}
-void ScrollView::TransformTo(const Vector3& position, const Vector3& scale, float rotation, float duration,
+void ScrollView::TransformTo(const Vector3& position, float duration, AlphaFunction alpha,
DirectionBias horizontalBias, DirectionBias verticalBias)
{
Actor self( Self() );
// Note that Emit() methods are called indirectly e.g. from within ScrollView::AnimateTo()
Toolkit::ScrollView handle( GetOwner() );
- DALI_LOG_SCROLL_STATE("[0x%X] pos[%.2f,%.2f], scale[%.2f,%.2f], rot[%.2f], duration[%.2f] bias[%d, %d]",
- this, position.x, position.y, scale.x, scale.y, rotation, duration, int(horizontalBias), int(verticalBias));
+ DALI_LOG_SCROLL_STATE("[0x%X] pos[%.2f,%.2f], duration[%.2f] bias[%d, %d]",
+ this, position.x, position.y, duration, int(horizontalBias), int(verticalBias));
Vector3 currentScrollPosition = GetCurrentScrollPosition();
self.SetProperty( mPropertyScrollStartPagePosition, currentScrollPosition );
mScrollStartedSignalV2.Emit( currentScrollPosition );
bool animating = AnimateTo(-position,
Vector3::ONE * duration,
- scale,
- Vector3::ONE * duration,
- rotation,
- duration,
- mSnapAlphaFunction,
+ alpha,
true,
horizontalBias,
verticalBias,
ScrollTo(position, duration, DirectionBiasNone, DirectionBiasNone);
}
+void ScrollView::ScrollTo(const Vector3& position, float duration, AlphaFunction alpha)
+{
+ ScrollTo(position, duration, alpha, DirectionBiasNone, DirectionBiasNone);
+}
+
void ScrollView::ScrollTo(const Vector3& position, float duration,
DirectionBias horizontalBias, DirectionBias verticalBias)
{
- DALI_LOG_SCROLL_STATE("[0x%X] position[%.2f, %.2f] duration[%.2f]",
- this, position.x, position.y, duration, int(horizontalBias), int(verticalBias));
+ ScrollTo(position, duration, mSnapAlphaFunction, horizontalBias, verticalBias);
+}
- TransformTo(position, mScrollPostScale, mScrollPostRotation, duration, horizontalBias, verticalBias);
+void ScrollView::ScrollTo(const Vector3& position, float duration, AlphaFunction alpha,
+ DirectionBias horizontalBias, DirectionBias verticalBias)
+{
+ DALI_LOG_SCROLL_STATE("[0x%X] position[%.2f, %.2f] duration[%.2f], bias[%d, %d]", this, position.x, position.y, duration, int(horizontalBias), int(verticalBias));
+ TransformTo(position, duration, alpha, horizontalBias, verticalBias);
}
void ScrollView::ScrollTo(unsigned int page)
return SnapWithVelocity( stationaryVelocity );
}
-void ScrollView::ScaleTo(const Vector3& scale)
-{
- ScaleTo(scale, mSnapDuration);
-}
-
-void ScrollView::ScaleTo(const Vector3& scale, float duration)
-{
- TransformTo(mScrollPostPosition, scale, mScrollPostRotation, duration);
-}
-
-
// TODO: In situations where axes are different (X snap, Y free)
// Each axis should really have their own independent animation (time and equation)
// Consider, X axis snapping to nearest grid point (EaseOut over fixed time)
float speed2 = velocity.LengthSquared();
AlphaFunction alphaFunction = mSnapAlphaFunction;
Vector3 positionDuration = Vector3::ONE * mSnapDuration;
- Vector3 scaleDuration = Vector3::ONE * mSnapDuration;
- float rotationDuration = mSnapDuration;
float biasX = 0.5f;
float biasY = 0.5f;
FindDirection horizontal = None;
// that will be accepted as a general N,E,S,W flick direction.
const float orthoAngleRange = FLICK_ORTHO_ANGLE_RANGE * M_PI / 180.0f;
- const float flickSpeedThreshold2 = FLICK_SPEED_THRESHOLD*FLICK_SPEED_THRESHOLD;
+ const float flickSpeedThreshold2 = mFlickSpeedThreshold * mFlickSpeedThreshold;
Vector3 positionSnap = mScrollPrePosition;
}
positionSnap += clampDelta;
- // Scale Snap ///////////////////////////////////////////////////////////////
- Vector3 scaleSnap = mScrollPostScale;
-
- scaleSnap.x = mRulerScaleX->Snap(scaleSnap.x);
- scaleSnap.y = mRulerScaleY->Snap(scaleSnap.y);
-
- ClampScale(scaleSnap);
-
- // Rotation Snap ////////////////////////////////////////////////////////////
- float rotationSnap = mScrollPostRotation;
- // TODO: implement rotation snap
-
bool animating = AnimateTo(positionSnap, positionDuration,
- scaleSnap, scaleDuration,
- rotationSnap, rotationDuration,
alphaFunction, false,
DirectionBiasNone, DirectionBiasNone,
isFlick || isFreeFlick ? Flick : Snap);
void ScrollView::StopAnimation(void)
{
// Clear Snap animation if exists.
- StopAnimation(mSnapAnimation);
StopAnimation(mInternalXAnimation);
StopAnimation(mInternalYAnimation);
mScrollStateFlags = 0;
}
bool ScrollView::AnimateTo(const Vector3& position, const Vector3& positionDuration,
- const Vector3& scale, const Vector3& scaleDuration,
- float rotation, float rotationDuration,
AlphaFunction alpha, bool findShortcuts,
DirectionBias horizontalBias, DirectionBias verticalBias,
SnapType snapType)
float totalDuration = 0.0f;
bool positionChanged = (mScrollTargetPosition != mScrollPostPosition);
- bool scaleChanged = (scale != mScrollPostScale);
- bool rotationChanged = fabsf(rotation - mScrollPostRotation) > Math::MACHINE_EPSILON_0;
if(positionChanged)
{
positionChanged = true;
}
- if(scaleChanged)
- {
- totalDuration = std::max(totalDuration, scaleDuration.x);
- totalDuration = std::max(totalDuration, scaleDuration.y);
- }
-
- if(rotationChanged)
- {
- totalDuration = std::max(totalDuration, rotationDuration);
- }
StopAnimation();
// Position Delta ///////////////////////////////////////////////////////
DALI_LOG_SCROLL_STATE("[0x%X] mPropertyPrePosition[%.2f, %.2f], mPropertyPosition[%.2f, %.2f]", this, self.GetProperty( mPropertyPrePosition ).Get<Vector3>().x, self.GetProperty( mPropertyPrePosition ).Get<Vector3>().y, self.GetProperty( mPropertyPosition ).Get<Vector3>().x, self.GetProperty( mPropertyPosition ).Get<Vector3>().y );
}
- // Scale Delta ///////////////////////////////////////////////////////
- if(scaleChanged)
- {
- if(totalDuration > Math::MACHINE_EPSILON_1)
- {
- mSnapAnimation = Animation::New(totalDuration);
- mSnapAnimation.FinishedSignal().Connect(this, &ScrollView::OnScrollAnimationFinished);
- // TODO: for non-uniform scaling to different bounds e.g. scaling a square to a 4:3 aspect ratio screen with a velocity
- // the height will hit first, and then the width, so that would require two different animation times just like position.
- mSnapAnimation.AnimateTo( Property(self, mPropertyScale), scale, alpha, TimePeriod(0.0f, scaleDuration.x));
-
- mSnapAnimation.AnimateTo( Property(self, mPropertyTime), totalDuration, AlphaFunctions::Linear );
- mSnapAnimation.Play();
- }
- else
- {
- self.SetProperty(mPropertyScale, scale);
-
- mScrollPreScale = mScrollPostScale = scale;
- }
- }
SetScrollUpdateNotification(true);
// Always send a snap event when AnimateTo is called.
Toolkit::ScrollView::SnapEvent snapEvent;
snapEvent.type = snapType;
snapEvent.position = -mScrollTargetPosition;
- snapEvent.scale = scale;
- snapEvent.rotation = rotation;
snapEvent.duration = totalDuration;
DALI_LOG_SCROLL_STATE("[0x%X] mSnapStartedSignalV2 [%.2f, %.2f]", this, snapEvent.position.x, snapEvent.position.y);
}
if( enabled )
{
- mMaxOvershoot = OVERSCROLL_CLAMP;
mOvershootIndicator->AttachToScrollable(*this);
}
else
return position;
}
-Vector3 ScrollView::GetPropertyScale() const
-{
- return Self().GetProperty<Vector3>(mPropertyScale);
-}
-
void ScrollView::HandleStoppedAnimation()
{
SetScrollUpdateNotification(false);
void ScrollView::OnPropertySet( Property::Index index, Property::Value propertyValue )
{
Actor self = Self();
- if( index == mPropertyX )
- {
- self.GetProperty(mPropertyPrePosition).Get(mScrollPrePosition);
- propertyValue.Get(mScrollPrePosition.x);
- DALI_LOG_SCROLL_STATE("[0x%X] Setting mPropertyPrePosition To[%.2f, %.2f]", this, mScrollPrePosition.x, mScrollPrePosition.y );
- self.SetProperty(mPropertyPrePosition, mScrollPrePosition);
- }
- else if( index == mPropertyY )
- {
- self.GetProperty(mPropertyPrePosition).Get(mScrollPrePosition);
- propertyValue.Get(mScrollPrePosition.y);
- DALI_LOG_SCROLL_STATE("[0x%X] Setting mPropertyPrePosition To[%.2f, %.2f]", this, mScrollPrePosition.x, mScrollPrePosition.y );
- self.SetProperty(mPropertyPrePosition, mScrollPrePosition);
- }
- else if( index == mPropertyPrePosition )
+ if( index == mPropertyPrePosition )
{
DALI_LOG_SCROLL_STATE("[0x%X]: mPropertyPrePosition[%.2f, %.2f]", this, propertyValue.Get<Vector3>().x, propertyValue.Get<Vector3>().y);
propertyValue.Get(mScrollPrePosition);
mScrollStateFlags = 0;
- mScrollPostScale = GetPropertyScale();
-
// Update Actor position with this wrapped value.
- // TODO Rotation
-
- mScrollPreScale = mScrollPostScale;
- mScrollPreRotation = mScrollPostRotation;
}
void ScrollView::FinaliseAnimatedScroll()
// update our local scroll positions
UpdateLocalScrollProperties();
- if( source == mSnapAnimation )
- {
- DALI_LOG_SCROLL_STATE("[0x%X] mSnapAnimation[0x%X]", this, mSnapAnimation.GetObjectPtr() );
-
- // generic snap animation used for scaling and rotation
- mSnapAnimation.Reset();
- }
-
if( source == mInternalXAnimation )
{
DALI_LOG_SCROLL_STATE("[0x%X] mInternalXAnimation[0x%X], expected[%.2f], actual[%.2f], post[%.2f]", this, mInternalXAnimation.GetObjectPtr(), mScrollTargetPosition.x, Self().GetProperty(mPropertyPrePosition).Get<Vector3>().x, mScrollPostPosition.x );
StopTouchDownTimer();
StopAnimation();
mPanDelta = Vector3::ZERO;
- mScaleDelta = Vector3::ONE;
- mRotationDelta = 0.0f;
mLastVelocity = Vector2(0.0f, 0.0f);
if( !mScrolling )
{
}
}
-void ScrollView::GestureContinuing(const Vector2& panDelta, const Vector2& scaleDelta, float rotationDelta)
+void ScrollView::GestureContinuing(const Vector2& panDelta)
{
mPanDelta.x+= panDelta.x;
mPanDelta.y+= panDelta.y;
- mScaleDelta.x*= scaleDelta.x;
- mScaleDelta.y*= scaleDelta.y;
- mRotationDelta+= rotationDelta;
// Save the velocity, there is a bug in PanGesture
// Whereby the Gesture::Finished's velocity is either:
}
// TODO: Upgrade to use a more powerful gesture detector (one that supports multiple touches on pan - so works as pan and flick gesture)
-// TODO: Reimplement Scaling (pinching 2+ points)
-// TODO: Reimplment Rotation (pinching 2+ points)
// BUG: Gesture::Finished doesn't always return velocity on release (due to
// timeDelta between last two events being 0 sometimes, or posiiton being the same)
-void ScrollView::OnPan(PanGesture gesture)
+void ScrollView::OnPan( const PanGesture& gesture )
{
// Guard against destruction during signal emission
// Note that Emit() methods are called indirectly e.g. from within ScrollView::OnGestureEx()
case Gesture::Started:
{
DALI_LOG_SCROLL_STATE("[0x%X] Pan Started", this);
+ mPanStartPosition = gesture.position - gesture.displacement;
UpdateLocalScrollProperties();
GestureStarted();
mPanning = true;
if ( mPanning )
{
DALI_LOG_SCROLL_STATE("[0x%X] Pan Continuing", this);
- GestureContinuing(gesture.screenDisplacement, Vector2::ZERO, 0.0f);
+ GestureContinuing(gesture.screenDisplacement);
}
else
{
mGestureStackDepth--;
if(mGestureStackDepth==0)
{
+ // no flick if we have not exceeded min flick distance
+ if( (fabsf(mPanDelta.x) < mMinFlickDistance.x)
+ && (fabsf(mPanDelta.y) < mMinFlickDistance.y) )
+ {
+ // reset flick velocity
+ mLastVelocity = Vector2::ZERO;
+ }
FinishTransform();
}
else
}
}
-void ScrollView::UpdateTransform()
-{
-// TODO: notify clamps using property notifications (or see if we need this, can deprecate it)
-}
-
void ScrollView::FinishTransform()
{
// at this stage internal x and x scroll position should have followed prescroll position exactly
PreAnimatedScrollSetup();
+ // convert pixels/millisecond to pixels per second
bool animating = SnapWithVelocity(mLastVelocity * 1000.0f);
if(!animating)
{
Vector3 size = Self().GetCurrentSize();
- // determine size of viewport relative to current scaled size.
- // e.g. if you're zoomed in 200%, then each pixel on screen is only 0.5 pixels on subject.
- if(fabsf(mScrollPostScale.x) > Math::MACHINE_EPSILON_0)
- {
- size.x /= mScrollPostScale.x;
- }
-
- if(fabsf(mScrollPostScale.y) > Math::MACHINE_EPSILON_0)
- {
- size.y /= mScrollPostScale.y;
- }
-
position.x = -mRulerX->Clamp(-position.x, size.width, 1.0f, clamped.x); // NOTE: X & Y rulers think in -ve coordinate system.
position.y = -mRulerY->Clamp(-position.y, size.height, 1.0f, clamped.y); // That is scrolling RIGHT (e.g. 100.0, 0.0) means moving LEFT.
}
}
-void ScrollView::ClampScale(Vector3& scale) const
-{
- ClampState3 clamped;
- ClampScale(scale, clamped);
-}
-
-void ScrollView::ClampScale(Vector3& scale, ClampState3 &clamped) const
-{
- scale.x = mRulerScaleX->Clamp(scale.x, 0.0f, 1.0f, clamped.x);
- scale.y = mRulerScaleY->Clamp(scale.y, 0.0f, 1.0f, clamped.y);
- clamped.z = NotClamped;
-}
-
void ScrollView::UpdateMainInternalConstraint()
{
// TODO: Only update the constraints which have changed, rather than remove all and add all again.
self.RemoveConstraint(mScrollMainInternalDeltaConstraint);
self.RemoveConstraint(mScrollMainInternalFinalConstraint);
self.RemoveConstraint(mScrollMainInternalRelativeConstraint);
- self.RemoveConstraint(mScrollMainInternalXConstraint);
- self.RemoveConstraint(mScrollMainInternalYConstraint);
}
if( mScrollMainInternalPrePositionConstraint )
{
{
constraint = Constraint::New<Vector3>( mPropertyPrePosition,
Source( detector, PanGestureDetector::LOCAL_POSITION ),
- Source( detector, PanGestureDetector::LOCAL_DISPLACEMENT ),
Source( self, Actor::SIZE ),
- InternalPrePositionConstraint( initialPanMask, mAxisAutoLock, mAxisAutoLockGradient, mLockAxis, mMaxOvershoot, mRulerX->GetDomain(), mRulerY->GetDomain() ) );
+ InternalPrePositionConstraint( mPanStartPosition, initialPanMask, mAxisAutoLock, mAxisAutoLockGradient, mLockAxis, mMaxOvershoot, mRulerX->GetDomain(), mRulerY->GetDomain() ) );
mScrollMainInternalPrePositionConstraint = self.ApplyConstraint( constraint );
}
InternalRelativePositionConstraint );
mScrollMainInternalRelativeConstraint = self.ApplyConstraint( constraint );
- constraint = Constraint::New<float>( mPropertyX,
- LocalSource( mPropertyPrePosition ),
- InternalXConstraint );
- mScrollMainInternalXConstraint = self.ApplyConstraint( constraint );
-
- constraint = Constraint::New<float>( mPropertyY,
- LocalSource( mPropertyPrePosition ),
- InternalYConstraint );
- mScrollMainInternalYConstraint = self.ApplyConstraint( constraint );
-
// When panning we want to make sure overshoot values are affected by pre position and post position
SetOvershootConstraintsEnabled(!mWrapMode);
}
// User definable constraints to apply to all child actors //////////////////
Actor self = Self();
- // LocalSource - The Actors to be moved.
- // self - The ScrollView
-
- // Apply some default constraints to ScrollView.
- // Movement + Scaling + Wrap function
+ // Apply some default constraints to ScrollView & its bound actors
+ // Movement + Wrap function
Constraint constraint;
- // MoveScaledActor (scrolling/zooming)
+ // MoveActor (scrolling)
constraint = Constraint::New<Vector3>( Actor::POSITION,
Source( self, mPropertyPosition ),
- Source( self, mPropertyScale ),
- MoveScaledActorConstraint );
- constraint.SetRemoveAction(Constraint::Discard);
- ApplyConstraintToBoundActors(constraint);
-
- // ScaleActor (scrolling/zooming)
- constraint = Constraint::New<Vector3>( Actor::SCALE,
- Source( self, mPropertyScale ),
- ScaleActorConstraint );
+ MoveActorConstraint );
constraint.SetRemoveAction(Constraint::Discard);
ApplyConstraintToBoundActors(constraint);