automated-tests/src/dali-toolkit/utc-Dali-PageTurnView.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 <string.h>
  21 #include <sstream>
  22 #include <dali-toolkit-test-suite-utils.h>
  23 #include <dali/integration-api/events/pan-gesture-event.h>
  24 #include <dali-toolkit/public-api/controls/page-turn-view/page-factory.h>
  25 #include <dali-toolkit/public-api/controls/page-turn-view/page-turn-landscape-view.h>
  26 #include <dali-toolkit/public-api/controls/page-turn-view/page-turn-portrait-view.h>
  27 #include <dali-toolkit/public-api/controls/page-turn-view/page-turn-view.h>
  28
  29
  30
  31 using namespace Dali;
  32 using namespace Dali::Toolkit;
  33
  34 namespace
  35 {
  36 const int RENDER_FRAME_INTERVAL = 16;                           ///< Duration of each frame in ms. (at approx 60FPS)
  37 const unsigned int TOTAL_PAGE_NUMBER = 20;
  38 const Vector2 PAGE_SIZE( 300.f,400.f );
  39 const unsigned int IMAGE_WIDTH = 30;
  40 const unsigned int IMAGE_HEIGHT = 30;
  41 const Vector2 IMAGE_SIZE( static_cast<float>( IMAGE_WIDTH ), static_cast<float>(IMAGE_HEIGHT) );
  42 const Vector2 SPINE_SHADOW_PARAMETER( 60.0f, 30.0f );
  43
  44 static bool gObjectCreatedCallBackCalled;
  45 static void TestCallback(BaseHandle handle)
  46 {
  47   gObjectCreatedCallBackCalled = true;
  48 }
  49
  50 /*
  51  * Simulate time passed by.
  52  *
  53  * @note this will always process at least 1 frame (1/60 sec)
  54  *
  55  * @param application Test application instance
  56  * @param duration Time to pass in milliseconds.
  57  */
  58 void Wait(ToolkitTestApplication& application, int duration = 0)
  59 {
  60   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
  61   {
  62     application.SendNotification();
  63     application.Render(RENDER_FRAME_INTERVAL);
  64   }
  65 }
  66
  67 // Generate a PanGestureEvent to send to Core
  68 Integration::PanGestureEvent GeneratePan(
  69     Gesture::State state,
  70     const Vector2& previousPosition,
  71     const Vector2& currentPosition,
  72     unsigned long timeDelta,
  73     unsigned int numberOfTouches = 1)
  74 {
  75   Integration::PanGestureEvent pan(state);
  76
  77   pan.previousPosition = previousPosition;
  78   pan.currentPosition = currentPosition;
  79   pan.timeDelta = timeDelta;
  80   pan.numberOfTouches = numberOfTouches;
  81
  82   return pan;
  83 }
  84
  85 /**
  86  * Helper to generate PanGestureEvent
  87  *
  88  * @param[in] application Application instance
  89  * @param[in] state The Gesture State
  90  * @param[in] pos The current position of touch.
  91  */
  92 static void SendPan(ToolkitTestApplication& application, Gesture::State state, const Vector2& pos)
  93 {
  94   static Vector2 last;
  95
  96   if( (state == Gesture::Started) ||
  97       (state == Gesture::Possible) )
  98   {
  99     last.x = pos.x;
 100     last.y = pos.y;
 101   }
 102
 103   application.ProcessEvent(GeneratePan(state, last, pos, RENDER_FRAME_INTERVAL));
 104
 105   last.x = pos.x;
 106   last.y = pos.y;
 107 }
 108
 109 static Vector2 PerformGestureDiagonalSwipe(ToolkitTestApplication& application, Vector2 start, Vector2 direction, int frames, bool toStart = true, bool toFinish = true)
 110 {
 111   // Now do a pan starting from (start) and heading (direction)
 112   Vector2 pos(start);
 113
 114   if( toStart )
 115   {
 116     SendPan(application, Gesture::Possible, pos);
 117     Wait(application);
 118     SendPan(application, Gesture::Started, pos);
 119     Wait(application);
 120   }
 121
 122   for(int i = 0;i<frames;i++)
 123   {
 124     pos += direction; // Move in this direction
 125     SendPan(application, Gesture::Continuing, pos);
 126     Wait(application);
 127   }
 128
 129   if(toFinish)
 130   {
 131     pos += direction; // Move in this direction
 132     SendPan(application, Gesture::Finished, pos);
 133     Wait(application);
 134   }
 135
 136   return pos;
 137 }
 138
 139
 140 //Functor to test whether PageTurnSignal / PagePanSignal is emitted
 141 class PageSignalCallback : public Dali::ConnectionTracker
 142 {
 143 public:
 144
 145   PageSignalCallback( bool& signalReceived, PageTurnView& view, unsigned int& pageIndex, bool& isForwards )
 146   : mSignalVerified( signalReceived ),
 147     mView( view ),
 148     mPageIndex( pageIndex ),
 149     mIsTurningForwards( isForwards )
 150   {
 151   }
 152
 153   // callback to be connected to PageTurnSignal
 154   void PageTurnSignalCallback( PageTurnView view, unsigned int pageIndex, bool isTurningForward )
 155   {
 156     tet_infoline( "Verifying PageTurnedSignal" );
 157
 158     if( mView == view && mPageIndex == pageIndex && mIsTurningForwards == isTurningForward )
 159     {
 160       mSignalVerified = true;
 161     }
 162   }
 163
 164   // callback to be connected to PagePanSignal
 165   void PagePanSignalCallback( PageTurnView view )
 166   {
 167     tet_infoline( "Verifying PagePannedSignal" );
 168
 169     if( mView == view )
 170     {
 171       mSignalVerified = true;
 172     }
 173   }
 174
 175   void Reset()
 176   {
 177     mSignalVerified = false;
 178   }
 179
 180   bool&         mSignalVerified;
 181   PageTurnView& mView;
 182   unsigned int& mPageIndex;
 183   bool&         mIsTurningForwards;
 184
 185 };
 186
 187
 188 //Implementation of PageFactory for providing page actors to PageTurnView
 189 class TestPageFactory : public PageFactory
 190 {
 191 public:
 192
 193   TestPageFactory(ToolkitTestApplication& application)
 194   : mApplication( application )
 195   {
 196     mSourceActors.resize(TOTAL_PAGE_NUMBER);
 197     mTotalPageNumber = TOTAL_PAGE_NUMBER;
 198   }
 199
 200   /**
 201    * Query the number of pages available from the factory.
 202    * The maximum available page has an ID of GetNumberOfPages()-1.
 203    */
 204   virtual unsigned int GetNumberOfPages()
 205   {
 206     return mTotalPageNumber;
 207   }
 208
 209   /**
 210    * Create an image actor to represent a page.
 211    * @param[in] pageId The ID of the page to create.
 212    * @return An image actor, or an uninitialized pointer if the ID is out of range.
 213    */
 214   virtual Actor NewPage( unsigned int pageId )
 215   {
 216     if(!mSourceActors[pageId])
 217     {
 218       Actor actor = CreateSolidColorImageActor(mApplication, Color::BLUE,IMAGE_WIDTH,IMAGE_HEIGHT);
 219       actor.SetName( static_cast<std::ostringstream*>( &(std::ostringstream() << pageId) )->str()  );
 220
 221       actor.SetParentOrigin( ParentOrigin::CENTER );
 222       actor.SetAnchorPoint( AnchorPoint::CENTER );
 223
 224       mSourceActors[pageId] = actor;
 225     }
 226
 227     return mSourceActors[pageId];
 228   }
 229
 230   void DeletePage( unsigned int pageId )
 231   {
 232     mSourceActors.erase( mSourceActors.begin() + pageId );
 233     mTotalPageNumber--;
 234   }
 235
 236 private:
 237   ToolkitTestApplication& mApplication;
 238   std::vector<Actor>      mSourceActors;
 239   unsigned int            mTotalPageNumber;
 240 };
 241
 242 }// namespace
 243
 244 void dali_page_turn_view_startup(void)
 245 {
 246   test_return_value = TET_UNDEF;
 247 }
 248
 249 void dali_page_turn_view_cleanup(void)
 250 {
 251   test_return_value = TET_PASS;
 252 }
 253
 254 int UtcDaliPageTurnPortraitViewNew(void)
 255 {
 256   ToolkitTestApplication application;
 257
 258   tet_infoline(" UtcDaliPageTurnViewNew ");
 259
 260   // Test default constructor
 261   PageTurnView portraitView;
 262   DALI_TEST_CHECK( !portraitView );
 263
 264   // Test object creation
 265   TestPageFactory factory(application);
 266   portraitView = PageTurnPortraitView::New( factory, PAGE_SIZE );
 267   DALI_TEST_CHECK( portraitView );
 268
 269   //Additional check to ensure object is created by checking if it's registered
 270   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 271   DALI_TEST_CHECK( registry );
 272
 273   gObjectCreatedCallBackCalled = false;
 274   registry.ObjectCreatedSignal().Connect( &TestCallback );
 275   {
 276     TestPageFactory factory(application);
 277     PageTurnView PortraitView = PageTurnPortraitView::New( factory, PAGE_SIZE );
 278   }
 279   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
 280
 281   // Test copy constructor
 282   PageTurnView viewCopy( portraitView );
 283   DALI_TEST_CHECK( viewCopy );
 284
 285   // Test down cast
 286   Handle handleView;
 287   handleView = portraitView;
 288   PageTurnView downCastView = PageTurnView::DownCast( handleView );
 289   DALI_TEST_CHECK( downCastView );
 290   END_TEST;
 291 }
 292
 293 int UtcDaliPageTurnLandscapeViewNew(void)
 294 {
 295   ToolkitTestApplication application;
 296
 297   tet_infoline(" UtcDaliPageTurnViewNew ");
 298
 299   //Test default constructor
 300   PageTurnView landscapeView;
 301   DALI_TEST_CHECK( !landscapeView );
 302
 303   // Test object creation
 304   TestPageFactory factory(application);
 305   landscapeView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
 306   DALI_TEST_CHECK( landscapeView );
 307
 308   //Additional check to ensure object is created by checking if it's registered
 309   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 310   DALI_TEST_CHECK( registry );
 311
 312   gObjectCreatedCallBackCalled = false;
 313   registry.ObjectCreatedSignal().Connect( &TestCallback );
 314   {
 315     TestPageFactory factory(application);
 316     PageTurnView landscapeView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
 317   }
 318   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
 319
 320   // Test copy constructor
 321   PageTurnView viewCopy( landscapeView );
 322   DALI_TEST_CHECK( viewCopy );
 323
 324   // Test down cast
 325   Handle handleView;
 326   handleView = landscapeView;
 327   PageTurnView downCastView = PageTurnView::DownCast( handleView );
 328   DALI_TEST_CHECK( downCastView );
 329
 330   END_TEST;
 331 }
 332
 333 int UtcDaliPageTurnViewSetGetProperty(void)
 334 {
 335   ToolkitTestApplication application;
 336
 337   tet_infoline(" UtcDaliPageTurnViewSetGetProperty ");
 338
 339   TestPageFactory factory(application);
 340   PageTurnView landscapeView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
 341   DALI_TEST_CHECK( landscapeView );
 342
 343   Stage::GetCurrent().Add( landscapeView );
 344
 345   // Test "page-size" property
 346   DALI_TEST_CHECK( landscapeView.GetPropertyIndex("page-size") == PageTurnView::Property::PAGE_SIZE  );
 347   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::PAGE_SIZE).Get<Vector2>(), PAGE_SIZE, TEST_LOCATION );
 348
 349   Vector2 newSize( PAGE_SIZE.x*0.75, PAGE_SIZE.y*0.5f );
 350   landscapeView.SetProperty( PageTurnView::Property::PAGE_SIZE, newSize );
 351   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::PAGE_SIZE).Get<Vector2>(), newSize, TEST_LOCATION );
 352   Wait( application);
 353   DALI_TEST_EQUALS( Vector2(landscapeView.GetTargetSize()), Vector2(newSize.x*2.f, newSize.y), TEST_LOCATION);
 354
 355   landscapeView.SetProperty( PageTurnView::Property::PAGE_SIZE,newSize*1.5f);
 356   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::PAGE_SIZE).Get<Vector2>(), newSize*1.5f, TEST_LOCATION );
 357   Wait( application);
 358   DALI_TEST_EQUALS( Vector2(landscapeView.GetTargetSize()), Vector2(newSize.x*3.f, newSize.y*1.5f), TEST_LOCATION);
 359
 360   // Test "current-page-id" property
 361   DALI_TEST_CHECK( landscapeView.GetPropertyIndex("current-page-id") == PageTurnView::Property::CURRENT_PAGE_ID );
 362   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION );
 363
 364   int pageId = static_cast<int>(TOTAL_PAGE_NUMBER)/3;
 365   landscapeView.SetProperty( PageTurnView::Property::CURRENT_PAGE_ID, pageId );
 366   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), pageId, TEST_LOCATION );
 367
 368   landscapeView.SetProperty( PageTurnView::Property::CURRENT_PAGE_ID, pageId*2 );
 369   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), pageId*2, TEST_LOCATION );
 370
 371   // Test "spin-shadow" property
 372   DALI_TEST_CHECK( landscapeView.GetPropertyIndex( "spine-shadow" ) == PageTurnView::Property::SPINE_SHADOW );
 373   landscapeView.SetProperty( PageTurnView::Property::SPINE_SHADOW, SPINE_SHADOW_PARAMETER );
 374   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::SPINE_SHADOW).Get<Vector2>(), SPINE_SHADOW_PARAMETER, TEST_LOCATION );
 375
 376   landscapeView.SetProperty( PageTurnView::Property::SPINE_SHADOW,  SPINE_SHADOW_PARAMETER*0.75f );
 377   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::SPINE_SHADOW).Get<Vector2>(), SPINE_SHADOW_PARAMETER*0.75f, TEST_LOCATION );
 378
 379   END_TEST;
 380 }
 381
 382 int UtcDaliPageTurnViewSignals(void)
 383 {
 384   ToolkitTestApplication application;
 385
 386   tet_infoline(" UtcDaliPageTurnViewSignals ");
 387
 388   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
 389
 390   TestPageFactory factory(application);
 391   Vector2 size = Stage::GetCurrent().GetSize();
 392   PageTurnView portraitView = PageTurnPortraitView::New( factory, size );
 393   portraitView.SetPositionInheritanceMode( USE_PARENT_POSITION );
 394   Stage::GetCurrent().Add( portraitView );
 395
 396   // Render and notify
 397   application.SendNotification();
 398   application.Render(RENDER_FRAME_INTERVAL);
 399
 400   // [0]: testing PageTurnStartedSignal;  [1]: testing PageTurnFinishedSignal
 401   // [2]: testing PagePanStartedSignal;   [3]: testing PagePanFinishedSignal
 402   bool signalVerified[4] = {false, false, false, false};
 403   PageTurnView currentView;
 404   unsigned int pageIndex;
 405   bool isTurningForwards;
 406
 407   PageSignalCallback callbackTurnStarted( signalVerified[0], currentView, pageIndex, isTurningForwards );
 408   portraitView.PageTurnStartedSignal().Connect( &callbackTurnStarted, &PageSignalCallback::PageTurnSignalCallback );
 409
 410   PageSignalCallback callbackTurnFinished( signalVerified[1], currentView, pageIndex, isTurningForwards );
 411   portraitView.PageTurnFinishedSignal().Connect( &callbackTurnFinished, &PageSignalCallback::PageTurnSignalCallback );
 412
 413   PageSignalCallback callbackPanStarted( signalVerified[2], currentView, pageIndex, isTurningForwards );
 414   portraitView.PagePanStartedSignal().Connect( &callbackPanStarted, &PageSignalCallback::PagePanSignalCallback );
 415
 416   PageSignalCallback callbackPanFinished( signalVerified[3], currentView, pageIndex, isTurningForwards );
 417   portraitView.PagePanFinishedSignal().Connect( &callbackPanFinished, &PageSignalCallback::PagePanSignalCallback );
 418
 419   DALI_TEST_CHECK( !callbackTurnStarted.mSignalVerified );
 420   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 421   DALI_TEST_CHECK( !callbackPanStarted.mSignalVerified );
 422   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 423
 424   currentView = portraitView;
 425
 426   //-----Test 1: pan 10 frames from position(size * 0.75f) to position(size * 0.25f), page 0 will be turned forward----
 427   pageIndex = 0;
 428   isTurningForwards = true;
 429   // Do a pan moving up diagonally.
 430   Vector2 start = size * 0.75f;
 431   Vector2 direction = -size*0.05f; //-size*0.5f/10.f;
 432
 433   DALI_TEST_EQUALS( portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION );
 434   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 435   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified );
 436   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 437   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 438   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 439
 440   PerformGestureDiagonalSwipe( application, start+direction*5.f, direction, 5, false, true);
 441   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 442   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 443
 444   Wait(application, 1000);
 445   DALI_TEST_CHECK( callbackTurnFinished.mSignalVerified );
 446   // the page is turn over
 447   DALI_TEST_EQUALS( portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), pageIndex+1, TEST_LOCATION );
 448
 449   //---Test 2: pan from position( size*0.5f ) to position( size.width, size.height*0.5f ) to position( size * 0.75f ), page 1 will bent then slid back---
 450   callbackTurnStarted.Reset();
 451   callbackTurnFinished.Reset();
 452   callbackPanStarted.Reset();
 453   callbackPanFinished.Reset();
 454   portraitView.SetProperty( PageTurnView::Property::CURRENT_PAGE_ID, 5 );
 455   pageIndex = 5;
 456   isTurningForwards = true;
 457
 458   //pan 10 frames from position( size.width, size.height*0.5f ) to position( size * 0.75f )
 459   start = Vector2( size.width, size.height*0.5f );
 460   direction = Vector2(-size.width*0.025f, size.height*0.025f);
 461   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 462   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 463   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified );
 464   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 465   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 466
 467   signalVerified[0] = false;
 468   isTurningForwards = false;
 469   PerformGestureDiagonalSwipe( application, start + direction*2 , direction, 5, false, true);
 470   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 471   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 472   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified ); // start the sliding back
 473
 474   Wait(application, 1000);
 475   DALI_TEST_CHECK( callbackTurnFinished.mSignalVerified );
 476   DALI_TEST_EQUALS( portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), pageIndex, TEST_LOCATION ); // the page is not turned over
 477
 478   // ----Test 3: pan 10 frames from position( size*0.25f ) to position( size.width*0.75f, size.height*0.25f ), the previous page will be turned backwards---
 479   callbackTurnStarted.Reset();
 480   callbackTurnFinished.Reset();
 481   callbackPanStarted.Reset();
 482   callbackPanFinished.Reset();
 483   portraitView.SetProperty( PageTurnView::Property::CURRENT_PAGE_ID, 10);
 484   pageIndex = 9; // will turn the previous page back
 485   isTurningForwards = false;
 486   start = size*0.25f;
 487   direction = Vector2(size.x*0.05f, 0.f);
 488   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 489   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 490   DALI_TEST_CHECK( !callbackTurnStarted.mSignalVerified );
 491   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 492   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 493
 494   PerformGestureDiagonalSwipe( application, start+direction*5.f, direction, 5, false, true);
 495   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified );
 496   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 497   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 498
 499   Wait( application, 1000 );
 500
 501   DALI_TEST_CHECK( callbackTurnFinished.mSignalVerified );
 502   DALI_TEST_EQUALS( portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 9, TEST_LOCATION );
 503   END_TEST;
 504 }