examples/page-turn-view/page-turn-view-example.cpp

   1 /*
   2  * Copyright (c) 2016 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 <dali/dali.h>
  19 #include <dali-toolkit/dali-toolkit.h>
  20 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
  21 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
  22 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
  23 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
  24
  25 #include <assert.h>
  26 #include <cstdlib>
  27 #include <string.h>
  28 #include <iostream>
  29
  30 #include "shared/view.h"
  31 #include "shared/utility.h"
  32
  33 using namespace Dali;
  34 using namespace Dali::Toolkit;
  35
  36 // LOCAL STUFF
  37 namespace
  38 {
  39 const char* const CHANGE_IMAGE_ICON(DEMO_IMAGE_DIR "icon-change.png");
  40 const char* const CHANGE_IMAGE_ICON_SELECTED( DEMO_IMAGE_DIR "icon-change-selected.png" );
  41
  42 // The content amount of one page between portrait and landscape view are different
  43 // set a ratio to modify the current page number when the rotation is changed
  44 const float PAGE_NUMBER_CORRESPONDING_RATIO(1.25f);
  45
  46 const char* BOOK_COVER_PORTRAIT( DEMO_IMAGE_DIR "book-portrait-cover.jpg" );
  47 const char* BOOK_COVER_LANDSCAPE( DEMO_IMAGE_DIR "book-landscape-cover.jpg" );
  48 const char* BOOK_COVER_BACK_LANDSCAPE( DEMO_IMAGE_DIR "book-landscape-cover-back.jpg" );
  49
  50 const char* PAGE_IMAGES_PORTRAIT[] =
  51 {
  52   DEMO_IMAGE_DIR "book-portrait-p1.jpg",
  53   DEMO_IMAGE_DIR "book-portrait-p2.jpg",
  54   DEMO_IMAGE_DIR "book-portrait-p3.jpg",
  55   DEMO_IMAGE_DIR "book-portrait-p4.jpg",
  56   DEMO_IMAGE_DIR "book-portrait-p5.jpg"
  57 };
  58 const unsigned int NUMBER_OF_PORTRAIT_IMAGE( sizeof(PAGE_IMAGES_PORTRAIT) / sizeof(PAGE_IMAGES_PORTRAIT[0]) );
  59
  60 const char* PAGE_IMAGES_LANDSCAPE[] =
  61 {
  62   DEMO_IMAGE_DIR "book-landscape-p1.jpg",
  63   DEMO_IMAGE_DIR "book-landscape-p2.jpg",
  64   DEMO_IMAGE_DIR "book-landscape-p3.jpg",
  65   DEMO_IMAGE_DIR "book-landscape-p4.jpg",
  66   DEMO_IMAGE_DIR "book-landscape-p5.jpg",
  67   DEMO_IMAGE_DIR "book-landscape-p6.jpg",
  68   DEMO_IMAGE_DIR "book-landscape-p7.jpg",
  69   DEMO_IMAGE_DIR "book-landscape-p8.jpg"
  70 };
  71 const unsigned int NUMBER_OF_LANDSCAPE_IMAGE( sizeof(PAGE_IMAGES_LANDSCAPE) / sizeof(PAGE_IMAGES_LANDSCAPE[0]) );
  72
  73 Texture LoadTextures( const char* imagePath1, const char* imagePath2 )
  74 {
  75   PixelData pixelData1 = DemoHelper::LoadPixelData( imagePath1, ImageDimensions(), FittingMode::DEFAULT, SamplingMode::DEFAULT );
  76   PixelData pixelData2 = DemoHelper::LoadPixelData( imagePath2, ImageDimensions(), FittingMode::DEFAULT, SamplingMode::DEFAULT );
  77
  78   unsigned int width = pixelData1.GetWidth() + pixelData2.GetWidth();
  79   unsigned int height = pixelData1.GetHeight() > pixelData2.GetHeight() ? pixelData1.GetHeight() : pixelData2.GetHeight();
  80
  81   Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D, Pixel::RGB888, width, height );
  82   texture.Upload( pixelData1 );
  83   texture.Upload( pixelData2, 0u, 0u, pixelData1.GetWidth(), 0u, pixelData2.GetWidth(), pixelData2.GetHeight() );
  84
  85   return texture;
  86 }
  87
  88 }// end LOCAL STUFF
  89
  90 class PortraitPageFactory : public PageFactory
  91 {
  92   /**
  93    * Query the number of pages available from the factory.
  94    * The maximum available page has an ID of GetNumberOfPages()-1.
  95    */
  96   virtual unsigned int GetNumberOfPages()
  97   {
  98     return 10*NUMBER_OF_PORTRAIT_IMAGE + 1;
  99   }
 100   /**
 101    * Create an texture to represent a page.
 102    * @param[in] pageId The ID of the page to create.
 103    * @return A texture, or an uninitialized handle if the ID is out of range.
 104    */
 105   virtual Texture NewPage( unsigned int pageId )
 106   {
 107     Texture page;
 108
 109     if( pageId == 0 )
 110     {
 111       page = DemoHelper::LoadTexture( BOOK_COVER_PORTRAIT );
 112     }
 113     else
 114     {
 115       page = DemoHelper::LoadTexture( PAGE_IMAGES_PORTRAIT[ (pageId-1) % NUMBER_OF_PORTRAIT_IMAGE ] );
 116     }
 117
 118     return page;
 119   }
 120 };
 121
 122 class LandscapePageFactory : public PageFactory
 123 {
 124
 125   /**
 126    * Query the number of pages available from the factory.
 127    * The maximum available page has an ID of GetNumberOfPages()-1.
 128    */
 129   virtual unsigned int GetNumberOfPages()
 130   {
 131     return 10*NUMBER_OF_LANDSCAPE_IMAGE / 2 + 1;
 132   }
 133   /**
 134    * Create an texture to represent a page.
 135    * @param[in] pageId The ID of the page to create.
 136    * @return A texture, or an uninitialized handle if the ID is out of range.
 137    */
 138   virtual Texture NewPage( unsigned int pageId )
 139   {
 140     Texture page;
 141     if( pageId == 0 )
 142     {
 143       page = LoadTextures( BOOK_COVER_LANDSCAPE, BOOK_COVER_BACK_LANDSCAPE );
 144     }
 145     else
 146     {
 147       unsigned int imageId = (pageId-1)*2;
 148       page = LoadTextures( PAGE_IMAGES_LANDSCAPE[ imageId % NUMBER_OF_LANDSCAPE_IMAGE ], PAGE_IMAGES_LANDSCAPE[ (imageId+1) % NUMBER_OF_LANDSCAPE_IMAGE ] );
 149     }
 150
 151     return page;
 152   }
 153 };
 154
 155 /**
 156  * This example shows how to use the page turn UI control to implement the page-turn demo
 157  * The effect follows the pan gesture to animate the page
 158  * Pan the page inwards, the page will bent,
 159  * Depends on the distance of the panning, the page might turn over or slide back
 160  * Also, in portrait view, the pan gesture outwards from position near the spine could turn the previous page back
 161  * Allows to turn multiple pages one by one quickly towards the same direction, multiple animations are launched in this case
 162 */
 163 class PageTurnController : public ConnectionTracker
 164 {
 165 public:
 166   PageTurnController( Application &app );
 167   ~PageTurnController();
 168
 169   //This method gets called once the main loop of application is up and running
 170   void OnInit( Application& app );
 171
 172 private:
 173
 174   /**
 175    * This method gets called when the button is clicked, switch between portrait and landscape views
 176    */
 177   bool OnButtonClicked(Toolkit::Button button);
 178
 179   /**
 180    * Main key event handler
 181    */
 182   void OnKeyEvent(const KeyEvent& event);
 183
 184   /**
 185    * Callback function of page turned signal
 186    * @param[in] pageTurnView The handle of the PageTurnPortraitView or PageTurnLandscapeView
 187    * @param[in] pageIndex The index of the page turned over
 188    * @param[in] isTurningForward The turning direction, forwards or backwards
 189    */
 190   void OnPageStartedTurn( PageTurnView pageTurnView, unsigned int pageIndex, bool isTurningForward );
 191
 192   /**
 193    * Callback function of page turned signal
 194    * @param[in] pageTurnView The handle of the PageTurnPortraitView or PageTurnLandscapeView
 195    * @param[in] pageIndex The index of the page turned over
 196    * @param[in] isTurningForward The turning direction, forwards or backwards
 197    */
 198   void OnPageFinishedTurn( PageTurnView pageTurnView, unsigned int pageIndex, bool isTurningForward );
 199
 200   /**
 201    * Callback function of page started pan signal
 202    *
 203    * @param[in] pageTurnView The calling page turn view
 204    */
 205   void OnPageStartedPan( PageTurnView pageTurnView );
 206
 207   /**
 208    * Callback function of page finished pan signal
 209    *
 210    * @param[in] pageTurnView The calling page turn view
 211    */
 212   void OnPageFinishedPan( PageTurnView pageTurnView );
 213
 214 private:
 215
 216   Application&                mApplication;
 217   Layer                       mButtonLayer;
 218
 219   PageTurnView                mPageTurnPortraitView;
 220   PageTurnView                mPageTurnLandscapeView;
 221   PortraitPageFactory         mPortraitPageFactory;
 222   LandscapePageFactory        mLandscapePageFactory;
 223
 224   bool                        mIsPortrait;
 225 };
 226
 227 PageTurnController::PageTurnController( Application &app )
 228 :mApplication( app ),
 229  mIsPortrait( true )
 230 {
 231   // Connect to the Application's Init signal
 232   app.InitSignal().Connect( this, &PageTurnController::OnInit );
 233 }
 234
 235 PageTurnController::~PageTurnController()
 236 {
 237 }
 238
 239
 240 void PageTurnController::OnInit( Application& app )
 241 {
 242   // The Init signal is received once ( only ) during the Application lifetime
 243
 244   Stage::GetCurrent().KeyEventSignal().Connect(this, &PageTurnController::OnKeyEvent);
 245
 246   // Hide the indicator bar
 247   app.GetWindow().ShowIndicator( Dali::Window::INVISIBLE );
 248
 249   Stage stage = Stage::GetCurrent();
 250   Vector2 stageSize =  stage.GetSize();
 251
 252   mButtonLayer = Layer::New();
 253   mButtonLayer.SetAnchorPoint( Dali::AnchorPoint::CENTER );
 254   mButtonLayer.SetParentOrigin( Dali::ParentOrigin::CENTER );
 255   mButtonLayer.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
 256   Toolkit::PushButton button = Toolkit::PushButton::New();
 257   button.SetAnchorPoint( AnchorPoint::TOP_RIGHT );
 258   button.SetParentOrigin( ParentOrigin::TOP_RIGHT );
 259   button.SetUnselectedImage( CHANGE_IMAGE_ICON  );
 260   button.SetSelectedImage( CHANGE_IMAGE_ICON_SELECTED );
 261   button.SetLeaveRequired( true );
 262   button.SetScale(1.5f);
 263   button.PressedSignal().Connect( this, &PageTurnController::OnButtonClicked );
 264   stage.Add( mButtonLayer );
 265   mButtonLayer.Add(button);
 266
 267   Vector2 bookSize( stageSize.x > stageSize.y ? stageSize.y : stageSize.x,
 268                     stageSize.x > stageSize.y ? stageSize.x : stageSize.y );
 269
 270   mPageTurnPortraitView = PageTurnPortraitView::New( mPortraitPageFactory, bookSize );
 271   mPageTurnPortraitView.SetParentOrigin( ParentOrigin::CENTER );
 272   mPageTurnPortraitView.SetAnchorPoint( AnchorPoint::CENTER );
 273   mPageTurnPortraitView.SetProperty( PageTurnView::Property::SPINE_SHADOW, Vector2(70.f, 30.f) );
 274   mPageTurnPortraitView.PageTurnStartedSignal().Connect( this, &PageTurnController::OnPageStartedTurn );
 275   mPageTurnPortraitView.PageTurnFinishedSignal().Connect( this, &PageTurnController::OnPageFinishedTurn );
 276   mPageTurnPortraitView.PagePanStartedSignal().Connect( this, &PageTurnController::OnPageStartedPan );
 277   mPageTurnPortraitView.PagePanFinishedSignal().Connect( this, &PageTurnController::OnPageFinishedPan );
 278
 279   mPageTurnLandscapeView = PageTurnLandscapeView::New( mLandscapePageFactory, Vector2(bookSize.y*0.5f, bookSize.x) );
 280   mPageTurnLandscapeView.SetParentOrigin( ParentOrigin::CENTER );
 281   mPageTurnLandscapeView.SetAnchorPoint( AnchorPoint::CENTER );
 282   mPageTurnLandscapeView.PageTurnStartedSignal().Connect( this, &PageTurnController::OnPageStartedTurn );
 283   mPageTurnLandscapeView.PageTurnFinishedSignal().Connect( this, &PageTurnController::OnPageFinishedTurn );
 284   mPageTurnLandscapeView.PagePanStartedSignal().Connect( this, &PageTurnController::OnPageStartedPan );
 285   mPageTurnLandscapeView.PagePanFinishedSignal().Connect( this, &PageTurnController::OnPageFinishedPan );
 286
 287   if( stageSize.x > stageSize.y )
 288   {
 289     stage.Add(mPageTurnLandscapeView);
 290     mPageTurnPortraitView.SetOrientation(Degree(90.f), Vector3::ZAXIS);
 291     mIsPortrait = false;
 292   }
 293   else
 294   {
 295     stage.Add(mPageTurnPortraitView);
 296     mPageTurnLandscapeView.SetOrientation(Degree(90.f), Vector3::ZAXIS);
 297     mIsPortrait = true;
 298   }
 299
 300   mButtonLayer.RaiseToTop();
 301 }
 302
 303 bool PageTurnController::OnButtonClicked(Toolkit::Button button)
 304 {
 305   if( mIsPortrait )
 306   {
 307     mPageTurnPortraitView.Unparent();
 308     Stage::GetCurrent().Add( mPageTurnLandscapeView );
 309     int pageId = mPageTurnPortraitView.GetProperty( PageTurnView::Property::CURRENT_PAGE_ID ).Get<int>();
 310     int currentPage = ceil( static_cast<float>(pageId) / PAGE_NUMBER_CORRESPONDING_RATIO );
 311     mPageTurnLandscapeView.SetProperty(PageTurnView::Property::CURRENT_PAGE_ID, currentPage );
 312   }
 313   else
 314   {
 315     mPageTurnLandscapeView.Unparent();
 316     Stage::GetCurrent().Add( mPageTurnPortraitView );
 317     int pageId = mPageTurnLandscapeView.GetProperty( PageTurnView::Property::CURRENT_PAGE_ID ).Get<int>();
 318     int currentPage = floor(pageId * PAGE_NUMBER_CORRESPONDING_RATIO );
 319     mPageTurnPortraitView.SetProperty(PageTurnView::Property::CURRENT_PAGE_ID, currentPage );
 320   }
 321
 322   mIsPortrait = !mIsPortrait;
 323   mButtonLayer.RaiseToTop();
 324   return true;
 325 }
 326
 327 /**
 328  * Main key event handler
 329  */
 330 void PageTurnController::OnKeyEvent(const KeyEvent& event)
 331 {
 332   if(event.state == KeyEvent::Down)
 333   {
 334     if( IsKey( event, Dali::DALI_KEY_ESCAPE) || IsKey( event, Dali::DALI_KEY_BACK) )
 335     {
 336       mApplication.Quit();
 337     }
 338   }
 339 }
 340
 341 void PageTurnController::OnPageStartedTurn( PageTurnView pageTurnView, unsigned int pageIndex, bool isTurningForward )
 342 {
 343   std::cout<< ( ( pageTurnView == mPageTurnPortraitView ) ? " portrait: " : " Landscape: " )
 344            << " page " << pageIndex
 345            << ( isTurningForward ? " is starting to turn forward" : " is starting to turn backward" )
 346            << std::endl;
 347 }
 348
 349 void PageTurnController::OnPageFinishedTurn( PageTurnView pageTurnView, unsigned int pageIndex, bool isTurningForward )
 350 {
 351   std::cout<< ( ( pageTurnView == mPageTurnPortraitView ) ? " portrait: " : " Landscape: " )
 352            << " page " << pageIndex
 353            << ( isTurningForward ? " has finished turning forward" : " has finished turning backward" )
 354            << std::endl;
 355 }
 356
 357 void PageTurnController::OnPageStartedPan( PageTurnView pageTurnView )
 358 {
 359   std::cout<< "Starting to pan" << std::endl;
 360 }
 361
 362 void PageTurnController::OnPageFinishedPan( PageTurnView pageTurnView )
 363 {
 364   std::cout<< "Finished panning" << std::endl;
 365 }
 366
 367 // Entry point for applications
 368 int DALI_EXPORT_API main( int argc, char **argv )
 369 {
 370   Application app = Application::New(&argc, &argv, DEMO_THEME_PATH);
 371   PageTurnController test ( app );
 372
 373   app.MainLoop();
 374
 375   return 0;
 376 }