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