automated-tests/src/dali-toolkit/utc-Dali-ScrollViewEffect.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
  21 // Need to override adaptor classes for toolkit test harness, so include
  22 // test harness headers before dali headers.
  23 #include <dali-toolkit-test-suite-utils.h>
  24
  25 #include <dali.h>
  26 #include <dali-toolkit/dali-toolkit.h>
  27 #include <dali/integration-api/events/touch-event-integ.h>
  28 #include <dali/integration-api/events/pan-gesture-event.h>
  29
  30 using namespace Dali;
  31 using namespace Toolkit;
  32
  33 void utc_dali_toolkit_scroll_view_effect_startup(void)
  34 {
  35   test_return_value = TET_UNDEF;
  36 }
  37
  38 void utc_dali_toolkit_scroll_view_effect_cleanup(void)
  39 {
  40   test_return_value = TET_PASS;
  41 }
  42
  43 namespace
  44 {
  45
  46 const int MILLISECONDS_PER_SECOND = 1000;
  47 const int RENDER_FRAME_INTERVAL = 16;                           ///< Duration of each frame in ms. (at approx 60FPS)
  48 const int RENDER_ANIMATION_TEST_DURATION_MS = 1000;             ///< 1000ms to test animation
  49 const int RENDER_DELAY_SCROLL = 1000;                           ///< duration to wait for any scroll to complete.
  50
  51 /*
  52  * Simulate time passed by.
  53  *
  54  * @note this will always process at least 1 frame (1/60 sec)
  55  *
  56  * @param application Test application instance
  57  * @param duration Time to pass in milliseconds.
  58  * @return The actual time passed in milliseconds
  59  */
  60 int Wait(ToolkitTestApplication& application, int duration = 0)
  61 {
  62   int time = 0;
  63
  64   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
  65   {
  66     application.SendNotification();
  67     application.Render(RENDER_FRAME_INTERVAL);
  68     time += RENDER_FRAME_INTERVAL;
  69   }
  70
  71   return time;
  72 }
  73
  74 /**
  75  * Creates a Ruler that snaps to a specified grid size.
  76  * If that grid size is 0.0 then this ruler does not
  77  * snap.
  78  *
  79  * @param[in] gridSize (optional) The grid size for the ruler,
  80  * (Default = 0.0 i.e. no snapping)
  81  * @return The ruler is returned.
  82  */
  83 RulerPtr CreateRuler(float gridSize = 0.0f)
  84 {
  85   if(gridSize <= Math::MACHINE_EPSILON_0)
  86   {
  87       return new DefaultRuler();
  88   }
  89   return new FixedRuler(gridSize);
  90 }
  91
  92 // Callback probes.
  93
  94 static bool gOnScrollStartCalled;                       ///< Whether the OnScrollStart signal was invoked.
  95 static bool gOnScrollUpdateCalled;                      ///< Whether the OnScrollUpdate signal was invoked.
  96 static bool gOnScrollCompleteCalled;                    ///< Whether the OnScrollComplete signal was invoked.
  97 static Vector3 gConstraintResult;                       ///< Result from constraint.
  98
  99 static ActorContainer gPages;                                ///< Keeps track of all the pages for applying effects.
 100
 101 static void ResetScrollCallbackResults()
 102 {
 103   gOnScrollStartCalled = false;
 104   gOnScrollUpdateCalled = false;
 105   gOnScrollCompleteCalled = false;
 106 }
 107
 108 /**
 109  * Invoked when scrolling starts.
 110  *
 111  * @param[in] position The current scroll position.
 112  */
 113 static void OnScrollStart( const Vector3& position )
 114 {
 115   gOnScrollStartCalled = true;
 116 }
 117
 118 /**
 119  * Invoked when scrolling updates (via dragging)
 120  *
 121  * @param[in] position The current scroll position.
 122  */
 123 static void OnScrollUpdate( const Vector3& position )
 124 {
 125   gOnScrollUpdateCalled = true;
 126 }
 127
 128 /**
 129  * Invoked when scrolling finishes
 130  *
 131  * @param[in] position The current scroll position.
 132  */
 133 static void OnScrollComplete( const Vector3& position )
 134 {
 135   gOnScrollCompleteCalled = true;
 136 }
 137
 138 ScrollView SetupTestScrollView(int rows, int columns, Vector2 size)
 139 {
 140   ScrollView scrollView = ScrollView::New();
 141   scrollView.SetSize(size);
 142   scrollView.SetAnchorPoint(AnchorPoint::CENTER);
 143   scrollView.SetParentOrigin(ParentOrigin::CENTER);
 144   scrollView.ApplyConstraint( Constraint::New<Dali::Vector3>( Dali::Actor::SIZE, Dali::ParentSource( Dali::Actor::SIZE ), Dali::EqualToConstraint() ) );
 145   scrollView.SetWrapMode(false);
 146   scrollView.ScrollStartedSignal().Connect( &OnScrollStart );
 147   scrollView.ScrollUpdatedSignal().Connect( &OnScrollUpdate );
 148   scrollView.ScrollCompletedSignal().Connect( &OnScrollComplete );
 149   Stage::GetCurrent().Add( scrollView );
 150   RulerPtr rulerX = CreateRuler(size.width);
 151   RulerPtr rulerY = CreateRuler(size.height);
 152   if(columns > 1)
 153   {
 154     rulerX->SetDomain(RulerDomain(0.0f, size.width * columns));
 155   }
 156   else
 157   {
 158     rulerX->Disable();
 159   }
 160   if(rows > 1)
 161   {
 162     rulerY->SetDomain(RulerDomain(0.0f, size.width * rows));
 163   }
 164   else
 165   {
 166     rulerY->Disable();
 167   }
 168
 169   scrollView.SetRulerX( rulerX );
 170   scrollView.SetRulerY( rulerY );
 171   Stage::GetCurrent().Add( scrollView );
 172
 173   Actor container = Actor::New();
 174   container.SetParentOrigin(ParentOrigin::CENTER);
 175   container.SetAnchorPoint(AnchorPoint::CENTER);
 176   container.SetSize( size );
 177   scrollView.Add( container );
 178   container.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
 179
 180   gPages.clear();
 181   for(int row = 0;row<rows;row++)
 182   {
 183     for(int column = 0;column<columns;column++)
 184     {
 185       Actor page = Actor::New();
 186       page.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
 187       page.SetParentOrigin( ParentOrigin::CENTER );
 188       page.SetAnchorPoint( AnchorPoint::CENTER );
 189       page.SetPosition( column * size.x, row * size.y );
 190       container.Add(page);
 191
 192       gPages.push_back(page);
 193     }
 194   }
 195
 196   ResetScrollCallbackResults();
 197   return scrollView;
 198 }
 199
 200 void CleanupTest()
 201 {
 202   gPages.clear();
 203   ResetScrollCallbackResults();
 204 }
 205
 206 Actor AddActorToPage(Actor page, float x, float y, float cols, float rows)
 207 {
 208   Stage stage = Stage::GetCurrent();
 209   Vector2 stageSize = stage.GetSize();
 210
 211   const float margin = 10.0f;
 212   const Vector2 actorSize((stageSize.x / cols) - margin, (stageSize.y / rows) - margin);
 213
 214   Actor actor = Actor::New();
 215   actor.SetParentOrigin( ParentOrigin::CENTER );
 216   actor.SetAnchorPoint( AnchorPoint::CENTER );
 217
 218   Vector3 position( margin * 0.5f + (actorSize.x + margin) * x - stageSize.width * 0.5f,
 219                     margin * 0.5f + (actorSize.y + margin) * y - stageSize.height * 0.5f,
 220                     0.0f);
 221   Vector3 positionEnd( margin * 0.5f + (actorSize.x + margin) * (x + cols) - stageSize.width * 0.5f - margin,
 222                        margin * 0.5f + (actorSize.y + margin) * (y + rows) - stageSize.height * 0.5f - margin,
 223                        0.0f);
 224   Vector3 size(positionEnd - position);
 225   actor.SetPosition( position + size * 0.5f);
 226   actor.SetSize( positionEnd - position );
 227   page.Add(actor);
 228   return actor;
 229 }
 230
 231 } // unnamed namespace
 232
 233
 234 int UtcDaliScrollViewCustomEffectSetup(void)
 235 {
 236   tet_infoline(" UtcDaliScrollViewCustomEffectSetup");
 237
 238   ScrollViewCustomEffect effect;
 239
 240   DALI_TEST_CHECK( !effect );
 241
 242   BaseHandle handle = ScrollViewCustomEffect::New();
 243
 244   DALI_TEST_CHECK( handle );
 245
 246   effect = ScrollViewCustomEffect::DownCast(handle);
 247
 248   DALI_TEST_CHECK( effect );
 249
 250   END_TEST;
 251 }
 252
 253 int UtcDaliScrollViewCubeEffectSetup(void)
 254 {
 255   tet_infoline(" UtcDaliScrollViewCubeEffectSetup");
 256
 257   ScrollViewCubeEffect effect;
 258
 259   DALI_TEST_CHECK( !effect );
 260
 261   BaseHandle handle = ScrollViewCubeEffect::New();
 262
 263   DALI_TEST_CHECK( handle );
 264
 265   effect = ScrollViewCubeEffect::DownCast(handle);
 266
 267   DALI_TEST_CHECK( effect );
 268   END_TEST;
 269 }
 270
 271 int UtcDaliScrollViewSpiralEffectSetup(void)
 272 {
 273   tet_infoline(" UtcDaliScrollViewSpiralEffectSetup");
 274
 275   ScrollViewPageSpiralEffect effect;
 276
 277   DALI_TEST_CHECK( !effect );
 278
 279   BaseHandle handle = ScrollViewPageSpiralEffect::New();
 280
 281   DALI_TEST_CHECK( handle );
 282
 283   effect = ScrollViewPageSpiralEffect::DownCast(handle);
 284
 285   DALI_TEST_CHECK( effect );
 286   END_TEST;
 287 }
 288
 289
 290
 291
 292 int UtcDaliScrollViewSlideEffectSetup(void)
 293 {
 294   tet_infoline(" UtcDaliScrollViewSlideEffectSetup");
 295
 296   ScrollViewSlideEffect effect;
 297
 298   DALI_TEST_CHECK( !effect );
 299
 300   BaseHandle handle = ScrollViewSlideEffect::New();
 301
 302   DALI_TEST_CHECK( handle );
 303
 304   effect = ScrollViewSlideEffect::DownCast(handle);
 305
 306   DALI_TEST_CHECK( effect );
 307   END_TEST;
 308 }
 309
 310 int UtcDaliScrollViewTwistEffectSetup(void)
 311 {
 312   tet_infoline(" UtcDaliScrollViewTwistEffectSetup");
 313
 314   ScrollViewTwistEffect effect;
 315
 316   DALI_TEST_CHECK( !effect );
 317
 318   BaseHandle handle = ScrollViewTwistEffect::New();
 319
 320   DALI_TEST_CHECK( handle );
 321
 322   effect = ScrollViewTwistEffect::DownCast(handle);
 323
 324   DALI_TEST_CHECK( effect );
 325   END_TEST;
 326 }
 327
 328 int UtcDaliScrollViewCubeEffectTest(void)
 329 {
 330   ToolkitTestApplication application;
 331   tet_infoline(" UtcDaliScrollViewCubeEffectTest");
 332
 333   Vector2 size = Stage::GetCurrent().GetSize();
 334
 335   ScrollView scrollView = SetupTestScrollView(1, 3, size);
 336   Actor page = gPages[1];
 337   Wait(application, 500);
 338
 339   ScrollViewCubeEffect effect = ScrollViewCubeEffect::New();
 340   scrollView.ApplyEffect(effect);
 341
 342   Actor actor = AddActorToPage(page, 0.5f, 0.5f, 3, 3);
 343   Wait(application);
 344   Vector3 actorPrePosition = actor.GetCurrentPosition();
 345
 346   effect.ApplyToActor(actor, page, Vector3(-105.0f, 30.0f, -240.0f), Vector2(Math::PI * 0.5f, Math::PI * 0.5f), Vector2(0.25f, 0.25f) * size);
 347
 348   Actor actor2 = AddActorToPage(page, 0.5f, 0.5f, 3, 3);
 349   effect.ApplyToActor(actor2, Vector3(-105.0f, 30.0f, -240.0f), Vector2(Math::PI * 0.5f, Math::PI * 0.5f), Vector2(0.25f, 0.25f) * size);
 350
 351   scrollView.ScrollTo(1);
 352   while(!gOnScrollCompleteCalled)
 353   {
 354     Wait(application);
 355   }
 356   // test that the first page has reached centre of screen
 357   Vector3 actorPostPosition = actor.GetCurrentPosition();
 358   // just check the actor has moved
 359   DALI_TEST_CHECK((actorPostPosition - actorPrePosition).Length() > Math::MACHINE_EPSILON_1);
 360   CleanupTest();
 361   END_TEST;
 362 }
 363
 364
 365 int UtcDaliScrollViewSpiralEffectTest(void)
 366 {
 367   ToolkitTestApplication application;
 368   tet_infoline(" UtcDaliScrollViewSpiralEffectTest");
 369
 370   Vector2 size = Stage::GetCurrent().GetSize();
 371
 372   ScrollView scrollView = SetupTestScrollView(1, 3, size);
 373   Actor testPage = gPages[1];
 374   Wait(application, 500);
 375
 376   ScrollViewPageSpiralEffect effect = ScrollViewPageSpiralEffect::New();
 377   scrollView.ApplyEffect(effect);
 378
 379   for(ActorIter pageIter = gPages.begin(); pageIter != gPages.end(); ++pageIter)
 380   {
 381     Actor page = *pageIter;
 382     page.RemoveConstraints();
 383     page.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
 384     effect.ApplyToPage(page, Vector2(Math::PI_2, 0.0f));
 385   }
 386   Wait(application);
 387
 388   scrollView.ScrollTo(1);
 389   while(!gOnScrollCompleteCalled)
 390   {
 391     Wait(application);
 392   }
 393   // test that the first page has reached centre of screen
 394   Vector3 pagePos = testPage.GetCurrentPosition();
 395   DALI_TEST_EQUALS(pagePos, Vector3::ZERO, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 396   CleanupTest();
 397   END_TEST;
 398 }
 399
 400
 401
 402 int UtcDaliScrollViewSlideEffectTest(void)
 403 {
 404   ToolkitTestApplication application;
 405   tet_infoline(" UtcDaliScrollViewSlideEffectTest");
 406
 407   Vector2 size = Stage::GetCurrent().GetSize();
 408   Vector3 pageSize(size.x, size.y, 0.0f);
 409
 410   ScrollView scrollView = SetupTestScrollView(1, 3, size);
 411   Actor testPage = gPages[1];
 412   Wait(application, 500);
 413
 414   ScrollViewSlideEffect effect = ScrollViewSlideEffect::New();
 415   effect.SetDelayReferenceOffset(pageSize * 0.25);
 416   DALI_TEST_EQUALS(effect.GetDelayReferenceOffset(), pageSize * 0.25, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 417   effect.SetMaxDelayDuration(0.5f);
 418   DALI_TEST_EQUALS(effect.GetMaxDelayDuration(), 0.5f, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 419   effect.SetSlideDirection(false);
 420   DALI_TEST_CHECK(!effect.GetSlideDirection());
 421
 422   scrollView.ApplyEffect(effect);
 423
 424   Actor actor = AddActorToPage(testPage, 0.5f, 0.5f, 3, 3);
 425   Wait(application);
 426   Vector3 actorPrePosition = actor.GetCurrentPosition();
 427
 428   effect.ApplyToActor(actor, 0.0f, 0.5f);
 429
 430   scrollView.ScrollTo(1);
 431   while(!gOnScrollCompleteCalled)
 432   {
 433     Wait(application);
 434   }
 435   // test that the first page has reached centre of screen
 436   Vector3 actorPostPosition = actor.GetCurrentPosition();
 437   // just check the actor has moved
 438   DALI_TEST_CHECK((actorPostPosition - actorPrePosition).Length() > Math::MACHINE_EPSILON_1);
 439   CleanupTest();
 440   END_TEST;
 441 }
 442
 443 int UtcDaliScrollViewTwistEffectTest(void)
 444 {
 445   ToolkitTestApplication application;
 446   tet_infoline(" UtcDaliScrollViewTwistEffectTest");
 447
 448   Vector2 size = Stage::GetCurrent().GetSize();
 449
 450   ScrollView scrollView = SetupTestScrollView(1, 3, size);
 451   Actor testPage = gPages[1];
 452   Wait(application, 500);
 453
 454   ScrollViewTwistEffect effect = ScrollViewTwistEffect::New();
 455   float shrinkDist = 0.2f;
 456   effect.SetMinimumDistanceForShrink(shrinkDist);
 457   DALI_TEST_CHECK((shrinkDist - effect.GetMinimumDistanceForShrink()) < Math::MACHINE_EPSILON_0);
 458   effect.EnableEffect(true);
 459   scrollView.ApplyEffect(effect);
 460
 461   Actor actor = AddActorToPage(testPage, 0.5f, 0.5f, 3, 3);
 462   Wait(application);
 463   Vector3 actorPrePosition = actor.GetCurrentPosition();
 464
 465   effect.ApplyToActor( actor,
 466       true,
 467       Vector2(Math::PI_2, Math::PI_2),
 468       0.0f);
 469
 470   scrollView.ScrollTo(1);
 471   while(!gOnScrollCompleteCalled)
 472   {
 473     Wait(application);
 474   }
 475   // test that the first page has reached centre of screen
 476   Vector3 actorPostPosition = actor.GetCurrentPosition();
 477   // just check the actor has moved
 478   DALI_TEST_CHECK((actorPostPosition - actorPrePosition).Length() > Math::MACHINE_EPSILON_1);
 479   CleanupTest();
 480   END_TEST;
 481 }
 482
 483 int UtcDaliScrollViewCustomEffectTest(void)
 484 {
 485   ToolkitTestApplication application;
 486   tet_infoline(" UtcDaliScrollViewCustomEffectTest");
 487
 488   Vector2 size = Stage::GetCurrent().GetSize();
 489   Vector3 pageSize(size.x, size.y, 0.0f);
 490
 491   ScrollView scrollView = SetupTestScrollView(1, 3, size);
 492   Actor testPage = gPages[1];
 493   Wait(application, 500);
 494   Vector3 pageStartPos, pagePos;
 495   pageStartPos = pagePos = testPage.GetCurrentPosition();
 496   //scrollView.RemoveConstraintsFromChildren();
 497
 498   ScrollViewCustomEffect effect = ScrollViewCustomEffect::DownCast(scrollView.ApplyEffect(ScrollView::PageEffectCarousel));
 499
 500   for(ActorIter pageIter = gPages.begin(); pageIter != gPages.end(); ++pageIter)
 501   {
 502     Actor page = *pageIter;
 503     page.RemoveConstraints();
 504     page.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
 505     effect.ApplyToPage(page, pageSize);
 506   }
 507   Wait(application);
 508   pagePos = testPage.GetCurrentPosition();
 509   DALI_TEST_EQUALS(pagePos, pageStartPos, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 510
 511   scrollView.ScrollTo(1);
 512   while(!gOnScrollCompleteCalled)
 513   {
 514     Wait(application);
 515   }
 516   ResetScrollCallbackResults();
 517   // test that the first page has reached centre of screen
 518   pagePos = testPage.GetCurrentPosition();
 519   DALI_TEST_EQUALS(pagePos, Vector3::ZERO, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 520
 521   // scroll back to page 0
 522   scrollView.ScrollTo(0);
 523   while(!gOnScrollCompleteCalled)
 524   {
 525     Wait(application);
 526   }
 527   ResetScrollCallbackResults();
 528   pagePos = testPage.GetCurrentPosition();
 529   DALI_TEST_EQUALS(pagePos, pageStartPos, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 530
 531   scrollView.RemoveEffect(effect);
 532
 533   effect = ScrollViewCustomEffect::New();
 534   effect.SetPageTranslation(Vector3(20.0f, 20.0f, 5.0f));
 535   effect.SetPageTranslation(Vector3(20.0f, 20.0f, 5.0f), Vector3(20.0f, 20.0f, -5.0f));
 536   effect.SetPageTranslationIn(Vector3(20.0f, 20.0f, 5.0f));
 537   effect.SetPageTranslationOut(Vector3(20.0f, 20.0f, -5.0f));
 538   effect.SetPageTranslation(Vector3(20.0f, 0.0f, 0.0f));
 539   effect.SetSwingAngle(Math::PI, Vector3::YAXIS);
 540   effect.SetPageSpacing(Vector2(20.0f, 20.0f));
 541   scrollView.ApplyEffect(effect);
 542
 543   for(ActorIter pageIter = gPages.begin(); pageIter != gPages.end(); ++pageIter)
 544   {
 545     Actor page = *pageIter;
 546     page.RemoveConstraints();
 547     page.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
 548     effect.ApplyToPage(page, pageSize);
 549   }
 550   Wait(application);
 551   pagePos = testPage.GetCurrentPosition();
 552   DALI_TEST_EQUALS(pagePos, pageStartPos, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 553
 554   scrollView.ScrollTo(1);
 555   while(!gOnScrollCompleteCalled)
 556   {
 557     Wait(application);
 558   }
 559   ResetScrollCallbackResults();
 560   // test that the first page has reached centre of screen
 561   pagePos = testPage.GetCurrentPosition();
 562   DALI_TEST_EQUALS(pagePos, Vector3::ZERO, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 563
 564   // scroll back to page 0
 565   scrollView.ScrollTo(0);
 566   while(!gOnScrollCompleteCalled)
 567   {
 568     Wait(application);
 569   }
 570   ResetScrollCallbackResults();
 571   pagePos = testPage.GetCurrentPosition();
 572   DALI_TEST_EQUALS(pagePos, pageStartPos, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 573
 574   scrollView.RemoveEffect(effect);
 575   effect = ScrollViewCustomEffect::New();
 576   effect.SetSwingAngle(Math::PI, Vector3::YAXIS);
 577   effect.SetSwingAnchor(AnchorPoint::CENTER_LEFT);
 578   effect.SetPageTranslation(Vector3(size.x, size.y, 0));
 579   effect.SetOpacityThreshold(0.66f);
 580   scrollView.ApplyEffect(effect);
 581
 582   for(ActorIter pageIter = gPages.begin(); pageIter != gPages.end(); ++pageIter)
 583   {
 584     Actor page = *pageIter;
 585     page.RemoveConstraints();
 586     page.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
 587     effect.ApplyToPage(page, pageSize);
 588   }
 589   Wait(application);
 590
 591   scrollView.ScrollTo(1);
 592   while(!gOnScrollCompleteCalled)
 593   {
 594     Wait(application);
 595   }
 596   ResetScrollCallbackResults();
 597   // test that the first page has reached centre of screen
 598   pagePos = testPage.GetCurrentPosition();
 599   DALI_TEST_EQUALS(pagePos, Vector3::ZERO, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 600
 601   // scroll back to page 0
 602   scrollView.ScrollTo(0);
 603   while(!gOnScrollCompleteCalled)
 604   {
 605     Wait(application);
 606   }
 607   ResetScrollCallbackResults();
 608   pagePos = testPage.GetCurrentPosition();
 609   DALI_TEST_EQUALS(pagePos, pageStartPos, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 610   scrollView.RemoveEffect(effect);
 611
 612
 613   effect.SetPageTranslateAlphaFunction(AlphaFunctions::Linear);
 614   effect.SetPageTranslateAlphaFunction(AlphaFunctions::Linear, AlphaFunctions::Linear);
 615   effect.SetPageTranslateAlphaFunctionIn(AlphaFunctions::Linear);
 616   effect.SetPageTranslateAlphaFunctionOut(AlphaFunctions::Linear);
 617   effect.SetGlobalPageRotation(Math::PI, Vector3::YAXIS);
 618   effect.SetAngledOriginPageRotation(Vector3(Math::PI, Math::PI, 0.0f));
 619   effect.SetGlobalPageRotation(Math::PI, Vector3::YAXIS, Math::PI, Vector3::YAXIS);
 620   effect.SetGlobalPageRotationIn(Math::PI, Vector3::YAXIS);
 621   effect.SetGlobalPageRotationOut(Math::PI, Vector3::YAXIS);
 622   effect.SetGlobalPageRotationOrigin(Vector3::ZERO);
 623   effect.SetGlobalPageRotationOrigin(Vector3::ZERO, Vector3::ZERO);
 624   effect.SetGlobalPageRotationOriginIn(Vector3::ZERO);
 625   effect.SetGlobalPageRotationOriginOut(Vector3::ZERO);
 626   effect.SetSwingAngle(Math::PI, Vector3::YAXIS);
 627   effect.SetSwingAngle(Math::PI, Vector3::YAXIS, Math::PI, Vector3::YAXIS);
 628   effect.SetSwingAngleIn(Math::PI, Vector3::YAXIS);
 629   effect.SetSwingAngleOut(Math::PI, Vector3::YAXIS);
 630   effect.SetSwingAngleAlphaFunction(AlphaFunctions::Linear);
 631   effect.SetSwingAngleAlphaFunction(AlphaFunctions::Linear, AlphaFunctions::Linear);
 632   effect.SetSwingAngleAlphaFunctionIn(AlphaFunctions::Linear);
 633   effect.SetSwingAngleAlphaFunctionOut(AlphaFunctions::Linear);
 634   effect.SetSwingAnchor(AnchorPoint::CENTER, AnchorPoint::CENTER_LEFT);
 635   effect.SetSwingAnchorIn(AnchorPoint::CENTER);
 636   effect.SetSwingAnchorOut(AnchorPoint::CENTER);
 637   effect.SetSwingAnchorAlphaFunction(AlphaFunctions::Linear);
 638   effect.SetSwingAnchorAlphaFunction(AlphaFunctions::Linear, AlphaFunctions::Linear);
 639   effect.SetSwingAnchorAlphaFunctionIn(AlphaFunctions::Linear);
 640   effect.SetSwingAnchorAlphaFunctionOut(AlphaFunctions::Linear);
 641   effect.SetOpacityThreshold(0.5f);
 642   effect.SetOpacityThreshold(0.5f, 0.5f);
 643   effect.SetOpacityThresholdIn(0.5f);
 644   effect.SetOpacityThresholdOut(0.5f);
 645   effect.SetOpacityAlphaFunction(AlphaFunctions::Linear);
 646   effect.SetOpacityAlphaFunction(AlphaFunctions::Linear, AlphaFunctions::Linear);
 647   effect.SetOpacityAlphaFunctionIn(AlphaFunctions::Linear);
 648   effect.SetOpacityAlphaFunctionOut(AlphaFunctions::Linear);
 649   CleanupTest();
 650   END_TEST;
 651 }