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

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