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