*
*/
-// 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 = 60.0f; ///< degrees. (if >45, then supports diagonal flicking)
+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);
GetImpl(effect).Attach(self);
}
-Toolkit::ScrollViewEffect ScrollView::ApplyEffect(Toolkit::ScrollView::PageEffect effect)
-{
- Toolkit::ScrollViewEffect scrollEffect;
- switch(effect)
- {
- case Toolkit::ScrollView::PageEffectNone:
- {
- break;
- }
- case Toolkit::ScrollView::PageEffectOuterCube:
- {
- Toolkit::ScrollViewCustomEffect customEffect;
- scrollEffect = customEffect = Toolkit::ScrollViewCustomEffect::New();
- Vector2 pageSize = Stage::GetCurrent().GetSize();
- // set the page translation to the slide off distance, also add an extra value to space the pages, having a smaller spacing on translationOut will allow the spacing to reduce over time
- // the page moving onto screen will start 50.0f further out (1.0f * 50.0f) and the spacing will reduce as its position reaches the centre (0.0f * 50.0f)
- // the page moving off screen will slowly build a spacing from 0.0f to 20.0f
- // the spacing from each page is added together for the final spacing between the two pages.
- customEffect.SetPageTranslation(Vector3(pageSize.x, pageSize.y, 0) + Vector3(50.0f, 50.0f, 0.0f), Vector3(pageSize.x, pageSize.y, 0) + Vector3(20.0f, 20.0f, 0.0f));
- customEffect.SetSwingAngleOut(ANGLE_CUSTOM_CUBE_SWING.x, Vector3(0.0f, -1.0f, 0.0f));
- customEffect.SetSwingAnchor(AnchorPoint::CENTER, AnchorPoint::CENTER_LEFT);
- customEffect.SetOpacityThreshold(0.7f);
- break;
- }
- case Toolkit::ScrollView::PageEffectDepth:
- {
- Toolkit::ScrollViewCustomEffect customEffect;
- scrollEffect = customEffect = Toolkit::ScrollViewCustomEffect::New();
- break;
- }
- case Toolkit::ScrollView::PageEffectInnerCube:
- {
- Toolkit::ScrollViewCustomEffect customEffect;
- scrollEffect = customEffect = Toolkit::ScrollViewCustomEffect::New();
- customEffect.SetPageSpacing(Vector2(30.0f, 30.0f));
- customEffect.SetAngledOriginPageRotation(ANGLE_CUBE_PAGE_ROTATE);
- customEffect.SetSwingAngle(ANGLE_CUBE_PAGE_ROTATE.x, Vector3(0,-1,0));
- customEffect.SetOpacityThreshold(0.5f);
- break;
- }
- case Toolkit::ScrollView::PageEffectCarousel:
- {
- Toolkit::ScrollViewCustomEffect customEffect;
- scrollEffect = customEffect = Toolkit::ScrollViewCustomEffect::New();
- customEffect.SetPageTranslation(Vector3(0,0,0), Vector3(-30, 0, 0));
- customEffect.SetPageSpacing(Vector2(60.0f, 60.0f));
- customEffect.SetAngledOriginPageRotation(-ANGLE_CUBE_PAGE_ROTATE);
- customEffect.SetOpacityThreshold(0.2f, 0.6f);
- break;
- }
- case Toolkit::ScrollView::PageEffectSpiral:
- {
- Toolkit::ScrollViewCustomEffect customEffect;
- scrollEffect = customEffect = Toolkit::ScrollViewCustomEffect::New();
-
- Vector2 pageSize = Stage::GetCurrent().GetSize();
- customEffect.SetSwingAngle(-ANGLE_SPIRAL_SWING_IN.x, Vector3(0.0f, -1.0f, 0.0f), ANGLE_SPIRAL_SWING_OUT.x, Vector3(0.0f, -1.0f, 0.0f));
- //customEffect.SetSwingAngleAlphaFunctionOut(AlphaFunctions::EaseOut);
- customEffect.SetSwingAnchor(AnchorPoint::CENTER_RIGHT);
- customEffect.SetPageTranslation(Vector3(pageSize.x, pageSize.y, 0) + Vector3(100.0f, 100.0f, 0.0f), Vector3(pageSize.x, pageSize.y, -pageSize.y * 2.0f) * 0.33f);
- //customEffect.SetPageTranslateAlphaFunctionOut(AlphaFunctions::EaseOut);
- customEffect.SetOpacityThreshold(0.75f, 0.6f);
- customEffect.SetOpacityAlphaFunctionIn(AlphaFunctions::EaseInOut);
- break;
- }
- default:
- {
- DALI_ASSERT_DEBUG(0 && "unknown scroll view effect");
- }
- }
- RemoveConstraintsFromChildren();
- if(scrollEffect)
- {
- ApplyEffect(scrollEffect);
- }
- return scrollEffect;
-}
-
void ScrollView::RemoveEffect(Toolkit::ScrollViewEffect effect)
{
Dali::Toolkit::ScrollView self = Dali::Toolkit::ScrollView::DownCast(Self());
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
}
if( scrollPositionChanged )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] Domain Changed, setting mPropertyPrePosition To[%.2f, %.2f]", this, mScrollPrePosition.x, mScrollPrePosition.y );
self.SetProperty(mPropertyPrePosition, mScrollPrePosition);
}
if( domainChanged )
}
}
-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();
}
else if((mSensitive) && (!sensitive))
{
+ DALI_LOG_SCROLL_STATE("[0x%X] BEFORE: panning:[%d]", this, int(mPanning));
+
// while the scroll view is panning, the state needs to be reset.
if ( mPanning )
{
mSensitive = sensitive;
mGestureStackDepth = 0;
+ DALI_LOG_SCROLL_STATE("[0x%X] AFTER: panning:[%d]", this, int(mPanning));
}
}
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 );
{
// set mScrolling to false, in case user has code that interrogates mScrolling Getter() in complete.
mScrolling = false;
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 1 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
- mScrollCompletedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 1 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
+ mScrollCompletedSignal.Emit( currentScrollPosition );
}
if( mPanning ) // are we interrupting a current pan?
self.SetProperty(mPropertyScrolling, true);
mScrolling = true;
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollStartedSignalV2 1 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
- mScrollStartedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollStartedSignal 1 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
+ mScrollStartedSignal.Emit( currentScrollPosition );
bool animating = AnimateTo(-position,
Vector3::ONE * duration,
- scale,
- Vector3::ONE * duration,
- rotation,
- duration,
- mSnapAlphaFunction,
+ alpha,
true,
horizontalBias,
verticalBias,
completedPosition = position;
}
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 2 [%.2f, %.2f]", this, completedPosition.x, completedPosition.y);
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 2 [%.2f, %.2f]", this, completedPosition.x, completedPosition.y);
SetScrollUpdateNotification(false);
- mScrollCompletedSignalV2.Emit( completedPosition );
+ mScrollCompletedSignal.Emit( completedPosition );
}
}
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)
bool ScrollView::ScrollToSnapPoint()
{
+ DALI_LOG_SCROLL_STATE("[0x%X]", this );
Vector2 stationaryVelocity = Vector2(0.0f, 0.0f);
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
+ if(IsScrollComponentEnabled(Toolkit::Scrollable::OvershootIndicator))
+ {
+ // Scroll to the end of the overshoot only when overshoot is enabled.
+ positionSnap += clampDelta;
+ }
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 ///////////////////////////////////////////////////////
if( !(mScrollStateFlags & SCROLL_ANIMATION_FLAGS) )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] Setting mPropertyPrePosition To[%.2f, %.2f]", this, mScrollTargetPosition.x, mScrollTargetPosition.y );
self.SetProperty(mPropertyPrePosition, mScrollTargetPosition);
mScrollPrePosition = mScrollTargetPosition;
mScrollPostPosition = mScrollTargetPosition;
WrapPosition(mScrollPostPosition);
}
- }
-
- // 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;
- }
+ DALI_LOG_SCROLL_STATE("[0x%X] position-changed, mScrollTargetPosition[%.2f, %.2f], mScrollPrePosition[%.2f, %.2f], mScrollPostPosition[%.2f, %.2f]", this, mScrollTargetPosition.x, mScrollTargetPosition.y, mScrollPrePosition.x, mScrollPrePosition.y, mScrollPostPosition.x, mScrollPostPosition.y );
+ 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 );
}
+
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);
- mSnapStartedSignalV2.Emit( snapEvent );
+ DALI_LOG_SCROLL_STATE("[0x%X] mSnapStartedSignal [%.2f, %.2f]", this, snapEvent.position.x, snapEvent.position.y);
+ mSnapStartedSignal.Emit( snapEvent );
return (mScrollStateFlags & SCROLL_ANIMATION_FLAGS) != 0;
}
}
if( enabled )
{
- mMaxOvershoot = OVERSCROLL_CLAMP;
mOvershootIndicator->AttachToScrollable(*this);
}
else
panGesture.RemoveDirection( direction );
}
-Toolkit::ScrollView::SnapStartedSignalV2& ScrollView::SnapStartedSignal()
+Toolkit::ScrollView::SnapStartedSignalType& ScrollView::SnapStartedSignal()
{
- return mSnapStartedSignalV2;
+ return mSnapStartedSignal;
}
void ScrollView::FindAndUnbindActor(Actor child)
return position;
}
-Vector3 ScrollView::GetPropertyScale() const
-{
- return Self().GetProperty<Vector3>(mPropertyScale);
-}
-
void ScrollView::HandleStoppedAnimation()
{
SetScrollUpdateNotification(false);
UpdateLocalScrollProperties();
WrapPosition(mScrollPrePosition);
+ DALI_LOG_SCROLL_STATE("[0x%X] Setting mPropertyPrePosition To[%.2f, %.2f]", this, mScrollPrePosition.x, mScrollPrePosition.y );
self.SetProperty(mPropertyPrePosition, mScrollPrePosition);
Vector3 currentScrollPosition = GetCurrentScrollPosition();
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 3 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
- mScrollCompletedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 3 current[%.2f, %.2f], mScrollTargetPosition[%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y, -mScrollTargetPosition.x, -mScrollTargetPosition.y );
+ mScrollCompletedSignal.Emit( currentScrollPosition );
mDomainOffset += deltaPosition - mScrollPostPosition;
self.SetProperty(mPropertyDomainOffset, mDomainOffset);
Toolkit::ScrollView handle( GetOwner() );
Vector3 currentScrollPosition = GetCurrentScrollPosition();
- mScrollUpdatedSignalV2.Emit( currentScrollPosition );
+ mScrollUpdatedSignal.Emit( currentScrollPosition );
}
bool ScrollView::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
void ScrollView::OnPropertySet( Property::Index index, Property::Value propertyValue )
{
Actor self = Self();
- if( index == mPropertyX )
- {
- self.GetProperty(mPropertyPrePosition).Get(mScrollPrePosition);
- propertyValue.Get(mScrollPrePosition.x);
- self.SetProperty(mPropertyPrePosition, mScrollPrePosition);
- }
- else if( index == mPropertyY )
+ if( index == mPropertyPrePosition )
{
- self.GetProperty(mPropertyPrePosition).Get(mScrollPrePosition);
- propertyValue.Get(mScrollPrePosition.y);
- self.SetProperty(mPropertyPrePosition, mScrollPrePosition);
- }
- else if( index == mPropertyPrePosition )
- {
- DALI_LOG_SCROLL_STATE("[0x%X]", this);
+ DALI_LOG_SCROLL_STATE("[0x%X]: mPropertyPrePosition[%.2f, %.2f]", this, propertyValue.Get<Vector3>().x, propertyValue.Get<Vector3>().y);
propertyValue.Get(mScrollPrePosition);
}
}
bool ScrollView::OnTouchDownTimeout()
{
+ DALI_LOG_SCROLL_STATE("[0x%X]", this);
+
mTouchDownTimeoutReached = true;
- if( mScrollStateFlags & (SCROLL_ANIMATION_FLAGS | SNAP_ANIMATION_FLAGS) )
+ unsigned int currentScrollStateFlags( mScrollStateFlags ); // Cleared in StopAnimation so keep local copy for comparison
+ if( currentScrollStateFlags & (SCROLL_ANIMATION_FLAGS | SNAP_ANIMATION_FLAGS) )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] Scrolling Or snapping flags set, stopping animation", this);
+
StopAnimation();
- if( mScrollStateFlags & SCROLL_ANIMATION_FLAGS )
+ if( currentScrollStateFlags & SCROLL_ANIMATION_FLAGS )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] Scrolling flags set, emitting signal", this);
+
mScrollInterrupted = true;
// reset domain offset as scrolling from original plane.
mDomainOffset = Vector3::ZERO;
UpdateLocalScrollProperties();
Vector3 currentScrollPosition = GetCurrentScrollPosition();
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 4 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
- mScrollCompletedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 4 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
+ mScrollCompletedSignal.Emit( currentScrollPosition );
}
}
{
if(!mSensitive)
{
+ DALI_LOG_SCROLL_STATE("[0x%X], Not Sensitive, ignoring", this);
+
// Ignore this touch event, if scrollview is insensitive.
return false;
}
// Ignore events with multiple-touch points
if (event.GetPointCount() != 1)
{
+ DALI_LOG_SCROLL_STATE("[0x%X], multiple touch, ignoring", this);
+
return false;
}
- if( event.GetPoint(0).state == TouchPoint::Down )
+ const TouchPoint::State pointState = event.GetPoint(0).state;
+ if( pointState == TouchPoint::Down )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] Down", this);
+
if(mGestureStackDepth==0)
{
mTouchDownTime = event.time;
// This allows time for a pan-gesture to start, to avoid breaking snap-animation behavior with fast flicks.
// If touch-down does not become a pan (after timeout interval), then snap-animation can be interrupted.
+ mTouchDownTimeoutReached = false;
+ mScrollInterrupted = false;
StartTouchDownTimer();
}
}
- else if( event.GetPoint(0).state == TouchPoint::Up )
+ else if( ( pointState == TouchPoint::Up ) ||
+ ( ( pointState == TouchPoint::Interrupted ) && ( event.GetPoint(0).hitActor == Self() ) ) )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] %s", this, ( ( pointState == TouchPoint::Up ) ? "Up" : "Interrupted" ) );
+
StopTouchDownTimer();
// if the user touches and releases without enough movement to go
// otherwise our scroll could be stopped (interrupted) half way through an animation.
if(mGestureStackDepth==0 && mTouchDownTimeoutReached)
{
- unsigned timeDelta( event.time - mTouchDownTime );
- if ( timeDelta >= MINIMUM_TIME_BETWEEN_DOWN_AND_UP_FOR_RESET )
+ if( ( event.GetPoint(0).state == TouchPoint::Interrupted ) ||
+ ( ( event.time - mTouchDownTime ) >= MINIMUM_TIME_BETWEEN_DOWN_AND_UP_FOR_RESET ) )
{
// Reset the velocity only if down was received a while ago
mLastVelocity = Vector2( 0.0f, 0.0f );
// Only finish the transform if scrolling was interrupted on down or if we are scrolling
if ( mScrollInterrupted || mScrolling )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] Calling FinishTransform", this);
+
FinishTransform();
}
}
Actor self = Self();
self.GetProperty(mPropertyPosition).Get(mScrollPostPosition);
mScrollPrePosition = mScrollPostPosition;
+ DALI_LOG_SCROLL_STATE("[0x%X] Setting mPropertyPrePosition To[%.2f, %.2f]", this, mScrollPostPosition.x, mScrollPostPosition.y );
self.SetProperty(mPropertyPrePosition, mScrollPostPosition);
}
mScrollStateFlags = 0;
- mScrollPostScale = GetPropertyScale();
-
// Update Actor position with this wrapped value.
- // TODO Rotation
-
- mScrollPreScale = mScrollPostScale;
- mScrollPreRotation = mScrollPostRotation;
}
void ScrollView::FinaliseAnimatedScroll()
if( duration > Math::MACHINE_EPSILON_10 )
{
Actor self = Self();
+ DALI_LOG_SCROLL_STATE("[0x%X], Animating from[%.2f] to[%.2f]", this, self.GetProperty(mPropertyPrePosition).Get<Vector3>().x, position );
mInternalXAnimation = Animation::New(duration);
+ DALI_LOG_SCROLL_STATE("[0x%X], mInternalXAnimation[0x%X]", this, mInternalXAnimation.GetObjectPtr() );
mInternalXAnimation.FinishedSignal().Connect(this, &ScrollView::OnScrollAnimationFinished);
mInternalXAnimation.AnimateTo( Property(self, mPropertyPrePosition, 0), position, alpha, duration);
mInternalXAnimation.Play();
if( duration > Math::MACHINE_EPSILON_10 )
{
Actor self = Self();
+ DALI_LOG_SCROLL_STATE("[0x%X], Animating from[%.2f] to[%.2f]", this, self.GetProperty(mPropertyPrePosition).Get<Vector3>().y, position );
mInternalYAnimation = Animation::New(duration);
+ DALI_LOG_SCROLL_STATE("[0x%X], mInternalYAnimation[0x%X]", this, mInternalYAnimation.GetObjectPtr() );
mInternalYAnimation.FinishedSignal().Connect(this, &ScrollView::OnScrollAnimationFinished);
mInternalYAnimation.AnimateTo( Property(self, mPropertyPrePosition, 1), position, alpha, TimePeriod(duration));
mInternalYAnimation.Play();
// update our local scroll positions
UpdateLocalScrollProperties();
- if( source == mSnapAnimation )
- {
- // 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 );
+
if( !(mScrollStateFlags & AnimatingInternalY) )
{
scrollingFinished = true;
{
const RulerDomain rulerDomain = mRulerX->GetDomain();
mScrollPrePosition.x = -WrapInDomain(-mScrollPrePosition.x, rulerDomain.min, rulerDomain.max);
+ DALI_LOG_SCROLL_STATE("[0x%X] Setting mPropertyPrePosition To[%.2f, %.2f]", this, mScrollPrePosition.x, mScrollPrePosition.y );
handle.SetProperty(mPropertyPrePosition, mScrollPrePosition);
}
SnapInternalXTo(mScrollPostPosition.x);
if( source == mInternalYAnimation )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] mInternalYAnimation[0x%X], expected[%.2f], actual[%.2f], post[%.2f]", this, mInternalYAnimation.GetObjectPtr(), mScrollTargetPosition.y, Self().GetProperty(mPropertyPrePosition).Get<Vector3>().y, mScrollPostPosition.y );
+
if( !(mScrollStateFlags & AnimatingInternalX) )
{
scrollingFinished = true;
// wrap pre scroll y position and set it
const RulerDomain rulerDomain = mRulerY->GetDomain();
mScrollPrePosition.y = -WrapInDomain(-mScrollPrePosition.y, rulerDomain.min, rulerDomain.max);
+ DALI_LOG_SCROLL_STATE("[0x%X] Setting mPropertyPrePosition To[%.2f, %.2f]", this, mScrollPrePosition.x, mScrollPrePosition.y );
handle.SetProperty(mPropertyPrePosition, mScrollPrePosition);
}
SnapInternalYTo(mScrollPostPosition.y);
}
+ DALI_LOG_SCROLL_STATE("[0x%X] scrollingFinished[%d] Animation[0x%X]", this, scrollingFinished, source.GetObjectPtr());
+
if(scrollingFinished)
{
HandleSnapAnimationFinished();
UpdateLocalScrollProperties();
if( source == mInternalXAnimation )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] Finished X PostPosition Animation", this );
+
// clear internal x animation flags
mScrollStateFlags &= ~SCROLL_X_STATE_MASK;
mInternalXAnimation.Reset();
}
if( source == mInternalYAnimation )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] Finished Y PostPosition Animation", this );
+
mScrollStateFlags &= ~SCROLL_Y_STATE_MASK;
mInternalYAnimation.Reset();
WrapPosition(mScrollPrePosition);
// if internal x not equal to inputed parameter, animate it
float duration = std::min(fabsf((position - mScrollPrePosition.x) / mMaxOvershoot.x) * mSnapOvershootDuration, mSnapOvershootDuration);
+ DALI_LOG_SCROLL_STATE("[0x%X] duration[%.2f]", this, duration );
if( duration > Math::MACHINE_EPSILON_1 )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] Starting X Snap Animation to[%.2f]", this, position );
+
mInternalXAnimation = Animation::New(duration);
mInternalXAnimation.FinishedSignal().Connect(this, &ScrollView::OnSnapInternalPositionFinished);
mInternalXAnimation.AnimateTo(Property(self, mPropertyPrePosition, 0), position);
// if internal y not equal to inputed parameter, animate it
float duration = std::min(fabsf((position - mScrollPrePosition.y) / mMaxOvershoot.y) * mSnapOvershootDuration, mSnapOvershootDuration);
+ DALI_LOG_SCROLL_STATE("[0x%X] duration[%.2f]", this, duration );
if( duration > Math::MACHINE_EPSILON_1 )
{
+ DALI_LOG_SCROLL_STATE("[0x%X] Starting Y Snap Animation to[%.2f]", this, position );
+
mInternalYAnimation = Animation::New(duration);
mInternalYAnimation.FinishedSignal().Connect(this, &ScrollView::OnSnapInternalPositionFinished);
mInternalYAnimation.AnimateTo(Property(self, mPropertyPrePosition, 1), position);
StopTouchDownTimer();
StopAnimation();
mPanDelta = Vector3::ZERO;
- mScaleDelta = Vector3::ONE;
- mRotationDelta = 0.0f;
mLastVelocity = Vector2(0.0f, 0.0f);
if( !mScrolling )
{
mScrolling = false;
// send negative scroll position since scroll internal scroll position works as an offset for actors,
// give applications the position within the domain from the scroll view's anchor position
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 5 [%.2f, %.2f]", this, -mScrollPostPosition.x, -mScrollPostPosition.y);
- mScrollCompletedSignalV2.Emit( -mScrollPostPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 5 [%.2f, %.2f]", this, -mScrollPostPosition.x, -mScrollPostPosition.y);
+ mScrollCompletedSignal.Emit( -mScrollPostPosition );
}
}
}
-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
{
Vector3 currentScrollPosition = GetCurrentScrollPosition();
Self().SetProperty(mPropertyScrolling, true);
mScrolling = true;
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollStartedSignalV2 2 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
- mScrollStartedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollStartedSignal 2 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
+ mScrollStartedSignal.Emit( currentScrollPosition );
}
else if( (state == Gesture::Finished) ||
(state == Gesture::Cancelled) ) // Finished/default
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)
SnapInternalYTo(mScrollTargetPosition.y);
}
Vector3 currentScrollPosition = GetCurrentScrollPosition();
- DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignalV2 6 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
- mScrollCompletedSignalV2.Emit( currentScrollPosition );
+ DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 6 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
+ mScrollCompletedSignal.Emit( currentScrollPosition );
}
}
{
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);