#include <algorithm>
#include <dali/public-api/animation/constraint.h>
#include <dali/public-api/animation/constraints.h>
-#include <dali/public-api/common/set-wrapper.h>
+#include <dali/devel-api/common/set-wrapper.h>
#include <dali/public-api/common/stage.h>
-#include <dali/public-api/events/mouse-wheel-event.h>
+#include <dali/public-api/events/wheel-event.h>
#include <dali/public-api/events/touch-event.h>
#include <dali/public-api/object/type-registry.h>
-#include <dali/public-api/object/type-registry-helper.h>
+#include <dali/devel-api/object/type-registry-helper.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scroll-bar/scroll-bar.h>
DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "layout-orientation", INTEGER, LAYOUT_ORIENTATION)
DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "scroll-content-size", FLOAT, SCROLL_CONTENT_SIZE)
+DALI_SIGNAL_REGISTRATION( Toolkit, ItemView, "layout-activated", LAYOUT_ACTIVATED_SIGNAL )
+
DALI_TYPE_REGISTRATION_END()
const float DEFAULT_MINIMUM_SWIPE_SPEED = 1.0f;
const float DEFAULT_MINIMUM_SWIPE_DISTANCE = 3.0f;
-const float DEFAULT_MOUSE_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION = 0.1f;
+const float DEFAULT_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION = 0.1f;
const float DEFAULT_MINIMUM_SWIPE_DURATION = 0.45f;
const float DEFAULT_MAXIMUM_SWIPE_DURATION = 2.6f;
const float DEFAULT_REFRESH_INTERVAL_LAYOUT_POSITIONS = 20.0f; // 1 updates per 20 items
-const int MOUSE_WHEEL_EVENT_FINISHED_TIME_OUT = 500; // 0.5 second
+const int WHEEL_EVENT_FINISHED_TIME_OUT = 500; // 0.5 second
const float DEFAULT_ANCHORING_DURATION = 1.0f; // 1 second
}
ItemView::ItemView(ItemFactory& factory)
-: Scrollable( ControlBehaviour( DISABLE_SIZE_NEGOTIATION | REQUIRES_MOUSE_WHEEL_EVENTS | REQUIRES_KEYBOARD_NAVIGATION_SUPPORT ) ),
+: Scrollable( ControlBehaviour( DISABLE_SIZE_NEGOTIATION | REQUIRES_WHEEL_EVENTS | REQUIRES_KEYBOARD_NAVIGATION_SUPPORT ) ),
mItemFactory(factory),
mActiveLayout(NULL),
mAnimatingOvershootOn(false),
mAnimateOvershootOff(false),
- mAnchoringEnabled(true),
+ mAnchoringEnabled(false),
mAnchoringDuration(DEFAULT_ANCHORING_DURATION),
mRefreshIntervalLayoutPositions(0.0f),
mRefreshOrderHint(true/*Refresh item 0 first*/),
mMinimumSwipeSpeed(DEFAULT_MINIMUM_SWIPE_SPEED),
mMinimumSwipeDistance(DEFAULT_MINIMUM_SWIPE_DISTANCE),
- mMouseWheelScrollDistanceStep(0.0f),
+ mWheelScrollDistanceStep(0.0f),
mScrollDistance(0.0f),
mScrollSpeed(0.0f),
mTotalPanDisplacement(Vector2::ZERO),
SetOvershootEnabled(true);
Vector2 stageSize = Stage::GetCurrent().GetSize();
- mMouseWheelScrollDistanceStep = stageSize.y * DEFAULT_MOUSE_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION;
+ mWheelScrollDistanceStep = stageSize.y * DEFAULT_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION;
EnableGestureDetection(Gesture::Type(Gesture::Pan));
- mMouseWheelEventFinishedTimer = Timer::New( MOUSE_WHEEL_EVENT_FINISHED_TIME_OUT );
- mMouseWheelEventFinishedTimer.TickSignal().Connect( this, &ItemView::OnMouseWheelEventFinished );
+ mWheelEventFinishedTimer = Timer::New( WHEEL_EVENT_FINISHED_TIME_OUT );
+ mWheelEventFinishedTimer.TickSignal().Connect( this, &ItemView::OnWheelEventFinished );
SetRefreshInterval(DEFAULT_REFRESH_INTERVAL_LAYOUT_POSITIONS);
}
actor.RemoveConstraints();
Vector3 size;
- if(mActiveLayout->GetItemSize(itemId, targetSize, size))
- {
- // resize immediately
- actor.SetSize( size.GetVectorXY() );
- }
+ mActiveLayout->GetItemSize( itemId, targetSize, size );
+ actor.SetSize( size.GetVectorXY() );
- mActiveLayout->ApplyConstraints(actor, itemId, durationSeconds, Self() );
+ mActiveLayout->ApplyConstraints(actor, itemId, targetSize, Self() );
}
// Refresh the new layout
ItemRange range = GetItemRange(*mActiveLayout, targetSize, GetCurrentLayoutPosition(0), false/* don't reserve extra*/);
- AddActorsWithinRange( range, durationSeconds );
+ AddActorsWithinRange( range, targetSize );
// Scroll to an appropriate layout position
mScrollAnimation.FinishedSignal().Connect(this, &ItemView::OnLayoutActivationScrollFinished);
mScrollAnimation.Play();
}
+ else
+ {
+ // Emit the layout activated signal
+ mLayoutActivatedSignal.Emit();
+ }
AnimateScrollOvershoot(0.0f);
mScrollOvershoot = 0.0f;
{
ItemRange range = GetItemRange(*mActiveLayout, mActiveLayoutTargetSize, currentLayoutPosition, cacheExtra/*reserve extra*/);
RemoveActorsOutsideRange( range );
- AddActorsWithinRange( range, 0.0f/*immediate*/ );
+ AddActorsWithinRange( range, Self().GetCurrentSize() );
mScrollUpdatedSignal.Emit( Vector2(0.0f, currentLayoutPosition) );
}
return mMinimumSwipeDistance;
}
-void ItemView::SetMouseWheelScrollDistanceStep(float step)
+void ItemView::SetWheelScrollDistanceStep(float step)
{
- mMouseWheelScrollDistanceStep = step;
+ mWheelScrollDistanceStep = step;
}
-float ItemView::GetMouseWheelScrollDistanceStep() const
+float ItemView::GetWheelScrollDistanceStep() const
{
- return mMouseWheelScrollDistanceStep;
+ return mWheelScrollDistanceStep;
}
void ItemView::SetAnchoring(bool enabled)
void ItemView::InsertItem( Item newItem, float durationSeconds )
{
mAddingItems = true;
+ Vector3 layoutSize = Self().GetCurrentSize();
Actor displacedActor;
ItemPoolIter afterDisplacedIter = mItemPool.end();
ItemPoolIter foundIter = mItemPool.find( newItem.first );
if( mItemPool.end() != foundIter )
{
- SetupActor( newItem, durationSeconds );
+ SetupActor( newItem, layoutSize );
Self().Add( newItem.second );
displacedActor = foundIter->second;
displacedActor = temp;
iter->second.RemoveConstraints();
- mActiveLayout->ApplyConstraints( iter->second, iter->first, durationSeconds, Self() );
+ mActiveLayout->ApplyConstraints( iter->second, iter->first, layoutSize, Self() );
}
// Create last item
mItemPool.insert( lastItem );
lastItem.second.RemoveConstraints();
- mActiveLayout->ApplyConstraints( lastItem.second, lastItem.first, durationSeconds, Self() );
+ mActiveLayout->ApplyConstraints( lastItem.second, lastItem.first, layoutSize, Self() );
}
}
- CalculateDomainSize(Self().GetCurrentSize());
+ CalculateDomainSize( layoutSize );
mAddingItems = false;
}
void ItemView::InsertItems( const ItemContainer& newItems, float durationSeconds )
{
mAddingItems = true;
+ Vector3 layoutSize = Self().GetCurrentSize();
// Insert from lowest id to highest
std::set<Item> sortedItems;
// If newly inserted
if( FindById( newItems, iter->first ) )
{
- SetupActor( *iter, durationSeconds );
+ SetupActor( *iter, layoutSize );
}
else
{
iter->second.RemoveConstraints();
- mActiveLayout->ApplyConstraints( iter->second, iter->first, durationSeconds, Self() );
+ mActiveLayout->ApplyConstraints( iter->second, iter->first, layoutSize, Self() );
}
}
- CalculateDomainSize(Self().GetCurrentSize());
+ CalculateDomainSize( layoutSize );
mAddingItems = false;
}
bool actorsReordered = RemoveActor( itemId );
if( actorsReordered )
{
- ReapplyAllConstraints( durationSeconds );
+ ReapplyAllConstraints();
OnItemsRemoved();
}
if( actorsReordered )
{
- ReapplyAllConstraints( durationSeconds );
+ ReapplyAllConstraints();
OnItemsRemoved();
}
void ItemView::ReplaceItem( Item replacementItem, float durationSeconds )
{
mAddingItems = true;
+ Vector3 layoutSize = Self().GetCurrentSize();
- SetupActor( replacementItem, durationSeconds );
+ SetupActor( replacementItem, layoutSize );
Self().Add( replacementItem.second );
const ItemPoolIter iter = mItemPool.find( replacementItem.first );
mItemPool.insert( replacementItem );
}
- CalculateDomainSize(Self().GetCurrentSize());
+ CalculateDomainSize( layoutSize );
mAddingItems = false;
}
}
}
-void ItemView::AddActorsWithinRange( ItemRange range, float durationSeconds )
+void ItemView::AddActorsWithinRange( ItemRange range, const Vector3& layoutSize )
{
range.end = std::min(mItemFactory.GetNumberOfItems(), range.end);
{
for (unsigned int itemId = range.begin; itemId < range.end; ++itemId)
{
- AddNewActor( itemId, durationSeconds );
+ AddNewActor( itemId, layoutSize );
}
}
else
{
for (unsigned int itemId = range.end; itemId > range.begin; --itemId)
{
- AddNewActor( itemId-1, durationSeconds );
+ AddNewActor( itemId-1, layoutSize );
}
}
CalculateDomainSize(Self().GetCurrentSize());
}
-void ItemView::AddNewActor( unsigned int itemId, float durationSeconds )
+void ItemView::AddNewActor( unsigned int itemId, const Vector3& layoutSize )
{
mAddingItems = true;
mItemPool.insert( newItem );
- SetupActor( newItem, durationSeconds );
+ SetupActor( newItem, layoutSize );
Self().Add( actor );
}
}
mAddingItems = false;
}
-void ItemView::SetupActor( Item item, float durationSeconds )
+void ItemView::SetupActor( Item item, const Vector3& layoutSize )
{
item.second.SetParentOrigin( mItemsParentOrigin );
item.second.SetAnchorPoint( mItemsAnchorPoint );
if( mActiveLayout )
{
Vector3 size;
- if( mActiveLayout->GetItemSize( item.first, mActiveLayoutTargetSize, size ) )
- {
- item.second.SetSize( size.GetVectorXY() );
- }
+ mActiveLayout->GetItemSize( item.first, mActiveLayoutTargetSize, size );
+ item.second.SetSize( size.GetVectorXY() );
- mActiveLayout->ApplyConstraints( item.second, item.first, durationSeconds, Self() );
+ mActiveLayout->ApplyConstraints( item.second, item.first, layoutSize, Self() );
}
}
return true; // consume since we're potentially scrolling
}
-bool ItemView::OnMouseWheelEvent(const MouseWheelEvent& event)
+bool ItemView::OnWheelEvent(const WheelEvent& event)
{
- // Respond the mouse wheel event to scroll
+ // Respond the wheel event to scroll
if (mActiveLayout)
{
Actor self = Self();
const Vector3 layoutSize = Self().GetCurrentSize();
- float layoutPositionDelta = GetCurrentLayoutPosition(0) - (event.z * mMouseWheelScrollDistanceStep * mActiveLayout->GetScrollSpeedFactor());
+ float layoutPositionDelta = GetCurrentLayoutPosition(0) - (event.z * mWheelScrollDistanceStep * mActiveLayout->GetScrollSpeedFactor());
float firstItemScrollPosition = ClampFirstItemPosition(layoutPositionDelta, layoutSize, *mActiveLayout);
self.SetProperty(Toolkit::ItemView::Property::LAYOUT_POSITION, firstItemScrollPosition );
mRefreshEnabled = true;
}
- if (mMouseWheelEventFinishedTimer.IsRunning())
+ if (mWheelEventFinishedTimer.IsRunning())
{
- mMouseWheelEventFinishedTimer.Stop();
+ mWheelEventFinishedTimer.Stop();
}
- mMouseWheelEventFinishedTimer.Start();
+ mWheelEventFinishedTimer.Start();
return true;
}
-bool ItemView::OnMouseWheelEventFinished()
+bool ItemView::OnWheelEventFinished()
{
if (mActiveLayout)
{
RemoveAnimation(mScrollAnimation);
- // No more mouse wheel events coming. Do the anchoring if enabled.
+ // No more wheel events coming. Do the anchoring if enabled.
mScrollAnimation = DoAnchoring();
if (mScrollAnimation)
{
return false;
}
-void ItemView::ReapplyAllConstraints( float durationSeconds )
+void ItemView::ReapplyAllConstraints()
{
+ Vector3 layoutSize = Self().GetCurrentSize();
+
for (ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
{
unsigned int id = iter->first;
Actor actor = iter->second;
actor.RemoveConstraints();
- mActiveLayout->ApplyConstraints(actor, id, durationSeconds, Self());
+ mActiveLayout->ApplyConstraints(actor, id, layoutSize, Self());
}
}
return true;
}
-Actor ItemView::GetNextKeyboardFocusableActor(Actor actor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
+Actor ItemView::GetNextKeyboardFocusableActor(Actor actor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
{
Actor nextFocusActor;
if(mActiveLayout)
float anchorPosition = mActiveLayout->GetClosestAnchorPosition( GetCurrentLayoutPosition(0) );
anchoringAnimation = Animation::New(mAnchoringDuration);
- anchoringAnimation.AnimateTo( Property(self, Toolkit::ItemView::Property::LAYOUT_POSITION), -anchorPosition, AlphaFunction::EASE_OUT );
+ anchoringAnimation.AnimateTo( Property(self, Toolkit::ItemView::Property::LAYOUT_POSITION), anchorPosition, AlphaFunction::EASE_OUT );
anchoringAnimation.AnimateTo( Property(self, Toolkit::ItemView::Property::SCROLL_SPEED), 0.0f, AlphaFunction::EASE_OUT );
if(!mIsFlicking)
{
RemoveAnimation(mScrollAnimation);
mRefreshEnabled = true;
DoRefresh(GetCurrentLayoutPosition(0), true);
+
+ // Emit the layout activated signal
+ mLayoutActivatedSignal.Emit();
}
void ItemView::OnOvershootOnFinished(Animation& animation)
mOvershootOverlay.SetColor(mOvershootEffectColor);
mOvershootOverlay.SetParentOrigin(ParentOrigin::TOP_LEFT);
mOvershootOverlay.SetAnchorPoint(AnchorPoint::TOP_LEFT);
- mOvershootOverlay.SetDrawMode(DrawMode::OVERLAY);
self.Add(mOvershootOverlay);
Constraint constraint = Constraint::New<Vector3>( mOvershootOverlay, Actor::Property::SIZE, OvershootOverlaySizeConstraint );
void ItemView::OnScrollPositionChanged( float position )
{
// Cancel scroll animation to prevent any fighting of setting the scroll position property.
- RemoveAnimation(mScrollAnimation);
+ if(!mRefreshEnabled)
+ {
+ RemoveAnimation(mScrollAnimation);
+ }
// Refresh the cache immediately when the scroll position is changed.
DoRefresh(position, false); // No need to cache extra items.
}
+bool ItemView::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
+{
+ Dali::BaseHandle handle( object );
+
+ bool connected( true );
+ Toolkit::ItemView itemView = Toolkit::ItemView::DownCast( handle );
+
+ if( 0 == strcmp( signalName.c_str(), LAYOUT_ACTIVATED_SIGNAL ) )
+ {
+ itemView.LayoutActivatedSignal().Connect( tracker, functor );
+ }
+ else
+ {
+ // signalName does not match any signal
+ connected = false;
+ }
+
+ return connected;
+}
+
} // namespace Internal
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff