sizeAnimationCalled(false),
touchEventCalled(false),
hoverEventCalled(false),
- mouseWheelEventCalled(false),
+ wheelEventCalled(false),
keyEventCalled(false),
keyInputFocusGained(false),
keyInputFocusLost(false)
void DummyControlImplOverride::OnSizeAnimation(Animation& animation, const Vector3& targetSize) { sizeAnimationCalled = true; }
bool DummyControlImplOverride::OnTouchEvent(const TouchEvent& event) { touchEventCalled = true; return false; }
bool DummyControlImplOverride::OnHoverEvent(const HoverEvent& event) { hoverEventCalled = true; return false; }
-bool DummyControlImplOverride::OnMouseWheelEvent(const MouseWheelEvent& event) { mouseWheelEventCalled = true; return false; }
+bool DummyControlImplOverride::OnWheelEvent(const WheelEvent& event) { wheelEventCalled = true; return false; }
bool DummyControlImplOverride::OnKeyEvent(const KeyEvent& event) { keyEventCalled = true; return false;}
void DummyControlImplOverride::OnKeyInputFocusGained() { keyInputFocusGained = true; }
void DummyControlImplOverride::OnKeyInputFocusLost() { keyInputFocusLost = true; }
virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize);
virtual bool OnTouchEvent(const TouchEvent& event);
virtual bool OnHoverEvent(const HoverEvent& event);
- virtual bool OnMouseWheelEvent(const MouseWheelEvent& event);
+ virtual bool OnWheelEvent(const WheelEvent& event);
virtual bool OnKeyEvent(const KeyEvent& event);
virtual void OnKeyInputFocusGained();
virtual void OnKeyInputFocusLost();
bool sizeAnimationCalled;
bool touchEventCalled;
bool hoverEventCalled;
- bool mouseWheelEventCalled;
+ bool wheelEventCalled;
bool keyEventCalled;
bool keyInputFocusGained;
bool keyInputFocusLost;
// EXTERNAL INCLUDES
#include <stdint.h>
#include <cstring>
-#include <dali/devel-api/images/image-operations.h>
+#include <dali/public-api/images/image-operations.h>
// INTERNAL INCLUDES
#include <dali/devel-api/common/set-wrapper.h>
#include <dali.h>
#include <dali-toolkit/dali-toolkit.h>
#include <dali/integration-api/events/key-event-integ.h>
-#include <dali/integration-api/events/mouse-wheel-event-integ.h>
+#include <dali/integration-api/events/wheel-event-integ.h>
#include <dali/integration-api/events/long-press-gesture-event.h>
#include <dali/integration-api/events/pinch-gesture-event.h>
#include <dali/integration-api/events/pan-gesture-event.h>
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace
{
-static bool MouseWheelEventCallback(Actor actor, const MouseWheelEvent& event)
+static bool WheelEventCallback(Actor actor, const WheelEvent& event)
{
return false;
}
}
-int UtcDaliControlImplMouseWheelEvent(void)
+int UtcDaliControlImplWheelEvent(void)
{
ToolkitTestApplication application;
dummy.SetAnchorPoint(AnchorPoint::TOP_LEFT);
Stage::GetCurrent().Add(dummy);
- dummy.MouseWheelEventSignal().Connect(&MouseWheelEventCallback);
+ dummy.WheelEventSignal().Connect(&WheelEventCallback);
application.Render();
application.SendNotification();
application.Render();
application.SendNotification();
- DALI_TEST_EQUALS( dummyImpl.mouseWheelEventCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS( dummyImpl.wheelEventCalled, false, TEST_LOCATION );
- // simulate a mouse wheel event
+ // simulate a wheel event
Vector2 screenCoordinates( 10.0f, 10.0f );
- Integration::MouseWheelEvent event(0, 0u, screenCoordinates, 1, 1000u);
- application.ProcessEvent(event);
- DALI_TEST_EQUALS( dummyImpl.mouseWheelEventCalled, true, TEST_LOCATION );
+ Integration::WheelEvent event( Integration::WheelEvent::MOUSE_WHEEL, 0, 0u, screenCoordinates, 1, 1000u );
+ application.ProcessEvent( event );
+ DALI_TEST_EQUALS( dummyImpl.wheelEventCalled, true, TEST_LOCATION );
Stage::GetCurrent().Remove(dummy);
}
dummy.SetAnchorPoint(AnchorPoint::TOP_LEFT);
Stage::GetCurrent().Add(dummy);
- dummy.MouseWheelEventSignal().Connect(&MouseWheelEventCallback);
+ dummy.WheelEventSignal().Connect(&WheelEventCallback);
application.Render();
application.SendNotification();
application.Render();
application.SendNotification();
- // simulate a mouse wheel event
+ // simulate a wheel event
Vector2 screenCoordinates( 20.0f, 20.0f );
- Integration::MouseWheelEvent event(0, 0u, screenCoordinates, 1, 1000u);
- application.ProcessEvent(event);
+ Integration::WheelEvent event( Integration::WheelEvent::MOUSE_WHEEL, 0, 0u, screenCoordinates, 1, 1000u );
+ application.ProcessEvent( event );
Stage::GetCurrent().Remove(dummy);
}
END_TEST;
}
+int UtcDaliControlImplOnAccessibilityActivatedP(void)
+{
+ ToolkitTestApplication application;
+
+ Control dummy = Control::New();
+ Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation( dummy );
+ DALI_TEST_EQUALS( false, controlImpl.OnAccessibilityActivated(), TEST_LOCATION );
+
+ // Invoke the control's activate action
+ TypeInfo type = TypeRegistry::Get().GetTypeInfo( "Control" );
+ DALI_TEST_CHECK( type );
+
+ BaseHandle handle = type.CreateInstance();
+ DALI_TEST_CHECK( handle );
+
+ std::vector<Property::Value> attributes;
+ DALI_TEST_EQUALS( false, handle.DoAction("control-activated", attributes), TEST_LOCATION );
+
+ END_TEST;
+}
int UtcDaliControlImplGetNextKeyboardFocusableActorP(void)
{
Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation( dummy );
Actor currentFocusedActor;
- Actor result = controlImpl.GetNextKeyboardFocusableActor( currentFocusedActor, Control::Left, false );
+ Actor result = controlImpl.GetNextKeyboardFocusableActor( currentFocusedActor, Control::KeyboardFocus::LEFT, false );
DALI_TEST_EQUALS( result, currentFocusedActor, TEST_LOCATION );
DALI_TEST_EQUALS(position, 0.0f, TEST_LOCATION);
- int focusItem = layout->GetNextFocusItemID(0, TOTAL_ITEM_NUMBER, Control::Left, true);
+ int focusItem = layout->GetNextFocusItemID(0, TOTAL_ITEM_NUMBER, Control::KeyboardFocus::LEFT, true);
DALI_TEST_CHECK(focusItem != 0);
TestItemLayoutPtr layout = TestItemLayout::New();
DALI_TEST_CHECK( layout );
- DALI_TEST_EQUALS(layout->GetNextFocusItemID(0, 100, Control::Left, true), 99, TEST_LOCATION );
- DALI_TEST_EQUALS(layout->GetNextFocusItemID(110, 100, Control::Right, true), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(layout->GetNextFocusItemID(0, 100, Control::KeyboardFocus::LEFT, true), 99, TEST_LOCATION );
+ DALI_TEST_EQUALS(layout->GetNextFocusItemID(110, 100, Control::KeyboardFocus::RIGHT, true), 0, TEST_LOCATION );
END_TEST;
}
END_TEST;
}
-int UtcDaliItemViewSetAndGetMouseWheelScrollDistanceStep(void)
+int UtcDaliItemViewSetAndGetWheelScrollDistanceStep(void)
{
ToolkitTestApplication application;
TestItemFactory factory;
ItemView view = ItemView::New(factory);
- // Set the scroll distance step for the mouse wheel event to be 100.0f
- view.SetMouseWheelScrollDistanceStep(100.0f);
+ // Set the scroll distance step for the wheel event to be 100.0f
+ view.SetWheelScrollDistanceStep(100.0f);
// Check the scroll distance step is 100.0f
- DALI_TEST_EQUALS(view.GetMouseWheelScrollDistanceStep(), 100.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(view.GetWheelScrollDistanceStep(), 100.0f, TEST_LOCATION );
END_TEST;
}
: mSignalVerified(signalReceived),
mCurrentFocusedActor(),
mProposedActorToFocus(),
- mDirection(Control::Left)
+ mDirection(Control::KeyboardFocus::LEFT)
{
}
- Actor Callback(Actor currentFocusedActor, Actor proposedActorToFocus, Control::KeyboardFocusNavigationDirection direction)
+ Actor Callback(Actor currentFocusedActor, Actor proposedActorToFocus, Control::KeyboardFocus::Direction direction)
{
tet_infoline("Verifying PreFocusChangeCallback()");
mSignalVerified = false;
mCurrentFocusedActor = Actor();
mProposedActorToFocus = Actor();
- mDirection = Control::Left;
+ mDirection = Control::KeyboardFocus::LEFT;
}
bool& mSignalVerified;
Actor mCurrentFocusedActor;
Actor mProposedActorToFocus;
- Control::KeyboardFocusNavigationDirection mDirection;
+ Control::KeyboardFocus::Direction mDirection;
};
// Functors to test whether focus changed signal is emitted when the keyboard focus is changed
Stage::GetCurrent().Add(second);
// Move the focus to the right
- DALI_TEST_CHECK(manager.MoveFocus(Control::Right) == false);
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
// Because no layout control in the stage and no actor is focused, it should emit the PreFocusChange signal
DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == Actor());
DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
- DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::Right);
+ DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::RIGHT);
preFocusChangeCallback.Reset();
// Check that the focus is set on the first actor
focusChangedCallback.Reset();
// Move the focus towards right
- DALI_TEST_CHECK(manager.MoveFocus(Control::Right) == false);
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
// Because no layout control in the stage and the first actor is focused, it should emit the PreFocusChange signal
DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == first);
DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
- DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::Right);
+ DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::RIGHT);
preFocusChangeCallback.Reset();
// Check that the focus is set on the second actor
focusChangedCallback.Reset();
// Move the focus towards up
- DALI_TEST_CHECK(manager.MoveFocus(Control::Up) == false);
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == false);
// Because no layout control in the stage and no actor is focused, it should emit the PreFocusChange signal
DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == second);
DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
- DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::Up);
+ DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::UP);
preFocusChangeCallback.Reset();
DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
focusChangedCallback.Reset();
// Move the focus towards right
- DALI_TEST_CHECK(manager.MoveFocus(Control::Right) == true);
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
focusChangedCallback.Reset();
// Move the focus towards down
- DALI_TEST_CHECK(manager.MoveFocus(Control::Down) == true);
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::DOWN) == true);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == fourth);
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == second);
focusChangedCallback.Reset();
// Move the focus towards left
- DALI_TEST_CHECK(manager.MoveFocus(Control::Left) == true);
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == fourth);
focusChangedCallback.Reset();
// Move the focus towards up
- DALI_TEST_CHECK(manager.MoveFocus(Control::Up) == true);
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == true);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == third);
focusChangedCallback.Reset();
// Move the focus towards left. The focus move will fail as no way to move it upwards
- DALI_TEST_CHECK(manager.MoveFocus(Control::Left) == false);
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == false);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == first);
DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
- DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::Left);
+ DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::LEFT);
preFocusChangeCallback.Reset();
DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(manager.GetFocusGroupLoop() == true);
// Move the focus towards left again. The focus should move to the fourth actor.
- DALI_TEST_CHECK(manager.MoveFocus(Control::Left) == true);
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == fourth);
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
END_TEST;
}
-int UtcDaliToolkitScrollViewSetMouseWheelScrollDistanceStepP(void)
+int UtcDaliToolkitScrollViewSetWheelScrollDistanceStepP(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliToolkitScrollViewSetMouseWheelScrollDistanceStepP");
+ tet_infoline(" UtcDaliToolkitScrollViewSetWheelScrollDistanceStepP");
ScrollView scrollView = ScrollView::New();
// Disable Refresh signal (TET environment cannot use adaptor's Timer)
- scrollView.SetMouseWheelScrollDistanceStep(Vector2(30.0f, 15.0f));
- DALI_TEST_EQUALS( scrollView.GetMouseWheelScrollDistanceStep(), Vector2(30.0f, 15.0f), TEST_LOCATION );
- scrollView.SetMouseWheelScrollDistanceStep(Vector2(60.0f, 30.0f));
- DALI_TEST_EQUALS( scrollView.GetMouseWheelScrollDistanceStep(), Vector2(60.0f, 30.0f), TEST_LOCATION);
+ scrollView.SetWheelScrollDistanceStep(Vector2(30.0f, 15.0f));
+ DALI_TEST_EQUALS( scrollView.GetWheelScrollDistanceStep(), Vector2(30.0f, 15.0f), TEST_LOCATION );
+ scrollView.SetWheelScrollDistanceStep(Vector2(60.0f, 30.0f));
+ DALI_TEST_EQUALS( scrollView.GetWheelScrollDistanceStep(), Vector2(60.0f, 30.0f), TEST_LOCATION);
END_TEST;
}
mLayer.Add( mBacking );
mBacking.SetOpacity(0.0f);
mBacking.TouchedSignal().Connect( this, &Popup::OnBackingTouched );
- mBacking.MouseWheelEventSignal().Connect(this, &Popup::OnBackingMouseWheelEvent);
+ mBacking.WheelEventSignal().Connect(this, &Popup::OnBackingWheelEvent);
}
void Popup::CreateDialog()
return true;
}
-bool Popup::OnBackingMouseWheelEvent(Actor actor, const MouseWheelEvent& event)
+bool Popup::OnBackingWheelEvent(Actor actor, const WheelEvent& event)
{
- // consume mouse wheel event in dimmed backing actor
+ // consume wheel event in dimmed backing actor
return true;
}
return GetNaturalSize().width;
}
-Actor Popup::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
+Actor Popup::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
{
Actor nextFocusableActor( currentFocusedActor );
{
switch ( direction )
{
- case Toolkit::Control::Left:
+ case Toolkit::Control::KeyboardFocus::LEFT:
{
if ( iter == focusableActors.begin() )
{
}
break;
}
- case Toolkit::Control::Right:
+ case Toolkit::Control::KeyboardFocus::RIGHT:
{
if ( iter == focusableActors.end() - 1 )
{
break;
}
- case Toolkit::Control::Up:
+ case Toolkit::Control::KeyboardFocus::UP:
{
if ( *iter == mContent )
{
break;
}
- case Toolkit::Control::Down:
+ case Toolkit::Control::KeyboardFocus::DOWN:
{
if ( mContent && mContent.IsKeyboardFocusable() )
{
bool OnBackingTouched(Actor actor, const TouchEvent& event);
/**
- * Signal occurs when the mouse wheel event is occured on dimmed backing for the Popup.
- * @param[in] actor The Actor got mouse wheel
- * @param[in] event The Mouse Wheel Event.
+ * Signal occurs when the wheel event is occured on dimmed backing for the Popup.
+ * @param[in] actor The Actor got wheel
+ * @param[in] event The Wheel Event.
* @return Whether to consume event or not.
*/
- bool OnBackingMouseWheelEvent(Actor actor, const MouseWheelEvent& event);
+ bool OnBackingWheelEvent(Actor actor, const WheelEvent& event);
/**
* Signal occurs when the dialog has been touched.
/**
* @copydoc Control::GetNextKeyboardFocusableActor()
*/
- Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled);
+ Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled);
/**
* Create the root actor for the footer
return scrollTo;
}
-int DepthLayout::GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
+int DepthLayout::GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
{
switch( direction )
{
- case Toolkit::Control::Left:
+ case Toolkit::Control::KeyboardFocus::LEFT:
{
itemID--;
if( itemID < 0 )
}
break;
}
- case Toolkit::Control::Up:
+ case Toolkit::Control::KeyboardFocus::UP:
{
itemID += mImpl->mNumberOfColumns;
if( itemID >= maxItems )
}
break;
}
- case Toolkit::Control::Right:
+ case Toolkit::Control::KeyboardFocus::RIGHT:
{
itemID++;
if( itemID >= maxItems )
}
break;
}
- case Toolkit::Control::Down:
+ case Toolkit::Control::KeyboardFocus::DOWN:
{
itemID -= mImpl->mNumberOfColumns;
if( itemID < 0 )
/**
* @copydoc ItemLayout::GetNextFocusItemID()
*/
- virtual int GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled);
+ virtual int GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled);
private:
return itemPosition;
}
-int GridLayout::GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
+int GridLayout::GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
{
switch( direction )
{
- case Toolkit::Control::Left:
+ case Toolkit::Control::KeyboardFocus::LEFT:
{
itemID--;
if( itemID < 0 )
}
break;
}
- case Toolkit::Control::Up:
+ case Toolkit::Control::KeyboardFocus::UP:
{
itemID -= mImpl->mNumberOfColumns;
if( itemID < 0 )
}
break;
}
- case Toolkit::Control::Right:
+ case Toolkit::Control::KeyboardFocus::RIGHT:
{
itemID++;
if( itemID >= maxItems )
}
break;
}
- case Toolkit::Control::Down:
+ case Toolkit::Control::KeyboardFocus::DOWN:
{
itemID += mImpl->mNumberOfColumns;
if( itemID >= maxItems )
/**
* @copydoc ItemLayout::GetNextFocusItemID()
*/
- virtual int GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled);
+ virtual int GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled);
private:
#include <dali/public-api/animation/constraints.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/devel-api/object/type-registry-helper.h>
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),
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);
}
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)
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 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 GetMinimumSwipeDistance() const;
/**
- * @copydoc Toolkit::ItemView::SetMouseWheelScrollDistanceStep
+ * @copydoc Toolkit::ItemView::SetWheelScrollDistanceStep
*/
- void SetMouseWheelScrollDistanceStep(float step);
+ void SetWheelScrollDistanceStep(float step);
/**
- * @copydoc Toolkit::ItemView::GetMouseWheelScrollDistanceStep
+ * @copydoc Toolkit::ItemView::GetWheelScrollDistanceStep
*/
- float GetMouseWheelScrollDistanceStep() const;
+ float GetWheelScrollDistanceStep() const;
/**
* @copydoc Toolkit::ItemView::SetAnchoring
virtual bool OnTouchEvent(const TouchEvent& event);
/**
- * From CustomActorImpl; called after a mouse-wheel-event is received by the owning actor.
- * @param[in] event The mouse wheel event.
+ * From CustomActorImpl; called after a wheel-event is received by the owning actor.
+ * @param[in] event The wheel event.
* @return True if the event should be consumed.
*/
- virtual bool OnMouseWheelEvent(const MouseWheelEvent& event);
+ virtual bool OnWheelEvent(const WheelEvent& event);
private: // From Control
/**
* @copydoc Toolkit::Control::GetNextKeyboardFocusableActor()
*/
- virtual Actor GetNextKeyboardFocusableActor(Actor actor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled);
+ virtual Actor GetNextKeyboardFocusableActor(Actor actor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled);
/**
* @copydoc Toolkit::Control::OnKeyboardFocusChangeCommitted()
void OnOvershootOnFinished(Animation& animation);
/**
- * This is called after a timeout when no new mouse wheel event is received for a certain period of time.
+ * This is called after a timeout when no new wheel event is received for a certain period of time.
* @return will return false; one-shot timer.
*/
- bool OnMouseWheelEventFinished();
+ bool OnWheelEventFinished();
/**
* Stops and removes animation if exists.
float mMinimumSwipeSpeed;
float mMinimumSwipeDistance;
- float mMouseWheelScrollDistanceStep; ///< The step of scroll distance in actor coordinates for each mouse wheel event received.
+ float mWheelScrollDistanceStep; ///< The step of scroll distance in actor coordinates for each wheel event received.
float mScrollDistance;
float mScrollSpeed;
float mScrollOvershoot;
bool mIsFlicking;
- Timer mMouseWheelEventFinishedTimer; ///< The timer to determine whether there is no mouse wheel event received for a certain period of time.
+ Timer mWheelEventFinishedTimer; ///< The timer to determine whether there is no wheel event received for a certain period of time.
Dali::Gesture::State mGestureState;
#include <cstring> // for strcmp
#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/wheel-event.h>
#include <dali/public-api/events/touch-event.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/devel-api/object/type-registry-helper.h>
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 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 Vector2 DEFAULT_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION = Vector2(0.17f, 0.1f); ///< The step of horizontal scroll distance in the proportion of stage size for each wheel event received.
const unsigned long MINIMUM_TIME_BETWEEN_DOWN_AND_UP_FOR_RESET( 150u );
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
}
ScrollView::ScrollView()
-: ScrollBase( ControlBehaviour( REQUIRES_MOUSE_WHEEL_EVENTS ) ), // Enable size negotiation
+: ScrollBase( ControlBehaviour( REQUIRES_WHEEL_EVENTS ) ), // Enable size negotiation
mTouchDownTime(0u),
mGestureStackDepth(0),
mScrollStateFlags(0),
mFrictionCoefficient(DEFAULT_FRICTION_COEFFICIENT),
mFlickSpeedCoefficient(DEFAULT_FLICK_SPEED_COEFFICIENT),
mMaxFlickSpeed(DEFAULT_MAX_FLICK_SPEED),
- mMouseWheelScrollDistanceStep(Vector2::ZERO),
+ mWheelScrollDistanceStep(Vector2::ZERO),
mInAccessibilityPan(false),
mInitialized(false),
mScrolling(false),
mScrollPostPosition = mScrollPrePosition = Vector2::ZERO;
- mMouseWheelScrollDistanceStep = Stage::GetCurrent().GetSize() * DEFAULT_MOUSE_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION;
+ mWheelScrollDistanceStep = Stage::GetCurrent().GetSize() * DEFAULT_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION;
mInitialized = true;
mMaxFlickSpeed = speed;
}
-void ScrollView::SetMouseWheelScrollDistanceStep(Vector2 step)
+void ScrollView::SetWheelScrollDistanceStep(Vector2 step)
{
- mMouseWheelScrollDistanceStep = step;
+ mWheelScrollDistanceStep = step;
}
-Vector2 ScrollView::GetMouseWheelScrollDistanceStep() const
+Vector2 ScrollView::GetWheelScrollDistanceStep() const
{
- return mMouseWheelScrollDistanceStep;
+ return mWheelScrollDistanceStep;
}
unsigned int ScrollView::GetCurrentPage() const
return true;
}
-bool ScrollView::OnMouseWheelEvent(const MouseWheelEvent& event)
+bool ScrollView::OnWheelEvent(const WheelEvent& event)
{
if(!mSensitive)
{
- // Ignore this mouse wheel event, if scrollview is insensitive.
+ // Ignore this wheel event, if scrollview is insensitive.
return false;
}
if(mRulerX->GetType() == Ruler::Free)
{
// Free panning mode
- targetScrollPosition.x += event.z * mMouseWheelScrollDistanceStep.x;
+ targetScrollPosition.x += event.z * mWheelScrollDistanceStep.x;
ClampPosition(targetScrollPosition);
ScrollTo(-targetScrollPosition);
}
if(mRulerY->GetType() == Ruler::Free)
{
// Free panning mode
- targetScrollPosition.y += event.z * mMouseWheelScrollDistanceStep.y;
+ targetScrollPosition.y += event.z * mWheelScrollDistanceStep.y;
ClampPosition(targetScrollPosition);
ScrollTo(-targetScrollPosition);
}
void SetMaxFlickSpeed(float speed);
/**
- * @copydoc Toolkit::ScrollView::GetMouseWheelScrollDistanceStep
+ * @copydoc Toolkit::ScrollView::GetWheelScrollDistanceStep
*/
- Vector2 GetMouseWheelScrollDistanceStep() const;
+ Vector2 GetWheelScrollDistanceStep() const;
/**
- * @copydoc Toolkit::ScrollView::SetMouseWheelScrollDistanceStep
+ * @copydoc Toolkit::ScrollView::SetWheelScrollDistanceStep
*/
- void SetMouseWheelScrollDistanceStep(Vector2 step);
+ void SetWheelScrollDistanceStep(Vector2 step);
/**
* @copydoc Toolkit::ScrollView::GetCurrentPage
virtual bool OnTouchEvent(const TouchEvent& event);
/**
- * From CustomActorImpl; called after a mouse-wheel-event is received by the owning actor.
- * @param[in] event The mouse wheel event.
+ * From CustomActorImpl; called after a wheel-event is received by the owning actor.
+ * @param[in] event The wheel event.
* @return True if the event should be consumed.
*/
- virtual bool OnMouseWheelEvent(const MouseWheelEvent& event);
+ virtual bool OnWheelEvent(const WheelEvent& event);
/**
* @copydoc Toolkit::Control::OnInitialize()
float mFlickSpeedCoefficient; ///< Flick velocity coefficient. Input touch velocity is multiplied by this.
float mMaxFlickSpeed; ///< Maximum flick speed. Maximum speed of flick in stage.lengths/sec.
- Vector2 mMouseWheelScrollDistanceStep; ///< The step of scroll distance in actor coordinates in X and Y axes for each mouse wheel event received.
+ Vector2 mWheelScrollDistanceStep; ///< The step of scroll distance in actor coordinates in X and Y axes for each wheel event received.
//ScrollInternalConstraintsPtr mScrollInternalConstraints;
Constraint mScrollMainInternalPrePositionConstraint;
// nothing to do
}
-Actor TableView::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
+Actor TableView::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
{
Actor nextFocusableActor;
switch ( direction )
{
- case Toolkit::Control::Left:
+ case Toolkit::Control::KeyboardFocus::LEFT:
{
if(--currentColumn < 0)
{
}
break;
}
- case Toolkit::Control::Right:
+ case Toolkit::Control::KeyboardFocus::RIGHT:
{
if(++currentColumn > numberOfColumns - 1)
{
}
break;
}
- case Toolkit::Control::Up:
+ case Toolkit::Control::KeyboardFocus::UP:
{
if(--currentRow < 0)
{
}
break;
}
- case Toolkit::Control::Down:
+ case Toolkit::Control::KeyboardFocus::DOWN:
{
if(++currentRow > numberOfRows - 1)
/**
* @copydoc Control::GetNextKeyboardFocusableActor
*/
- virtual Actor GetNextKeyboardFocusableActor( Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled );
+ virtual Actor GetNextKeyboardFocusableActor( Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled );
/**
* @copydoc Control::GetNaturalSize()
GetTapGestureDetector().SetMaximumTapsRequired( 2 );
EnableGestureDetection(Gesture::Pan);
+ self.TouchedSignal().Connect( this, &TextField::OnTouched );
+
// Set BoundingBox to stage size if not already set.
if ( mDecorator->GetBoundingBox().IsEmpty() )
{
}
}
+bool TextField::OnTouched( Actor actor, const TouchEvent& event )
+{
+ return true;
+}
+
TextField::TextField()
: Control( ControlBehaviour( REQUIRES_STYLE_CHANGE_SIGNALS ) ),
mRenderingBackend( DEFAULT_RENDERING_BACKEND ),
void KeyboardStatusChanged( bool keyboardShown );
/**
+ * @brief Callback when Textfield is touched
+ *
+ * @param[in] actor TextField touched
+ * @param[in] event TouchEvent information
+ */
+ bool OnTouched( Actor actor, const TouchEvent& event );
+
+ /**
* Construct a new TextField.
*/
TextField();
return Toolkit::Control::DownCast(parent);
}
-bool KeyboardFocusManager::MoveFocus(Toolkit::Control::KeyboardFocusNavigationDirection direction)
+bool KeyboardFocusManager::MoveFocus(Toolkit::Control::KeyboardFocus::Direction direction)
{
Actor currentFocusActor = GetCurrentFocusActor();
return succeed;
}
-bool KeyboardFocusManager::DoMoveFocusWithinLayoutControl(Toolkit::Control control, Actor actor, Toolkit::Control::KeyboardFocusNavigationDirection direction)
+bool KeyboardFocusManager::DoMoveFocusWithinLayoutControl(Toolkit::Control control, Actor actor, Toolkit::Control::KeyboardFocus::Direction direction)
{
// Ask the control for the next actor to focus
Actor nextFocusableActor = GetImplementation( control ).GetNextKeyboardFocusableActor(actor, direction, mFocusGroupLoopEnabled);
{
// If the current focus group has a parent layout control, we can probably automatically
// move the focus to the next focus group in the forward or backward direction.
- Toolkit::Control::KeyboardFocusNavigationDirection direction = forward ? Toolkit::Control::Right : Toolkit::Control::Left;
+ Toolkit::Control::KeyboardFocus::Direction direction = forward ? Toolkit::Control::KeyboardFocus::RIGHT : Toolkit::Control::KeyboardFocus::LEFT;
succeed = DoMoveFocusWithinLayoutControl(parentLayoutControl, GetCurrentFocusActor(), direction);
parentLayoutControl = GetParentLayoutControl(parentLayoutControl);
}
else
{
// Move the focus towards left
- MoveFocus(Toolkit::Control::Left);
+ MoveFocus(Toolkit::Control::KeyboardFocus::LEFT);
}
isFocusStartableKey = true;
else
{
// Move the focus towards right
- MoveFocus(Toolkit::Control::Right);
+ MoveFocus(Toolkit::Control::KeyboardFocus::RIGHT);
}
}
else
else
{
// Move the focus towards up
- MoveFocus(Toolkit::Control::Up);
+ MoveFocus(Toolkit::Control::KeyboardFocus::UP);
}
isFocusStartableKey = true;
else
{
// Move the focus towards down
- MoveFocus(Toolkit::Control::Down);
+ MoveFocus(Toolkit::Control::KeyboardFocus::DOWN);
}
isFocusStartableKey = true;
{
// No actor is focused but keyboard focus is activated by the key press
// Let's try to move the initial focus
- MoveFocus(Toolkit::Control::Right);
+ MoveFocus(Toolkit::Control::KeyboardFocus::RIGHT);
}
else if(mFocusIndicatorActor)
{
/**
* @copydoc Toolkit::KeyboardFocusManager::MoveFocus
*/
- bool MoveFocus(Toolkit::Control::KeyboardFocusNavigationDirection direction);
+ bool MoveFocus(Toolkit::Control::KeyboardFocus::Direction direction);
/**
* @copydoc Toolkit::KeyboardFocusManager::ClearFocus
* @param direction The direction of focus movement
* @return Whether the focus is successful or not
*/
- bool DoMoveFocusWithinLayoutControl(Toolkit::Control control, Actor actor, Toolkit::Control::KeyboardFocusNavigationDirection direction);
+ bool DoMoveFocusWithinLayoutControl(Toolkit::Control control, Actor actor, Toolkit::Control::KeyboardFocus::Direction direction);
/**
* Move the focus to the first focusable actor in the next focus group in the forward
return false; // Accessibility value change action is not handled by default
}
-Actor Control::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
+Actor Control::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
{
return Actor();
}
return false; // Do not consume
}
-bool Control::OnMouseWheelEvent(const MouseWheelEvent& event)
+bool Control::OnWheelEvent(const WheelEvent& event)
{
return false; // Do not consume
}
virtual bool OnKeyEvent( const KeyEvent& event );
/**
- * @copydoc CustomActorImpl::OnMouseWheelEvent()
+ * @copydoc CustomActorImpl::OnWheelEvent()
*/
- virtual bool OnMouseWheelEvent( const MouseWheelEvent& event );
+ virtual bool OnWheelEvent( const WheelEvent& event );
/**
* @copydoc CustomActorImpl::OnRelayout()
* @param[in] loopEnabled Whether the focus movement should be looped within the control.
* @return the next keyboard focusable actor in this control or an empty handle if no actor can be focused.
*/
- virtual Actor GetNextKeyboardFocusableActor( Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled );
+ virtual Actor GetNextKeyboardFocusableActor( Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled );
/**
* @brief Informs this control that its chosen focusable actor will be focused.
/**
* @brief Describes the direction to move the keyboard focus towards.
*/
- enum KeyboardFocusNavigationDirection
+ struct KeyboardFocus
{
- Left, ///< Move keyboard focus towards the left direction
- Right, ///< Move keyboard focus towards the right direction
- Up, ///< Move keyboard focus towards the up direction
- Down ///< Move keyboard focus towards the down direction
+ enum Direction
+ {
+ LEFT, ///< Move keyboard focus towards the left direction
+ RIGHT, ///< Move keyboard focus towards the right direction
+ UP, ///< Move keyboard focus towards the up direction
+ DOWN ///< Move keyboard focus towards the down direction
+ };
};
// Typedefs
return currentLayoutPosition;
}
-int ItemLayout::GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
+int ItemLayout::GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
{
switch( direction )
{
- case Control::Left:
- case Control::Up:
+ case Control::KeyboardFocus::LEFT:
+ case Control::KeyboardFocus::UP:
{
itemID--;
if( itemID < 0 )
}
break;
}
- case Control::Right:
- case Control::Down:
+ case Control::KeyboardFocus::RIGHT:
+ case Control::KeyboardFocus::DOWN:
{
itemID++;
if( itemID >= maxItems )
* @param[in] loopEnabled Whether the KeyboardFocusManager is set to wrap around between first and last item
* @return The next item ID.
*/
- DALI_IMPORT_API virtual int GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled);
+ DALI_IMPORT_API virtual int GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled);
/**
* @brief Query the flick speed factor of the layout while swipping.
return GetImpl(*this).GetMinimumSwipeDistance();
}
-void ItemView::SetMouseWheelScrollDistanceStep(float step)
+void ItemView::SetWheelScrollDistanceStep(float step)
{
- GetImpl(*this).SetMouseWheelScrollDistanceStep(step);
+ GetImpl(*this).SetWheelScrollDistanceStep(step);
}
-float ItemView::GetMouseWheelScrollDistanceStep() const
+float ItemView::GetWheelScrollDistanceStep() const
{
- return GetImpl(*this).GetMouseWheelScrollDistanceStep();
+ return GetImpl(*this).GetWheelScrollDistanceStep();
}
void ItemView::SetAnchoring(bool enabled)
float GetMinimumSwipeDistance() const;
/**
- * @brief Set the step of scroll distance in actor coordinates for each mouse wheel event received.
+ * @brief Set the step of scroll distance in actor coordinates for each wheel event received.
*
* @param[in] step The step of scroll distance(pixel).
*/
- void SetMouseWheelScrollDistanceStep(float step);
+ void SetWheelScrollDistanceStep(float step);
/**
- * @brief Get the step of scroll distance in actor coordinates for each mouse wheel event received.
+ * @brief Get the step of scroll distance in actor coordinates for each wheel event received.
*
* @return The step of scroll distance(pixel)
*/
- float GetMouseWheelScrollDistanceStep() const;
+ float GetWheelScrollDistanceStep() const;
/**
* @brief Set whether to enable the animation for the layout to
GetImpl(*this).SetMaxFlickSpeed(speed);
}
-Vector2 ScrollView::GetMouseWheelScrollDistanceStep() const
+Vector2 ScrollView::GetWheelScrollDistanceStep() const
{
- return GetImpl(*this).GetMouseWheelScrollDistanceStep();
+ return GetImpl(*this).GetWheelScrollDistanceStep();
}
-void ScrollView::SetMouseWheelScrollDistanceStep(Vector2 step)
+void ScrollView::SetWheelScrollDistanceStep(Vector2 step)
{
- GetImpl(*this).SetMouseWheelScrollDistanceStep(step);
+ GetImpl(*this).SetWheelScrollDistanceStep(step);
}
Vector2 ScrollView::GetCurrentScrollPosition() const
/**
* @brief Gets the step of scroll distance in actor coordinates for
- * each mouse wheel event received in free panning mode.
+ * each wheel event received in free panning mode.
*
* @return The step of scroll distance(pixel) in X and Y axes.
*/
- Vector2 GetMouseWheelScrollDistanceStep() const;
+ Vector2 GetWheelScrollDistanceStep() const;
/**
* @brief Sets the step of scroll distance in actor coordinates for
- * each mouse wheel event received in free panning mode.
+ * each wheel event received in free panning mode.
*
* @param[in] step The step of scroll distance(pixel) in X and Y axes.
*
* @note: If snap points are defined in the rulers, it will always
* scroll to the next snap point towards the scroll direction while
- * receiving the mouse wheel events.
+ * receiving the wheel events.
*
*/
- void SetMouseWheelScrollDistanceStep(Vector2 step);
+ void SetWheelScrollDistanceStep(Vector2 step);
/**
* @brief Retrieves current scroll position.
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 0;
-const unsigned int TOOLKIT_MICRO_VERSION = 41;
+const unsigned int TOOLKIT_MICRO_VERSION = 42;
const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
return GetImpl(*this).GetCurrentFocusActor();
}
-bool KeyboardFocusManager::MoveFocus(Control::KeyboardFocusNavigationDirection direction)
+bool KeyboardFocusManager::MoveFocus(Control::KeyboardFocus::Direction direction)
{
return GetImpl(*this).MoveFocus(direction);
}
public:
/// @brief Pre focus change signal
- typedef Signal< Actor ( Actor, Actor, Control::KeyboardFocusNavigationDirection ) > PreFocusChangeSignalType;
+ typedef Signal< Actor ( Actor, Actor, Control::KeyboardFocus::Direction ) > PreFocusChangeSignalType;
/// @brief Focus changed signal
typedef Signal< void ( Actor, Actor ) > FocusChangedSignalType;
* @param direction The direction of focus movement
* @return true if the movement was successful
*/
- bool MoveFocus(Control::KeyboardFocusNavigationDirection direction);
+ bool MoveFocus(Control::KeyboardFocus::Direction direction);
/**
* @brief Clear the focus from the current focused actor if any, so
*
* A callback of the following type may be connected:
* @code
- * Actor YourCallbackName(Actor currentFocusedActor, Actor proposedActorToFocus, Control::KeyboardFocusNavigationDirection direction);
+ * Actor YourCallbackName(Actor currentFocusedActor, Actor proposedActorToFocus, Control::KeyboardFocus::Direction direction);
* @endcode
* @pre The Object has been initialized.
* @return The signal to connect to.
### UI Controls
+ [Text Label](@ref text-label)
- + TextEntry
+ + [Text Field](@ref text-field)
+ Buttons
+ TableView
+ [Scroll View](@ref scroll-view)
--- /dev/null
+/**
+ *
+
+# Text Field {#text-field}
+
+## Overview
+
+The Dali::Toolkit::TextField is a control which provides a single-line editable text field.
+
+### Basic usage
+
+Before any text has been entered, the TextField can display some placeholder text.
+An alternative placeholder can be displayed when the TextField has keyboard focus.
+For example a TextField used to enter a username could initially show "Unknown Name", and then show "Enter Name." when the cursor is shown.
+
+~~~{.cpp}
+// C++
+
+TextField field = TextField::New();
+field.SetProperty( TextField::Property::PLACEHOLDER_TEXT, "Unnamed Name" );
+field.SetProperty( TextField::Property::PLACEHOLDER_TEXT_FOCUSED, "Enter Name." );
+
+Stage::GetCurrent().Add( field );
+~~~
+
+~~~{.js}
+// JavaScript
+
+var field = new dali.TextField();
+field.placeholderText = "Unnamed Name";
+field.placeholderTextFocused = "Enter Name.";
+
+dali.stage.add( field );
+~~~
+
+When the TextField is tapped, it will automatically gain the keyboard focus. Key events will then result in text being inserted, and the placeholder text will be removed.
+After text has been entered, it can be retrieved from the TEXT property.
+
+~~~{.cpp}
+// C++
+
+Property::Value fieldText = field.GetProperty( TextField::Property::TEXT );
+std::cout << "Received text: " << fieldText.Get< std::string >() << std::endl;
+~~~
+
+~~~{.js}
+// JavaScript
+
+console.log( field.text );
+~~~
+
+### Font Selection
+
+TextField will automatically select a suitable fonts, in the same was as TextLabel.
+The preferred font can also be selected from a JSON stylesheet:
+
+~~~{.json}
+{
+ "styles":
+ {
+ "textfield":
+ {
+ "font-family":"Arial",
+ "font-style":"Regular",
+ "point-size":8
+ }
+ }
+}
+~~~
+
+### Text Alignment
+
+TextField displays a single-line of text, which will scroll if there is not enough room for the text displayed.
+If there is enough room, then the text can be aligned horizontally to the beginning, end, or center of the available area:
+
+~~~{.cpp}
+// C++
+
+field.SetProperty( TextField::Property::HORIZONTAL_ALIGNMENT, "BEGIN" ); // "CENTER" or "END"
+~~~
+
+~~~{.js}
+// JavaScript
+
+field.HorizontalAlignment = "BEGIN"; // "CENTER" or "END"
+~~~
+
+### TextField Decorations
+
+#### Color
+
+To change the color of the text, the recommended way is to use the TEXT_COLOR property.
+An alternative color can be used for placeholder text by setting PLACEHOLDER_TEXT_COLOR.
+Note that unlike the Actor::COLOR property, these properties will not affect child Actors added to the TextField.
+
+~~~{.cpp}
+// C++
+field.SetProperty( TextField::Property::TEXT_COLOR, Color::CYAN );
+field.SetProperty( TextField::Property::PLACEHOLDER_TEXT_COLOR, Color::BLACK );
+~~~
+
+~~~{.js}
+// JavaScript
+
+field.textColor = dali.COLOR_CYAN;
+field.placeholderTextColor = dali.COLOR_BLACK;
+~~~
+
+### Text Field Properties
+
+ Name (JavaScript) | Name (C++) | Type | Writable | Animatable
+-----------------------------------|--------------------------------------|--------------|--------------|-----------
+ renderingBackend | RENDERING_BACKEND | INTEGER | O | X
+ text | TEXT | STRING | O | X
+ placeholderText | PLACEHOLDER_TEXT | STRING | O | X
+ placeholderTextFocused | PLACEHOLDER_TEXT_FOCUSED | STRING | O | X
+ fontFamily | FONT_FAMILY | STRING | O | X
+ fontStyle | FONT_STYLE | STRING | O | X
+ pointSize | POINT_SIZE | FLOAT | O | X
+ maxLength | MAX_LENGTH | INTEGER | O | X
+ exceedPolicy | EXCEED_POLICY | INTEGER | O | X
+ horizontalAlignment | HORIZONTAL_ALIGNMENT | STRING | O | X
+ verticalAlignment | VERTICAL_ALIGNMENT | STRING | O | X
+ textColor | TEXT_COLOR | VECTOR4 | O | X
+ shadowOffset | SHADOW_OFFSET | VECTOR2 | O | X
+ shadowColor | SHADOW_COLOR | VECTOR4 | O | X
+ primaryCursorColor | PRIMARY_CURSOR_COLOR | VECTOR4 | O | X
+ secondaryCursorColor | SECONDARY_CURSOR_COLOR | VECTOR4 | O | X
+ enableCursorBlink | ENABLE_CURSOR_BLINK | BOOLEAN | O | X
+ cursorBlinkInterval | CURSOR_BLINK_INTERVAL | FLOAT | O | X
+ cursorBlinkDuration | CURSOR_BLINK_DURATION | FLOAT | O | X
+ grabHandleImage | GRAB_HANDLE_IMAGE | STRING | O | X
+ grabHandlePressedImage | GRAB_HANDLE_PRESSED_IMAGE | STRING | O | X
+ scrollThreshold | SCROLL_THRESHOLD | FLOAT | O | X
+ scrollSpreed | SCROLL_SPEED | FLOAT | O | X
+ selectionHandleImageLeft | SELECTION_HANDLE_IMAGE_LEFT | STRING | O | X
+ selectionHandleImageRight | SELECTION_HANDLE_IMAGE_RIGHT | STRING | O | X
+ selectionHandlePressedImageLeft | SELECTION_HANDLE_PRESSED_IMAGE_LEFT | STRING | O | X
+ selectionHandlePressedImageRight | SELECTION_HANDLE_PRESSED_IMAGE_RIGHT | STRING | O | X
+ selectionHighlightColor | SELECTION_HIGHLIGHT_COLOR | VECTOR4 | O | X
+ decorationBoundingBox | DECORATION_BOUNDING_BOX | RECTANGLE | O | X
+ inputMethodSettings | INPUT_METHOD_SETTINGS | MAP | O | X
+
+@class TextField
+
+*/
Name (JavaScript) | Name (C++) | Type | Writable | Animatable
---------------------|---------------------|--------------|--------------|-----------
- renderingBackend | RENDERING_BACKEND | INTEGER | ✔ | ✘
- text | TEXT | STRING | ✔ | ✘
- fontFamily | FONT_FAMILY | STRING | ✔ | ✘
- fontStyle | FONT_STYLE | STRING | ✔ | ✘
- pointSize | POINT_SIZE | FLOAT | ✔ | ✘
- multiLine | MULTI_LINE | BOOLEAN | ✔ | ✘
- horizontalAlignment | HORIZONTAL_ALIGNMENT| STRING | ✔ | ✘
- verticalAlignment | VERTICAL_ALIGNMENT | STRING | ✔ | ✘
- textColor | TEXT_COLOR | VECTOR4 | ✔ | ✘
- shadowOffset | SHADOW_OFFSET | VECTOR2 | ✔ | ✘
- shadowColor | SHADOW_COLOR | VECTOR4 | ✔ | ✘
- underlineEnabled | UNDERLINE_ENABLED | BOOLEAN | ✔ | ✘
- underlineColor | UNDERLINE_COLOR | VECTOR4 | ✔ | ✘
- underlineHeight | UNDERLINE_HEIGHT | FLOAT | ✔ | ✘
+ renderingBackend | RENDERING_BACKEND | INTEGER | O | X
+ text | TEXT | STRING | O | X
+ fontFamily | FONT_FAMILY | STRING | O | X
+ fontStyle | FONT_STYLE | STRING | O | X
+ pointSize | POINT_SIZE | FLOAT | O | X
+ multiLine | MULTI_LINE | BOOLEAN | O | X
+ horizontalAlignment | HORIZONTAL_ALIGNMENT| STRING | O | X
+ verticalAlignment | VERTICAL_ALIGNMENT | STRING | O | X
+ textColor | TEXT_COLOR | VECTOR4 | O | X
+ shadowOffset | SHADOW_OFFSET | VECTOR2 | O | X
+ shadowColor | SHADOW_COLOR | VECTOR4 | O | X
+ underlineEnabled | UNDERLINE_ENABLED | BOOLEAN | O | X
+ underlineColor | UNDERLINE_COLOR | VECTOR4 | O | X
+ underlineHeight | UNDERLINE_HEIGHT | FLOAT | O | X
Name: dali-toolkit
Summary: The OpenGLES Canvas Core Library Toolkit
-Version: 1.0.41
+Version: 1.0.42
Release: 1
Group: System/Libraries
License: Apache-2.0
return handleScope.Escape( hoverObject );
}
-v8::Handle<v8::Object> EventObjectGenerator::CreateMouseWheelEvent( v8::Isolate* isolate, const MouseWheelEvent& wheelEvent)
+v8::Handle<v8::Object> EventObjectGenerator::CreateWheelEvent( v8::Isolate* isolate, const WheelEvent& wheelEvent)
{
- // we are creating a mouse wheel event object that looks like this
+ // we are creating a wheel event object that looks like this
//
+ // event.type = "mouseWheel" or "customWheel" type of the wheel event
// event.direction = "vertical" or "horizontal" direction the wheel is being rolled
// event.shiftPressed = boolean, shift key is held
// event.ctrlPressed = boolean, ctrl key is held
// event.altPressed = boolean, alt key is held
// event.keyModifiers = bitmask of keys pressed
// event.point {x,y} = The co-ordinates of the mouse cursor relative to the top-left of the screen when the wheel is being rolled.
- // event.rolled = offset of mouse wheel rolling, positive = rolling down, negative = rolling up
+ // event.rolled = offset of wheel rolling, positive = rolling down or clockwise, negative = rolling up or counter-clockwise
// event.timestamp = The time (in ms) that the touch event occurred
v8::EscapableHandleScope handleScope( isolate );
v8::Local<v8::Object> wheelObject = v8::Object::New( isolate );
+ // Set the type
+ std::string type = wheelEvent.type ? "mouseWheel" : "customWheel";
+ wheelObject->Set( v8::String::NewFromUtf8( isolate, "type" ), v8::String::NewFromUtf8( isolate, type.c_str() ) );
+
// Set the direction
std::string direction = wheelEvent.direction ? "vertical" : "horizontal";
wheelObject->Set( v8::String::NewFromUtf8( isolate, "direction" ), v8::String::NewFromUtf8( isolate, direction.c_str() ) );
#include <v8.h>
#include <dali/public-api/events/touch-event.h>
#include <dali/public-api/events/hover-event.h>
-#include <dali/public-api/events/mouse-wheel-event.h>
+#include <dali/public-api/events/wheel-event.h>
#include <dali/public-api/events/key-event.h>
#include <dali/public-api/events/pan-gesture.h>
v8::Handle<v8::Object> CreateTouchEvent( v8::Isolate* isolate, const TouchEvent& touchEvent);
v8::Handle<v8::Object> CreateHoverEvent( v8::Isolate* isolate, const HoverEvent& hoverEvent);
- v8::Handle<v8::Object> CreateMouseWheelEvent( v8::Isolate* isolate, const MouseWheelEvent& wheelEvent);
+ v8::Handle<v8::Object> CreateWheelEvent( v8::Isolate* isolate, const WheelEvent& wheelEvent);
v8::Handle<v8::Object> CreateKeyEvent( v8::Isolate* isolate, const KeyEvent& keyEvent);
v8::Handle<v8::Object> CreatePanGesture( v8::Isolate* isolate, const PanGesture& panGesture);
#include "resource-image-api.h"
// EXTERNAL INCLUDES
-#include <dali/devel-api/images/image-operations.h>
+#include <dali/public-api/images/image-operations.h>
// INTERNAL INCLUDES
#include <v8-utils.h>
{
returnValue = EventObjectGenerator::CreateHoverEvent( isolate, value.Get<HoverEvent>() );
}
- else if( typeInfo == typeid( Dali::MouseWheelEvent ) )
+ else if( typeInfo == typeid( Dali::WheelEvent ) )
{
- returnValue = EventObjectGenerator::CreateMouseWheelEvent( isolate, value.Get<MouseWheelEvent>() );
+ returnValue = EventObjectGenerator::CreateWheelEvent( isolate, value.Get<WheelEvent>() );
}
else if( typeInfo == typeid( Dali::KeyEvent ) )
{
#include <dali/public-api/images/image.h>
#include <dali/public-api/events/touch-event.h>
#include <dali/public-api/events/hover-event.h>
-#include <dali/public-api/events/mouse-wheel-event.h>
+#include <dali/public-api/events/wheel-event.h>
#include <dali/public-api/events/key-event.h>
#include <dali/public-api/events/pan-gesture.h>
{
const char* const SIGNAL_TOUCHED = "touched";
const char* const SIGNAL_HOVERED = "hovered";
-const char* const SIGNAL_MOUSE_WHEEL_EVENT = "mouse-wheel-event";
+const char* const SIGNAL_WHEEL_EVENT = "wheel-event";
const char* const SIGNAL_ON_STAGE = "on-stage";
const char* const SIGNAL_OFF_STAGE = "off-stage";
const char* const ANIMATION_SIGNAL_FINISHED = "finished";
returnValue.Get(ret);
return ret;
}
- bool OnMouseWheel( Actor actor, const MouseWheelEvent& event)
+ bool OnWheel( Actor actor, const WheelEvent& event)
{
std::vector< Dali::Any > arguments;
Dali::Any returnValue(false);
Actor PreFocusChangeSignal(Actor currentFocusedActor,
Actor proposedActorToFocus,
- Toolkit::Control::KeyboardFocusNavigationDirection direction )
+ Toolkit::Control::KeyboardFocus::Direction direction )
{
std::vector< Dali::Any > arguments;
Dali::Any returnValue = Actor(); // we want an actor as a return value
{
actor.HoveredSignal().Connect( callback, &ActorCallback::OnHover );
}
- else if ( strcmp( signalName.c_str(), SIGNAL_MOUSE_WHEEL_EVENT ) == 0 )
+ else if ( strcmp( signalName.c_str(), SIGNAL_WHEEL_EVENT ) == 0 )
{
- actor.MouseWheelEventSignal().Connect( callback, &ActorCallback::OnMouseWheel );
+ actor.WheelEventSignal().Connect( callback, &ActorCallback::OnWheel );
}
else if ( strcmp( signalName.c_str(), SIGNAL_ON_STAGE ) == 0 )
{
{
-Toolkit::Control::KeyboardFocusNavigationDirection GetDirection( std::string name, v8::Isolate* isolate )
+Toolkit::Control::KeyboardFocus::Direction GetDirection( std::string name, v8::Isolate* isolate )
{
if( name == "left")
{
- return Dali::Toolkit::Control::Left;
+ return Dali::Toolkit::Control::KeyboardFocus::LEFT;
}
if( name == "right")
{
- return Dali::Toolkit::Control::Right;
+ return Dali::Toolkit::Control::KeyboardFocus::RIGHT;
}
if( name == "up")
{
- return Dali::Toolkit::Control::Up;
+ return Dali::Toolkit::Control::KeyboardFocus::UP;
}
if( name == "down")
{
- return Dali::Toolkit::Control::Down;
+ return Dali::Toolkit::Control::KeyboardFocus::DOWN;
}
DALI_SCRIPT_EXCEPTION( isolate, "direction not found ( wanted left,right,up,down)" );
- return Dali::Toolkit::Control::Up;
+ return Dali::Toolkit::Control::KeyboardFocus::UP;
}
}; //un-named namespace
return;
}
- Toolkit::Control::KeyboardFocusNavigationDirection dir = GetDirection( direction, isolate );
+ Toolkit::Control::KeyboardFocus::Direction dir = GetDirection( direction, isolate );
Toolkit::KeyboardFocusManager::Get().MoveFocus( dir );
}
}
-std::string KeyboardFocusManagerWrapper::GetDirectionName( Toolkit::Control::KeyboardFocusNavigationDirection dir )
+std::string KeyboardFocusManagerWrapper::GetDirectionName( Toolkit::Control::KeyboardFocus::Direction dir )
{
switch( dir )
{
- case Dali::Toolkit::Control::Left:
+ case Dali::Toolkit::Control::KeyboardFocus::LEFT:
{
return "left";
break;
}
- case Dali::Toolkit::Control::Right:
+ case Dali::Toolkit::Control::KeyboardFocus::RIGHT:
{
return "right";
break;
}
- case Dali::Toolkit::Control::Up:
+ case Dali::Toolkit::Control::KeyboardFocus::UP:
{
return "up";
break;
}
- case Dali::Toolkit::Control::Down:
+ case Dali::Toolkit::Control::KeyboardFocus::DOWN:
{
return "down";
break;
virtual SignalManager* GetSignalManager() { return &mSignalManager;}
- static std::string GetDirectionName( Toolkit::Control::KeyboardFocusNavigationDirection dir );
+ static std::string GetDirectionName( Toolkit::Control::KeyboardFocus::Direction dir );
private:
projects / platform / core / uifw / dali-toolkit.git / commitdiff