dali-toolkit/internal/controls/page-turn-view/page-turn-view-impl.cpp

   1 /*
   2  * Copyright (c) 2021 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 // CLASS HEADER
  19 #include <dali-toolkit/internal/controls/page-turn-view/page-turn-view-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23 #include <dali/public-api/animation/animation.h>
  24 #include <dali/public-api/animation/constraint.h>
  25 #include <dali/public-api/object/type-registry-helper.h>
  26 #include <dali/public-api/object/type-registry.h>
  27 #include <cstring> // for strcmp
  28
  29 // INTERNAL INCLUDES
  30 #include <dali-toolkit/devel-api/controls/control-devel.h>
  31 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
  32 #include <dali-toolkit/internal/controls/page-turn-view/page-turn-book-spine-effect.h>
  33 #include <dali-toolkit/internal/controls/page-turn-view/page-turn-effect.h>
  34 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  35 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  36 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  37
  38 using namespace Dali;
  39
  40 namespace //Unnamed namespace
  41 {
  42 // properties set on shader, these properties have the constant value in regardless of the page status
  43 const char* const PROPERTY_SPINE_SHADOW("uSpineShadowParameter"); // uniform for both spine and turn effect
  44
  45 // properties set on actor, the value of these properties varies depending on the page status
  46 //    properties used in turn effect
  47 const char* const PROPERTY_TURN_DIRECTION("uIsTurningBack");       // uniform
  48 const char* const PROPERTY_COMMON_PARAMETERS("uCommonParameters"); //uniform
  49
  50 const char* const PROPERTY_PAN_DISPLACEMENT("panDisplacement"); // property used to constrain the uniforms
  51 const char* const PROPERTY_PAN_CENTER("panCenter");             // property used to constrain the uniforms
  52
  53 // default grid density for page turn effect, 20 pixels by 20 pixels
  54 const float DEFAULT_GRID_DENSITY(20.0f);
  55
  56 // to bent the page, the minimal horizontal pan start position is viewPageSize.x * MINIMUM_START_POSITION_RATIO
  57 const float MINIMUM_START_POSITION_RATIO(0.6f);
  58
  59 // the maximum vertical displacement of pan gesture, if exceed, will reduce it: viewPageSize.y * MAXIMUM_VERTICAL_MOVEMENT_RATIO
  60 const float MAXIMUM_VERTICAL_MOVEMENT_RATIO(0.15f);
  61
  62 // when the x component of pan position reaches viewPageSize.x * PAGE_TURN_OVER_THRESHOLD_RATIO, page starts to turn over
  63 const float PAGE_TURN_OVER_THRESHOLD_RATIO(0.5f);
  64
  65 // duration of animation, shorter for faster speed
  66 const float PAGE_SLIDE_BACK_ANIMATION_DURATION(1.0f);
  67 const float PAGE_TURN_OVER_ANIMATION_DURATION(1.2f);
  68
  69 // the major&minor radius (in pixels) to form an ellipse shape
  70 // the top-left quarter of this ellipse is used to calculate spine normal for simulating shadow
  71 const Vector2 DEFAULT_SPINE_SHADOW_PARAMETER(50.0f, 20.0f);
  72
  73 // constants for shadow casting
  74 const float   POINT_LIGHT_HEIGHT_RATIO(2.f);
  75 const Vector4 DEFAULT_SHADOW_COLOR = Vector4(0.2f, 0.2f, 0.2f, 0.5f);
  76
  77 // constraints ////////////////////////////////////////////////////////////////
  78 /**
  79  * Original Center Constraint
  80  *
  81  * This constraint adjusts the original center property of the page turn shader effect
  82  * based on the X-direction displacement of the pan gesture
  83  */
  84 struct OriginalCenterConstraint
  85 {
  86   OriginalCenterConstraint(const Vector2& originalCenter, const Vector2& offset)
  87   : mOldCenter(originalCenter)
  88   {
  89     mNewCenter = originalCenter + offset;
  90     mDistance  = offset.Length() * 0.5f;
  91     mDirection = offset / mDistance;
  92   }
  93
  94   void operator()(Vector2& current, const PropertyInputContainer& inputs)
  95   {
  96     float displacement = inputs[0]->GetFloat();
  97
  98     if(displacement < mDistance)
  99     {
 100       current = mOldCenter + mDirection * displacement;
 101     }
 102     else
 103     {
 104       current = mNewCenter + Vector2(0.25f * (displacement - mDistance), 0.f);
 105     }
 106   }
 107
 108   Vector2 mOldCenter;
 109   Vector2 mNewCenter;
 110   float   mDistance;
 111   Vector2 mDirection;
 112 };
 113
 114 /**
 115  * Rotation Constraint
 116  *
 117  * This constraint adjusts the rotation property of the page actor
 118  * based on the X-direction displacement of the pan gesture
 119  */
 120 struct RotationConstraint
 121 {
 122   RotationConstraint(float distance, float pageWidth, bool isTurnBack)
 123   : mDistance(distance * 0.5f)
 124   {
 125     mStep     = 1.f / pageWidth;
 126     mSign     = isTurnBack ? -1.0f : 1.0f;
 127     mConst    = isTurnBack ? -1.0f : 0.f;
 128     mRotation = isTurnBack ? Quaternion(Radian(-Math::PI), Vector3::YAXIS) : Quaternion(Radian(0.f), Vector3::YAXIS);
 129   }
 130
 131   void operator()(Quaternion& current, const PropertyInputContainer& inputs)
 132   {
 133     float displacement = inputs[0]->GetFloat();
 134     if(displacement < mDistance)
 135     {
 136       current = mRotation;
 137     }
 138     else
 139     {
 140       float coef  = std::max(-1.0f, mStep * (mDistance - displacement));
 141       float angle = Math::PI * (mConst + mSign * coef);
 142       current     = Quaternion(Radian(angle), Vector3::YAXIS);
 143     }
 144   }
 145
 146   float      mDistance;
 147   float      mStep;
 148   float      mConst;
 149   float      mSign;
 150   Quaternion mRotation;
 151 };
 152
 153 /**
 154  * Current Center Constraint
 155  *
 156  * This constraint adjusts the current center property of the page turn shader effect
 157  * based on the pan position and the original center position
 158  */
 159 struct CurrentCenterConstraint
 160 {
 161   CurrentCenterConstraint(float pageWidth)
 162   : mPageWidth(pageWidth)
 163   {
 164     mThres = pageWidth * PAGE_TURN_OVER_THRESHOLD_RATIO * 0.5f;
 165   }
 166
 167   void operator()(Vector2& current, const PropertyInputContainer& inputs)
 168   {
 169     const Vector2& centerPosition = inputs[0]->GetVector2();
 170     if(centerPosition.x > 0.f)
 171     {
 172       current.x = mThres + centerPosition.x * 0.5f;
 173       current.y = centerPosition.y;
 174     }
 175     else
 176     {
 177       const Vector2& centerOrigin = inputs[1]->GetVector2();
 178       Vector2        direction    = centerOrigin - Vector2(mThres, centerPosition.y);
 179       float          coef         = 1.f + (centerPosition.x * 2.f / mPageWidth);
 180       // when coef <= 0, the page is flat, slow down the last moment of the page stretch by 10 times to avoid a small bounce
 181       if(coef < 0.025f)
 182       {
 183         coef = (coef + 0.225f) / 10.0f;
 184       }
 185       current = centerOrigin - direction * coef;
 186     }
 187   }
 188
 189   float mPageWidth;
 190   float mThres;
 191 };
 192
 193 struct ShadowBlurStrengthConstraint
 194 {
 195   ShadowBlurStrengthConstraint(float thres)
 196   : mThres(thres)
 197   {
 198   }
 199
 200   void operator()(float& blurStrength, const PropertyInputContainer& inputs)
 201   {
 202     float displacement = inputs[2]->GetFloat();
 203     if(EqualsZero(displacement))
 204     {
 205       const Vector2& cur = inputs[0]->GetVector2();
 206       const Vector2& ori = inputs[1]->GetVector2();
 207       blurStrength       = 5.f * (ori - cur).Length() / mThres;
 208     }
 209     else
 210     {
 211       blurStrength = 1.f - (displacement - 2.f * mThres) / mThres;
 212     }
 213
 214     blurStrength = blurStrength > 1.f ? 1.f : (blurStrength < 0.f ? 0.f : blurStrength);
 215   }
 216
 217   float mThres;
 218 };
 219
 220 } //unnamed namespace
 221
 222 namespace Dali
 223 {
 224 namespace Toolkit
 225 {
 226 namespace Internal
 227 {
 228 namespace
 229 {
 230 BaseHandle Create()
 231 {
 232   // empty handle as we cannot create PageTurnView(but type registered for page turn signal)
 233   return BaseHandle();
 234 }
 235
 236 // Setup properties, signals and actions using the type-registry.
 237 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::PageTurnView, Toolkit::Control, Create);
 238
 239 DALI_PROPERTY_REGISTRATION(Toolkit, PageTurnView, "viewPageSize", VECTOR2, VIEW_PAGE_SIZE)
 240 DALI_PROPERTY_REGISTRATION(Toolkit, PageTurnView, "currentPageId", INTEGER, CURRENT_PAGE_ID)
 241 DALI_PROPERTY_REGISTRATION(Toolkit, PageTurnView, "spineShadow", VECTOR2, SPINE_SHADOW)
 242
 243 DALI_SIGNAL_REGISTRATION(Toolkit, PageTurnView, "pageTurnStarted", SIGNAL_PAGE_TURN_STARTED)
 244 DALI_SIGNAL_REGISTRATION(Toolkit, PageTurnView, "pageTurnFinished", SIGNAL_PAGE_TURN_FINISHED)
 245 DALI_SIGNAL_REGISTRATION(Toolkit, PageTurnView, "pagePanStarted", SIGNAL_PAGE_PAN_STARTED)
 246 DALI_SIGNAL_REGISTRATION(Toolkit, PageTurnView, "pagePanFinished", SIGNAL_PAGE_PAN_FINISHED)
 247
 248 DALI_TYPE_REGISTRATION_END()
 249
 250 } // namespace
 251
 252 // these several constants are also used in the derived classes
 253 const char* const PageTurnView::PROPERTY_TEXTURE_WIDTH("uTextureWidth");    // uniform name
 254 const char* const PageTurnView::PROPERTY_ORIGINAL_CENTER("originalCenter"); // property used to constrain the uniform
 255 const char* const PageTurnView::PROPERTY_CURRENT_CENTER("currentCenter");   // property used to constrain the uniform
 256 const int         PageTurnView::MAXIMUM_TURNING_NUM              = 4;
 257 const int         PageTurnView::NUMBER_OF_CACHED_PAGES_EACH_SIDE = MAXIMUM_TURNING_NUM + 1;
 258 const int         PageTurnView::NUMBER_OF_CACHED_PAGES           = NUMBER_OF_CACHED_PAGES_EACH_SIDE * 2;
 259 const float       PageTurnView::STATIC_PAGE_INTERVAL_DISTANCE    = 1.0f;
 260
 261 PageTurnView::Page::Page()
 262 : isTurnBack(false)
 263 {
 264   actor = Actor::New();
 265   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
 266   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
 267   actor.SetProperty(Actor::Property::VISIBLE, false);
 268
 269   propertyPanDisplacement = actor.RegisterProperty(PROPERTY_PAN_DISPLACEMENT, 0.f);
 270   propertyPanCenter       = actor.RegisterProperty(PROPERTY_PAN_CENTER, Vector2::ZERO);
 271
 272   propertyOriginalCenter = actor.RegisterProperty(PROPERTY_ORIGINAL_CENTER, Vector2::ZERO);
 273   propertyCurrentCenter  = actor.RegisterProperty(PROPERTY_CURRENT_CENTER, Vector2::ZERO);
 274   Matrix zeroMatrix(true);
 275   actor.RegisterProperty(PROPERTY_COMMON_PARAMETERS, zeroMatrix);
 276   propertyTurnDirection = actor.RegisterProperty(PROPERTY_TURN_DIRECTION, -1.f);
 277 }
 278
 279 void PageTurnView::Page::SetTexture(Texture texture)
 280 {
 281   if(!textureSet)
 282   {
 283     textureSet = TextureSet::New();
 284   }
 285   textureSet.SetTexture(0u, texture);
 286 }
 287
 288 void PageTurnView::Page::UseEffect(Shader newShader)
 289 {
 290   shader = newShader;
 291   if(renderer)
 292   {
 293     renderer.SetShader(shader);
 294   }
 295 }
 296
 297 void PageTurnView::Page::UseEffect(Shader newShader, Geometry geometry)
 298 {
 299   UseEffect(newShader);
 300
 301   if(!renderer)
 302   {
 303     renderer = Renderer::New(geometry, shader);
 304
 305     if(!textureSet)
 306     {
 307       textureSet = TextureSet::New();
 308     }
 309
 310     renderer.SetTextures(textureSet);
 311     renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::ON);
 312     actor.AddRenderer(renderer);
 313   }
 314 }
 315
 316 void PageTurnView::Page::ChangeTurnDirection()
 317 {
 318   isTurnBack = !isTurnBack;
 319   actor.SetProperty(propertyTurnDirection, isTurnBack ? 1.f : -1.f);
 320 }
 321
 322 void PageTurnView::Page::SetPanDisplacement(float value)
 323 {
 324   actor.SetProperty(propertyPanDisplacement, value);
 325 }
 326
 327 void PageTurnView::Page::SetPanCenter(const Vector2& value)
 328 {
 329   actor.SetProperty(propertyPanCenter, value);
 330 }
 331
 332 void PageTurnView::Page::SetOriginalCenter(const Vector2& value)
 333 {
 334   actor.SetProperty(propertyOriginalCenter, value);
 335 }
 336
 337 void PageTurnView::Page::SetCurrentCenter(const Vector2& value)
 338 {
 339   actor.SetProperty(propertyCurrentCenter, value);
 340 }
 341
 342 PageTurnView::PageTurnView(PageFactory& pageFactory, const Vector2& viewPageSize)
 343 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
 344   mPageFactory(&pageFactory),
 345   mPageSize(viewPageSize),
 346   mSpineShadowParameter(DEFAULT_SPINE_SHADOW_PARAMETER),
 347   mDistanceUpCorner(0.f),
 348   mDistanceBottomCorner(0.f),
 349   mPanDisplacement(0.f),
 350   mTotalPageCount(0),
 351   mCurrentPageIndex(0),
 352   mTurningPageIndex(0),
 353   mIndex(0),
 354   mSlidingCount(0),
 355   mAnimatingCount(0),
 356   mConstraints(false),
 357   mPress(false),
 358   mPageUpdated(true),
 359   mPageTurnStartedSignal(),
 360   mPageTurnFinishedSignal(),
 361   mPagePanStartedSignal(),
 362   mPagePanFinishedSignal()
 363 {
 364 }
 365
 366 PageTurnView::~PageTurnView()
 367 {
 368 }
 369
 370 void PageTurnView::OnInitialize()
 371 {
 372   // create the book spine effect for static pages
 373   Property::Map spineEffectMap = CreatePageTurnBookSpineEffect();
 374   mSpineEffectShader           = CreateShader(spineEffectMap);
 375   mSpineEffectShader.RegisterProperty(PROPERTY_SPINE_SHADOW, mSpineShadowParameter);
 376   // create the turn effect for turning pages
 377   Property::Map turnEffectMap = CreatePageTurnEffect();
 378   mTurnEffectShader           = CreateShader(turnEffectMap);
 379   mTurnEffectShader.RegisterProperty(PROPERTY_SPINE_SHADOW, mSpineShadowParameter);
 380
 381   // create the grid geometry for pages
 382   uint16_t width  = static_cast<uint16_t>(mPageSize.width / DEFAULT_GRID_DENSITY + 0.5f);
 383   uint16_t height = static_cast<uint16_t>(mPageSize.height / DEFAULT_GRID_DENSITY + 0.5f);
 384   mGeometry       = VisualFactoryCache::CreateGridGeometry(Uint16Pair(width, height));
 385
 386   mPages.reserve(NUMBER_OF_CACHED_PAGES);
 387   for(int i = 0; i < NUMBER_OF_CACHED_PAGES; i++)
 388   {
 389     mPages.push_back(Page());
 390     mPages[i].actor.SetProperty(Actor::Property::SIZE, mPageSize);
 391     Self().Add(mPages[i].actor);
 392   }
 393
 394   // create the layer for turning pages
 395   mTurningPageLayer = Layer::New();
 396   mTurningPageLayer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
 397   mTurningPageLayer.SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_3D);
 398   mTurningPageLayer.Raise();
 399
 400   // Set control size and the parent origin of page layers
 401   OnPageTurnViewInitialize();
 402
 403   Self().Add(mTurningPageLayer);
 404
 405   mTotalPageCount = static_cast<int>(mPageFactory->GetNumberOfPages());
 406   // add pages to the scene, and set depth for the stacked pages
 407   for(int i = 0; i < NUMBER_OF_CACHED_PAGES_EACH_SIDE; i++)
 408   {
 409     AddPage(i);
 410     mPages[i].actor.SetProperty(Actor::Property::POSITION_Z, -static_cast<float>(i) * STATIC_PAGE_INTERVAL_DISTANCE);
 411   }
 412   mPages[0].actor.SetProperty(Actor::Property::VISIBLE, true);
 413
 414   // enable the pan gesture which is attached to the control
 415   EnableGestureDetection(GestureType::Value(GestureType::PAN));
 416
 417   DevelControl::SetAccessibilityConstructor(Self(), [](Dali::Actor actor) {
 418     return std::unique_ptr<Dali::Accessibility::Accessible>(
 419       new DevelControl::AccessibleImpl(actor, Dali::Accessibility::Role::PAGE_TAB_LIST));
 420   });
 421 }
 422
 423 Shader PageTurnView::CreateShader(const Property::Map& shaderMap)
 424 {
 425   Shader           shader;
 426   Property::Value* shaderValue = shaderMap.Find(Toolkit::Visual::Property::SHADER, CUSTOM_SHADER);
 427   Property::Map    shaderSource;
 428   if(shaderValue && shaderValue->Get(shaderSource))
 429   {
 430     std::string      vertexShader;
 431     Property::Value* vertexShaderValue = shaderSource.Find(Toolkit::Visual::Shader::Property::VERTEX_SHADER, CUSTOM_VERTEX_SHADER);
 432     if(!vertexShaderValue || !vertexShaderValue->Get(vertexShader))
 433     {
 434       DALI_LOG_ERROR("PageTurnView::CreateShader failed: vertex shader source is not available.\n");
 435     }
 436     std::string      fragmentShader;
 437     Property::Value* fragmentShaderValue = shaderSource.Find(Toolkit::Visual::Shader::Property::FRAGMENT_SHADER, CUSTOM_FRAGMENT_SHADER);
 438     if(!fragmentShaderValue || !fragmentShaderValue->Get(fragmentShader))
 439     {
 440       DALI_LOG_ERROR("PageTurnView::CreateShader failed: fragment shader source is not available.\n");
 441     }
 442     shader = Shader::New(vertexShader, fragmentShader);
 443   }
 444   else
 445   {
 446     DALI_LOG_ERROR("PageTurnView::CreateShader failed: shader source is not available.\n");
 447   }
 448
 449   return shader;
 450 }
 451
 452 void PageTurnView::SetupShadowView()
 453 {
 454   mShadowView    = Toolkit::ShadowView::New(0.25f, 0.25f);
 455   Vector3 origin = mTurningPageLayer.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN);
 456   mShadowView.SetProperty(Actor::Property::PARENT_ORIGIN, origin);
 457   mShadowView.SetProperty(Actor::Property::ANCHOR_POINT, origin);
 458   mShadowView.SetPointLightFieldOfView(Math::PI / 2.0f);
 459   mShadowView.SetShadowColor(DEFAULT_SHADOW_COLOR);
 460
 461   mShadowPlaneBackground = Actor::New();
 462   mShadowPlaneBackground.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 463   mShadowPlaneBackground.SetProperty(Actor::Property::SIZE, mControlSize);
 464   Self().Add(mShadowPlaneBackground);
 465   mShadowView.SetShadowPlaneBackground(mShadowPlaneBackground);
 466
 467   mPointLight = Actor::New();
 468   mPointLight.SetProperty(Actor::Property::ANCHOR_POINT, origin);
 469   mPointLight.SetProperty(Actor::Property::PARENT_ORIGIN, origin);
 470   mPointLight.SetProperty(Actor::Property::POSITION, Vector3(0.f, 0.f, mPageSize.width * POINT_LIGHT_HEIGHT_RATIO));
 471   Self().Add(mPointLight);
 472   mShadowView.SetPointLight(mPointLight);
 473
 474   mTurningPageLayer.Add(mShadowView);
 475   mShadowView.Activate();
 476 }
 477
 478 void PageTurnView::OnSceneConnection(int depth)
 479 {
 480   SetupShadowView();
 481
 482   Control::OnSceneConnection(depth);
 483 }
 484
 485 void PageTurnView::OnSceneDisconnection()
 486 {
 487   if(mShadowView)
 488   {
 489     mShadowView.RemoveConstraints();
 490     mPointLight.Unparent();
 491     mShadowPlaneBackground.Unparent();
 492     mShadowView.Unparent();
 493   }
 494
 495   // make sure the status of the control is updated correctly when the pan gesture is interrupted
 496   StopTurning();
 497
 498   Control::OnSceneDisconnection();
 499 }
 500
 501 void PageTurnView::SetPageSize(const Vector2& viewPageSize)
 502 {
 503   mPageSize = viewPageSize;
 504
 505   if(mPointLight)
 506   {
 507     mPointLight.SetProperty(Actor::Property::POSITION, Vector3(0.f, 0.f, mPageSize.width * POINT_LIGHT_HEIGHT_RATIO));
 508   }
 509
 510   for(size_t i = 0; i < mPages.size(); i++)
 511   {
 512     mPages[i].actor.SetProperty(Actor::Property::SIZE, mPageSize);
 513   }
 514
 515   OnPageTurnViewInitialize();
 516
 517   if(mShadowPlaneBackground)
 518   {
 519     mShadowPlaneBackground.SetProperty(Actor::Property::SIZE, mControlSize);
 520   }
 521 }
 522
 523 Vector2 PageTurnView::GetPageSize()
 524 {
 525   return mPageSize;
 526 }
 527
 528 void PageTurnView::SetSpineShadowParameter(const Vector2& spineShadowParameter)
 529 {
 530   mSpineShadowParameter = spineShadowParameter;
 531
 532   // set spine shadow parameter to all the shader effects
 533   mSpineEffectShader.RegisterProperty(PROPERTY_SPINE_SHADOW, mSpineShadowParameter);
 534   mTurnEffectShader.RegisterProperty(PROPERTY_SPINE_SHADOW, mSpineShadowParameter);
 535 }
 536
 537 Vector2 PageTurnView::GetSpineShadowParameter()
 538 {
 539   return mSpineShadowParameter;
 540 }
 541
 542 void PageTurnView::GoToPage(unsigned int pageId)
 543 {
 544   int pageIdx = Clamp(static_cast<int>(pageId), 0, mTotalPageCount - 1);
 545
 546   if(mCurrentPageIndex == pageIdx)
 547   {
 548     return;
 549   }
 550
 551   // if any animation ongoing, stop it.
 552   StopTurning();
 553
 554   // record the new current page index
 555   mCurrentPageIndex = pageIdx;
 556
 557   // add the current page and the pages right before and after it
 558   for(int i = pageIdx - NUMBER_OF_CACHED_PAGES_EACH_SIDE; i < pageIdx + NUMBER_OF_CACHED_PAGES_EACH_SIDE; i++)
 559   {
 560     AddPage(i);
 561   }
 562
 563   mPages[pageId % NUMBER_OF_CACHED_PAGES].actor.SetProperty(Actor::Property::VISIBLE, true);
 564   if(pageId > 0)
 565   {
 566     mPages[(pageId - 1) % NUMBER_OF_CACHED_PAGES].actor.SetProperty(Actor::Property::VISIBLE, true);
 567   }
 568   // set ordered depth to the stacked pages
 569   OrganizePageDepth();
 570 }
 571
 572 unsigned int PageTurnView::GetCurrentPage()
 573 {
 574   DALI_ASSERT_ALWAYS(mCurrentPageIndex >= 0);
 575   return static_cast<unsigned int>(mCurrentPageIndex);
 576 }
 577
 578 void PageTurnView::AddPage(int pageIndex)
 579 {
 580   if(pageIndex > -1 && pageIndex < mTotalPageCount) // whether the page is available from the page factory
 581   {
 582     int index = pageIndex % NUMBER_OF_CACHED_PAGES;
 583
 584     Texture newPage;
 585     newPage = mPageFactory->NewPage(pageIndex);
 586     DALI_ASSERT_ALWAYS(newPage && "must pass in valid texture");
 587
 588     bool isLeftSide = (pageIndex < mCurrentPageIndex);
 589     if(mPages[index].isTurnBack != isLeftSide)
 590     {
 591       mPages[index].ChangeTurnDirection();
 592     }
 593
 594     float degree = isLeftSide ? 180.f : 0.f;
 595     mPages[index].actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(degree), Vector3::YAXIS));
 596     mPages[index].actor.SetProperty(Actor::Property::VISIBLE, false);
 597     mPages[index].UseEffect(mSpineEffectShader, mGeometry);
 598     mPages[index].SetTexture(newPage);
 599
 600     // For Portrait, nothing to do
 601     // For Landscape, set the parent origin to CENTER
 602     OnAddPage(mPages[index].actor, isLeftSide);
 603   }
 604 }
 605
 606 void PageTurnView::RemovePage(int pageIndex)
 607 {
 608   if(pageIndex > -1 && pageIndex < mTotalPageCount)
 609   {
 610     int index = pageIndex % NUMBER_OF_CACHED_PAGES;
 611     mPages[index].actor.SetProperty(Actor::Property::VISIBLE, false);
 612   }
 613 }
 614
 615 void PageTurnView::OnPan(const PanGesture& gesture)
 616 {
 617   // the pan gesture is attached to control itself instead of each page
 618   switch(gesture.GetState())
 619   {
 620     case GestureState::STARTED:
 621     {
 622       // check whether the undergoing turning page number already reaches the maximum allowed
 623       if(mPageUpdated && mAnimatingCount < MAXIMUM_TURNING_NUM && mSlidingCount < 1)
 624       {
 625         const Vector2& position = gesture.GetPosition();
 626         SetPanActor(position);                                                                                        // determine which page actor is panned
 627         if(mTurningPageIndex != -1 && mPages[mTurningPageIndex % NUMBER_OF_CACHED_PAGES].actor.GetParent() != Self()) // if the page is added to turning layer,it is undergoing an animation currently
 628         {
 629           mTurningPageIndex = -1;
 630         }
 631         PanStarted(SetPanPosition(position)); // pass in the pan position in the local page coordinate
 632       }
 633       else
 634       {
 635         mTurningPageIndex = -1;
 636       }
 637       break;
 638     }
 639     case GestureState::CONTINUING:
 640     {
 641       PanContinuing(SetPanPosition(gesture.GetPosition())); // pass in the pan position in the local page coordinate
 642       break;
 643     }
 644     case GestureState::FINISHED:
 645     case GestureState::CANCELLED:
 646     {
 647       PanFinished(SetPanPosition(gesture.GetPosition()), gesture.GetSpeed());
 648       break;
 649     }
 650     case GestureState::CLEAR:
 651     case GestureState::POSSIBLE:
 652     default:
 653     {
 654       break;
 655     }
 656   }
 657 }
 658
 659 void PageTurnView::PanStarted(const Vector2& gesturePosition)
 660 {
 661   mPressDownPosition = gesturePosition;
 662
 663   if(mTurningPageIndex == -1)
 664   {
 665     return;
 666   }
 667
 668   mIndex = mTurningPageIndex % NUMBER_OF_CACHED_PAGES;
 669
 670   mOriginalCenter = gesturePosition;
 671   mPress          = false;
 672   mPageUpdated    = false;
 673
 674   // Guard against destruction during signal emission
 675   Toolkit::PageTurnView handle(GetOwner());
 676   mPagePanStartedSignal.Emit(handle);
 677 }
 678
 679 void PageTurnView::PanContinuing(const Vector2& gesturePosition)
 680 {
 681   if(mTurningPageIndex == -1)
 682   {
 683     return;
 684   }
 685
 686   // Guard against destruction during signal emission
 687   Toolkit::PageTurnView handle(GetOwner());
 688
 689   if(!mPress)
 690   {
 691     // when the touch down position is near the spine
 692     // or when the panning goes outwards or some other position which would tear the paper in real situation
 693     // we change the start position into the current panning position and update the shader parameters
 694     if(mOriginalCenter.x < mPageSize.width * MINIMUM_START_POSITION_RATIO || gesturePosition.x > mOriginalCenter.x - 1.0f || ((gesturePosition.x / mOriginalCenter.x > gesturePosition.y / mOriginalCenter.y) && (gesturePosition.x / mOriginalCenter.x > (gesturePosition.y - mPageSize.height) / (mOriginalCenter.y - mPageSize.height))))
 695     {
 696       mOriginalCenter = gesturePosition;
 697     }
 698     else
 699     {
 700       mDistanceUpCorner     = mOriginalCenter.Length();
 701       mDistanceBottomCorner = (mOriginalCenter - Vector2(0.0f, mPageSize.height)).Length();
 702       mShadowView.Add(mPages[mIndex].actor);
 703       mPages[mIndex].UseEffect(mTurnEffectShader);
 704       mPages[mIndex].SetOriginalCenter(mOriginalCenter);
 705       mCurrentCenter = mOriginalCenter;
 706       mPages[mIndex].SetCurrentCenter(mCurrentCenter);
 707       mPanDisplacement = 0.f;
 708       mConstraints     = false;
 709       mPress           = true;
 710       mAnimatingCount++;
 711
 712       mPageTurnStartedSignal.Emit(handle, static_cast<unsigned int>(mTurningPageIndex), !mPages[mIndex].isTurnBack);
 713       int id = mTurningPageIndex + (mPages[mIndex].isTurnBack ? -1 : 1);
 714       if(id >= 0 && id < mTotalPageCount)
 715       {
 716         mPages[id % NUMBER_OF_CACHED_PAGES].actor.SetProperty(Actor::Property::VISIBLE, true);
 717       }
 718
 719       mShadowView.RemoveConstraints();
 720       Actor self = Self();
 721       mPages[mIndex].SetPanDisplacement(0.f);
 722
 723       Constraint shadowBlurStrengthConstraint = Constraint::New<float>(mShadowView, mShadowView.GetBlurStrengthPropertyIndex(), ShadowBlurStrengthConstraint(mPageSize.width * PAGE_TURN_OVER_THRESHOLD_RATIO));
 724       shadowBlurStrengthConstraint.AddSource(Source(mPages[mIndex].actor, mPages[mIndex].propertyCurrentCenter));
 725       shadowBlurStrengthConstraint.AddSource(Source(mPages[mIndex].actor, mPages[mIndex].propertyOriginalCenter));
 726       shadowBlurStrengthConstraint.AddSource(Source(mPages[mIndex].actor, mPages[mIndex].propertyPanDisplacement));
 727       shadowBlurStrengthConstraint.Apply();
 728     }
 729   }
 730   else
 731   {
 732     Vector2 currentCenter = gesturePosition;
 733
 734     // Test whether the new current center would tear the paper from the top pine in real situation
 735     // we do not forbid this totally, which would restrict the panning gesture too much
 736     // instead, set it to the nearest allowable position
 737     float distanceUpCorner     = currentCenter.Length();
 738     float distanceBottomCorner = (currentCenter - Vector2(0.0f, mPageSize.height)).Length();
 739     if(distanceUpCorner > mDistanceUpCorner)
 740     {
 741       currentCenter = currentCenter * mDistanceUpCorner / distanceUpCorner;
 742     }
 743     // would tear the paper from the bottom spine in real situation
 744     if(distanceBottomCorner > mDistanceBottomCorner)
 745     {
 746       currentCenter = ((currentCenter - Vector2(0.0f, mPageSize.height)) * mDistanceBottomCorner / distanceBottomCorner + Vector2(0.0f, mPageSize.height));
 747     }
 748     // If direction has a very high y component, reduce it.
 749     Vector2 curveDirection = currentCenter - mOriginalCenter;
 750     if(fabs(curveDirection.y) > fabs(curveDirection.x))
 751     {
 752       currentCenter.y = mOriginalCenter.y + (currentCenter.y - mOriginalCenter.y) * fabs(curveDirection.x / curveDirection.y);
 753     }
 754     // If the vertical distance is high, reduce it
 755     float yShift = currentCenter.y - mOriginalCenter.y;
 756     if(fabs(yShift) > mPageSize.height * MAXIMUM_VERTICAL_MOVEMENT_RATIO)
 757     {
 758       currentCenter.y = mOriginalCenter.y + yShift * mPageSize.height * MAXIMUM_VERTICAL_MOVEMENT_RATIO / fabs(yShift);
 759     }
 760
 761     // use contraints to control the page shape and rotation when the pan position is near the spine
 762     if(currentCenter.x <= mPageSize.width * PAGE_TURN_OVER_THRESHOLD_RATIO && mOriginalCenter.x > mPageSize.width * PAGE_TURN_OVER_THRESHOLD_RATIO)
 763     {
 764       // set the property values used by the constraints
 765       mPanDisplacement = mPageSize.width * PAGE_TURN_OVER_THRESHOLD_RATIO - currentCenter.x;
 766       mPages[mIndex].SetPanDisplacement(mPanDisplacement);
 767       mPages[mIndex].SetPanCenter(currentCenter);
 768
 769       // set up the OriginalCenterConstraint and CurrentCebterConstraint to the PageTurnEdffect
 770       // also set up the RotationConstraint to the page actor
 771       if(!mConstraints)
 772       {
 773         Vector2 corner;
 774         // the corner position need to be a little far away from the page edge to ensure the whole page is lift up
 775         if(currentCenter.y >= mOriginalCenter.y)
 776         {
 777           corner = Vector2(1.1f * mPageSize.width, 0.f);
 778         }
 779         else
 780         {
 781           corner = mPageSize * 1.1f;
 782         }
 783
 784         Vector2 offset(currentCenter - mOriginalCenter);
 785         float   k = -((mOriginalCenter.x - corner.x) * offset.x + (mOriginalCenter.y - corner.y) * offset.y) / (offset.x * offset.x + offset.y * offset.y);
 786         offset *= k;
 787         Actor self = Self();
 788
 789         Constraint originalCenterConstraint = Constraint::New<Vector2>(mPages[mIndex].actor, mPages[mIndex].propertyOriginalCenter, OriginalCenterConstraint(mOriginalCenter, offset));
 790         originalCenterConstraint.AddSource(Source(mPages[mIndex].actor, mPages[mIndex].propertyPanDisplacement));
 791         originalCenterConstraint.Apply();
 792
 793         Constraint currentCenterConstraint = Constraint::New<Vector2>(mPages[mIndex].actor, mPages[mIndex].propertyCurrentCenter, CurrentCenterConstraint(mPageSize.width));
 794         currentCenterConstraint.AddSource(Source(mPages[mIndex].actor, mPages[mIndex].propertyPanCenter));
 795         currentCenterConstraint.AddSource(Source(mPages[mIndex].actor, mPages[mIndex].propertyOriginalCenter));
 796         currentCenterConstraint.Apply();
 797
 798         PageTurnApplyInternalConstraint(mPages[mIndex].actor, mPageSize.height);
 799
 800         float      distance           = offset.Length();
 801         Constraint rotationConstraint = Constraint::New<Quaternion>(mPages[mIndex].actor, Actor::Property::ORIENTATION, RotationConstraint(distance, mPageSize.width, mPages[mIndex].isTurnBack));
 802         rotationConstraint.AddSource(Source(mPages[mIndex].actor, mPages[mIndex].propertyPanDisplacement));
 803         rotationConstraint.Apply();
 804
 805         mConstraints = true;
 806       }
 807     }
 808     else
 809     {
 810       if(mConstraints) // remove the constraint is the pan position move back to far away from the spine
 811       {
 812         mPages[mIndex].actor.RemoveConstraints();
 813         mPages[mIndex].SetOriginalCenter(mOriginalCenter);
 814         mConstraints     = false;
 815         mPanDisplacement = 0.f;
 816       }
 817
 818       mPages[mIndex].SetCurrentCenter(currentCenter);
 819       mCurrentCenter = currentCenter;
 820       PageTurnApplyInternalConstraint(mPages[mIndex].actor, mPageSize.height);
 821     }
 822   }
 823 }
 824
 825 void PageTurnView::PanFinished(const Vector2& gesturePosition, float gestureSpeed)
 826 {
 827   // Guard against destruction during signal emission
 828   Toolkit::PageTurnView handle(GetOwner());
 829
 830   if(mTurningPageIndex == -1)
 831   {
 832     if(mAnimatingCount < MAXIMUM_TURNING_NUM && mSlidingCount < 1)
 833     {
 834       OnPossibleOutwardsFlick(gesturePosition, gestureSpeed);
 835     }
 836
 837     return;
 838   }
 839
 840   mPagePanFinishedSignal.Emit(handle);
 841
 842   if(mPress)
 843   {
 844     if(mConstraints) // if with constraints, the pan finished position is near spine, set up an animation to turn the page over
 845     {
 846       // update the pages here instead of in the TurnedOver callback function
 847       // as new page is allowed to respond to the pan gesture before other pages finishing animation
 848       if(mPages[mIndex].isTurnBack)
 849       {
 850         mCurrentPageIndex--;
 851         RemovePage(mCurrentPageIndex + NUMBER_OF_CACHED_PAGES_EACH_SIDE);
 852         AddPage(mCurrentPageIndex - NUMBER_OF_CACHED_PAGES_EACH_SIDE);
 853       }
 854       else
 855       {
 856         mCurrentPageIndex++;
 857         RemovePage(mCurrentPageIndex - NUMBER_OF_CACHED_PAGES_EACH_SIDE - 1);
 858         AddPage(mCurrentPageIndex + NUMBER_OF_CACHED_PAGES_EACH_SIDE - 1);
 859       }
 860       OrganizePageDepth();
 861
 862       // set up an animation to turn the page over
 863       float     width     = mPageSize.width * (1.f + PAGE_TURN_OVER_THRESHOLD_RATIO);
 864       Animation animation = Animation::New(std::max(0.1f, PAGE_TURN_OVER_ANIMATION_DURATION * (1.0f - mPanDisplacement / width)));
 865       animation.AnimateTo(Property(mPages[mIndex].actor, mPages[mIndex].propertyPanDisplacement),
 866                           width,
 867                           AlphaFunction::EASE_OUT_SINE);
 868       animation.AnimateTo(Property(mPages[mIndex].actor, mPages[mIndex].propertyPanCenter),
 869                           Vector2(-mPageSize.width * 1.1f, 0.5f * mPageSize.height),
 870                           AlphaFunction::EASE_OUT_SINE);
 871       mAnimationPageIdPair[animation] = mTurningPageIndex;
 872       animation.Play();
 873       animation.FinishedSignal().Connect(this, &PageTurnView::TurnedOver);
 874     }
 875     else // the pan finished position is far away from the spine, set up an animation to slide the page back instead of turning over
 876     {
 877       Animation animation = Animation::New(PAGE_SLIDE_BACK_ANIMATION_DURATION * (mOriginalCenter.x - mCurrentCenter.x) / mPageSize.width / PAGE_TURN_OVER_THRESHOLD_RATIO);
 878       animation.AnimateTo(Property(mPages[mIndex].actor, mPages[mIndex].propertyCurrentCenter),
 879                           mOriginalCenter,
 880                           AlphaFunction::LINEAR);
 881       mAnimationPageIdPair[animation] = mTurningPageIndex;
 882       animation.Play();
 883       mSlidingCount++;
 884       animation.FinishedSignal().Connect(this, &PageTurnView::SliddenBack);
 885
 886       mPageTurnStartedSignal.Emit(handle, static_cast<unsigned int>(mTurningPageIndex), mPages[mIndex].isTurnBack);
 887     }
 888   }
 889   else
 890   {
 891     // In portrait view, an outwards flick should turn the previous page back
 892     // In landscape view, nothing to do
 893     OnPossibleOutwardsFlick(gesturePosition, gestureSpeed);
 894   }
 895   mPageUpdated = true;
 896 }
 897
 898 void PageTurnView::TurnedOver(Animation& animation)
 899 {
 900   int pageId = mAnimationPageIdPair[animation];
 901   int index  = pageId % NUMBER_OF_CACHED_PAGES;
 902
 903   mPages[index].ChangeTurnDirection();
 904   mPages[index].actor.RemoveConstraints();
 905   Self().Add(mPages[index].actor);
 906   mAnimatingCount--;
 907   mAnimationPageIdPair.erase(animation);
 908
 909   float degree = mPages[index].isTurnBack ? 180.f : 0.f;
 910   mPages[index].actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(degree), Vector3::YAXIS));
 911   mPages[index].UseEffect(mSpineEffectShader);
 912
 913   int id = pageId + (mPages[index].isTurnBack ? -1 : 1);
 914   if(id >= 0 && id < mTotalPageCount)
 915   {
 916     mPages[id % NUMBER_OF_CACHED_PAGES].actor.SetProperty(Actor::Property::VISIBLE, false);
 917   }
 918
 919   OnTurnedOver(mPages[index].actor, mPages[index].isTurnBack);
 920
 921   // Guard against destruction during signal emission
 922   Toolkit::PageTurnView handle(GetOwner());
 923   mPageTurnFinishedSignal.Emit(handle, static_cast<unsigned int>(pageId), mPages[index].isTurnBack);
 924 }
 925
 926 void PageTurnView::SliddenBack(Animation& animation)
 927 {
 928   int pageId = mAnimationPageIdPair[animation];
 929   int index  = pageId % NUMBER_OF_CACHED_PAGES;
 930   Self().Add(mPages[index].actor);
 931   mSlidingCount--;
 932   mAnimatingCount--;
 933   mAnimationPageIdPair.erase(animation);
 934
 935   mPages[index].UseEffect(mSpineEffectShader);
 936
 937   int id = pageId + (mPages[index].isTurnBack ? -1 : 1);
 938   if(id >= 0 && id < mTotalPageCount)
 939   {
 940     mPages[id % NUMBER_OF_CACHED_PAGES].actor.SetProperty(Actor::Property::VISIBLE, false);
 941   }
 942
 943   // Guard against destruction during signal emission
 944   Toolkit::PageTurnView handle(GetOwner());
 945   mPageTurnFinishedSignal.Emit(handle, static_cast<unsigned int>(pageId), mPages[index].isTurnBack);
 946 }
 947
 948 void PageTurnView::OrganizePageDepth()
 949 {
 950   for(int i = 0; i < NUMBER_OF_CACHED_PAGES_EACH_SIDE; i++)
 951   {
 952     if(mCurrentPageIndex + i < mTotalPageCount)
 953     {
 954       mPages[(mCurrentPageIndex + i) % NUMBER_OF_CACHED_PAGES].actor.SetProperty(Actor::Property::POSITION_Z, -static_cast<float>(i) * STATIC_PAGE_INTERVAL_DISTANCE);
 955     }
 956     if(mCurrentPageIndex >= i + 1)
 957     {
 958       mPages[(mCurrentPageIndex - i - 1) % NUMBER_OF_CACHED_PAGES].actor.SetProperty(Actor::Property::POSITION_Z, -static_cast<float>(i) * STATIC_PAGE_INTERVAL_DISTANCE);
 959     }
 960   }
 961 }
 962
 963 void PageTurnView::StopTurning()
 964 {
 965   mAnimatingCount = 0;
 966   mSlidingCount   = 0;
 967
 968   if(!mPageUpdated)
 969   {
 970     int index = mTurningPageIndex % NUMBER_OF_CACHED_PAGES;
 971     Self().Add(mPages[index].actor);
 972     mPages[index].actor.RemoveConstraints();
 973     mPages[index].UseEffect(mSpineEffectShader);
 974     float degree = mTurningPageIndex == mCurrentPageIndex ? 0.f : 180.f;
 975     mPages[index].actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(degree), Vector3::YAXIS));
 976     mPageUpdated = true;
 977   }
 978
 979   if(!mAnimationPageIdPair.empty())
 980   {
 981     for(std::map<Animation, int>::iterator it = mAnimationPageIdPair.begin(); it != mAnimationPageIdPair.end(); ++it)
 982     {
 983       static_cast<Animation>(it->first).SetCurrentProgress(1.f);
 984     }
 985   }
 986 }
 987
 988 Toolkit::PageTurnView::PageTurnSignal& PageTurnView::PageTurnStartedSignal()
 989 {
 990   return mPageTurnStartedSignal;
 991 }
 992
 993 Toolkit::PageTurnView::PageTurnSignal& PageTurnView::PageTurnFinishedSignal()
 994 {
 995   return mPageTurnFinishedSignal;
 996 }
 997
 998 Toolkit::PageTurnView::PagePanSignal& PageTurnView::PagePanStartedSignal()
 999 {
1000   return mPagePanStartedSignal;
1001 }
1002
1003 Toolkit::PageTurnView::PagePanSignal& PageTurnView::PagePanFinishedSignal()
1004 {
1005   return mPagePanFinishedSignal;
1006 }
1007
1008 bool PageTurnView::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor)
1009 {
1010   Dali::BaseHandle handle(object);
1011
1012   bool                  connected(true);
1013   Toolkit::PageTurnView pageTurnView = Toolkit::PageTurnView::DownCast(handle);
1014
1015   if(0 == strcmp(signalName.c_str(), SIGNAL_PAGE_TURN_STARTED))
1016   {
1017     pageTurnView.PageTurnStartedSignal().Connect(tracker, functor);
1018   }
1019   else if(0 == strcmp(signalName.c_str(), SIGNAL_PAGE_TURN_FINISHED))
1020   {
1021     pageTurnView.PageTurnFinishedSignal().Connect(tracker, functor);
1022   }
1023   else if(0 == strcmp(signalName.c_str(), SIGNAL_PAGE_PAN_STARTED))
1024   {
1025     pageTurnView.PagePanStartedSignal().Connect(tracker, functor);
1026   }
1027   else if(0 == strcmp(signalName.c_str(), SIGNAL_PAGE_PAN_FINISHED))
1028   {
1029     pageTurnView.PagePanFinishedSignal().Connect(tracker, functor);
1030   }
1031   else
1032   {
1033     // signalName does not match any signal
1034     connected = false;
1035   }
1036
1037   return connected;
1038 }
1039
1040 void PageTurnView::SetProperty(BaseObject* object, Property::Index index, const Property::Value& value)
1041 {
1042   Toolkit::PageTurnView pageTurnView = Toolkit::PageTurnView::DownCast(Dali::BaseHandle(object));
1043
1044   if(pageTurnView)
1045   {
1046     PageTurnView& pageTurnViewImpl(GetImplementation(pageTurnView));
1047
1048     switch(index)
1049     {
1050       case Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE:
1051       {
1052         pageTurnViewImpl.SetPageSize(value.Get<Vector2>());
1053         break;
1054       }
1055       case Toolkit::PageTurnView::Property::CURRENT_PAGE_ID:
1056       {
1057         pageTurnViewImpl.GoToPage(value.Get<int>());
1058         break;
1059       }
1060       case Toolkit::PageTurnView::Property::SPINE_SHADOW:
1061       {
1062         pageTurnViewImpl.SetSpineShadowParameter(value.Get<Vector2>());
1063         break;
1064       }
1065     }
1066   }
1067 }
1068
1069 Property::Value PageTurnView::GetProperty(BaseObject* object, Property::Index index)
1070 {
1071   Property::Value value;
1072
1073   Toolkit::PageTurnView pageTurnView = Toolkit::PageTurnView::DownCast(Dali::BaseHandle(object));
1074
1075   if(pageTurnView)
1076   {
1077     PageTurnView& pageTurnViewImpl(GetImplementation(pageTurnView));
1078
1079     switch(index)
1080     {
1081       case Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE:
1082       {
1083         value = pageTurnViewImpl.GetPageSize();
1084         break;
1085       }
1086       case Toolkit::PageTurnView::Property::CURRENT_PAGE_ID:
1087       {
1088         value = static_cast<int>(pageTurnViewImpl.GetCurrentPage());
1089         break;
1090       }
1091       case Toolkit::PageTurnView::Property::SPINE_SHADOW:
1092       {
1093         value = pageTurnViewImpl.GetSpineShadowParameter();
1094         break;
1095       }
1096     }
1097   }
1098   return value;
1099 }
1100
1101 } // namespace Internal
1102
1103 } // namespace Toolkit
1104
1105 } // namespace Dali