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

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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 #include <iostream>
  18 #include <stdlib.h>
  19 #include <dali-toolkit-test-suite-utils.h>
  20 #include <dali-toolkit/dali-toolkit.h>
  21 #include <dali/integration-api/events/touch-event-integ.h>
  22 #include <dali/integration-api/events/pan-gesture-event.h>
  23
  24 using namespace Dali;
  25 using namespace Toolkit;
  26
  27 void scroll_view_startup(void)
  28 {
  29   test_return_value = TET_UNDEF;
  30 }
  31
  32 void scroll_view_cleanup(void)
  33 {
  34   test_return_value = TET_PASS;
  35 }
  36
  37 namespace
  38 {
  39 static bool gObjectCreatedCallBackCalled;
  40
  41 static void TestCallback(BaseHandle handle)
  42 {
  43   gObjectCreatedCallBackCalled = true;
  44 }
  45
  46
  47 const int MILLISECONDS_PER_SECOND = 1000;
  48 const int RENDER_FRAME_INTERVAL = 16;                           ///< Duration of each frame in ms. (at approx 60FPS)
  49 const int RENDER_ANIMATION_TEST_DURATION_MS = 1000;             ///< 1000ms to test animation
  50 const int RENDER_DELAY_SCROLL = 1000;                           ///< duration to wait for any scroll to complete.
  51
  52 // For Clamp Signal testing...
  53 const float CLAMP_EXCESS_WIDTH = 200.0f;                        ///< Amount of width that can be panned outside scrollview
  54 const float CLAMP_EXCESS_HEIGHT = 200.0f;                       ///< Amount of height that can be panned outside scrollview
  55 const int CLAMP_STEP_0_CHECK_NOTCLAMPED = 0;                    ///< FSM: "First check that scrollview isn't clamped"
  56 const int CLAMP_STEP_1_CHECK_CLAMPED_WEST = 1;                  ///< FSM: "Next check that scrollview clamps against left side"
  57 const int CLAMP_STEP_2_CHECK_CLAMPED_SOUTH_WEST = 2;            ///< FSM: "Then check that scrollview clamps against bottom-left side"
  58 const int CLAMP_STEP_3_SUCCESS = 3;                             ///< FSM: "Finished (Success)"
  59 const Vector3 CLAMP_START_SCROLL_POSITION(30.0f, 100.0f, 0.0f); ///< Scroll start position for the Clamping tests.
  60 const Vector2 CLAMP_TOUCH_START( 100.0f, 100.0f );              ///< Start point to touch from for the Clamping tests.
  61 const Vector2 CLAMP_TOUCH_MOVEMENT( 5.0f, -5.0f );              ///< Amount to move touch for each frame for the Clamping tests.
  62 const int CLAMP_GESTURE_FRAMES = 100;                           ///< Number of Frames to synthesize a gesture for the Clamping tests.
  63 const Vector3 TEST_ACTOR_POSITION(100.0f, 100.0f, 0.0f);        ///< A Test actor position offset (arbitrary value)
  64 const Vector3 TEST_CONSTRAINT_OFFSET(1.0f, 2.0f, 0.0f);         ///< A Test constraint offset (arbitrary value to test effects)
  65 const float TEST_RATIO_TOLERANCE = 0.05;                        ///< +/-5% tolerance for ratio comparisons.
  66
  67 const int MAX_FRAMES_TO_TEST_OVERSHOOT = 600;                         ///< 10 seconds (at 60 frames per second).
  68 const Vector3 OVERSHOOT_START_SCROLL_POSITION(100.0f, 100.0f, 0.0f);  ///< Scroll start position for the Overshoot tests.
  69 const float TEST_DEFAULT_SNAP_OVERSHOOT_DURATION = 0.25f;             ///< 0.25 seconds should be default snap overshoot duration
  70 const float TEST_CUSTOM1_SNAP_OVERSHOOT_DURATION = 0.05f;             ///< a Test duration
  71 const float TEST_CUSTOM2_SNAP_OVERSHOOT_DURATION = 1.5f;              ///< another Test duration
  72 const float TEST_CUSTOM3_SNAP_OVERSHOOT_DURATION = TEST_CUSTOM2_SNAP_OVERSHOOT_DURATION * 0.5f; // Same as above, but different alpha function.
  73 const float TIME_TOLERANCE = 0.05f;                                   ///< Allow testing tolerance between a 10th of second (+/- 3 frames)
  74
  75
  76 // Generate a PanGestureEvent to send to Core
  77 Integration::PanGestureEvent GeneratePan(
  78     Gesture::State state,
  79     const Vector2& previousPosition,
  80     const Vector2& currentPosition,
  81     unsigned long timeDelta,
  82     unsigned int numberOfTouches = 1)
  83 {
  84   Integration::PanGestureEvent pan(state);
  85
  86   pan.previousPosition = previousPosition;
  87   pan.currentPosition = currentPosition;
  88   pan.timeDelta = timeDelta;
  89   pan.numberOfTouches = numberOfTouches;
  90
  91   return pan;
  92 }
  93
  94 /**
  95  * Helper to generate PanGestureEvent
  96  *
  97  * @param[in] application Application instance
  98  * @param[in] state The Gesture State
  99  * @param[in] pos The current position of touch.
 100  */
 101 static void SendPan(ToolkitTestApplication& application, Gesture::State state, const Vector2& pos)
 102 {
 103   static Vector2 last;
 104
 105   if( (state == Gesture::Started) ||
 106       (state == Gesture::Possible) )
 107   {
 108     last.x = pos.x;
 109     last.y = pos.y;
 110   }
 111
 112   application.ProcessEvent(GeneratePan(state, last, pos, RENDER_FRAME_INTERVAL));
 113
 114   last.x = pos.x;
 115   last.y = pos.y;
 116 }
 117
 118 /*
 119  * Simulate time passed by.
 120  *
 121  * @note this will always process at least 1 frame (1/60 sec)
 122  *
 123  * @param application Test application instance
 124  * @param duration Time to pass in milliseconds.
 125  * @return The actual time passed in milliseconds
 126  */
 127 int Wait(ToolkitTestApplication& application, int duration = 0)
 128 {
 129   int time = 0;
 130
 131   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
 132   {
 133     application.SendNotification();
 134     application.Render(RENDER_FRAME_INTERVAL);
 135     time += RENDER_FRAME_INTERVAL;
 136   }
 137
 138   return time;
 139 }
 140
 141 // Callback probes.
 142
 143 static bool gOnScrollStartCalled;                       ///< Whether the OnScrollStart signal was invoked.
 144 static bool gOnScrollUpdateCalled;                      ///< Whether the OnScrollUpdate signal was invoked.
 145 static bool gOnScrollCompleteCalled;                    ///< Whether the OnScrollComplete signal was invoked.
 146 static bool gOnScrollClampedCalled;                     ///< Whether the OnScrollClamped signal was invoked.
 147 static bool gOnSnapStartCalled;                         ///< Whether the OnSnapStart signal was invoked.
 148 static ClampState3 gLastClampPosition;                  ///< Clamping information from OnScrollClampedEvent.
 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 scrolling clamped.
 184  *
 185  * @param[in] event The position/scale/rotation axes that were clamped.
 186  */
 187 static void OnScrollClamped( const ScrollView::ClampEvent& event )
 188 {
 189   gOnScrollClampedCalled = true;
 190   gLastClampPosition = event.position;
 191 }
 192
 193 /**
 194  * Invoked when a snap or flick started.
 195  *
 196  * @param[in] event The type of snap and the target position/scale/rotation.
 197  */
 198 static void OnSnapStart( const ScrollView::SnapEvent& event )
 199 {
 200   gOnSnapStartCalled = true;
 201   gLastSnapType = event.type;
 202 }
 203
 204 /**
 205  * TestSumConstraint
 206  *
 207  * Summation of current value, property, and offset.
 208  *
 209  * current' = current + mOffset + property;
 210  */
 211 struct TestSumConstraint
 212 {
 213   /**
 214    * @param[in] offset The offset to be added to current.
 215    */
 216   TestSumConstraint(const Vector3& offset)
 217   :mOffset(offset)
 218   {
 219   }
 220
 221   /**
 222    * @param[in] current The current base value
 223    * @param[in] property The property to be added to current.
 224    * @return The new current Vector.
 225    */
 226   Vector3 operator()(const Vector3& current)
 227   {
 228     gConstraintResult = current + mOffset;
 229     return gConstraintResult;
 230   }
 231
 232   /**
 233    * @param[in] current The current base value
 234    * @param[in] property The property to be added to current.
 235    * @return The new current Vector.
 236    */
 237   Vector3 operator()(const Vector3&    current,
 238                     const PropertyInput& property)
 239   {
 240     gConstraintResult = current + property.GetVector3() + mOffset;
 241     return gConstraintResult;
 242   }
 243
 244   Vector3 mOffset;
 245
 246 };
 247
 248 /**
 249  * @param[in] application The application instance
 250  * @param[in] scrollView The scrollView instance
 251  * @return The time taken for the overshoot to reach origin (zero)
 252  */
 253 static float TestOvershootSnapDuration(ToolkitTestApplication &application, ScrollView scrollView)
 254 {
 255   Property::Index overshootPropertyX = scrollView.GetPropertyIndex(ScrollView::SCROLL_OVERSHOOT_X_PROPERTY_NAME);
 256   Property::Index overshootPropertyY = scrollView.GetPropertyIndex(ScrollView::SCROLL_OVERSHOOT_Y_PROPERTY_NAME);
 257
 258   int timeToReachOrigin = -1;
 259   for(int i = 0;i<MAX_FRAMES_TO_TEST_OVERSHOOT;i++)
 260   {
 261     float overshootXValue = scrollView.GetProperty<float>(overshootPropertyX);
 262     float overshootYValue = scrollView.GetProperty<float>(overshootPropertyY);
 263     if(overshootXValue == 0.0f && overshootYValue == 0.0f)
 264     {
 265       break;
 266     }
 267
 268     timeToReachOrigin += Wait(application);
 269   }
 270
 271   return static_cast<float>(timeToReachOrigin) * 0.001f; // return in seconds not ms.
 272 }
 273
 274 /**
 275  * y = 2x alpha function, which is clamped between 0.0f - 1.0f
 276  *
 277  * Animations should appear to finish (reach 100% point)
 278  * at just half the time of a regular Linear AlphaFunction.
 279  *
 280  * @param[in] progress value (ranges from 0.0f - 1.0f)
 281  * @return interpolation value (ranges from 0.0f - 1.0f)
 282  */
 283 float TestAlphaFunction(float progress)
 284 {
 285   return std::min( progress * 2.0f, 1.0f );
 286 }
 287
 288 } // unnamed namespace
 289
 290
 291 int UtcDaliScrollViewNew(void)
 292 {
 293   ToolkitTestApplication application;
 294   tet_infoline(" UtcDaliScrollViewNew");
 295
 296   ScrollView scrollView;
 297
 298   DALI_TEST_CHECK( !scrollView );
 299
 300   scrollView = ScrollView::New();
 301
 302   DALI_TEST_CHECK( scrollView );
 303
 304   ScrollView scrollView2(scrollView);
 305
 306   DALI_TEST_CHECK( scrollView2 == scrollView );
 307
 308   //Additional check to ensure object is created by checking if it's registered
 309   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 310   DALI_TEST_CHECK( registry );
 311
 312   gObjectCreatedCallBackCalled = false;
 313   registry.ObjectCreatedSignal().Connect( &TestCallback );
 314   {
 315     ScrollView scrollView = ScrollView::New();
 316   }
 317   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
 318   END_TEST;
 319 }
 320
 321 int UtcDaliScrollViewDownCast(void)
 322 {
 323   ToolkitTestApplication application;
 324   tet_infoline(" UtcDaliScrollViewDownCast");
 325
 326   ScrollView scrollView = ScrollView::New();
 327   BaseHandle handle(scrollView);
 328
 329   ScrollView newScrollView = ScrollView::DownCast( handle );
 330   DALI_TEST_CHECK( scrollView );
 331   DALI_TEST_CHECK( newScrollView == scrollView );
 332   END_TEST;
 333 }
 334
 335 int UtcDaliScrollViewScrollToPosition(void)
 336 {
 337   ToolkitTestApplication application;
 338   tet_infoline(" UtcDaliScrollViewScrollToPosition");
 339
 340   // Create the ScrollView actor
 341   ScrollView scrollView = ScrollView::New();
 342   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 343   scrollView.SetRefreshInterval(0);
 344   Stage::GetCurrent().Add( scrollView );
 345
 346   const Vector3 target = Vector3(100.0f, 200.0f, 0.0f);
 347   const Vector3 target2 = Vector3(300.0f, 100.0f, 0.0f);
 348
 349   scrollView.ScrollTo( target, 0.0f );
 350   Wait(application);
 351   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), target, TEST_LOCATION );
 352   scrollView.ScrollTo( target2 );
 353   Wait(application, RENDER_DELAY_SCROLL);
 354   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), target2, TEST_LOCATION );
 355
 356   Wait(application);
 357   END_TEST;
 358 }
 359
 360 int UtcDaliScrollViewScrollToPage(void)
 361 {
 362   ToolkitTestApplication application;
 363   tet_infoline(" UtcDaliScrollViewScrollToPage");
 364
 365   ScrollView scrollView = ScrollView::New();
 366   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 367   scrollView.SetRefreshInterval(0);
 368   Stage::GetCurrent().Add( scrollView );
 369   RulerPtr rulerX = new FixedRuler( 100.0f );
 370   rulerX->SetDomain( RulerDomain(0.0f, 800.0f, true) );
 371   RulerPtr rulerY = new FixedRuler( 100.0f );
 372   rulerY->SetDomain( RulerDomain(0.0f, 400.0f, true) );
 373
 374   scrollView.SetRulerX( rulerX );
 375   scrollView.SetRulerY( rulerY );
 376
 377   scrollView.ScrollTo( 1, 0.0f );
 378   Wait(application);
 379   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector3(100.0f, 0.0f, 0.0f), TEST_LOCATION );
 380
 381   scrollView.ScrollTo( 5, 0.0f );
 382   Wait(application);
 383   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector3(500.0f, 0.0f, 0.0f), TEST_LOCATION );
 384
 385   scrollView.ScrollTo( 10, 0.0f );
 386   Wait(application);
 387   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector3(200.0f, 100.0f, 0.0f), TEST_LOCATION );
 388
 389   scrollView.ScrollTo( 15, 0.0f );
 390   Wait(application);
 391   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector3(700.0f, 100.0f, 0.0f), TEST_LOCATION );
 392   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 15, TEST_LOCATION );
 393
 394   scrollView.ScrollTo( 3 );
 395   Wait(application, RENDER_DELAY_SCROLL);
 396   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector3(300.0f, 0.0f, 0.0f), TEST_LOCATION );
 397   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 3, TEST_LOCATION );
 398
 399   scrollView.ScrollTo( 9 );
 400   Wait(application, RENDER_DELAY_SCROLL);
 401   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector3(100.0f, 100.0f, 0.0f), TEST_LOCATION );
 402   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 9, TEST_LOCATION );
 403
 404   // Apply DefaultRulers instead and see what happens.
 405   rulerX = new DefaultRuler();
 406   rulerX->SetDomain( RulerDomain(0.0f, 800.0f, true) );
 407   rulerY = new DefaultRuler();
 408   rulerY->SetDomain( RulerDomain(0.0f, 400.0f, true) );
 409
 410   scrollView.SetRulerX( rulerX );
 411   scrollView.SetRulerY( rulerY );
 412
 413   // This time should always scroll to origin (0.0f, 0.0f)
 414   scrollView.ScrollTo( 1, 0.0f );
 415   Wait(application);
 416   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION );
 417   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 0, TEST_LOCATION );
 418
 419   Wait(application);
 420   END_TEST;
 421 }
 422
 423 int UtcDaliScrollViewScrollToActor(void)
 424 {
 425   ToolkitTestApplication application;
 426   tet_infoline(" UtcDaliScrollViewScrollToActor");
 427
 428   ScrollView scrollView = ScrollView::New();
 429   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 430   scrollView.SetRefreshInterval(0);
 431   Stage::GetCurrent().Add( scrollView );
 432
 433   Actor actorA = Actor::New();
 434   const Vector3 positionA = Vector3(100.0f, 400.0f, 0.0f);
 435   actorA.SetPosition(positionA);
 436   scrollView.Add(actorA);
 437
 438   Actor actorB = Actor::New();
 439   const Vector3 positionB = Vector3(500.0f, 200.0f, 0.0f);
 440   actorB.SetPosition(positionB);
 441   scrollView.Add(actorB);
 442
 443   Wait(application);
 444
 445   scrollView.ScrollTo(actorA, 0.0f);
 446   Wait(application);
 447   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), positionA, TEST_LOCATION );
 448
 449   Wait(application);
 450   scrollView.ScrollTo(actorB, 0.0f);
 451   Wait(application);
 452   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), positionB, TEST_LOCATION );
 453
 454   scrollView.ScrollTo(actorA);
 455   Wait(application, RENDER_DELAY_SCROLL);
 456   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), positionA, TEST_LOCATION );
 457
 458   scrollView.ScrollTo(actorB);
 459   Wait(application, RENDER_DELAY_SCROLL);
 460   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), positionB, TEST_LOCATION );
 461   END_TEST;
 462 }
 463
 464 int UtcDaliScrollViewScrollToSnapPoint(void)
 465 {
 466   ToolkitTestApplication application;
 467   tet_infoline(" UtcDaliScrollViewScrollToSnapPoint");
 468
 469   ScrollView scrollView = ScrollView::New();
 470   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 471   scrollView.SetRefreshInterval(0);
 472   Stage::GetCurrent().Add( scrollView );
 473   RulerPtr rulerX = new FixedRuler( 100.0f );
 474   rulerX->SetDomain( RulerDomain(0.0f, 800.0f, true) );
 475   RulerPtr rulerY = new FixedRuler( 100.0f );
 476   rulerY->SetDomain( RulerDomain(0.0f, 400.0f, true) );
 477
 478   scrollView.SetRulerX( rulerX );
 479   scrollView.SetRulerY( rulerY );
 480
 481   scrollView.ScrollTo( Vector3(120.0f, 190.0f, 0.0f), 0.0f );
 482   Wait(application);
 483   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector3(120.0f, 190.0f, 0.0f), TEST_LOCATION );
 484
 485   scrollView.ScrollToSnapPoint();
 486
 487   Wait(application, RENDER_DELAY_SCROLL);
 488   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), Vector3(100.0f, 200.0f, 0.0f), TEST_LOCATION );
 489   END_TEST;
 490 }
 491
 492 int UtcDaliScrollViewRulerScale(void)
 493 {
 494   ToolkitTestApplication application;
 495   tet_infoline(" UtcDaliScrollViewRulerScale");
 496
 497   ScrollView scrollView = ScrollView::New();
 498   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 499   scrollView.SetRefreshInterval(0);
 500   Stage::GetCurrent().Add( scrollView );
 501
 502   RulerPtr rulerScaleX = new FixedRuler(0.25f);
 503   RulerPtr rulerScaleY = new DefaultRuler();
 504   rulerScaleX->SetDomain( RulerDomain(0.1f, 0.9f, true) );
 505   rulerScaleY->SetDomain( RulerDomain(0.1f, 2.0f, true) );
 506   scrollView.SetRulerScaleX(rulerScaleX);
 507   scrollView.SetRulerScaleY(rulerScaleY);
 508
 509   scrollView.Add(Actor::New());
 510
 511   // Scroll to a position, and then snap.
 512   scrollView.ScaleTo(Vector3(1.95f, 1.4f, 1.0f), 0.0f);
 513   scrollView.ScrollToSnapPoint();
 514   Wait(application, RENDER_DELAY_SCROLL);
 515   DALI_TEST_EQUALS( scrollView.GetCurrentScrollScale(), Vector3(0.9f, 1.4f, 1.0f), TEST_LOCATION );
 516
 517   // Scroll SLOWLY to another position, and then snap.
 518   scrollView.ScaleTo(Vector3(0.45f, -1.0f, 1.0f));
 519   Wait(application, RENDER_DELAY_SCROLL);
 520   scrollView.ScrollToSnapPoint();
 521   Wait(application, RENDER_DELAY_SCROLL);
 522   DALI_TEST_EQUALS( scrollView.GetCurrentScrollScale(), Vector3(0.5f, 0.1f, 1.0f), TEST_LOCATION );
 523
 524   // Scroll to another position, and then snap.
 525   scrollView.ScaleTo(Vector3(0.71f, 0.71f, 1.0f), 0.0f);
 526   scrollView.ScrollToSnapPoint();
 527   Wait(application, RENDER_DELAY_SCROLL);
 528   DALI_TEST_EQUALS( scrollView.GetCurrentScrollScale(), Vector3(0.75f, 0.71f, 1.0f), TEST_LOCATION );
 529   END_TEST;
 530 }
 531
 532 int UtcDaliScrollViewTransformTo(void)
 533 {
 534   ToolkitTestApplication application;
 535   tet_infoline(" UtcDaliScrollViewTransformTo");
 536
 537   ScrollView scrollView = ScrollView::New();
 538   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 539   scrollView.SetRefreshInterval(0);
 540   Stage::GetCurrent().Add( scrollView );
 541
 542   // Position rulers.
 543   RulerPtr rulerX = new FixedRuler(50.0f);
 544   RulerPtr rulerY = new FixedRuler(50.0f);
 545   rulerX->SetDomain( RulerDomain(0.0f, 200.0f, true) );
 546   rulerY->SetDomain( RulerDomain(0.0f, 200.0f, true) );
 547   scrollView.SetRulerX(rulerX);
 548   scrollView.SetRulerY(rulerY);
 549
 550   // Scale rulers.
 551   RulerPtr rulerScaleX = new FixedRuler(0.1f);
 552   RulerPtr rulerScaleY = new FixedRuler(0.1f);
 553   rulerScaleX->SetDomain( RulerDomain(0.0f, 1.0f, true) );
 554   rulerScaleY->SetDomain( RulerDomain(0.0f, 1.0f, true) );
 555   scrollView.SetRulerScaleX(rulerScaleX);
 556   scrollView.SetRulerScaleY(rulerScaleY);
 557
 558   // transform to a random position/scale
 559   Vector3 targetPosition = Vector3(100.0f, 200.0f, 0.0f);
 560   Vector3 targetScale = Vector3(0.44f, 0.58f, 1.0f);
 561   float targetRotation = 0.0f;
 562   scrollView.TransformTo(targetPosition, targetScale, targetRotation, 0.0f);
 563   Wait(application);
 564
 565   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), targetPosition, TEST_LOCATION );
 566   DALI_TEST_EQUALS( scrollView.GetCurrentScrollScale(), targetScale, TEST_LOCATION );
 567
 568   // transform to another random position/scale (SLOWLY)
 569   targetPosition = Vector3(60.0f, 40.0f, 0.0f);
 570   targetScale = Vector3(0.4f, 0.6f, 1.0f);
 571   targetRotation = 0.0f;
 572   scrollView.TransformTo(targetPosition, targetScale, targetRotation);
 573   Wait(application, RENDER_DELAY_SCROLL);
 574
 575   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), targetPosition, TEST_LOCATION );
 576   DALI_TEST_EQUALS( scrollView.GetCurrentScrollScale(), targetScale, TEST_LOCATION );
 577   END_TEST;
 578 }
 579
 580 int UtcDaliScrollViewRefreshInterval(void)
 581 {
 582   ToolkitTestApplication application;
 583   tet_infoline(" UtcDaliScrollViewRefreshInterval");
 584
 585   ScrollView scrollView = ScrollView::New();
 586   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 587   scrollView.SetRefreshInterval(0);
 588   DALI_TEST_EQUALS( scrollView.GetRefreshInterval(), 0, TEST_LOCATION);
 589   scrollView.SetRefreshInterval(10);
 590   DALI_TEST_EQUALS( scrollView.GetRefreshInterval(), 10, TEST_LOCATION);
 591   scrollView.SetRefreshInterval(1000);
 592   DALI_TEST_EQUALS( scrollView.GetRefreshInterval(), 1000, TEST_LOCATION);
 593   END_TEST;
 594 }
 595
 596 int UtcDaliScrollViewWrapMode(void)
 597 {
 598   ToolkitTestApplication application;
 599   tet_infoline(" UtcDaliScrollViewWrapMode");
 600
 601   ScrollView scrollView = ScrollView::New();
 602   Stage::GetCurrent().Add( scrollView );
 603
 604   // Position rulers. 4x4 grid.
 605   RulerPtr rulerX = new FixedRuler(50.0f);
 606   RulerPtr rulerY = new FixedRuler(50.0f);
 607   rulerX->SetDomain( RulerDomain(0.0f, 200.0f, false) );
 608   rulerY->SetDomain( RulerDomain(0.0f, 200.0f, false) );
 609   scrollView.SetRulerX(rulerX);
 610   scrollView.SetRulerY(rulerY);
 611
 612   scrollView.SetWrapMode(false);
 613   scrollView.ScrollTo(Vector3(225.0f, 125.0f, 0.0f), 0.0f); // 5th (1st) page across, and 3rd (3rd) page down. (wrapped)
 614   Wait(application);
 615   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 17, TEST_LOCATION );
 616   scrollView.SetWrapMode(true);
 617   DALI_TEST_EQUALS( static_cast<int>(scrollView.GetCurrentPage()), 13, TEST_LOCATION );
 618   END_TEST;
 619 }
 620
 621 int UtcDaliScrollViewActorAutoSnap(void)
 622 {
 623   ToolkitTestApplication application;
 624   tet_infoline(" UtcDaliScrollViewActorAutoSnap");
 625
 626   ScrollView scrollView = ScrollView::New();
 627   Stage::GetCurrent().Add( scrollView );
 628   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 629   scrollView.SetRefreshInterval(0);
 630
 631   // Position rulers.
 632   RulerPtr rulerX = new DefaultRuler();
 633   RulerPtr rulerY = new DefaultRuler();
 634   rulerX->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 635   rulerY->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 636   scrollView.SetRulerX(rulerX);
 637   scrollView.SetRulerY(rulerY);
 638
 639   const Vector3 aPosition = Vector3(200.0f, 50.0f, 0.0f);
 640   Actor a = Actor::New();
 641   scrollView.Add(a);
 642   a.SetPosition(aPosition);
 643
 644   const Vector3 bPosition = Vector3(600.0f, 600.0f, 0.0f);
 645   Actor b = Actor::New();
 646   scrollView.Add(b);
 647   b.SetPosition(bPosition);
 648
 649   // Goto a random position, and execute snap (should not move)
 650   Vector3 targetScroll = Vector3(500.0f, 500.0f, 0.0f);
 651   scrollView.ScrollTo(targetScroll, 0.0f);
 652   Wait(application);
 653   scrollView.ScrollToSnapPoint();
 654   Wait(application, RENDER_DELAY_SCROLL);
 655   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), targetScroll, TEST_LOCATION );
 656
 657   // Enable ActorAutoSnap, and now try snapping.
 658   scrollView.SetActorAutoSnap(true);
 659   scrollView.ScrollToSnapPoint();
 660   Wait(application, RENDER_DELAY_SCROLL);
 661   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), bPosition, TEST_LOCATION );
 662
 663   scrollView.ScrollTo(Vector3(0.0f, 0.0f, 0.0f), 0.0f);
 664   Wait(application);
 665   scrollView.ScrollToSnapPoint();
 666   Wait(application, RENDER_DELAY_SCROLL);
 667   DALI_TEST_EQUALS( scrollView.GetCurrentScrollPosition(), aPosition, TEST_LOCATION );
 668   END_TEST;
 669 }
 670
 671 int UtcDaliScrollViewSignalsStartComplete(void)
 672 {
 673   ToolkitTestApplication application;
 674   tet_infoline(" UtcDaliScrollViewSignalsStartComplete");
 675
 676   gOnScrollStartCalled = false;
 677   gOnScrollCompleteCalled = false;
 678
 679   ScrollView scrollView = ScrollView::New();
 680   Stage::GetCurrent().Add( scrollView );
 681   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 682   scrollView.SetRefreshInterval(0);
 683
 684   // Position rulers.
 685   RulerPtr rulerX = new DefaultRuler();
 686   RulerPtr rulerY = new DefaultRuler();
 687   rulerX->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 688   rulerY->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 689   scrollView.SetRulerX(rulerX);
 690   scrollView.SetRulerY(rulerY);
 691   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
 692   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
 693   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
 694   scrollView.ScrollTo( 100.0f, 100.0f );
 695   Wait(application, RENDER_DELAY_SCROLL);
 696
 697   DALI_TEST_CHECK(gOnScrollStartCalled);
 698   DALI_TEST_CHECK(gOnScrollCompleteCalled);
 699   END_TEST;
 700 }
 701
 702 int UtcDaliScrollViewSignalsUpdate(void)
 703 {
 704   ToolkitTestApplication application;
 705   tet_infoline(" UtcDaliScrollViewSignalsUpdate");
 706
 707   gOnScrollStartCalled = false;
 708   gOnScrollUpdateCalled = false;
 709   gOnScrollCompleteCalled = false;
 710
 711   ScrollView scrollView = ScrollView::New();
 712   Stage::GetCurrent().Add( scrollView );
 713   Vector2 stageSize = Stage::GetCurrent().GetSize();
 714   scrollView.SetSize(stageSize);
 715   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 716   scrollView.SetRefreshInterval(0);
 717   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
 718   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 719
 720   // Position rulers.
 721   RulerPtr rulerX = new DefaultRuler();
 722   RulerPtr rulerY = new DefaultRuler();
 723   rulerX->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 724   rulerY->SetDomain( RulerDomain(0.0f, 1000.0f, false) );
 725   scrollView.SetRulerX(rulerX);
 726   scrollView.SetRulerY(rulerY);
 727   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
 728   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
 729   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
 730
 731   ImageActor image = CreateSolidColorActor( Color::RED );
 732   image.SetSize(stageSize);
 733   image.SetParentOrigin(ParentOrigin::TOP_LEFT);
 734   image.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 735   scrollView.Add(image);
 736
 737   Wait(application);
 738
 739   // Do a pan starting from 100,100 and moving down diagonally.
 740   Vector2 pos(100.0f, 100.0f);
 741   SendPan(application, Gesture::Possible, pos);
 742   SendPan(application, Gesture::Started, pos);
 743   pos.x += 5.0f;
 744   pos.y += 5.0f;
 745   Wait(application, 100);
 746
 747   for(int i = 0;i<20;i++)
 748   {
 749     SendPan(application, Gesture::Continuing, pos);
 750     pos.x += 5.0f;
 751     pos.y += 5.0f;
 752     Wait(application);
 753   }
 754
 755   SendPan(application, Gesture::Finished, pos);
 756   Wait(application, RENDER_DELAY_SCROLL);
 757
 758   DALI_TEST_CHECK(gOnScrollStartCalled);
 759   DALI_TEST_CHECK(gOnScrollUpdateCalled);
 760   DALI_TEST_CHECK(gOnScrollCompleteCalled);
 761   END_TEST;
 762 }
 763
 764 // Creates a scroll domain slightly bigger than the stage size.
 765 // ScrollView is scrolled to center, slightly to the left.
 766 // Then a pan gesture is carried out causing the scrollview
 767 // to pan South-West direction. Resulting in ClampEvents
 768 // to fire (first Western boundary, then both Western and
 769 // Southern boundary).
 770 int UtcDaliScrollViewSignalsClamped(void)
 771 {
 772   ToolkitTestApplication application;
 773   tet_infoline(" UtcDaliScrollViewSignalsClamped");
 774
 775   gOnScrollUpdateCalled = false;
 776   gOnScrollCompleteCalled = false;
 777
 778   // Set up a scrollView...
 779   ScrollView scrollView = ScrollView::New();
 780   Stage::GetCurrent().Add( scrollView );
 781   Vector2 stageSize = Stage::GetCurrent().GetSize();
 782   scrollView.SetSize(stageSize);
 783   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 784   scrollView.SetRefreshInterval(0);
 785   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
 786   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 787
 788   // Position rulers.
 789   RulerPtr rulerX = new DefaultRuler();
 790   RulerPtr rulerY = new DefaultRuler();
 791   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
 792   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
 793   scrollView.SetRulerX(rulerX);
 794   scrollView.SetRulerY(rulerY);
 795   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
 796   scrollView.ScrollClampedSignal().Connect( &OnScrollClamped );
 797
 798   scrollView.ScrollTo(CLAMP_START_SCROLL_POSITION, 0.0f); // move in a little.
 799   Wait(application);
 800
 801   // Now do a pan starting from 100,100 and heading South-West
 802   Vector2 pos(CLAMP_TOUCH_START);
 803   SendPan(application, Gesture::Possible, pos);
 804   SendPan(application, Gesture::Started, pos);
 805   pos += CLAMP_TOUCH_MOVEMENT; // Move South-West a little
 806   Wait(application);
 807
 808   int step = CLAMP_STEP_0_CHECK_NOTCLAMPED;
 809   // Move 500,500 pixels South-West
 810   // should be initially not clamped (0)
 811   // then it should clamp against West boundary (X Min) (1)
 812   // then it should clamp against South-West boundary (X Min, Y Max) (2)
 813   gLastClampPosition.x = Toolkit::NotClamped;
 814   gLastClampPosition.y = Toolkit::NotClamped;
 815
 816   for(int i = 0;i<CLAMP_GESTURE_FRAMES;i++)
 817   {
 818     SendPan(application, Gesture::Continuing, pos);
 819     pos += CLAMP_TOUCH_MOVEMENT; // Move South-West a little
 820     Wait(application);
 821
 822     if((gLastClampPosition.x == Toolkit::NotClamped) && (gLastClampPosition.y == Toolkit::NotClamped) && (step==CLAMP_STEP_0_CHECK_NOTCLAMPED))
 823     {
 824       step = CLAMP_STEP_1_CHECK_CLAMPED_WEST;
 825     }
 826     else if((gLastClampPosition.x == Toolkit::ClampedToMin) && (gLastClampPosition.y == Toolkit::NotClamped) && (step==CLAMP_STEP_1_CHECK_CLAMPED_WEST))
 827     {
 828       step = CLAMP_STEP_2_CHECK_CLAMPED_SOUTH_WEST;
 829     }
 830     else if((gLastClampPosition.x == Toolkit::ClampedToMin) && (gLastClampPosition.y == Toolkit::ClampedToMax) && (step==CLAMP_STEP_2_CHECK_CLAMPED_SOUTH_WEST))
 831     {
 832       step = CLAMP_STEP_3_SUCCESS;
 833     }
 834   }
 835
 836   SendPan(application, Gesture::Finished, pos);
 837   Wait(application);
 838
 839   DALI_TEST_CHECK( gOnScrollClampedCalled );
 840   DALI_TEST_EQUALS( step, CLAMP_STEP_3_SUCCESS, TEST_LOCATION );
 841   END_TEST;
 842 }
 843
 844 static Vector2 PerformGestureDiagonalSwipe(ToolkitTestApplication& application, Vector2 start, Vector2 direction, int frames, bool finish = true)
 845 {
 846   gOnScrollStartCalled = false;
 847   gOnScrollUpdateCalled = false;
 848   gOnScrollCompleteCalled = false;
 849   gOnSnapStartCalled = false;
 850
 851   // Now do a pan starting from (start) and heading (direction)
 852   Vector2 pos(start);
 853   SendPan(application, Gesture::Possible, pos);
 854   SendPan(application, Gesture::Started, pos);
 855   Wait(application);
 856
 857   for(int i = 0;i<frames;i++)
 858   {
 859     pos += direction; // Move in this direction
 860     SendPan(application, Gesture::Continuing, pos);
 861     Wait(application);
 862   }
 863
 864   if(finish)
 865   {
 866     pos += direction; // Move in this direction.
 867     SendPan(application, Gesture::Finished, pos);
 868     Wait(application, RENDER_DELAY_SCROLL);
 869   }
 870
 871   return pos;
 872 }
 873
 874 int UtcDaliScrollViewScrollSensitive(void)
 875 {
 876   ToolkitTestApplication application;
 877   tet_infoline(" UtcDaliScrollViewScrollSensitive");
 878
 879   // Set up a scrollView...
 880   ScrollView scrollView = ScrollView::New();
 881   Stage::GetCurrent().Add( scrollView );
 882   Vector2 stageSize = Stage::GetCurrent().GetSize();
 883   scrollView.SetSize(stageSize);
 884   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 885   scrollView.SetRefreshInterval(0);
 886   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
 887   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 888
 889   // Position rulers.
 890   RulerPtr rulerX = new DefaultRuler();
 891   RulerPtr rulerY = new DefaultRuler();
 892   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
 893   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
 894   scrollView.SetRulerX(rulerX);
 895   scrollView.SetRulerY(rulerY);
 896   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
 897   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
 898   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
 899   scrollView.SnapStartedSignal().Connect( &OnSnapStart );
 900
 901   scrollView.ScrollTo(CLAMP_START_SCROLL_POSITION, 0.0f); // move in a little.
 902   Wait(application);
 903
 904   // First try insensitive swipe.
 905   scrollView.SetScrollSensitive(false);
 906   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, CLAMP_TOUCH_MOVEMENT, CLAMP_GESTURE_FRAMES, true);
 907
 908   DALI_TEST_CHECK( !gOnScrollStartCalled );
 909   DALI_TEST_CHECK( !gOnScrollUpdateCalled );
 910   DALI_TEST_CHECK( !gOnScrollCompleteCalled );
 911   DALI_TEST_CHECK( !gOnSnapStartCalled );
 912
 913   // Second try sensitive swipe.
 914   scrollView.SetScrollSensitive(true);
 915   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, CLAMP_TOUCH_MOVEMENT, CLAMP_GESTURE_FRAMES, true);
 916
 917   DALI_TEST_CHECK( gOnScrollStartCalled );
 918   DALI_TEST_CHECK( gOnScrollUpdateCalled );
 919   DALI_TEST_CHECK( gOnScrollCompleteCalled );
 920   DALI_TEST_CHECK( gOnSnapStartCalled );
 921   END_TEST;
 922 }
 923
 924 int UtcDaliScrollViewTouchesRequired(void)
 925 {
 926   ToolkitTestApplication application;
 927   tet_infoline(" UtcDaliScrollViewTouchesRequired");
 928
 929   // Set up a scrollView...
 930   ScrollView scrollView = ScrollView::New();
 931   Stage::GetCurrent().Add( scrollView );
 932   Vector2 stageSize = Stage::GetCurrent().GetSize();
 933   scrollView.SetSize(stageSize);
 934   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 935   scrollView.SetRefreshInterval(0);
 936   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
 937   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 938
 939   // Position rulers.
 940   RulerPtr rulerX = new DefaultRuler();
 941   RulerPtr rulerY = new DefaultRuler();
 942   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
 943   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
 944   scrollView.SetRulerX(rulerX);
 945   scrollView.SetRulerY(rulerY);
 946   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
 947   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
 948   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
 949   scrollView.SnapStartedSignal().Connect( &OnSnapStart );
 950
 951   scrollView.ScrollTo(CLAMP_START_SCROLL_POSITION, 0.0f); // move in a little.
 952   Wait(application);
 953
 954   // First try touches required being a minimum and maximum of 2.
 955   scrollView.SetTouchesRequiredForPanning(2, 2, true);
 956   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, CLAMP_TOUCH_MOVEMENT, CLAMP_GESTURE_FRAMES, true);
 957
 958   DALI_TEST_CHECK( !gOnScrollStartCalled );
 959   DALI_TEST_CHECK( !gOnScrollUpdateCalled );
 960   DALI_TEST_CHECK( !gOnScrollCompleteCalled );
 961   DALI_TEST_CHECK( !gOnSnapStartCalled );
 962
 963   // Second try touches required being a minimum and maximum of 1.
 964   scrollView.SetTouchesRequiredForPanning(1, 1, true);
 965   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, CLAMP_TOUCH_MOVEMENT, CLAMP_GESTURE_FRAMES, true);
 966
 967   DALI_TEST_CHECK( gOnScrollStartCalled );
 968   DALI_TEST_CHECK( gOnScrollUpdateCalled );
 969   DALI_TEST_CHECK( gOnScrollCompleteCalled );
 970   DALI_TEST_CHECK( gOnSnapStartCalled );
 971   END_TEST;
 972 }
 973
 974 int UtcDaliScrollViewAxisAutoLock(void)
 975 {
 976   ToolkitTestApplication application;
 977   tet_infoline(" UtcDaliScrollViewAxisAutoLock");
 978
 979   // Set up a scrollView...
 980   ScrollView scrollView = ScrollView::New();
 981   Stage::GetCurrent().Add( scrollView );
 982   Vector2 stageSize = Stage::GetCurrent().GetSize();
 983   scrollView.SetSize(stageSize);
 984   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
 985   scrollView.SetRefreshInterval(0);
 986   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
 987   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 988
 989   // Position rulers.
 990   RulerPtr rulerX = new DefaultRuler();
 991   RulerPtr rulerY = new DefaultRuler();
 992   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
 993   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
 994   scrollView.SetRulerX(rulerX);
 995   scrollView.SetRulerY(rulerY);
 996   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
 997   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
 998   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
 999
1000   // Normal
1001   scrollView.ScrollTo(Vector3(100.0f, 100.0f, 0.0f), 0.0f); // move in a little.
1002   Wait(application);
1003   Vector3 startPosition = scrollView.GetCurrentScrollPosition();
1004   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, Vector2(5.0f, 1.0f), 50, true); // mostly horizontal
1005   const Vector3 positionAfterNormal = scrollView.GetCurrentScrollPosition();
1006
1007   // Autolock
1008   scrollView.SetAxisAutoLock(true);
1009   DALI_TEST_CHECK(scrollView.GetAxisAutoLock());
1010
1011   scrollView.ScrollTo(Vector3(100.0f, 100.0f, 0.0f), 0.0f); // move in a little.
1012   Wait(application);
1013   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, Vector2(5.0f, 1.0f), 50, true); // mostly horizontal
1014   const Vector3 positionAfterAutoLock = scrollView.GetCurrentScrollPosition();
1015
1016   // compare how much the Y position has deviated for normal and autolock.
1017   const float devianceNormal = fabsf(startPosition.y - positionAfterNormal.y);
1018   const float devianceAutoLock = fabsf(startPosition.y - positionAfterAutoLock.y);
1019
1020   // in auto-lock it should be a mostly horizontal pan (thus deviance should be much lower)
1021   DALI_TEST_CHECK(devianceAutoLock < devianceNormal);
1022
1023   scrollView.SetAxisAutoLock(false);
1024   DALI_TEST_CHECK(!scrollView.GetAxisAutoLock());
1025   END_TEST;
1026 }
1027
1028 int UtcDaliScrollViewAxisAutoLockGradient(void)
1029 {
1030   ToolkitTestApplication application;
1031   tet_infoline(" UtcDaliScrollViewAxisAutoLockGradient");
1032
1033   // Set up a scrollView...
1034   ScrollView scrollView = ScrollView::New();
1035   scrollView.SetAxisAutoLockGradient(0.5f);
1036   DALI_TEST_EQUALS(scrollView.GetAxisAutoLockGradient(), 0.5f, TEST_LOCATION);
1037   scrollView.SetAxisAutoLockGradient(1.0f);
1038   DALI_TEST_EQUALS(scrollView.GetAxisAutoLockGradient(), 1.0f, TEST_LOCATION);
1039   END_TEST;
1040 }
1041
1042 int UtcDaliScrollViewConstraints(void)
1043 {
1044   ToolkitTestApplication application;
1045   tet_infoline(" UtcDaliScrollViewConstraints");
1046
1047   // Set up a scrollView...
1048   ScrollView scrollView = ScrollView::New();
1049   Stage::GetCurrent().Add( scrollView );
1050   Vector2 stageSize = Stage::GetCurrent().GetSize();
1051   scrollView.SetSize(stageSize);
1052   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
1053   scrollView.SetRefreshInterval(0);
1054   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
1055   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1056
1057   // Position rulers.
1058   RulerPtr rulerX = new DefaultRuler();
1059   RulerPtr rulerY = new DefaultRuler();
1060   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
1061   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
1062   scrollView.SetRulerX(rulerX);
1063   scrollView.SetRulerY(rulerY);
1064
1065   // Add an Actor to ScrollView,
1066   // Apply TestSumConstraint to ScrollView's children (includes this Actor)
1067   gConstraintResult = Vector3::ZERO;
1068   Actor a = Actor::New();
1069   scrollView.Add(a);
1070   a.SetPosition( TEST_ACTOR_POSITION );
1071   Wait(application);
1072
1073   Property::Index scrollPositionProperty = scrollView.GetPropertyIndex(ScrollView::SCROLL_POSITION_PROPERTY_NAME);
1074   Constraint constraint = Constraint::New<Vector3>( Actor::POSITION,
1075                                                        Source(scrollView, scrollPositionProperty),
1076                                                        TestSumConstraint( TEST_CONSTRAINT_OFFSET ) );
1077   constraint.SetRemoveAction(Constraint::Discard);
1078   scrollView.ApplyConstraintToChildren(constraint);
1079   Wait(application);
1080
1081   DALI_TEST_EQUALS( gConstraintResult, TEST_ACTOR_POSITION + TEST_CONSTRAINT_OFFSET, TEST_LOCATION );
1082
1083   gConstraintResult = Vector3::ZERO;
1084   scrollView.RemoveConstraintsFromChildren();
1085   Wait(application);
1086
1087   DALI_TEST_EQUALS( gConstraintResult, Vector3::ZERO, TEST_LOCATION );
1088   END_TEST;
1089 }
1090
1091 int UtcDaliScrollViewBind(void)
1092 {
1093   ToolkitTestApplication application;
1094   tet_infoline(" UtcDaliScrollViewBind");
1095
1096   // Set up a scrollView...
1097   ScrollView scrollView = ScrollView::New();
1098   Stage::GetCurrent().Add( scrollView );
1099   Vector2 stageSize = Stage::GetCurrent().GetSize();
1100   scrollView.SetSize(stageSize);
1101   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
1102   scrollView.SetRefreshInterval(0);
1103   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
1104   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1105
1106   // Position rulers.
1107   RulerPtr rulerX = new DefaultRuler();
1108   RulerPtr rulerY = new DefaultRuler();
1109   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
1110   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
1111   scrollView.SetRulerX(rulerX);
1112   scrollView.SetRulerY(rulerY);
1113
1114   // Add an Actor to ScrollView,
1115   // Apply TestSumConstraint to ScrollView's children (includes this Actor)
1116
1117   gConstraintResult = Vector3::ZERO;
1118   Actor a = Actor::New();
1119   scrollView.Add(a);
1120   a.SetPosition( TEST_ACTOR_POSITION );
1121   Wait(application);
1122
1123   Property::Index scrollPositionProperty = scrollView.GetPropertyIndex(ScrollView::SCROLL_POSITION_PROPERTY_NAME);
1124   // apply this constraint to scrollview
1125   Constraint constraint = Constraint::New<Vector3>( Actor::POSITION,
1126                                                        Source(scrollView, scrollPositionProperty),
1127                                                        TestSumConstraint( TEST_CONSTRAINT_OFFSET ) );
1128
1129   constraint.SetRemoveAction(Constraint::Discard);
1130   scrollView.ApplyConstraintToChildren(constraint);
1131
1132   Wait(application);
1133   // Defaulty Bound.
1134   DALI_TEST_EQUALS( gConstraintResult, TEST_ACTOR_POSITION + TEST_CONSTRAINT_OFFSET, TEST_LOCATION );
1135
1136   // UnBind
1137   gConstraintResult = Vector3::ZERO;
1138   scrollView.UnbindActor( a );
1139   Wait(application);
1140   DALI_TEST_EQUALS( gConstraintResult, Vector3::ZERO, TEST_LOCATION );
1141
1142   // Bind
1143   gConstraintResult = Vector3::ZERO;
1144   scrollView.BindActor( a );
1145   Wait(application);
1146   DALI_TEST_EQUALS( gConstraintResult, TEST_ACTOR_POSITION + TEST_CONSTRAINT_OFFSET, TEST_LOCATION );
1147   END_TEST;
1148 }
1149
1150 int UtcDaliRulerEnableDisable(void)
1151 {
1152   ToolkitTestApplication application;
1153   tet_infoline(" UtcDaliRulerEnableDisable");
1154
1155   RulerPtr ruler = new DefaultRuler();
1156
1157   DALI_TEST_CHECK( ruler->IsEnabled() );
1158   ruler->Disable();
1159   DALI_TEST_CHECK( !ruler->IsEnabled() );
1160   ruler->Enable();
1161   DALI_TEST_CHECK( ruler->IsEnabled() );
1162   END_TEST;
1163 }
1164
1165 int UtcDaliRulerDomainEnableDisable(void)
1166 {
1167   ToolkitTestApplication application;
1168   tet_infoline(" UtcDaliRulerDomainEnableDisable");
1169
1170   RulerPtr ruler = new DefaultRuler();
1171   DALI_TEST_EQUALS( ruler->GetDomain().GetSize(), 1.0f, TEST_LOCATION );
1172
1173
1174   ruler->SetDomain( RulerDomain(0.0f, 100.0f, true) );
1175   DALI_TEST_EQUALS( ruler->GetDomain().GetSize(), 100.0f, TEST_LOCATION );
1176   DALI_TEST_EQUALS( ruler->Clamp(-200.0f), 0.0f, TEST_LOCATION );
1177   DALI_TEST_EQUALS( ruler->Clamp(200.0f), 100.0f, TEST_LOCATION );
1178
1179   ruler->DisableDomain();
1180   DALI_TEST_EQUALS( ruler->GetDomain().GetSize(), 1.0f, TEST_LOCATION );
1181   DALI_TEST_EQUALS( ruler->Clamp(-200.0f), -200.0f, TEST_LOCATION );
1182   DALI_TEST_EQUALS( ruler->Clamp(200.0f), 200.0f, TEST_LOCATION );
1183   END_TEST;
1184 }
1185
1186 int UtcDaliRulerSnapAndClamp(void)
1187 {
1188   ToolkitTestApplication application;
1189   tet_infoline(" UtcDaliRulerSnapAndClamp");
1190
1191   RulerPtr ruler = new FixedRuler( 50.0f );
1192   ruler->SetDomain( RulerDomain(0.0f, 400.0f, true) );
1193
1194   // default testing. (snap and clamp)
1195   DALI_TEST_EQUALS( ruler->SnapAndClamp(50.0f), 50.0f, TEST_LOCATION);
1196   DALI_TEST_EQUALS( ruler->SnapAndClamp(30.0f), 50.0f, TEST_LOCATION);
1197   DALI_TEST_EQUALS( ruler->SnapAndClamp(10.0f), 0.0f, TEST_LOCATION);
1198   DALI_TEST_EQUALS( ruler->SnapAndClamp(-40.0f), 0.0f, TEST_LOCATION);
1199   DALI_TEST_EQUALS( ruler->SnapAndClamp(390.0f), 400.0f, TEST_LOCATION);
1200   DALI_TEST_EQUALS( ruler->SnapAndClamp(430.0f), 400.0f, TEST_LOCATION);
1201
1202   // bias testing.
1203   DALI_TEST_EQUALS( ruler->SnapAndClamp(40.0f, 0.0f), 0.0f, TEST_LOCATION); // Flick Left
1204   DALI_TEST_EQUALS( ruler->SnapAndClamp(40.0f, 0.5f), 50.0f, TEST_LOCATION); // No Flick
1205   DALI_TEST_EQUALS( ruler->SnapAndClamp(40.0f, 1.0f), 50.0f, TEST_LOCATION); // Flick Right
1206
1207   DALI_TEST_EQUALS( ruler->SnapAndClamp(20.0f, 0.0f), 0.0f, TEST_LOCATION); // Flick Left
1208   DALI_TEST_EQUALS( ruler->SnapAndClamp(20.0f, 0.5f), 0.0f, TEST_LOCATION); // No Flick
1209   DALI_TEST_EQUALS( ruler->SnapAndClamp(20.0f, 1.0f), 50.0f, TEST_LOCATION); // Flick Right
1210
1211   // length testing.
1212   DALI_TEST_EQUALS( ruler->SnapAndClamp(-10.0f, 0.5f, 10.0f), 0.0f, TEST_LOCATION); // 10 units long (over left boundary)
1213   DALI_TEST_EQUALS( ruler->SnapAndClamp(-5.0f, 0.5f, 10.0f), 0.0f, TEST_LOCATION); // 10 units long (slightly ovr left boundary)
1214   DALI_TEST_EQUALS( ruler->SnapAndClamp(300.0f, 0.5f, 10.0f), 300.0f, TEST_LOCATION); // 10 units long (not over a boundary)
1215   DALI_TEST_EQUALS( ruler->SnapAndClamp(395.0f, 0.5f, 10.0f), 390.0f, TEST_LOCATION); // 10 units long (slightly over right boundary)
1216   DALI_TEST_EQUALS( ruler->SnapAndClamp(500.0f, 0.5f, 10.0f), 390.0f, TEST_LOCATION); // 10 units long (over right boundary)
1217
1218   // scale testing.
1219   DALI_TEST_EQUALS( ruler->SnapAndClamp(-100.0f, 0.5f, 0.0f, 2.0f), 0.0f, TEST_LOCATION);
1220   DALI_TEST_EQUALS( ruler->SnapAndClamp(50.0f, 0.5f, 0.0f, 2.0f), 50.0f, TEST_LOCATION);
1221   DALI_TEST_EQUALS( ruler->SnapAndClamp(700.0f, 0.5f, 0.0f, 2.0f), 700.0f, TEST_LOCATION);
1222   DALI_TEST_EQUALS( ruler->SnapAndClamp(850.0f, 0.5f, 0.0f, 2.0f), 800.0f, TEST_LOCATION);
1223
1224   // clamp state testing.
1225   ClampState clamped;
1226   DALI_TEST_EQUALS( ruler->SnapAndClamp(50.0f, 0.5f, 0.0f, 1.0f, clamped), 50.0f, TEST_LOCATION);
1227   DALI_TEST_EQUALS( clamped, NotClamped, TEST_LOCATION );
1228   DALI_TEST_EQUALS( ruler->SnapAndClamp(30.0f, 0.5f, 0.0f, 1.0f, clamped), 50.0f, TEST_LOCATION);
1229   DALI_TEST_EQUALS( clamped, NotClamped, TEST_LOCATION );
1230   DALI_TEST_EQUALS( ruler->SnapAndClamp(10.0f, 0.5f, 0.0f, 1.0f, clamped), 0.0f, TEST_LOCATION);
1231   DALI_TEST_EQUALS( clamped, NotClamped, TEST_LOCATION );
1232   DALI_TEST_EQUALS( ruler->SnapAndClamp(-40.0f, 0.5f, 0.0f, 1.0f, clamped), 0.0f, TEST_LOCATION);
1233   DALI_TEST_EQUALS( clamped, ClampedToMin, TEST_LOCATION );
1234   DALI_TEST_EQUALS( ruler->SnapAndClamp(390.0f, 0.5f, 0.0f, 1.0f, clamped), 400.0f, TEST_LOCATION);
1235   DALI_TEST_EQUALS( clamped, NotClamped, TEST_LOCATION );
1236   DALI_TEST_EQUALS( ruler->SnapAndClamp(430.0f, 0.5f, 0.0f, 1.0f, clamped), 400.0f, TEST_LOCATION);
1237   DALI_TEST_EQUALS( clamped, ClampedToMax, TEST_LOCATION );
1238   END_TEST;
1239 }
1240
1241 int UtcDaliRulerFixedRulerSpacing(void)
1242 {
1243   ToolkitTestApplication application;
1244   tet_infoline(" UtcDaliRulerFixedRulerSpacing");
1245
1246   RulerPtr rulerZero = new FixedRuler( 0.0f );
1247   rulerZero->SetDomain( RulerDomain(10.0f, 90.0f, true) );
1248
1249   RulerPtr rulerNormal = new FixedRuler( 25.0f );
1250   rulerNormal->SetDomain( RulerDomain(10.0f, 90.0f, true) );
1251
1252   unsigned int volume;
1253   float position;
1254
1255   position = rulerZero->GetPositionFromPage(1, volume, true);
1256   DALI_TEST_EQUALS( position, 10.0f, TEST_LOCATION );
1257   DALI_TEST_EQUALS( volume, 1u, TEST_LOCATION );
1258
1259   position = rulerNormal->GetPositionFromPage(1, volume, true);
1260   DALI_TEST_EQUALS( position, 35.0f, TEST_LOCATION );
1261   DALI_TEST_EQUALS( volume, 0u, TEST_LOCATION );
1262
1263   position = rulerZero->GetPositionFromPage(2, volume, true);
1264   DALI_TEST_EQUALS( position, 10.0f, TEST_LOCATION );
1265   DALI_TEST_EQUALS( volume, 2u, TEST_LOCATION );
1266
1267   position = rulerNormal->GetPositionFromPage(2, volume, true);
1268   DALI_TEST_EQUALS( position, 60.0f, TEST_LOCATION );
1269   DALI_TEST_EQUALS( volume, 0u, TEST_LOCATION );
1270   END_TEST;
1271 }
1272
1273 int UtcDaliScrollViewOvershoot(void)
1274 {
1275   ToolkitTestApplication application;
1276   tet_infoline(" UtcDaliScrollViewOvershoot");
1277
1278   // Set up a scrollView...
1279   ScrollView scrollView = ScrollView::New();
1280   Stage::GetCurrent().Add( scrollView );
1281   Vector2 stageSize = Stage::GetCurrent().GetSize();
1282   scrollView.SetSize(stageSize);
1283   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
1284   scrollView.SetRefreshInterval(0);
1285   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
1286   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1287
1288   // Position rulers.
1289   RulerPtr rulerX = new DefaultRuler();
1290   RulerPtr rulerY = new DefaultRuler();
1291   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
1292   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
1293   scrollView.SetRulerX(rulerX);
1294   scrollView.SetRulerY(rulerY);
1295   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
1296   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
1297   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
1298
1299   scrollView.ScrollTo(OVERSHOOT_START_SCROLL_POSITION, 0.0f); // move in a little.
1300   Wait(application);
1301
1302   // 1. Scroll page in NW (-500,-500 pixels), then inspect overshoot. (don't release touch)
1303   Vector2 currentPos = Vector2(100.0f, 100.0f);
1304   currentPos = PerformGestureDiagonalSwipe(application, currentPos, Vector2(5.0f, 5.0f), 100, false);
1305   Property::Index overshootXProperty = scrollView.GetPropertyIndex(ScrollView::SCROLL_OVERSHOOT_X_PROPERTY_NAME);
1306   Property::Index overshootYProperty = scrollView.GetPropertyIndex(ScrollView::SCROLL_OVERSHOOT_Y_PROPERTY_NAME);
1307   Property::Index scrollPositionProperty = scrollView.GetPropertyIndex(ScrollView::SCROLL_POSITION_PROPERTY_NAME);
1308   float overshootXValue = scrollView.GetProperty<float>(overshootXProperty);
1309   float overshootYValue = scrollView.GetProperty<float>(overshootYProperty);
1310   Vector3 positionValue = scrollView.GetProperty<Vector3>(scrollPositionProperty);
1311   DALI_TEST_EQUALS(overshootXValue, -1.0f, TEST_LOCATION);
1312   DALI_TEST_EQUALS(overshootYValue, -1.0f, TEST_LOCATION);
1313   DALI_TEST_EQUALS(positionValue, Vector3::ZERO, TEST_LOCATION);
1314
1315   float timeToReachOrigin;
1316
1317   // Now release touch. Overshoot should snap back to zero.
1318   SendPan(application, Gesture::Finished, currentPos);
1319   timeToReachOrigin = TestOvershootSnapDuration(application, scrollView);
1320
1321   DALI_TEST_CHECK( (timeToReachOrigin > TEST_DEFAULT_SNAP_OVERSHOOT_DURATION - TIME_TOLERANCE) &&
1322                    (timeToReachOrigin < TEST_DEFAULT_SNAP_OVERSHOOT_DURATION + TIME_TOLERANCE) );
1323
1324   // 2. Repeat Scroll, but this time change overshoot snap duration to shorter time
1325   scrollView.SetSnapOvershootDuration(TEST_CUSTOM1_SNAP_OVERSHOOT_DURATION);
1326
1327   currentPos = PerformGestureDiagonalSwipe(application, Vector2(100.0f, 100.0f), Vector2(5.0f, 5.0f), 100, false);
1328   // Now release touch. Overshoot should snap back to zero.
1329   SendPan(application, Gesture::Finished, currentPos);
1330   timeToReachOrigin = TestOvershootSnapDuration(application, scrollView);
1331
1332   DALI_TEST_CHECK( (timeToReachOrigin > TEST_CUSTOM1_SNAP_OVERSHOOT_DURATION - TIME_TOLERANCE) &&
1333                    (timeToReachOrigin < TEST_CUSTOM1_SNAP_OVERSHOOT_DURATION + TIME_TOLERANCE) );
1334
1335   // 3. Repeat Scroll, but this time change overshoot snap duration to longer time.
1336   scrollView.SetSnapOvershootDuration(TEST_CUSTOM2_SNAP_OVERSHOOT_DURATION);
1337
1338   currentPos = PerformGestureDiagonalSwipe(application, Vector2(100.0f, 100.0f), Vector2(5.0f, 5.0f), 100, false);
1339   // Now release touch. Overshoot should snap back to zero.
1340   SendPan(application, Gesture::Finished, currentPos);
1341   timeToReachOrigin = TestOvershootSnapDuration(application, scrollView);
1342
1343   DALI_TEST_CHECK( (timeToReachOrigin > TEST_CUSTOM2_SNAP_OVERSHOOT_DURATION - TIME_TOLERANCE) &&
1344                    (timeToReachOrigin < TEST_CUSTOM2_SNAP_OVERSHOOT_DURATION + TIME_TOLERANCE) );
1345
1346   // 4. Repeat Scroll, but this time change overshoot function.
1347   scrollView.SetSnapOvershootAlphaFunction(TestAlphaFunction);
1348
1349   currentPos = PerformGestureDiagonalSwipe(application, Vector2(100.0f, 100.0f), Vector2(5.0f, 5.0f), 100, false);
1350   // Now release touch. Overshoot should snap back to zero.
1351   SendPan(application, Gesture::Finished, currentPos);
1352   timeToReachOrigin = TestOvershootSnapDuration(application, scrollView);
1353
1354   DALI_TEST_CHECK( (timeToReachOrigin > TEST_CUSTOM3_SNAP_OVERSHOOT_DURATION - TIME_TOLERANCE) &&
1355                    (timeToReachOrigin < TEST_CUSTOM3_SNAP_OVERSHOOT_DURATION + TIME_TOLERANCE) );
1356   END_TEST;
1357 }
1358
1359 int UtcDaliScrollViewSnapAlphaFunction(void)
1360 {
1361   ToolkitTestApplication application;
1362   tet_infoline(" UtcDaliScrollViewSnapAlphaFunction");
1363
1364   // Set up a scrollView...
1365   ScrollView scrollView = ScrollView::New();
1366   scrollView.SetScrollSnapAlphaFunction( AlphaFunctions::EaseIn );
1367   DALI_TEST_CHECK( scrollView.GetScrollSnapAlphaFunction() == AlphaFunctions::EaseIn );
1368   scrollView.SetScrollSnapAlphaFunction( AlphaFunctions::EaseOut );
1369   DALI_TEST_CHECK( scrollView.GetScrollSnapAlphaFunction() == AlphaFunctions::EaseOut );
1370
1371   scrollView.SetScrollFlickAlphaFunction( AlphaFunctions::Bounce );
1372   DALI_TEST_CHECK( scrollView.GetScrollFlickAlphaFunction() == AlphaFunctions::Bounce );
1373   scrollView.SetScrollFlickAlphaFunction( AlphaFunctions::BounceBack );
1374   DALI_TEST_CHECK( scrollView.GetScrollFlickAlphaFunction() == AlphaFunctions::BounceBack );
1375   END_TEST;
1376 }
1377
1378 int UtcDaliScrollViewSnapDuration(void)
1379 {
1380   ToolkitTestApplication application;
1381   tet_infoline(" UtcDaliScrollViewSnapDuration");
1382
1383   // Set up a scrollView...
1384   ScrollView scrollView = ScrollView::New();
1385   scrollView.SetScrollSnapDuration( 1.0f );
1386   DALI_TEST_EQUALS( scrollView.GetScrollSnapDuration(), 1.0f, TEST_LOCATION );
1387   scrollView.SetScrollSnapDuration( 0.5f );
1388   DALI_TEST_EQUALS( scrollView.GetScrollSnapDuration(), 0.5f, TEST_LOCATION );
1389
1390   scrollView.SetScrollFlickDuration( 2.0f );
1391   DALI_TEST_EQUALS( scrollView.GetScrollFlickDuration(), 2.0f, TEST_LOCATION );
1392   scrollView.SetScrollFlickDuration( 1.5f );
1393   DALI_TEST_EQUALS( scrollView.GetScrollFlickDuration(), 1.5f, TEST_LOCATION );
1394   END_TEST;
1395 }
1396
1397 int UtcDaliScrollViewSignalsSnapStart(void)
1398 {
1399   ToolkitTestApplication application;
1400   tet_infoline(" UtcDaliScrollViewSignalsSnapStart");
1401
1402   // Set up a scrollView...
1403   ScrollView scrollView = ScrollView::New();
1404   Stage::GetCurrent().Add( scrollView );
1405   Vector2 stageSize = Stage::GetCurrent().GetSize();
1406   scrollView.SetSize(stageSize);
1407   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
1408   scrollView.SetRefreshInterval(0);
1409   scrollView.SetParentOrigin(ParentOrigin::TOP_LEFT);
1410   scrollView.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1411
1412   // Position rulers.
1413   RulerPtr rulerX = new DefaultRuler();
1414   RulerPtr rulerY = new DefaultRuler();
1415   rulerX->SetDomain( RulerDomain(0.0f, stageSize.width + CLAMP_EXCESS_WIDTH, true) );
1416   rulerY->SetDomain( RulerDomain(0.0f, stageSize.height + CLAMP_EXCESS_HEIGHT, true) );
1417   scrollView.SetRulerX(rulerX);
1418   scrollView.SetRulerY(rulerY);
1419   scrollView.SnapStartedSignal().Connect( &OnSnapStart );
1420
1421   scrollView.ScrollTo(CLAMP_START_SCROLL_POSITION, 0.0f); // move in a little.
1422   Wait(application);
1423
1424   DALI_TEST_CHECK( !gOnSnapStartCalled );
1425
1426   // First try a snap.
1427   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, Vector2(0.5f, 0.0f), 60, true);
1428
1429   DALI_TEST_CHECK( gOnSnapStartCalled );
1430   DALI_TEST_CHECK( gLastSnapType == Toolkit::Snap );
1431
1432   // Second try a swipe.
1433   PerformGestureDiagonalSwipe(application, CLAMP_TOUCH_START, Vector2(20.0f, 0.0f), 60, true);
1434
1435   DALI_TEST_CHECK( gOnSnapStartCalled );
1436   DALI_TEST_CHECK( gLastSnapType == Toolkit::Flick );
1437   END_TEST;
1438 }
1439
1440
1441 int UtcDaliScrollViewSetMouseWheelScrollDistanceStep(void)
1442 {
1443   ToolkitTestApplication application;
1444   tet_infoline(" UtcDaliScrollViewSetMouseWheelScrollDistanceStep");
1445
1446   ScrollView scrollView = ScrollView::New();
1447   // Disable Refresh signal (TET environment cannot use adaptor's Timer)
1448   scrollView.SetMouseWheelScrollDistanceStep(Vector2(30.0f, 15.0f));
1449   DALI_TEST_EQUALS( scrollView.GetMouseWheelScrollDistanceStep(), Vector2(30.0f, 15.0f), TEST_LOCATION );
1450   scrollView.SetMouseWheelScrollDistanceStep(Vector2(60.0f, 30.0f));
1451   DALI_TEST_EQUALS( scrollView.GetMouseWheelScrollDistanceStep(), Vector2(60.0f, 30.0f), TEST_LOCATION);
1452   END_TEST;
1453 }
1454
1455 int UtcDaliScrollViewGetSet(void)
1456 {
1457   ToolkitTestApplication application;
1458   tet_infoline(" UtcDaliScrollViewGetSet");
1459   ScrollView scrollView = ScrollView::New();
1460   scrollView.SetMaxOvershoot(50.0f, 50.0f);
1461   scrollView.SetMaxFlickSpeed(0.5f);
1462   DALI_TEST_EQUALS(scrollView.GetMaxFlickSpeed(), 0.5f, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1463   scrollView.SetFrictionCoefficient(0.6f);
1464   DALI_TEST_EQUALS(scrollView.GetFrictionCoefficient(), 0.6f, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1465   scrollView.SetFlickSpeedCoefficient(0.7f);
1466   DALI_TEST_EQUALS(scrollView.GetFlickSpeedCoefficient(), 0.7f, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1467   END_TEST;
1468 }