automated-tests/src/dali-toolkit/utc-Dali-ScrollView.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <iostream>
  19 #include <stdlib.h>
  20 #include <dali-toolkit-test-suite-utils.h>
  21 #include <dali-toolkit/dali-toolkit.h>
  22 #include <dali/integration-api/events/touch-event-integ.h>
  23 #include <dali/integration-api/events/pan-gesture-event.h>
  24
  25 using namespace Dali;
  26 using namespace Toolkit;
  27
  28 void scroll_view_startup(void)
  29 {
  30   test_return_value = TET_UNDEF;
  31 }
  32
  33 void scroll_view_cleanup(void)
  34 {
  35   test_return_value = TET_PASS;
  36 }
  37
  38 namespace
  39 {
  40 static bool gObjectCreatedCallBackCalled;
  41
  42 static void TestCallback(BaseHandle handle)
  43 {
  44   gObjectCreatedCallBackCalled = true;
  45 }
  46
  47
  48 const int MILLISECONDS_PER_SECOND = 1000;
  49 const int RENDER_FRAME_INTERVAL = 16;                           ///< Duration of each frame in ms. (at approx 60FPS)
  50 const int RENDER_ANIMATION_TEST_DURATION_MS = 1000;             ///< 1000ms to test animation
  51 const int RENDER_DELAY_SCROLL = 1000;                           ///< duration to wait for any scroll to complete.
  52
  53 // For Clamp Signal testing...
  54 const float CLAMP_EXCESS_WIDTH = 200.0f;                        ///< Amount of width that can be panned outside scrollview
  55 const float CLAMP_EXCESS_HEIGHT = 200.0f;                       ///< Amount of height that can be panned outside scrollview
  56 const int CLAMP_STEP_0_CHECK_NOTCLAMPED = 0;                    ///< FSM: "First check that scrollview isn't clamped"
  57 const int CLAMP_STEP_1_CHECK_CLAMPED_WEST = 1;                  ///< FSM: "Next check that scrollview clamps against left side"
  58 const int CLAMP_STEP_2_CHECK_CLAMPED_SOUTH_WEST = 2;            ///< FSM: "Then check that scrollview clamps against bottom-left side"
  59 const int CLAMP_STEP_3_SUCCESS = 3;                             ///< FSM: "Finished (Success)"
  60 const Vector2 CLAMP_START_SCROLL_POSITION(30.0f, 100.0f);       ///< Scroll start position for the Clamping tests.
  61 const Vector2 CLAMP_TOUCH_START( 100.0f, 100.0f );              ///< Start point to touch from for the Clamping tests.
  62 const Vector2 CLAMP_TOUCH_MOVEMENT( 5.0f, -5.0f );              ///< Amount to move touch for each frame for the Clamping tests.
  63 const int CLAMP_GESTURE_FRAMES = 100;                           ///< Number of Frames to synthesize a gesture for the Clamping tests.
  64 const Vector3 TEST_ACTOR_POSITION(100.0f, 100.0f, 0.0f);        ///< A Test actor position offset (arbitrary value)
  65 const Vector3 TEST_CONSTRAINT_OFFSET(1.0f, 2.0f, 0.0f);         ///< A Test constraint offset (arbitrary value to test effects)
  66 const float TEST_RATIO_TOLERANCE = 0.05;                        ///< +/-5% tolerance for ratio comparisons.
  67
  68 const float DEFAULT_SNAP_OVERSHOOT_DURATION(0.5f);                  ///< Default overshoot snapping animation time.
  69 const float DEFAULT_MAX_OVERSHOOT(100.0f);                          ///< Default maximum allowed overshoot in pixels
  70
  71 const int MAX_FRAMES_TO_TEST_OVERSHOOT = 600;                       ///< 10 seconds (at 60 frames per second).
  72 const Vector2 OVERSHOOT_START_SCROLL_POSITION(100.0f, 100.0f);       ///< Scroll start position for the Overshoot tests.
  73 const float SCROLL_ANIMATION_DURATION(0.33f);                       ///< Duration of scroll animation in Overshoot tests (i.e. 100 pixels of overshoot in the speed of 500 pixels per 100 frames, 100/(500/(100/60)) = 0.33)
  74 const Vector2 SNAP_POSITION_WITH_DECELERATED_VELOCITY(74.0f, 74.0f); ///< the snap position for Overshoot tests with the decelerated velocity (i.e. Decelerated from 500 pixels per 100 frames).
  75 const float TEST_CUSTOM1_SNAP_OVERSHOOT_DURATION = 0.05f;           ///< a Test duration
  76 const float TEST_CUSTOM2_SNAP_OVERSHOOT_DURATION = 1.5f;            ///< another Test duration
  77 const float TEST_CUSTOM3_SNAP_OVERSHOOT_DURATION = TEST_CUSTOM2_SNAP_OVERSHOOT_DURATION * 0.5f; // Same as above, but different alpha function.
  78 const float TIME_TOLERANCE = 0.05f;                                 ///< Allow testing tolerance between a 10th of second (+/- 3 frames)
  79
  80
  81 // Generate a PanGestureEvent to send to Core
  82 Integration::PanGestureEvent GeneratePan(
  83     Gesture::State state,
  84     const Vector2& previousPosition,
  85     const Vector2& currentPosition,
  86     unsigned long timeDelta,
  87     unsigned int numberOfTouches = 1)
  88 {
  89   Integration::PanGestureEvent pan(state);
  90
  91   pan.previousPosition = previousPosition;
  92   pan.currentPosition = currentPosition;
  93   pan.timeDelta = timeDelta;
  94   pan.numberOfTouches = numberOfTouches;
  95
  96   return pan;
  97 }
  98
  99 /**
 100  * Helper to generate PanGestureEvent
 101  *
 102  * @param[in] application Application instance
 103  * @param[in] state The Gesture State
 104  * @param[in] pos The current position of touch.
 105  */
 106 static void SendPan(ToolkitTestApplication& application, Gesture::State state, const Vector2& pos)
 107 {
 108   static Vector2 last;
 109
 110   if( (state == Gesture::Started) ||
 111       (state == Gesture::Possible) )
 112   {
 113     last.x = pos.x;
 114     last.y = pos.y;
 115   }
 116
 117   application.ProcessEvent(GeneratePan(state, last, pos, RENDER_FRAME_INTERVAL));
 118
 119   last.x = pos.x;
 120   last.y = pos.y;
 121 }
 122
 123 /*
 124  * Simulate time passed by.
 125  *
 126  * @note this will always process at least 1 frame (1/60 sec)
 127  *
 128  * @param application Test application instance
 129  * @param duration Time to pass in milliseconds.
 130  * @return The actual time passed in milliseconds
 131  */
 132 int Wait(ToolkitTestApplication& application, int duration = 0)
 133 {
 134   int time = 0;
 135
 136   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
 137   {
 138     application.SendNotification();
 139     application.Render(RENDER_FRAME_INTERVAL);
 140     time += RENDER_FRAME_INTERVAL;
 141   }
 142
 143   return time;
 144 }
 145
 146 // Callback probes.
 147
 148 static bool gOnScrollStartCalled;                       ///< Whether the OnScrollStart signal was invoked.
 149 static bool gOnScrollUpdateCalled;                      ///< Whether the OnScrollUpdate signal was invoked.
 150 static bool gOnScrollCompleteCalled;                    ///< Whether the OnScrollComplete signal was invoked.
 151 static bool gOnSnapStartCalled;                         ///< Whether the OnSnapStart signal was invoked.
 152 static SnapType gLastSnapType;                          ///< Snaping information from SnapEvent.
 153 static Vector3 gConstraintResult;                       ///< Result from constraint.
 154
 155 /**
 156  * Invoked when scrolling starts.
 157  *
 158  * @param[in] position The current scroll position.
 159  */
 160 static void OnScrollStart( const Vector2& position )
 161 {
 162   gOnScrollStartCalled = true;
 163 }
 164
 165 /**
 166  * Invoked when scrolling updates (via dragging)
 167  *
 168  * @param[in] position The current scroll position.
 169  */
 170 static void OnScrollUpdate( const Vector2& position )
 171 {
 172   gOnScrollUpdateCalled = true;
 173 }
 174
 175 /**
 176  * Invoked when scrolling finishes
 177  *
 178  * @param[in] position The current scroll position.
 179  */
 180 static void OnScrollComplete( const Vector2& position )
 181 {
 182   gOnScrollCompleteCalled = true;
 183 }
 184
 185 /**
 186  * Invoked when a snap or flick started.
 187  *
 188  * @param[in] event The type of snap and the target position/scale/rotation.
 189  */
 190 static void OnSnapStart( const ScrollView::SnapEvent& event )
 191 {
 192   gOnSnapStartCalled = true;
 193   gLastSnapType = event.type;
 194 }
 195
 196 /**
 197  * TestSumConstraint
 198  *
 199  * Summation of current value, property, and offset.
 200  *
 201  * current' = current + mOffset + property;
 202  */
 203 struct TestSumConstraint
 204 {
 205   /**
 206    * @param[in] offset The offset to be added to current.
 207    */
 208   TestSumConstraint(const Vector3& offset)
 209   :mOffset(offset)
 210   {
 211   }
 212
 213   /**
 214    * @param[in] current The current base value
 215    * @param[in] inputs Contains the property to be added to current.
 216    * @return The new current Vector.
 217    */
 218   void operator()( Vector3& current, const PropertyInputContainer& inputs )
 219   {
 220     gConstraintResult = current + Vector3(inputs[0]->GetVector2()) + mOffset;
 221     current = gConstraintResult;
 222   }
 223
 224   Vector3 mOffset;
 225
 226 };
 227
 228 /**
 229  * @param[in] application The application instance
 230  * @param[in] scrollView The scrollView instance
 231  * @return The time taken for the overshoot to reach origin (zero)
 232  */
 233 static float TestOvershootSnapDuration(ToolkitTestApplication &application, ScrollView scrollView)
 234 {
 235   int timeToReachOrigin = -1;
 236   for(int i = 0;i<MAX_FRAMES_TO_TEST_OVERSHOOT;i++)
 237   {
 238     float overshootXValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_X);
 239     float overshootYValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_Y);
 240     if(overshootXValue == 0.0f && overshootYValue == 0.0f)
 241     {
 242       break;
 243     }
 244
 245     timeToReachOrigin += Wait(application);
 246   }
 247
 248   return static_cast<float>(timeToReachOrigin) * 0.001f; // return in seconds not ms.
 249 }
 250
 251 /**
 252  * y = 2x alpha function, which is clamped between 0.0f - 1.0f
 253  *
 254  * Animations should appear to finish (reach 100% point)
 255  * at just half the time of a regular Linear AlphaFunction.
 256  *
 257  * @param[in] progress value (ranges from 0.0f - 1.0f)
 258  * @return interpolation value (ranges from 0.0f - 1.0f)
 259  */
 260 float TestAlphaFunction(float progress)
 261 {
 262   return std::min( progress * 2.0f, 1.0f );
 263 }
 264
 265 } // unnamed namespace
 266
 267
 268 int UtcDaliScrollViewNew(void)
 269 {
 270   ToolkitTestApplication application;
 271   tet_infoline(" UtcDaliScrollViewNew");
 272
 273   ScrollView scrollView;
 274
 275   DALI_TEST_CHECK( !scrollView );
 276
 277   scrollView = ScrollView::New();
 278
 279   DALI_TEST_CHECK( scrollView );
 280
 281   ScrollView scrollView2(scrollView);
 282
 283   DALI_TEST_CHECK( scrollView2 == scrollView );
 284
 285   //Additional check to ensure object is created by checking if it's registered
 286   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 287   DALI_TEST_CHECK( registry );
 288
 289   gObjectCreatedCallBackCalled = false;
 290   registry.ObjectCreatedSignal().Connect( &TestCallback );
 291   {
 292     ScrollView scrollView = ScrollView::New();
 293   }
 294   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
 295   END_TEST;
 296 }
 297
 298 int UtcDaliScrollViewDownCast(void)
 299 {
 300   ToolkitTestApplication application;
 301   tet_infoline(" UtcDaliScrollViewDownCast");
 302
 303   ScrollView scrollView = ScrollView::New();
 304   BaseHandle handle(scrollView);
 305
 306   ScrollView newScrollView = ScrollView::DownCast( handle );
 307   DALI_TEST_CHECK( scrollView );
 308   DALI_TEST_CHECK( newScrollView == scrollView );
 309   END_TEST;
 310 }
 311
 312 int UtcDaliScrollViewScrollToPosition(void)
 313 {
 314   ToolkitTestApplication application;
 315   tet_infoline(" UtcDaliScrollViewScrollToPosition");
 316
 317   // Create the ScrollView actor
 318   ScrollView scrollView = ScrollView::New();
 319   Stage::GetCurrent().Add( scrollView );
 320
 321   const Vector2 target = Vector2(100.0f, 200.0f);
 322   const Vector2 target2 = Vector2(300.0f, 100.0f);
 323
 324   scrollView.ScrollTo( target, 0.0f );
 325   Wait(application);
 326   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), target, TEST_LOCATION );
 327   scrollView.ScrollTo( target2 );
 328   Wait(application, RENDER_DELAY_SCROLL);
 329   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), target2, TEST_LOCATION );
 330
 331   Wait(application);
 332   END_TEST;
 333 }
 334
 335 int UtcDaliScrollViewScrollToPage(void)
 336 {
 337   ToolkitTestApplication application;
 338   tet_infoline(" UtcDaliScrollViewScrollToPage");
 339
 340   ScrollView scrollView = ScrollView::New();
 341   Stage::GetCurrent().Add( scrollView );
 342   RulerPtr rulerX = new FixedRuler( 100.0f );
 343   rulerX->SetDomain( RulerDomain(0.0f, 800.0f, true) );
 344   RulerPtr rulerY = new FixedRuler( 100.0f );
 345   rulerY->SetDomain( RulerDomain(0.0f, 400.0f, true) );
 346
 347   scrollView.SetRulerX( rulerX );
 348   scrollView.SetRulerY( rulerY );
 349
 350   scrollView.ScrollTo( 1, 0.0f );
 351   Wait(application);
 352   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector2(100.0f, 0.0f), TEST_LOCATION );
 353
 354   scrollView.ScrollTo( 5, 0.0f );
 355   Wait(application);
 356   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector2(500.0f, 0.0f), TEST_LOCATION );
 357
 358   scrollView.ScrollTo( 10, 0.0f );
 359   Wait(application);
 360   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector2(200.0f, 100.0f), TEST_LOCATION );
 361
 362   scrollView.ScrollTo( 15, 0.0f );
 363   Wait(application);
 364   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector2(700.0f, 100.0f), TEST_LOCATION );
 365   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 15, TEST_LOCATION );
 366
 367   scrollView.ScrollTo( 3 );
 368   Wait(application, RENDER_DELAY_SCROLL);
 369   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector2(300.0f, 0.0f), TEST_LOCATION );
 370   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 3, TEST_LOCATION );
 371
 372   scrollView.ScrollTo( 9 );
 373   Wait(application, RENDER_DELAY_SCROLL);
 374   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector2(100.0f, 100.0f), TEST_LOCATION );
 375   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 9, TEST_LOCATION );
 376
 377   // Apply DefaultRulers instead and see what happens.
 378   rulerX = new DefaultRuler();
 379   rulerX->SetDomain( RulerDomain(0.0f, 800.0f, true) );
 380   rulerY = new DefaultRuler();
 381   rulerY->SetDomain( RulerDomain(0.0f, 400.0f, true) );
 382
 383   scrollView.SetRulerX( rulerX );
 384   scrollView.SetRulerY( rulerY );
 385
 386   // This time should always scroll to origin (0.0f, 0.0f)
 387   scrollView.ScrollTo( 1, 0.0f );
 388   Wait(application);
 389   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector2(0.0f, 0.0f), TEST_LOCATION );
 390   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 0, TEST_LOCATION );
 391
 392   Wait(application);
 393   END_TEST;
 394 }
 395
 396 int UtcDaliScrollViewScrollToActor(void)
 397 {
 398   ToolkitTestApplication application;
 399   tet_infoline(" UtcDaliScrollViewScrollToActor");
 400
 401   ScrollView scrollView = ScrollView::New();
 402   Stage::GetCurrent().Add( scrollView );
 403
 404   Actor actorA = Actor::New();
 405   const Vector3 positionA = Vector3(100.0f, 400.0f, 0.0f);
 406   actorA.SetPosition(positionA);
 407   scrollView.Add(actorA);
 408
 409   Actor actorB = Actor::New();
 410   const Vector3 positionB = Vector3(500.0f, 200.0f, 0.0f);
 411   actorB.SetPosition(positionB);
 412   scrollView.Add(actorB);
 413
 414   Wait(application);
 415
 416   scrollView.ScrollTo(actorA, 0.0f);
 417   Wait(application);
 418   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), positionA.GetVectorXY(), TEST_LOCATION );
 419
 420   Wait(application);
 421   scrollView.ScrollTo(actorB, 0.0f);
 422   Wait(application);
 423   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), positionB.GetVectorXY(), TEST_LOCATION );
 424
 425   scrollView.ScrollTo(actorA);
 426   Wait(application, RENDER_DELAY_SCROLL);
 427   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), positionA.GetVectorXY(), TEST_LOCATION );
 428
 429   scrollView.ScrollTo(actorB);
 430   Wait(application, RENDER_DELAY_SCROLL);
 431   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), positionB.GetVectorXY(), TEST_LOCATION );
 432   END_TEST;
 433 }
 434
 435 int UtcDaliScrollViewScrollToSnapPoint(void)
 436 {
 437   ToolkitTestApplication application;
 438   tet_infoline(" UtcDaliScrollViewScrollToSnapPoint");
 439
 440   ScrollView scrollView = ScrollView::New();
 441   Stage::GetCurrent().Add( scrollView );
 442   RulerPtr rulerX = new FixedRuler( 100.0f );
 443   rulerX->SetDomain( RulerDomain(0.0f, 800.0f, true) );
 444   RulerPtr rulerY = new FixedRuler( 100.0f );
 445   rulerY->SetDomain( RulerDomain(0.0f, 400.0f, true) );
 446
 447   scrollView.SetRulerX( rulerX );
 448   scrollView.SetRulerY( rulerY );
 449
 450   scrollView.ScrollTo( Vector2(120.0f, 190.0f), 0.0f );
 451   Wait(application);
 452   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector2(120.0f, 190.0f), TEST_LOCATION );
 453
 454   scrollView.ScrollToSnapPoint();
 455
 456   Wait(application, RENDER_DELAY_SCROLL);
 457   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector2(100.0f, 200.0f), TEST_LOCATION );
 458   END_TEST;
 459 }
 460
 461 int UtcDaliScrollViewSetScrollUpdateDistance(void)
 462 {
 463   ToolkitTestApplication application;
 464   tet_infoline(" UtcDaliScrollViewRefreshInterval");
 465
 466   ScrollView scrollView = ScrollView::New();
 467
 468   scrollView.SetScrollUpdateDistance(0);
 469   DALI_TEST_EQUALS( scrollView.GetScrollUpdateDistance(), 0, TEST_LOCATION);
 470   scrollView.SetScrollUpdateDistance(10);
 471   DALI_TEST_EQUALS( scrollView.GetScrollUpdateDistance(), 10, TEST_LOCATION);
 472   scrollView.SetScrollUpdateDistance(1000);
 473   DALI_TEST_EQUALS( scrollView.GetScrollUpdateDistance(), 1000, TEST_LOCATION);
 474   END_TEST;
 475 }
 476
 477 int UtcDaliScrollViewWrapMode(void)
 478 {
 479   ToolkitTestApplication application;
 480   tet_infoline(" UtcDaliScrollViewWrapMode");
 481
 482   ScrollView scrollView = ScrollView::New();
 483   Stage::GetCurrent().Add( scrollView );
 484
 485   // Position rulers. 4x4 grid.
 486   RulerPtr rulerX = new FixedRuler(50.0f);
 487   RulerPtr rulerY = new FixedRuler(50.0f);
 488   rulerX->SetDomain( RulerDomain(0.0f, 200.0f, false) );
 489   rulerY->SetDomain( RulerDomain(0.0f, 200.0f, false) );
 490   scrollView.SetRulerX(rulerX);
 491   scrollView.SetRulerY(rulerY);
 492
 493   scrollView.SetWrapMode(false);
 494   scrollView.ScrollTo(Vector2(225.0f, 125.0f), 0.0f); // 5th (1st) page across, and 3rd (3rd) page down. (wrapped)
 495   Wait(application);
 496   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 17, TEST_LOCATION );
 497   scrollView.SetWrapMode(true);
 498   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 13, TEST_LOCATION );
 499   END_TEST;
 500 }
 501
 502 int UtcDaliScrollViewActorAutoSnap(void)
 503 {
 504   ToolkitTestApplication application;
 505   tet_infoline(" UtcDaliScrollViewActorAutoSnap");
 506
 507   ScrollView scrollView = ScrollView::New();
 508   Stage::GetCurrent().Add( scrollView );
 509
 510   // Position rulers.
 511   RulerPtr rulerX = new DefaultRuler();
 512   RulerPtr rulerY = new DefaultRuler();
 513   rulerX->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 514   rulerY->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 515   scrollView.SetRulerX(rulerX);
 516   scrollView.SetRulerY(rulerY);
 517
 518   const Vector3 aPosition = Vector3(200.0f, 50.0f, 0.0f);
 519   Actor a = Actor::New();
 520   scrollView.Add(a);
 521   a.SetPosition(aPosition);
 522
 523   const Vector3 bPosition = Vector3(600.0f, 600.0f, 0.0f);
 524   Actor b = Actor::New();
 525   scrollView.Add(b);
 526   b.SetPosition(bPosition);
 527
 528   // Goto a random position, and execute snap (should not move)
 529   Vector2 targetScroll = Vector2(500.0f, 500.0f);
 530   scrollView.ScrollTo(targetScroll, 0.0f);
 531   Wait(application);
 532   scrollView.ScrollToSnapPoint();
 533   Wait(application, RENDER_DELAY_SCROLL);
 534   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), targetScroll, TEST_LOCATION );
 535
 536   // Enable ActorAutoSnap, and now try snapping.
 537   scrollView.SetActorAutoSnap(true);
 538   scrollView.ScrollToSnapPoint();
 539   Wait(application, RENDER_DELAY_SCROLL);
 540   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), bPosition.GetVectorXY(), TEST_LOCATION );
 541
 542   scrollView.ScrollTo(Vector2(0.0f, 0.0f), 0.0f);
 543   Wait(application);
 544   scrollView.ScrollToSnapPoint();
 545   Wait(application, RENDER_DELAY_SCROLL);
 546   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), aPosition.GetVectorXY(), TEST_LOCATION );
 547   END_TEST;
 548 }
 549
 550 int UtcDaliScrollViewSignalsStartComplete(void)
 551 {
 552   ToolkitTestApplication application;
 553   tet_infoline(" UtcDaliScrollViewSignalsStartComplete");
 554
 555   gOnScrollStartCalled = false;
 556   gOnScrollCompleteCalled = false;
 557
 558   ScrollView scrollView = ScrollView::New();
 559   Stage::GetCurrent().Add( scrollView );
 560
 561   // Position rulers.
 562   RulerPtr rulerX = new DefaultRuler();
 563   RulerPtr rulerY = new DefaultRuler();
 564   rulerX->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 565   rulerY->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 566   scrollView.SetRulerX(rulerX);
 567   scrollView.SetRulerY(rulerY);
 568   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
 569   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
 570   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
 571   scrollView.ScrollTo( Vector2(100.0f, 100.0f) );
 572   Wait(application, RENDER_DELAY_SCROLL);
 573
 574   DALI_TEST_CHECK(gOnScrollStartCalled);
 575   DALI_TEST_CHECK(gOnScrollCompleteCalled);
 576   END_TEST;
 577 }
 578
 579 int UtcDaliScrollViewSignalsUpdate(void)
 580 {
 581   ToolkitTestApplication application;
 582   tet_infoline(" UtcDaliScrollViewSignalsUpdate");
 583
 584   gOnScrollStartCalled = false;
 585   gOnScrollUpdateCalled = false;
 586   gOnScrollCompleteCalled = false;
 587
 588   ScrollView scrollView = ScrollView::New();
 589   Stage::GetCurrent().Add( scrollView );
 590   Vector2 stageSize = Stage::GetCurrent().GetSize();
 591   scrollView.SetSize(stageSize);
 592   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
 593   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 594
 595   // Position rulers.
 596   RulerPtr rulerX = new DefaultRuler();
 597   RulerPtr rulerY = new DefaultRuler();
 598   rulerX->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 599   rulerY->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 600   scrollView.SetRulerX(rulerX);
 601   scrollView.SetRulerY(rulerY);
 602   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
 603   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
 604   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
 605
 606   ImageActor image = CreateSolidColorActor( Color::RED );
 607   image.SetSize(stageSize);
 608   image.SetParentOrigin(ParentOrigin::TOP_LEFT);
 609   image.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 610   scrollView.Add(image);
 611
 612   Wait(application);
 613
 614   // Do a pan starting from 100,100 and moving down diagonally.
 615   Vector2 pos(100.0f, 100.0f);
 616   SendPan(application, Gesture::Possible, pos);
 617   SendPan(application, Gesture::Started, pos);
 618   pos.x += 5.0f;
 619   pos.y += 5.0f;
 620   Wait(application, 100);
 621
 622   for(int i = 0;i<20;i++)
 623   {
 624     SendPan(application, Gesture::Continuing, pos);
 625     pos.x += 5.0f;
 626     pos.y += 5.0f;
 627     Wait(application);
 628   }
 629
 630   SendPan(application, Gesture::Finished, pos);
 631   Wait(application, RENDER_DELAY_SCROLL);
 632
 633   DALI_TEST_CHECK(gOnScrollStartCalled);
 634   DALI_TEST_CHECK(gOnScrollUpdateCalled);
 635   DALI_TEST_CHECK(gOnScrollCompleteCalled);
 636   END_TEST;
 637 }
 638
 639 static Vector2 PerformGestureDiagonalSwipe(ToolkitTestApplication& application, Vector2 start, Vector2 direction, int frames, bool finish = true)
 640 {
 641   gOnScrollStartCalled = false;
 642   gOnScrollUpdateCalled = false;
 643   gOnScrollCompleteCalled = false;
 644   gOnSnapStartCalled = false;
 645
 646   // Now do a pan starting from (start) and heading (direction)
 647   Vector2 pos(start);
 648   SendPan(application, Gesture::Possible, pos);
 649   SendPan(application, Gesture::Started, pos);
 650   Wait(application);
 651
 652   for(int i = 0;i<frames;i++)
 653   {
 654     pos += direction; // Move in this direction
 655     SendPan(application, Gesture::Continuing, pos);
 656     Wait(application);
 657   }
 658
 659   if(finish)
 660   {
 661     pos += direction; // Move in this direction.
 662     SendPan(application, Gesture::Finished, pos);
 663     Wait(application, RENDER_DELAY_SCROLL);
 664   }
 665
 666   return pos;
 667 }
 668
 669 int UtcDaliScrollViewScrollSensitive(void)
 670 {
 671   ToolkitTestApplication application;
 672   tet_infoline(" UtcDaliScrollViewScrollSensitive");
 673
 674   // Set up a scrollView...
 675   ScrollView scrollView = ScrollView::New();
 676   Stage::GetCurrent().Add( scrollView );
 677   Vector2 stageSize = Stage::GetCurrent().GetSize();
 678   scrollView.SetSize(stageSize);
 679   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
 680   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 681
 682   // Position rulers.
 683   RulerPtr rulerX = new DefaultRuler();
 684   RulerPtr rulerY = new DefaultRuler();
 685   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
 686   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
 687   scrollView.SetRulerX(rulerX);
 688   scrollView.SetRulerY(rulerY);
 689   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
 690   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
 691   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
 692   scrollView.SnapStartedSignal().Connect( &OnSnapStart );
 693
 694   scrollView.ScrollTo(CLAMP_START_SCROLL_POSITION, 0.0f); // move in a little.
 695   Wait(application);
 696
 697   // First try insensitive swipe.
 698   scrollView.SetScrollSensitive(false);
 699   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, CLAMP_TOUCH_MOVEMENT, CLAMP_GESTURE_FRAMES, true);
 700
 701   DALI_TEST_CHECK( !gOnScrollStartCalled );
 702   DALI_TEST_CHECK( !gOnScrollCompleteCalled );
 703   DALI_TEST_CHECK( !gOnSnapStartCalled );
 704
 705   // Second try sensitive swipe.
 706   scrollView.SetScrollSensitive(true);
 707   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, CLAMP_TOUCH_MOVEMENT, CLAMP_GESTURE_FRAMES, true);
 708
 709   DALI_TEST_CHECK( gOnScrollStartCalled );
 710   DALI_TEST_CHECK( gOnScrollCompleteCalled );
 711   DALI_TEST_CHECK( gOnSnapStartCalled );
 712   END_TEST;
 713 }
 714
 715 int UtcDaliScrollViewAxisAutoLock(void)
 716 {
 717   ToolkitTestApplication application;
 718   tet_infoline(" UtcDaliScrollViewAxisAutoLock");
 719
 720   // Set up a scrollView...
 721   ScrollView scrollView = ScrollView::New();
 722   Stage::GetCurrent().Add( scrollView );
 723   Vector2 stageSize = Stage::GetCurrent().GetSize();
 724   scrollView.SetSize(stageSize);
 725   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
 726   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 727
 728   // Position rulers.
 729   RulerPtr rulerX = new DefaultRuler();
 730   RulerPtr rulerY = new DefaultRuler();
 731   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
 732   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
 733   scrollView.SetRulerX(rulerX);
 734   scrollView.SetRulerY(rulerY);
 735   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
 736   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
 737   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
 738
 739   // Normal
 740   scrollView.ScrollTo(Vector2(100.0f, 100.0f), 0.0f); // move in a little.
 741   Wait(application);
 742   Vector2 startPosition = scrollView.GetCurrentScrollPosition();
 743   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, Vector2(5.0f, 1.0f), 50, true); // mostly horizontal
 744   const Vector2 positionAfterNormal = scrollView.GetCurrentScrollPosition();
 745
 746   // Autolock
 747   scrollView.SetAxisAutoLock(true);
 748   DALI_TEST_CHECK(scrollView.GetAxisAutoLock());
 749
 750   scrollView.ScrollTo(Vector2(100.0f, 100.0f), 0.0f); // move in a little.
 751   Wait(application);
 752   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, Vector2(5.0f, 1.0f), 50, true); // mostly horizontal
 753   const Vector2 positionAfterAutoLock = scrollView.GetCurrentScrollPosition();
 754
 755   // compare how much the Y position has deviated for normal and autolock.
 756   const float devianceNormal = fabsf(startPosition.y - positionAfterNormal.y);
 757   const float devianceAutoLock = fabsf(startPosition.y - positionAfterAutoLock.y);
 758
 759   // in auto-lock it should be a mostly horizontal pan (thus deviance should be much lower)
 760   DALI_TEST_CHECK(devianceAutoLock < devianceNormal);
 761
 762   scrollView.SetAxisAutoLock(false);
 763   DALI_TEST_CHECK(!scrollView.GetAxisAutoLock());
 764   END_TEST;
 765 }
 766
 767 int UtcDaliScrollViewAxisAutoLockGradient(void)
 768 {
 769   ToolkitTestApplication application;
 770   tet_infoline(" UtcDaliScrollViewAxisAutoLockGradient");
 771
 772   // Set up a scrollView...
 773   ScrollView scrollView = ScrollView::New();
 774   scrollView.SetAxisAutoLockGradient(0.5f);
 775   DALI_TEST_EQUALS(scrollView.GetAxisAutoLockGradient(), 0.5f, TEST_LOCATION);
 776   scrollView.SetAxisAutoLockGradient(1.0f);
 777   DALI_TEST_EQUALS(scrollView.GetAxisAutoLockGradient(), 1.0f, TEST_LOCATION);
 778   END_TEST;
 779 }
 780
 781 int UtcDaliScrollViewConstraints(void)
 782 {
 783   ToolkitTestApplication application;
 784   tet_infoline(" UtcDaliScrollViewConstraints");
 785
 786   // Set up a scrollView...
 787   ScrollView scrollView = ScrollView::New();
 788   Stage::GetCurrent().Add( scrollView );
 789   Vector2 stageSize = Stage::GetCurrent().GetSize();
 790   scrollView.SetSize(stageSize);
 791   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
 792   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 793
 794   // Position rulers.
 795   RulerPtr rulerX = new DefaultRuler();
 796   RulerPtr rulerY = new DefaultRuler();
 797   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
 798   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
 799   scrollView.SetRulerX(rulerX);
 800   scrollView.SetRulerY(rulerY);
 801
 802   // Add an Actor to ScrollView,
 803   // Apply TestSumConstraint to ScrollView's children (includes this Actor)
 804   gConstraintResult = Vector3::ZERO;
 805   Actor a = Actor::New();
 806   scrollView.Add(a);
 807   a.SetPosition( TEST_ACTOR_POSITION );
 808   Wait(application);
 809
 810   Constraint constraint = Constraint::New<Vector3>( scrollView, Actor::Property::POSITION, TestSumConstraint( TEST_CONSTRAINT_OFFSET ) );
 811   constraint.AddSource( Source(scrollView, ScrollView::Property::SCROLL_POSITION) );
 812   constraint.SetRemoveAction(Constraint::Discard);
 813   scrollView.ApplyConstraintToChildren(constraint);
 814   Wait(application);
 815
 816   DALI_TEST_EQUALS( gConstraintResult, TEST_ACTOR_POSITION + TEST_CONSTRAINT_OFFSET, TEST_LOCATION );
 817
 818   gConstraintResult = Vector3::ZERO;
 819   scrollView.RemoveConstraintsFromChildren();
 820   Wait(application);
 821
 822   DALI_TEST_EQUALS( gConstraintResult, Vector3::ZERO, TEST_LOCATION );
 823   END_TEST;
 824 }
 825
 826 int UtcDaliScrollViewBind(void)
 827 {
 828   ToolkitTestApplication application;
 829   tet_infoline(" UtcDaliScrollViewBind");
 830
 831   // Set up a scrollView...
 832   ScrollView scrollView = ScrollView::New();
 833   Stage::GetCurrent().Add( scrollView );
 834   Vector2 stageSize = Stage::GetCurrent().GetSize();
 835   scrollView.SetSize(stageSize);
 836   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
 837   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 838
 839   // Position rulers.
 840   RulerPtr rulerX = new DefaultRuler();
 841   RulerPtr rulerY = new DefaultRuler();
 842   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
 843   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
 844   scrollView.SetRulerX(rulerX);
 845   scrollView.SetRulerY(rulerY);
 846
 847   // Add an Actor to ScrollView,
 848   // Apply TestSumConstraint to ScrollView's children (includes this Actor)
 849
 850   gConstraintResult = Vector3::ZERO;
 851   Actor a = Actor::New();
 852   scrollView.Add(a);
 853   a.SetPosition( TEST_ACTOR_POSITION );
 854   Wait(application);
 855
 856   // apply this constraint to scrollview
 857   Constraint constraint = Constraint::New<Vector3>( scrollView, Actor::Property::POSITION, TestSumConstraint( TEST_CONSTRAINT_OFFSET ) );
 858   constraint.AddSource( Source(scrollView, ScrollView::Property::SCROLL_POSITION) );
 859   constraint.SetRemoveAction(Constraint::Discard);
 860   scrollView.ApplyConstraintToChildren(constraint);
 861
 862   Wait(application);
 863   // Defaulty Bound.
 864   DALI_TEST_EQUALS( gConstraintResult, TEST_ACTOR_POSITION + TEST_CONSTRAINT_OFFSET, TEST_LOCATION );
 865
 866   // UnBind
 867   gConstraintResult = Vector3::ZERO;
 868   scrollView.UnbindActor( a );
 869   Wait(application);
 870   DALI_TEST_EQUALS( gConstraintResult, Vector3::ZERO, TEST_LOCATION );
 871
 872   // Bind
 873   gConstraintResult = Vector3::ZERO;
 874   scrollView.BindActor( a );
 875   Wait(application);
 876   DALI_TEST_EQUALS( gConstraintResult, TEST_ACTOR_POSITION + TEST_CONSTRAINT_OFFSET, TEST_LOCATION );
 877   END_TEST;
 878 }
 879
 880 int UtcDaliRulerEnableDisable(void)
 881 {
 882   ToolkitTestApplication application;
 883   tet_infoline(" UtcDaliRulerEnableDisable");
 884
 885   RulerPtr ruler = new DefaultRuler();
 886
 887   DALI_TEST_CHECK( ruler->IsEnabled() );
 888   ruler->Disable();
 889   DALI_TEST_CHECK( !ruler->IsEnabled() );
 890   ruler->Enable();
 891   DALI_TEST_CHECK( ruler->IsEnabled() );
 892   END_TEST;
 893 }
 894
 895 int UtcDaliRulerDomainEnableDisable(void)
 896 {
 897   ToolkitTestApplication application;
 898   tet_infoline(" UtcDaliRulerDomainEnableDisable");
 899
 900   RulerPtr ruler = new DefaultRuler();
 901   DALI_TEST_EQUALS( ruler->GetDomain().GetSize(), 1.0f, TEST_LOCATION );
 902
 903
 904   ruler->SetDomain( RulerDomain(0.0f, 100.0f, true) );
 905   DALI_TEST_EQUALS( ruler->GetDomain().GetSize(), 100.0f, TEST_LOCATION );
 906   DALI_TEST_EQUALS( ruler->Clamp(-200.0f), 0.0f, TEST_LOCATION );
 907   DALI_TEST_EQUALS( ruler->Clamp(200.0f), 100.0f, TEST_LOCATION );
 908
 909   ruler->DisableDomain();
 910   DALI_TEST_EQUALS( ruler->GetDomain().GetSize(), 1.0f, TEST_LOCATION );
 911   DALI_TEST_EQUALS( ruler->Clamp(-200.0f), -200.0f, TEST_LOCATION );
 912   DALI_TEST_EQUALS( ruler->Clamp(200.0f), 200.0f, TEST_LOCATION );
 913   END_TEST;
 914 }
 915
 916 int UtcDaliRulerSnapAndClamp(void)
 917 {
 918   ToolkitTestApplication application;
 919   tet_infoline(" UtcDaliRulerSnapAndClamp");
 920
 921   RulerPtr ruler = new FixedRuler( 50.0f );
 922   ruler->SetDomain( RulerDomain(0.0f, 400.0f, true) );
 923
 924   // default testing. (snap and clamp)
 925   DALI_TEST_EQUALS( ruler->SnapAndClamp(50.0f), 50.0f, TEST_LOCATION);
 926   DALI_TEST_EQUALS( ruler->SnapAndClamp(30.0f), 50.0f, TEST_LOCATION);
 927   DALI_TEST_EQUALS( ruler->SnapAndClamp(10.0f), 0.0f, TEST_LOCATION);
 928   DALI_TEST_EQUALS( ruler->SnapAndClamp(-40.0f), 0.0f, TEST_LOCATION);
 929   DALI_TEST_EQUALS( ruler->SnapAndClamp(390.0f), 400.0f, TEST_LOCATION);
 930   DALI_TEST_EQUALS( ruler->SnapAndClamp(430.0f), 400.0f, TEST_LOCATION);
 931
 932   // bias testing.
 933   DALI_TEST_EQUALS( ruler->SnapAndClamp(40.0f, 0.0f), 0.0f, TEST_LOCATION); // Flick Left
 934   DALI_TEST_EQUALS( ruler->SnapAndClamp(40.0f, 0.5f), 50.0f, TEST_LOCATION); // No Flick
 935   DALI_TEST_EQUALS( ruler->SnapAndClamp(40.0f, 1.0f), 50.0f, TEST_LOCATION); // Flick Right
 936
 937   DALI_TEST_EQUALS( ruler->SnapAndClamp(20.0f, 0.0f), 0.0f, TEST_LOCATION); // Flick Left
 938   DALI_TEST_EQUALS( ruler->SnapAndClamp(20.0f, 0.5f), 0.0f, TEST_LOCATION); // No Flick
 939   DALI_TEST_EQUALS( ruler->SnapAndClamp(20.0f, 1.0f), 50.0f, TEST_LOCATION); // Flick Right
 940
 941   // length testing.
 942   DALI_TEST_EQUALS( ruler->SnapAndClamp(-10.0f, 0.5f, 10.0f), 0.0f, TEST_LOCATION); // 10 units long (over left boundary)
 943   DALI_TEST_EQUALS( ruler->SnapAndClamp(-5.0f, 0.5f, 10.0f), 0.0f, TEST_LOCATION); // 10 units long (slightly ovr left boundary)
 944   DALI_TEST_EQUALS( ruler->SnapAndClamp(300.0f, 0.5f, 10.0f), 300.0f, TEST_LOCATION); // 10 units long (not over a boundary)
 945   DALI_TEST_EQUALS( ruler->SnapAndClamp(395.0f, 0.5f, 10.0f), 390.0f, TEST_LOCATION); // 10 units long (slightly over right boundary)
 946   DALI_TEST_EQUALS( ruler->SnapAndClamp(500.0f, 0.5f, 10.0f), 390.0f, TEST_LOCATION); // 10 units long (over right boundary)
 947
 948   // scale testing.
 949   DALI_TEST_EQUALS( ruler->SnapAndClamp(-100.0f, 0.5f, 0.0f, 2.0f), 0.0f, TEST_LOCATION);
 950   DALI_TEST_EQUALS( ruler->SnapAndClamp(50.0f, 0.5f, 0.0f, 2.0f), 50.0f, TEST_LOCATION);
 951   DALI_TEST_EQUALS( ruler->SnapAndClamp(700.0f, 0.5f, 0.0f, 2.0f), 700.0f, TEST_LOCATION);
 952   DALI_TEST_EQUALS( ruler->SnapAndClamp(850.0f, 0.5f, 0.0f, 2.0f), 800.0f, TEST_LOCATION);
 953
 954   // clamp state testing.
 955   ClampState clamped;
 956   DALI_TEST_EQUALS( ruler->SnapAndClamp(50.0f, 0.5f, 0.0f, 1.0f, clamped), 50.0f, TEST_LOCATION);
 957   DALI_TEST_EQUALS( clamped, NotClamped, TEST_LOCATION );
 958   DALI_TEST_EQUALS( ruler->SnapAndClamp(30.0f, 0.5f, 0.0f, 1.0f, clamped), 50.0f, TEST_LOCATION);
 959   DALI_TEST_EQUALS( clamped, NotClamped, TEST_LOCATION );
 960   DALI_TEST_EQUALS( ruler->SnapAndClamp(10.0f, 0.5f, 0.0f, 1.0f, clamped), 0.0f, TEST_LOCATION);
 961   DALI_TEST_EQUALS( clamped, NotClamped, TEST_LOCATION );
 962   DALI_TEST_EQUALS( ruler->SnapAndClamp(-40.0f, 0.5f, 0.0f, 1.0f, clamped), 0.0f, TEST_LOCATION);
 963   DALI_TEST_EQUALS( clamped, ClampedToMin, TEST_LOCATION );
 964   DALI_TEST_EQUALS( ruler->SnapAndClamp(390.0f, 0.5f, 0.0f, 1.0f, clamped), 400.0f, TEST_LOCATION);
 965   DALI_TEST_EQUALS( clamped, NotClamped, TEST_LOCATION );
 966   DALI_TEST_EQUALS( ruler->SnapAndClamp(430.0f, 0.5f, 0.0f, 1.0f, clamped), 400.0f, TEST_LOCATION);
 967   DALI_TEST_EQUALS( clamped, ClampedToMax, TEST_LOCATION );
 968   END_TEST;
 969 }
 970
 971 int UtcDaliRulerFixedRulerSpacing(void)
 972 {
 973   ToolkitTestApplication application;
 974   tet_infoline(" UtcDaliRulerFixedRulerSpacing");
 975
 976   RulerPtr rulerNormal = new FixedRuler( 25.0f );
 977   rulerNormal->SetDomain( RulerDomain(10.0f, 90.0f, true) );
 978
 979   unsigned int volume;
 980   float position;
 981
 982   position = rulerNormal->GetPositionFromPage(1, volume, true);
 983   DALI_TEST_EQUALS( position, 35.0f, TEST_LOCATION );
 984   DALI_TEST_EQUALS( volume, 0u, TEST_LOCATION );
 985
 986   position = rulerNormal->GetPositionFromPage(2, volume, true);
 987   DALI_TEST_EQUALS( position, 60.0f, TEST_LOCATION );
 988   DALI_TEST_EQUALS( volume, 0u, TEST_LOCATION );
 989   END_TEST;
 990 }
 991
 992 int UtcDaliScrollViewOvershoot(void)
 993 {
 994   ToolkitTestApplication application;
 995   tet_infoline(" UtcDaliScrollViewOvershoot");
 996
 997   // Set up a scrollView...
 998   ScrollView scrollView = ScrollView::New();
 999   Stage::GetCurrent().Add( scrollView );
1000   Vector2 stageSize = Stage::GetCurrent().GetSize();
1001   scrollView.SetSize(stageSize);
1002   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
1003   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1004
1005   // Position rulers.
1006   RulerPtr rulerX = new DefaultRuler();
1007   RulerPtr rulerY = new DefaultRuler();
1008   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
1009   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
1010   scrollView.SetRulerX(rulerX);
1011   scrollView.SetRulerY(rulerY);
1012   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
1013   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
1014   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
1015
1016   scrollView.ScrollTo(OVERSHOOT_START_SCROLL_POSITION, 0.0f); // move in a little.
1017   Wait(application);
1018
1019   // 1. Scroll page in NW (-500,-500 pixels), then inspect overshoot. (don't release touch)
1020   Vector2 currentPos = Vector2(100.0f, 100.0f);
1021   currentPos = PerformGestureDiagonalSwipe(application, currentPos, Vector2(5.0f, 5.0f), 100, false);
1022   float overshootXValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_X);
1023   float overshootYValue = scrollView.GetProperty<float>(ScrollView::Property::OVERSHOOT_Y);
1024   Vector2 positionValue = scrollView.GetProperty<Vector2>(ScrollView::Property::SCROLL_POSITION);
1025   DALI_TEST_EQUALS(overshootXValue, 1.0f, TEST_LOCATION);
1026   DALI_TEST_EQUALS(overshootYValue, 1.0f, TEST_LOCATION);
1027   DALI_TEST_EQUALS(positionValue, Vector2::ZERO, TEST_LOCATION);
1028
1029   float timeToReachOrigin;
1030
1031   // Now release touch. Overshoot should snap back to zero.
1032   SendPan(application, Gesture::Finished, currentPos);
1033   timeToReachOrigin = TestOvershootSnapDuration(application, scrollView);
1034
1035   float minTimeToReachOrigin = SCROLL_ANIMATION_DURATION + DEFAULT_SNAP_OVERSHOOT_DURATION * (SNAP_POSITION_WITH_DECELERATED_VELOCITY.x / DEFAULT_MAX_OVERSHOOT) - TIME_TOLERANCE;
1036   float maxTimeToReachOrigin = SCROLL_ANIMATION_DURATION + DEFAULT_SNAP_OVERSHOOT_DURATION * (SNAP_POSITION_WITH_DECELERATED_VELOCITY.x / DEFAULT_MAX_OVERSHOOT) + TIME_TOLERANCE;
1037
1038   DALI_TEST_CHECK( (timeToReachOrigin > minTimeToReachOrigin) &&
1039                    (timeToReachOrigin < maxTimeToReachOrigin) );
1040
1041   // 2. Repeat Scroll, but this time change overshoot snap duration to shorter time
1042   scrollView.SetSnapOvershootDuration(TEST_CUSTOM1_SNAP_OVERSHOOT_DURATION);
1043
1044   currentPos = PerformGestureDiagonalSwipe(application, Vector2(100.0f, 100.0f), Vector2(5.0f, 5.0f), 100, false);
1045   // Now release touch. Overshoot should snap back to zero.
1046   SendPan(application, Gesture::Finished, currentPos);
1047   timeToReachOrigin = TestOvershootSnapDuration(application, scrollView);
1048
1049   minTimeToReachOrigin = SCROLL_ANIMATION_DURATION + TEST_CUSTOM1_SNAP_OVERSHOOT_DURATION * (SNAP_POSITION_WITH_DECELERATED_VELOCITY.x / DEFAULT_MAX_OVERSHOOT) - TIME_TOLERANCE;
1050   maxTimeToReachOrigin = SCROLL_ANIMATION_DURATION + TEST_CUSTOM1_SNAP_OVERSHOOT_DURATION * (SNAP_POSITION_WITH_DECELERATED_VELOCITY.x / DEFAULT_MAX_OVERSHOOT) + TIME_TOLERANCE;
1051
1052   DALI_TEST_CHECK( (timeToReachOrigin > minTimeToReachOrigin) &&
1053                    (timeToReachOrigin < maxTimeToReachOrigin) );
1054
1055   // 3. Repeat Scroll, but this time change overshoot snap duration to longer time.
1056   scrollView.SetSnapOvershootDuration(TEST_CUSTOM2_SNAP_OVERSHOOT_DURATION);
1057
1058   currentPos = PerformGestureDiagonalSwipe(application, Vector2(100.0f, 100.0f), Vector2(5.0f, 5.0f), 100, false);
1059   // Now release touch. Overshoot should snap back to zero.
1060   SendPan(application, Gesture::Finished, currentPos);
1061   timeToReachOrigin = TestOvershootSnapDuration(application, scrollView);
1062
1063   minTimeToReachOrigin = SCROLL_ANIMATION_DURATION + TEST_CUSTOM2_SNAP_OVERSHOOT_DURATION * (SNAP_POSITION_WITH_DECELERATED_VELOCITY.x / DEFAULT_MAX_OVERSHOOT) - TIME_TOLERANCE;
1064   maxTimeToReachOrigin = SCROLL_ANIMATION_DURATION + TEST_CUSTOM2_SNAP_OVERSHOOT_DURATION * (SNAP_POSITION_WITH_DECELERATED_VELOCITY.x / DEFAULT_MAX_OVERSHOOT) + TIME_TOLERANCE;
1065
1066   DALI_TEST_CHECK( (timeToReachOrigin > minTimeToReachOrigin) &&
1067                    (timeToReachOrigin < maxTimeToReachOrigin) );
1068
1069   // 4. Repeat Scroll, but this time change overshoot function.
1070   scrollView.SetSnapOvershootDuration(TEST_CUSTOM3_SNAP_OVERSHOOT_DURATION);
1071   scrollView.SetSnapOvershootAlphaFunction(TestAlphaFunction);
1072
1073   currentPos = PerformGestureDiagonalSwipe(application, Vector2(100.0f, 100.0f), Vector2(5.0f, 5.0f), 100, false);
1074   // Now release touch. Overshoot should snap back to zero.
1075   SendPan(application, Gesture::Finished, currentPos);
1076   timeToReachOrigin = TestOvershootSnapDuration(application, scrollView);
1077
1078   minTimeToReachOrigin = SCROLL_ANIMATION_DURATION + TEST_CUSTOM3_SNAP_OVERSHOOT_DURATION * (SNAP_POSITION_WITH_DECELERATED_VELOCITY.x / DEFAULT_MAX_OVERSHOOT) - TIME_TOLERANCE;
1079   maxTimeToReachOrigin = SCROLL_ANIMATION_DURATION + TEST_CUSTOM3_SNAP_OVERSHOOT_DURATION * (SNAP_POSITION_WITH_DECELERATED_VELOCITY.x / DEFAULT_MAX_OVERSHOOT) + TIME_TOLERANCE;
1080
1081   DALI_TEST_CHECK( (timeToReachOrigin > minTimeToReachOrigin) &&
1082                    (timeToReachOrigin < maxTimeToReachOrigin) );
1083   END_TEST;
1084 }
1085
1086 int UtcDaliScrollViewSnapAlphaFunction(void)
1087 {
1088   ToolkitTestApplication application;
1089   tet_infoline(" UtcDaliScrollViewSnapAlphaFunction");
1090
1091   // Set up a scrollView...
1092   ScrollView scrollView = ScrollView::New();
1093   scrollView.SetScrollSnapAlphaFunction( AlphaFunction::EASE_IN );
1094   DALI_TEST_CHECK( scrollView.GetScrollSnapAlphaFunction().GetBuiltinFunction() == AlphaFunction::EASE_IN );
1095   scrollView.SetScrollSnapAlphaFunction( AlphaFunction::EASE_OUT );
1096   DALI_TEST_CHECK( scrollView.GetScrollSnapAlphaFunction().GetBuiltinFunction() == AlphaFunction::EASE_OUT );
1097
1098   scrollView.SetScrollFlickAlphaFunction( AlphaFunction::BOUNCE );
1099   DALI_TEST_CHECK( scrollView.GetScrollFlickAlphaFunction().GetBuiltinFunction() == AlphaFunction::BOUNCE );
1100
1101   END_TEST;
1102 }
1103
1104 int UtcDaliScrollViewSnapDuration(void)
1105 {
1106   ToolkitTestApplication application;
1107   tet_infoline(" UtcDaliScrollViewSnapDuration");
1108
1109   // Set up a scrollView...
1110   ScrollView scrollView = ScrollView::New();
1111   scrollView.SetScrollSnapDuration( 1.0f );
1112   DALI_TEST_EQUALS( scrollView.GetScrollSnapDuration(), 1.0f, TEST_LOCATION );
1113   scrollView.SetScrollSnapDuration( 0.5f );
1114   DALI_TEST_EQUALS( scrollView.GetScrollSnapDuration(), 0.5f, TEST_LOCATION );
1115
1116   scrollView.SetScrollFlickDuration( 2.0f );
1117   DALI_TEST_EQUALS( scrollView.GetScrollFlickDuration(), 2.0f, TEST_LOCATION );
1118   scrollView.SetScrollFlickDuration( 1.5f );
1119   DALI_TEST_EQUALS( scrollView.GetScrollFlickDuration(), 1.5f, TEST_LOCATION );
1120   END_TEST;
1121 }
1122
1123 int UtcDaliScrollViewSignalsSnapStart(void)
1124 {
1125   ToolkitTestApplication application;
1126   tet_infoline(" UtcDaliScrollViewSignalsSnapStart");
1127
1128   // Set up a scrollView...
1129   ScrollView scrollView = ScrollView::New();
1130   Stage::GetCurrent().Add( scrollView );
1131   Vector2 stageSize = Stage::GetCurrent().GetSize();
1132   scrollView.SetSize(stageSize);
1133   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
1134   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1135
1136   // Position rulers.
1137   RulerPtr rulerX = new DefaultRuler();
1138   RulerPtr rulerY = new DefaultRuler();
1139   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
1140   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
1141   scrollView.SetRulerX(rulerX);
1142   scrollView.SetRulerY(rulerY);
1143   scrollView.SnapStartedSignal().Connect( &OnSnapStart );
1144
1145   scrollView.ScrollTo(CLAMP_START_SCROLL_POSITION, 0.0f); // move in a little.
1146   Wait(application);
1147
1148   // First try a snap.
1149   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, Vector2(0.5f, 0.0f), 60, true);
1150
1151   DALI_TEST_CHECK( gOnSnapStartCalled );
1152   DALI_TEST_CHECK( gLastSnapType == Toolkit::Snap );
1153
1154   // Second try a swipe.
1155   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, Vector2(20.0f, 0.0f), 60, true);
1156
1157   DALI_TEST_CHECK( gOnSnapStartCalled );
1158   DALI_TEST_CHECK( gLastSnapType == Toolkit::Flick );
1159   END_TEST;
1160 }
1161
1162
1163 int UtcDaliScrollViewSetMouseWheelScrollDistanceStep(void)
1164 {
1165   ToolkitTestApplication application;
1166   tet_infoline(" UtcDaliScrollViewSetMouseWheelScrollDistanceStep");
1167
1168   ScrollView scrollView = ScrollView::New();
1169   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
1170   scrollView.SetMouseWheelScrollDistanceStep(Vector2(30.0f, 15.0f));
1171   DALI_TEST_EQUALS( scrollView.GetMouseWheelScrollDistanceStep(), Vector2(30.0f, 15.0f), TEST_LOCATION );
1172   scrollView.SetMouseWheelScrollDistanceStep(Vector2(60.0f, 30.0f));
1173   DALI_TEST_EQUALS( scrollView.GetMouseWheelScrollDistanceStep(), Vector2(60.0f, 30.0f), TEST_LOCATION);
1174   END_TEST;
1175 }
1176
1177 int UtcDaliScrollViewGetSet(void)
1178 {
1179   ToolkitTestApplication application;
1180   tet_infoline(" UtcDaliScrollViewGetSet");
1181   ScrollView scrollView = ScrollView::New();
1182   scrollView.SetMaxOvershoot(50.0f, 50.0f);
1183   scrollView.SetMaxFlickSpeed(0.5f);
1184   DALI_TEST_EQUALS(scrollView.GetMaxFlickSpeed(), 0.5f, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1185   scrollView.SetFrictionCoefficient(0.6f);
1186   DALI_TEST_EQUALS(scrollView.GetFrictionCoefficient(), 0.6f, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1187   scrollView.SetFlickSpeedCoefficient(0.7f);
1188   DALI_TEST_EQUALS(scrollView.GetFlickSpeedCoefficient(), 0.7f, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1189   END_TEST;
1190 }