X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=demo%2Fdali-table-view.cpp;h=81190fb6ff219354c0c9af53b4ed1e68e84ca688;hb=b4aed990f90ddd8f69a765effbb911b6c800c30f;hp=454a16d381eb9057f806cf3c7a0c102e5035de6e;hpb=6501ecf527a61ef1f2e9fe424ffc43069937cd83;p=platform%2Fcore%2Fuifw%2Fdali-demo.git

diff --git a/demo/dali-table-view.cpp b/demo/dali-table-view.cpp
index 454a16d..827b665 100644
--- a/demo/dali-table-view.cpp
+++ b/demo/dali-table-view.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,12 +17,20 @@
 
 // CLASS HEADER
 #include "dali-table-view.h"
-#include "examples/shared/view.h"
 
 // EXTERNAL INCLUDES
 #include <algorithm>
 #include <sstream>
-#include<unistd.h>
+#include <unistd.h>
+#include <dali/devel-api/images/distance-field.h>
+#include <dali-toolkit/devel-api/shader-effects/alpha-discard-effect.h>
+#include <dali-toolkit/devel-api/shader-effects/distance-field-effect.h>
+#include <dali-toolkit/dali-toolkit.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+
+// INTERNAL INCLUDES
+#include "shared/view.h"
+#include "shared/utility.h"
 
 using namespace Dali;
 using namespace Dali::Toolkit;
@@ -32,39 +40,38 @@ using namespace Dali::Toolkit;
 namespace
 {
 
-const std::string BUTTON_BACKWARD( "Backward" );
-const std::string BUTTON_FORWARD( "Forward" );
-const std::string BUTTON_QUIT( "Quit" );
-const std::string BUTTON_OK( "Ok" );
-const std::string BUTTON_CANCEL( "Cancel" );
-
-const std::string DEFAULT_BACKGROUND_IMAGE_PATH( DALI_IMAGE_DIR "background-gradient.jpg" );
-const std::string LOGO_PATH( DALI_IMAGE_DIR "dali-logo.png" );
-const std::string DEFAULT_TOOLBAR_IMAGE_PATH( DALI_IMAGE_DIR "top-bar.png" );
-const std::string BUTTON_BACKGROUND(DALI_IMAGE_DIR "button-background.png");
-const std::string TILE_BACKGROUND(DALI_IMAGE_DIR "item-background.png");
-const std::string TILE_BACKGROUND_ALPHA(DALI_IMAGE_DIR "item-background-alpha.png");
-
-const char * const DEFAULT_TOOLBAR_TEXT( "TOUCH TO LAUNCH EXAMPLE" );
+const std::string LOGO_PATH( DEMO_IMAGE_DIR "Logo-for-demo.png" );
+const std::string TILE_BACKGROUND(DEMO_IMAGE_DIR "item-background.9.png");
+const std::string TILE_BACKGROUND_ALPHA( DEMO_IMAGE_DIR "demo-tile-texture.9.png" );
 
-const float BUTTON_PRESS_ANIMATION_TIME = 0.25f;                ///< Time to perform button scale effect.
+const float TILE_LABEL_PADDING = 8.0f;                          ///< Border between edge of tile and the example text
+const float BUTTON_PRESS_ANIMATION_TIME = 0.35f;                ///< Time to perform button scale effect.
 const float ROTATE_ANIMATION_TIME = 0.5f;                       ///< Time to perform rotate effect.
 const int MAX_PAGES = 256;                                      ///< Maximum pages (arbitrary safety limit)
 const int EXAMPLES_PER_ROW = 3;
 const int ROWS_PER_PAGE = 3;
 const int EXAMPLES_PER_PAGE = EXAMPLES_PER_ROW * ROWS_PER_PAGE;
-const float TOP_ROW_HEIGHT = 35.0f;
-const float BOTTOM_ROW_HEIGHT = 35.0f;
-const int BOTTOM_PADDING_HEIGHT = 40;
-const int LOGO_BOTTOM_PADDING_HEIGHT = 30;
-const Vector3 TABLE_RELATIVE_SIZE(0.9f, 1.0f, 0.8f );          ///< TableView's relative size to the entire stage.
+const float LOGO_MARGIN_RATIO = 0.1f / 0.3f;
+const float BOTTOM_PADDING_RATIO = 0.4f / 0.9f;
+const Vector3 SCROLLVIEW_RELATIVE_SIZE(0.9f, 1.0f, 0.8f );      ///< ScrollView's relative size to its parent
+const Vector3 TABLE_RELATIVE_SIZE(0.95f, 0.9f, 0.8f );          ///< TableView's relative size to the entire stage. The Y value means sum of the logo and table relative heights.
 const float STENCIL_RELATIVE_SIZE = 1.0f;
 
 const float EFFECT_SNAP_DURATION = 0.66f;                       ///< Scroll Snap Duration for Effects
 const float EFFECT_FLICK_DURATION = 0.5f;                       ///< Scroll Flick Duration for Effects
 const Vector3 ANGLE_CUBE_PAGE_ROTATE(Math::PI * 0.5f, Math::PI * 0.5f, 0.0f);
+const Vector4 TILE_COLOR( 0.4f, 0.6f, 0.9f, 0.6f );
+
+const Vector4 BUBBLE_COLOR[] =
+{
+  Vector4( 0.3255f, 0.3412f, 0.6353f, 0.32f ),
+  Vector4( 0.3647f, 0.7569f, 0.8157f, 0.32f ),
+  Vector4( 0.3804f, 0.7412f, 0.6510f, 0.32f ),
+  Vector4( 1.f, 1.f, 1.f, 0.13f )
+};
+const int NUMBER_OF_BUBBLE_COLOR( sizeof(BUBBLE_COLOR) / sizeof(BUBBLE_COLOR[0]) );
 
-const int NUM_BACKGROUND_IMAGES = 20;
+const int NUM_BACKGROUND_IMAGES = 18;
 const float BACKGROUND_SWIPE_SCALE = 0.025f;
 const float BACKGROUND_SPREAD_SCALE = 1.5f;
 const float SCALE_MOD = 1000.0f * Math::PI * 2.0f;
@@ -73,141 +80,118 @@ const float SCALE_SPEED_SIN = 0.1f;
 
 const unsigned int BACKGROUND_ANIMATION_DURATION = 15000; // 15 secs
 
-const float BACKGROUND_Z = -1000.0f;
-const float BACKGROUND_SIZE_SCALE = 2.0f;
-const Vector4 BACKGROUND_COLOR( 1.0f, 1.0f, 1.0f, 1.0f );
+const Vector4 BACKGROUND_COLOR( 0.3569f, 0.5451f, 0.7294f, 1.0f );
 
+const float BUBBLE_MIN_Z = -1.0;
+const float BUBBLE_MAX_Z = 0.0f;
 
-const std::string             DEFAULT_TEXT_STYLE_FONT_FAMILY("HelveticaNeue");
-const std::string             DEFAULT_TEXT_STYLE_FONT_STYLE("Regular");
-const Dali::PointSize         DEFAULT_TEXT_STYLE_POINT_SIZE( 8.0f );
-const Dali::TextStyle::Weight DEFAULT_TEXT_STYLE_WEIGHT(Dali::TextStyle::REGULAR);
-const Dali::Vector4           DEFAULT_TEXT_STYLE_COLOR(0.7f, 0.7f, 0.7f, 1.0f);
+// This shader takes a texture.
+// An alpha discard is performed.
+// The shader uses the tiles position within the scroll-view page and the scroll-views rotation position to create a parallax effect.
+const char* FRAGMENT_SHADER_TEXTURED = DALI_COMPOSE_SHADER(
+  varying mediump vec2  vTexCoord;
+  varying mediump vec3  vIllumination;
+  uniform lowp    vec4  uColor;
+  uniform sampler2D     sTexture;
+  uniform mediump vec3  uCustomPosition;
 
-const std::string             TABLE_TEXT_STYLE_FONT_FAMILY("HelveticaNeue");
-const std::string             TABLE_TEXT_STYLE_FONT_STYLE("Regular");
-const Dali::PointSize         TABLE_TEXT_STYLE_POINT_SIZE( 8.0f );
-const Dali::TextStyle::Weight TABLE_TEXT_STYLE_WEIGHT(Dali::TextStyle::LIGHT);
-const Dali::Vector4           TABLE_TEXT_STYLE_COLOR(0.0f, 0.0f, 0.0f, 1.0f);
+  void main()
+  {
+    if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )
+    {
+      discard;
+    }
 
+    mediump vec2 wrapTexCoord = vec2( ( vTexCoord.x / 4.0 ) + ( uCustomPosition.x / 4.0 ) + ( uCustomPosition.z / 2.0 ), vTexCoord.y / 4.0 );
+    mediump vec4 color = texture2D( sTexture, wrapTexCoord );
+    mediump float positionWeight = ( uCustomPosition.y + 0.3 ) * color.r * 2.0;
 
-TextStyle GetTableTextStyle()
-{
-  TextStyle textStyle;
-  textStyle.SetFontName(TABLE_TEXT_STYLE_FONT_FAMILY);
-  textStyle.SetFontStyle(TABLE_TEXT_STYLE_FONT_STYLE);
-  textStyle.SetFontPointSize( Dali::PointSize(DemoHelper::ScalePointSize(TABLE_TEXT_STYLE_POINT_SIZE)));
-  textStyle.SetWeight(TABLE_TEXT_STYLE_WEIGHT);
-  textStyle.SetTextColor(TABLE_TEXT_STYLE_COLOR);
-  return textStyle;
-}
+    gl_FragColor = vec4( positionWeight, positionWeight, positionWeight, 0.9 ) * uColor + vec4( uColor.xyz, 0.0 );
+  }
+);
 
 /**
  * Creates the background image
  */
-ImageActor CreateBackground( std::string imagePath )
+Control CreateBackground( std::string stylename )
 {
-  Image image = Image::New( imagePath );
-  ImageActor background = ImageActor::New( image );
-
+  Control background = Control::New();
+  Stage::GetCurrent().Add( background );
+  background.SetStyleName( stylename );
+  background.SetName( "BACKGROUND" );
   background.SetAnchorPoint( AnchorPoint::CENTER );
   background.SetParentOrigin( ParentOrigin::CENTER );
-  background.SetZ( -1.0f );
-
+  background.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
   return background;
 }
 
-// These values depend on the tile image
-const float IMAGE_BORDER_LEFT = 11.0f;
-const float IMAGE_BORDER_RIGHT = IMAGE_BORDER_LEFT;
-const float IMAGE_BORDER_TOP = IMAGE_BORDER_LEFT;
-const float IMAGE_BORDER_BOTTOM = IMAGE_BORDER_LEFT;
-
 /**
- * TableViewVisibilityConstraint
+ * Constraint to return a position for a bubble based on the scroll value and vertical wrapping
  */
-struct TableViewVisibilityConstraint
-{
-  bool operator()( const bool& current,
-              const PropertyInput& pagePositionProperty,
-              const PropertyInput& pageSizeProperty )
-  {
-    // Only the tableview in the current page should be visible.
-    const Vector3& pagePosition = pagePositionProperty.GetVector3();
-    const Vector3& pageSize = pageSizeProperty.GetVector3();
-    return fabsf( pagePosition.x ) < pageSize.x;
-  }
-};
-
-/**
- * Constraint to wrap an actor in y that is moving vertically
- */
-Vector3 ShapeMovementConstraint( const Vector3& current,
-                         const PropertyInput& shapeSizeProperty,
-                         const PropertyInput& parentSizeProperty )
-{
-  const Vector3& shapeSize = shapeSizeProperty.GetVector3();
-  const Vector3& parentSize = parentSizeProperty.GetVector3();
-
-  Vector3 pos( current );
-  if( pos.y + shapeSize.y * 0.5f < -parentSize.y * 0.5f )
-  {
-    pos.y += parentSize.y + shapeSize.y;
-  }
-
-  return pos;
-}
-
-/**
- * Constraint to return a position for the background based on the scroll value
- */
-struct AnimScrollConstraint
+struct AnimateBubbleConstraint
 {
 public:
-
-  AnimScrollConstraint( const Vector3& initialPos, float scale )
-      : mInitialPos( initialPos ),
-        mScale( scale )
+  AnimateBubbleConstraint( const Vector3& initialPos, float scale )
+  : mInitialX( initialPos.x ),
+    mScale( scale )
   {
-
   }
 
-  Vector3 operator()( const Vector3& current, const PropertyInput& scrollProperty )
+  void operator()( Vector3& position, const PropertyInputContainer& inputs )
   {
-    float scrollPos = scrollProperty.GetVector3().x;
+    const Vector3& parentSize = inputs[1]->GetVector3();
+    const Vector3& childSize = inputs[2]->GetVector3();
+
+    // Wrap bubbles vertically.
+    float range = parentSize.y + childSize.y;
+    // This performs a float mod (we don't use fmod as we want the arithmetic modulus as opposed to the remainder).
+    position.y -= range * ( floor( position.y / range ) + 0.5f );
 
-    return mInitialPos + Vector3( -scrollPos * mScale, 0.0f, 0.0f );
+    // Bubbles X position moves parallax to horizontal
+    // panning by a scale factor unique to each bubble.
+    position.x = mInitialX + ( inputs[0]->GetVector2().x * mScale );
   }
 
 private:
-  Vector3 mInitialPos;
+  float mInitialX;
   float mScale;
 };
 
 /**
- * Constraint to return a tracked world position added to the constant local position
+ * Constraint to precalculate values from the scroll-view
+ * and tile positions to pass to the tile shader.
  */
-struct TranslateLocalConstraint
+struct TileShaderPositionConstraint
 {
-public:
-
-  TranslateLocalConstraint( const Vector3& localPos )
-      : mLocalPos( localPos )
+  TileShaderPositionConstraint( float pageWidth, float tileXOffset )
+  : mPageWidth( pageWidth ),
+    mTileXOffset( tileXOffset )
   {
   }
 
-  Vector3 operator()( const Vector3& current, const PropertyInput& pagePosProperty )
+  void operator()( Vector3& position, const PropertyInputContainer& inputs )
   {
-    Vector3 worldPos = pagePosProperty.GetVector3();
-
-    return ( worldPos + mLocalPos );
+    // Set up position.x as the tiles X offset (0.0 -> 1.0).
+    position.x = mTileXOffset;
+    // Set up position.z as the linear scroll-view X offset (0.0 -> 1.0).
+    position.z = 1.0f * ( -fmod( inputs[0]->GetVector2().x, mPageWidth ) / mPageWidth );
+    // Set up position.y as a rectified version of the scroll-views X offset.
+    // IE. instead of 0.0 -> 1.0, it moves between 0.0 -> 0.5 -> 0.0 within the same span.
+    if( position.z > 0.5f )
+    {
+      position.y = 1.0f - position.z;
+    }
+    else
+    {
+      position.y = position.z;
+    }
   }
 
 private:
-  Vector3 mLocalPos;
+  float mPageWidth;
+  float mTileXOffset;
 };
 
-
 bool CompareByTitle( const Example& lhs, const Example& rhs )
 {
   return lhs.title < rhs.title;
@@ -216,11 +200,25 @@ bool CompareByTitle( const Example& lhs, const Example& rhs )
 } // namespace
 
 DaliTableView::DaliTableView( Application& application )
-    : mApplication( application ),
-        mScrolling( false ),
-        mBackgroundImagePath( DEFAULT_BACKGROUND_IMAGE_PATH ),
-        mSortAlphabetically( false ),
-        mBackgroundAnimsPlaying( false )
+: mApplication( application ),
+  mRootActor(),
+  mRotateAnimation(),
+  mPressedAnimation(),
+  mScrollView(),
+  mScrollViewEffect(),
+  mScrollRulerX(),
+  mScrollRulerY(),
+  mPressedActor(),
+  mAnimationTimer(),
+  mLogoTapDetector(),
+  mVersionPopup(),
+  mPages(),
+  mBackgroundAnimations(),
+  mExampleList(),
+  mTotalPages(),
+  mScrolling( false ),
+  mSortAlphabetically( false ),
+  mBackgroundAnimsPlaying( false )
 {
   application.InitSignal().Connect( this, &DaliTableView::Initialize );
 }
@@ -232,12 +230,6 @@ DaliTableView::~DaliTableView()
 void DaliTableView::AddExample( Example example )
 {
   mExampleList.push_back( example );
-  mExampleMap[ example.name ] = example;
-}
-
-void DaliTableView::SetBackgroundPath( std::string imagePath )
-{
-  mBackgroundImagePath = imagePath;
 }
 
 void DaliTableView::SortAlphabetically( bool sortAlphabetically )
@@ -248,90 +240,63 @@ void DaliTableView::SortAlphabetically( bool sortAlphabetically )
 void DaliTableView::Initialize( Application& application )
 {
   Stage::GetCurrent().KeyEventSignal().Connect( this, &DaliTableView::OnKeyEvent );
-
-  Vector2 stageSize = Stage::GetCurrent().GetSize();
+  const Vector2 stageSize = Stage::GetCurrent().GetSize();
 
   // Background
-  mBackground = CreateBackground( mBackgroundImagePath );
-  // set same size as parent actor
-  mBackground.SetSize( stageSize );
-  Stage::GetCurrent().Add( mBackground );
-
-  // Render entire content as overlays, as is all on same 2D plane.
-  mRootActor = TableView::New( 4, 1 );
-  mRootActor.SetAnchorPoint( AnchorPoint::CENTER );
-  mRootActor.SetParentOrigin( ParentOrigin::CENTER );
-  mRootActor.SetFixedHeight( 3, BOTTOM_PADDING_HEIGHT );
+  mRootActor = CreateBackground( "LauncherBackground" );
   Stage::GetCurrent().Add( mRootActor );
 
-  // Toolbar at top
-  Dali::Toolkit::ToolBar toolbar;
-  Dali::Layer toolBarLayer = DemoHelper::CreateToolbar(toolbar,
-                                                       DEFAULT_TOOLBAR_IMAGE_PATH,
-                                                       DEFAULT_TOOLBAR_TEXT,
-                                                       DemoHelper::DEFAULT_VIEW_STYLE,
-                                                       DemoHelper::GetDefaultTextStyle());
-
-  mRootActor.AddChild( toolBarLayer, TableView::CellPosition( 0, 0 ) );
-  mRootActor.SetFixedHeight( 0, DemoHelper::DEFAULT_VIEW_STYLE.mToolBarHeight );
-
   // Add logo
-  mLogo = CreateLogo( LOGO_PATH );
-  mRootActor.SetFixedHeight( 1, mLogo.GetImage().GetHeight() + LOGO_BOTTOM_PADDING_HEIGHT );
-
-  Alignment alignment = Alignment::New();
-  alignment.Add(mLogo);
-  mRootActor.AddChild( alignment, TableView::CellPosition( 1, 0 ) );
-
-  // scrollview occupying the majority of the screen
+  ImageView logo = CreateLogo( LOGO_PATH );
+  logo.SetName( "LOGO_IMAGE" );
+  logo.SetAnchorPoint( AnchorPoint::TOP_CENTER );
+  logo.SetParentOrigin( Vector3( 0.5f, 0.1f, 0.5f ) );
+  logo.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
+
+  // Show version in a popup when log is tapped
+  mLogoTapDetector = TapGestureDetector::New();
+  mLogoTapDetector.Attach( logo );
+  mLogoTapDetector.DetectedSignal().Connect( this, &DaliTableView::OnLogoTapped );
+
+  // Scrollview occupying the majority of the screen
   mScrollView = ScrollView::New();
+  mScrollView.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
+  mScrollView.SetParentOrigin( Vector3( 0.5f, 1.0f - 0.05f, 0.5f ) );
+  mScrollView.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
+  mScrollView.SetResizePolicy( ResizePolicy::SIZE_RELATIVE_TO_PARENT, Dimension::HEIGHT );
+  mScrollView.SetSizeModeFactor( Vector3( 0.0f, 0.6f, 0.0f ) );
+
+  const float buttonsPageMargin = ( 1.0f - TABLE_RELATIVE_SIZE.x ) * 0.5f * stageSize.width;
+  mScrollView.SetPadding( Padding( buttonsPageMargin, buttonsPageMargin, 0.0f, 0.0f ) );
 
-  mScrollView.SetAnchorPoint( AnchorPoint::CENTER );
-  mScrollView.SetParentOrigin( ParentOrigin::CENTER );
-  mScrollView.ApplyConstraint( Dali::Constraint::New<Dali::Vector3>( Dali::Actor::SIZE, Dali::ParentSource( Dali::Actor::SIZE ), Dali::RelativeToConstraint( TABLE_RELATIVE_SIZE ) ) );
   mScrollView.SetAxisAutoLock( true );
   mScrollView.ScrollCompletedSignal().Connect( this, &DaliTableView::OnScrollComplete );
   mScrollView.ScrollStartedSignal().Connect( this, &DaliTableView::OnScrollStart );
-  mScrollView.TouchedSignal().Connect( this, &DaliTableView::OnScrollTouched );
+  mScrollView.TouchSignal().Connect( this, &DaliTableView::OnScrollTouched );
 
-  mScrollViewLayer = Layer::New();
-  mScrollViewLayer.SetAnchorPoint( AnchorPoint::CENTER );
-  mScrollViewLayer.SetParentOrigin( ParentOrigin::CENTER );
-  mScrollViewLayer.SetSize( stageSize );
-  mScrollViewLayer.Add( mScrollView );
-  mRootActor.AddChild( mScrollViewLayer, TableView::CellPosition( 2, 0 ) );
+  mPageWidth = stageSize.width * TABLE_RELATIVE_SIZE.x * 0.5f;
 
-  // Setup the scenegraph
-  // 1) Add scroll view effect and setup constraints on pages
-  ApplyScrollViewEffect();
-
-  // 2) Add pages and tiles
-  Populate();
+  // Populate background and bubbles - needs to be scrollViewLayer so scroll ends show
+  Actor bubbleContainer = Actor::New();
+  bubbleContainer.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+  bubbleContainer.SetAnchorPoint( AnchorPoint::CENTER );
+  bubbleContainer.SetParentOrigin( ParentOrigin::CENTER );
+  SetupBackground( bubbleContainer );
 
-  // 3) Populate scrollview with background so constraints on background layers can work with scrollview
-  SetupBackground( mScrollView, stageSize );
+  mRootActor.Add( logo );
+  // We use depth index to bring the logo above the bubbles (as an alternative to creating actors).
+  logo.GetRendererAt( 0 ).SetProperty( Renderer::Property::DEPTH_INDEX, 30000 );
+  mRootActor.Add( bubbleContainer );
+  mRootActor.Add( mScrollView );
 
-  // 4) Remove constraints for inner cube effect
-  for( TableViewListIter pageIter = mTableViewList.begin(); pageIter != mTableViewList.end(); ++pageIter )
-  {
-    TableView page = *pageIter;
+  // Add scroll view effect and setup constraints on pages
+  ApplyScrollViewEffect();
 
-    unsigned int numChildren = page.GetChildCount();
-    Actor pageActor = page;
-    for( unsigned int i=0; i<numChildren; ++i)
-    {
-      // Remove old effect's manual constraints.
-      Actor child = pageActor.GetChildAt(i);
-      if( child )
-      {
-        child.RemoveConstraints();
-      }
-    }
-  }
+  // Add pages and tiles
+  Populate();
 
-  // Set initial orientation
-  unsigned int degrees = application.GetOrientation().GetDegrees();
-  Rotate( degrees );
+  // Remove constraints for inner cube effect
+  ApplyCubeEffectToPages();
 
   Dali::Window winHandle = application.GetWindow();
   winHandle.AddAvailableOrientation( Dali::Window::PORTRAIT );
@@ -339,27 +304,42 @@ void DaliTableView::Initialize( Application& application )
   winHandle.AddAvailableOrientation( Dali::Window::PORTRAIT_INVERSE );
   winHandle.RemoveAvailableOrientation( Dali::Window::LANDSCAPE_INVERSE );
 
-  Dali::Orientation orientation = winHandle.GetOrientation();
-  orientation.ChangedSignal().Connect( this, &DaliTableView::OrientationChanged );
+  // Set initial orientation
+  unsigned int degrees = 0;
+  Rotate( degrees );
 
   winHandle.ShowIndicator( Dali::Window::INVISIBLE );
 
-  //
+  // Background animation
   mAnimationTimer = Timer::New( BACKGROUND_ANIMATION_DURATION );
   mAnimationTimer.TickSignal().Connect( this, &DaliTableView::PauseBackgroundAnimation );
   mAnimationTimer.Start();
   mBackgroundAnimsPlaying = true;
 
   KeyboardFocusManager::Get().PreFocusChangeSignal().Connect( this, &DaliTableView::OnKeyboardPreFocusChange );
-  KeyboardFocusManager::Get().FocusedActorActivatedSignal().Connect( this, &DaliTableView::OnFocusedActorActivated );
+  KeyboardFocusManager::Get().FocusedActorEnterKeySignal().Connect( this, &DaliTableView::OnFocusedActorActivated );
+  AccessibilityManager::Get().FocusedActorActivatedSignal().Connect( this, &DaliTableView::OnFocusedActorActivated );
+}
+
+void DaliTableView::ApplyCubeEffectToPages()
+{
+  ScrollViewPagePathEffect effect = ScrollViewPagePathEffect::DownCast( mScrollViewEffect );
+  unsigned int pageCount(0);
+  for( std::vector< Actor >::iterator pageIter = mPages.begin(); pageIter != mPages.end(); ++pageIter )
+  {
+    Actor page = *pageIter;
+    effect.ApplyToPage( page, pageCount++ );
+  }
+}
+
+void DaliTableView::OnButtonsPageRelayout( const Dali::Actor& actor )
+{
 }
 
 void DaliTableView::Populate()
 {
   const Vector2 stageSize = Stage::GetCurrent().GetSize();
 
-  const Size demoTileSize( 0.25f * stageSize.width, 0.25f * stageSize.height );
-
   mTotalPages = ( mExampleList.size() + EXAMPLES_PER_PAGE - 1 ) / EXAMPLES_PER_PAGE;
 
   // Populate ScrollView.
@@ -372,50 +352,40 @@ void DaliTableView::Populate()
 
     unsigned int exampleCount = 0;
     ExampleListConstIter iter = mExampleList.begin();
+
     for( int t = 0; t < mTotalPages; t++ )
     {
-      // Create Table. (contains up to 9 Examples)
-      TableView tableView = TableView::New( 4, 3 );
-      // Add tableView to container.
-      mScrollView.Add( tableView );
-      ApplyEffectToPage( tableView, TABLE_RELATIVE_SIZE );
-
-      tableView.SetAnchorPoint( AnchorPoint::CENTER );
-      tableView.SetParentOrigin( ParentOrigin::CENTER );
-      // 2 pixels of padding
-      tableView.SetCellPadding( Size( 2.0f, 2.0f ) );
-
-      Constraint constraint = Constraint::New<Vector3>( Actor::SCALE,
-                                                        LocalSource( Actor::SIZE ),
-                                                        ParentSource( Actor::SIZE ),
-                                                        ScaleToFitConstraint() );
-      tableView.ApplyConstraint(constraint);
-
-      // Apply visibility constraint to table view
-      Constraint visibleConstraint = Constraint::New< bool >( Actor::VISIBLE,
-                                                              LocalSource( Actor::POSITION ),
-                                                              ParentSource( Actor::SIZE ),
-                                                              TableViewVisibilityConstraint() );
-      visibleConstraint.SetRemoveAction( Constraint::Discard );
-      tableView.ApplyConstraint( visibleConstraint );
-
-      // add cells to table
-      for( int y = 0; y < ROWS_PER_PAGE; y++ )
+      // Create Table
+      TableView page = TableView::New( ROWS_PER_PAGE, EXAMPLES_PER_ROW );
+      page.SetAnchorPoint( AnchorPoint::CENTER );
+      page.SetParentOrigin( ParentOrigin::CENTER );
+      page.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+      mScrollView.Add( page );
+
+      // Calculate the number of images going across (columns) within a page, according to the screen resolution and dpi.
+      const float margin = 2.0f;
+      const float tileParentMultiplier = 1.0f / EXAMPLES_PER_ROW;
+
+      for(int row = 0; row < ROWS_PER_PAGE; row++)
       {
-        for( int x = 0; x < EXAMPLES_PER_ROW; x++ )
+        for(int column = 0; column < EXAMPLES_PER_ROW; column++)
         {
           const Example& example = ( *iter );
 
-          Actor tile = CreateTile( example.name, example.title, demoTileSize, true );
-          FocusManager focusManager = FocusManager::Get();
-          focusManager.SetFocusOrder( tile, ++exampleCount );
-          focusManager.SetAccessibilityAttribute( tile, Dali::Toolkit::FocusManager::ACCESSIBILITY_LABEL,
+          // Calculate the tiles relative position on the page (between 0 & 1 in each dimension).
+          Vector2 position( static_cast<float>( column ) / ( EXAMPLES_PER_ROW - 1.0f ), static_cast<float>( row ) / ( EXAMPLES_PER_ROW - 1.0f ) );
+          Actor tile = CreateTile( example.name, example.title, Vector3( tileParentMultiplier, tileParentMultiplier, 1.0f ), position );
+          AccessibilityManager accessibilityManager = AccessibilityManager::Get();
+          accessibilityManager.SetFocusOrder( tile, ++exampleCount );
+          accessibilityManager.SetAccessibilityAttribute( tile, Dali::Toolkit::AccessibilityManager::ACCESSIBILITY_LABEL,
                                                   example.title );
-          focusManager.SetAccessibilityAttribute( tile, Dali::Toolkit::FocusManager::ACCESSIBILITY_TRAIT, "Tile" );
-          focusManager.SetAccessibilityAttribute( tile, Dali::Toolkit::FocusManager::ACCESSIBILITY_HINT,
+          accessibilityManager.SetAccessibilityAttribute( tile, Dali::Toolkit::AccessibilityManager::ACCESSIBILITY_TRAIT, "Tile" );
+          accessibilityManager.SetAccessibilityAttribute( tile, Dali::Toolkit::AccessibilityManager::ACCESSIBILITY_HINT,
                                                   "You can run this example" );
 
-          tableView.AddChild( tile, TableView::CellPosition( y, x ) );
+          tile.SetPadding( Padding( margin, margin, margin, margin ) );
+          page.AddChild( tile, TableView::CellPosition( row, column ) );
+
           iter++;
 
           if( iter == mExampleList.end() )
@@ -423,31 +393,18 @@ void DaliTableView::Populate()
             break;
           }
         }
+
         if( iter == mExampleList.end() )
         {
           break;
         }
       }
 
-      // last row is thin.
-      tableView.SetFixedHeight( 3, BOTTOM_ROW_HEIGHT );
-
-      std::stringstream out;
-      out << ( t + 1 ) << " of " << mTotalPages;
-      Actor pageNumberText = CreateTile( "", out.str(), Size( 0.8f * stageSize.width, BOTTOM_ROW_HEIGHT ), false );
-
-      pageNumberText.ApplyConstraint( Constraint::New< Vector3 >( Actor::POSITION, Source( tableView, Actor::WORLD_POSITION),
-                                                                   TranslateLocalConstraint( Vector3( 0.0f, stageSize.y * 0.4f, 0.0f ) ) ) );
-      pageNumberText.ApplyConstraint( Constraint::New< Quaternion >( Actor::ROTATION, Source( tableView, Actor::WORLD_ROTATION ), EqualToConstraint() ) );
-      pageNumberText.ApplyConstraint( Constraint::New< Vector4 >( Actor::COLOR, Source( tableView, Actor::COLOR ), EqualToConstraint() ) );
-
-      //Stage::GetCurrent().Add( pageNumberText );
-
       // Set tableview position
-      Vector3 tableViewPos( stageSize.x * TABLE_RELATIVE_SIZE.x * t, 0.0f, 0.0f );
-      tableView.SetPosition( tableViewPos );
+      Vector3 pagePos( stageSize.width * TABLE_RELATIVE_SIZE.x * t, 0.0f, 0.0f );
+      page.SetPosition( pagePos );
 
-      mTableViewList.push_back( tableView );
+      mPages.push_back( page );
 
       if( iter == mExampleList.end() )
       {
@@ -457,19 +414,14 @@ void DaliTableView::Populate()
   }
 
   // Update Ruler info.
-  mScrollRulerX = new FixedRuler( stageSize.width * TABLE_RELATIVE_SIZE.x );
+  mScrollRulerX = new FixedRuler( mPageWidth );
   mScrollRulerY = new DefaultRuler();
-  mScrollRulerX->SetDomain( RulerDomain( 0.0f, mTotalPages * stageSize.width * TABLE_RELATIVE_SIZE.x, true ) );
+  mScrollRulerX->SetDomain( RulerDomain( 0.0f, (mTotalPages+1) * stageSize.width * TABLE_RELATIVE_SIZE.x * 0.5f, true ) );
   mScrollRulerY->Disable();
   mScrollView.SetRulerX( mScrollRulerX );
   mScrollView.SetRulerY( mScrollRulerY );
 }
 
-void DaliTableView::OrientationChanged( Orientation orientation )
-{
-  // TODO: Implement if orientation change required
-}
-
 void DaliTableView::Rotate( unsigned int degrees )
 {
   // Resize the root actor
@@ -488,98 +440,89 @@ void DaliTableView::Rotate( unsigned int degrees )
   }
 
   mRotateAnimation = Animation::New( ROTATE_ANIMATION_TIME );
-  mRotateAnimation.RotateTo( mRootActor, Degree( 360 - degrees ), Vector3::ZAXIS, AlphaFunctions::EaseOut );
-  mRotateAnimation.Resize( mRootActor, targetSize, AlphaFunctions::EaseOut );
+  mRotateAnimation.AnimateTo( Property( mRootActor, Actor::Property::ORIENTATION ), Quaternion( Radian( Degree( 360 - degrees ) ), Vector3::ZAXIS ), AlphaFunction::EASE_OUT );
+  mRotateAnimation.AnimateTo( Property( mRootActor, Actor::Property::SIZE ), targetSize, AlphaFunction::EASE_OUT );
   mRotateAnimation.Play();
 }
 
-Actor DaliTableView::CreateTile( const std::string& name, const std::string& title, const Size& parentSize, bool addBackground )
+Actor DaliTableView::CreateTile( const std::string& name, const std::string& title, const Dali::Vector3& sizeMultiplier, Vector2& position )
 {
-  Actor tile = Actor::New();
-  tile.SetName( name );
-  tile.SetAnchorPoint( AnchorPoint::CENTER );
-  tile.SetParentOrigin( ParentOrigin::CENTER );
-
-  // make the tile 100% of parent
-  tile.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
-
   Actor content = Actor::New();
+  content.SetName( name );
   content.SetAnchorPoint( AnchorPoint::CENTER );
   content.SetParentOrigin( ParentOrigin::CENTER );
-  content.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
-  tile.Add(content);
-
-  // create background image
-  if( addBackground )
-  {
-    Image bg = Image::New( TILE_BACKGROUND );
-    ImageActor image = ImageActor::New( bg );
-    image.SetAnchorPoint( AnchorPoint::CENTER );
-    image.SetParentOrigin( ParentOrigin::CENTER );
-    // make the image 100% of tile
-    image.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
-    // move image back to get text appear in front
-    image.SetZ( -1 );
-    image.SetStyle( ImageActor::STYLE_NINE_PATCH );
-    image.SetNinePatchBorder( Vector4( IMAGE_BORDER_LEFT, IMAGE_BORDER_TOP, IMAGE_BORDER_RIGHT, IMAGE_BORDER_BOTTOM ) );
-
-    content.Add( image );
-
-    // Add stencil
-    ImageActor stencil = NewStencilImage();
-    stencil.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
-    image.Add( stencil );
-  }
-
-  TextView text = TextView::New( title );
-  text.SetAnchorPoint( AnchorPoint::CENTER );
-  text.SetParentOrigin( ParentOrigin::CENTER );
-  text.SetWidthExceedPolicy( Toolkit::TextView::ShrinkToFit );
-  text.SetMultilinePolicy( Toolkit::TextView::SplitByWord );
-  text.SetLineJustification( Toolkit::TextView::Center );
-  text.SetTextAlignment( Toolkit::Alignment::Type( Alignment::HorizontalCenter | Alignment::VerticalCenter ) );
-  text.SetColor( Color::WHITE );
-  text.SetZ( 1 );
-  // make the text 90% of tile
-  text.SetSize( 0.9f * parentSize.width, 0.9f * parentSize.height );
-  text.SetStyleToCurrentText( GetTableTextStyle() );
-  text.SetSnapshotModeEnabled( false );
-  content.Add( text );
+  content.SetResizePolicy( ResizePolicy::SIZE_RELATIVE_TO_PARENT, Dimension::ALL_DIMENSIONS );
+  content.SetSizeModeFactor( sizeMultiplier );
+
+  Toolkit::ImageView tileContent = ImageView::New();
+  tileContent.SetParentOrigin( ParentOrigin::CENTER );
+  tileContent.SetAnchorPoint( AnchorPoint::CENTER );
+  tileContent.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+
+  // Add the image via the property first.
+  tileContent.SetProperty( Toolkit::ImageView::Property::IMAGE, TILE_BACKGROUND_ALPHA );
+  // Register a property with the ImageView. This allows us to inject the scroll-view position into the shader.
+  Property::Value value = Vector3( 0.0f, 0.0f, 0.0f );
+  Property::Index propertyIndex = tileContent.RegisterProperty( "uCustomPosition", value );
+
+  // Add a shader to the image (details in shader source).
+  Property::Map map;
+  Property::Map customShader;
+  customShader[ Visual::Shader::Property::FRAGMENT_SHADER ] = FRAGMENT_SHADER_TEXTURED;
+  map[ Visual::Property::SHADER ] = customShader;
+  tileContent.SetProperty( Toolkit::ImageView::Property::IMAGE, map );
+  tileContent.SetColor( TILE_COLOR );
+
+  // We create a constraint to perform a precalculation on the scroll-view X offset
+  // and pass it to the shader uniform, along with the tile's position.
+  Constraint shaderPosition = Constraint::New < Vector3 > ( tileContent, propertyIndex, TileShaderPositionConstraint( mPageWidth, position.x ) );
+  shaderPosition.AddSource( Source( mScrollView, ScrollView::Property::SCROLL_POSITION ) );
+  shaderPosition.SetRemoveAction( Constraint::Discard );
+  shaderPosition.Apply();
+  content.Add( tileContent );
+
+  // Create an ImageView for the 9-patch border around the tile.
+  ImageView image = ImageView::New( TILE_BACKGROUND );
+  image.SetAnchorPoint( AnchorPoint::CENTER );
+  image.SetParentOrigin( ParentOrigin::CENTER );
+  image.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+  image.SetOpacity( 0.8f );
+  tileContent.Add( image );
+
+  TextLabel label = TextLabel::New();
+  label.SetAnchorPoint( AnchorPoint::CENTER );
+  label.SetParentOrigin( ParentOrigin::CENTER );
+  label.SetStyleName( "LauncherLabel" );
+  label.SetProperty( TextLabel::Property::MULTI_LINE, true );
+  label.SetProperty( TextLabel::Property::TEXT, title );
+  label.SetProperty( TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
+  label.SetProperty( TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
+  label.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::HEIGHT );
+
+  // Pad around the label as its size is the same as the 9-patch border. It will overlap it without padding.
+  label.SetPadding( Padding( TILE_LABEL_PADDING, TILE_LABEL_PADDING, TILE_LABEL_PADDING, TILE_LABEL_PADDING ) );
+  content.Add( label );
 
   // Set the tile to be keyboard focusable
-  tile.SetKeyboardFocusable(true);
+  content.SetKeyboardFocusable(true);
 
   // connect to the touch events
-  tile.TouchedSignal().Connect( this, &DaliTableView::OnTilePressed );
-  tile.HoveredSignal().Connect( this, &DaliTableView::OnTileHovered );
+  content.TouchSignal().Connect( this, &DaliTableView::OnTilePressed );
+  content.HoveredSignal().Connect( this, &DaliTableView::OnTileHovered );
 
-  return tile;
+  return content;
 }
 
-ImageActor DaliTableView::NewStencilImage()
+bool DaliTableView::OnTilePressed( Actor actor, const TouchData& event )
 {
-  Image alpha = Image::New( TILE_BACKGROUND_ALPHA );
-
-  ImageActor stencilActor = ImageActor::New( alpha );
-  stencilActor.SetStyle( ImageActor::STYLE_NINE_PATCH );
-  stencilActor.SetNinePatchBorder( Vector4( IMAGE_BORDER_LEFT, IMAGE_BORDER_TOP, IMAGE_BORDER_RIGHT, IMAGE_BORDER_BOTTOM ) );
-
-  stencilActor.SetParentOrigin( ParentOrigin::CENTER );
-  stencilActor.SetAnchorPoint( AnchorPoint::CENTER );
-  stencilActor.SetDrawMode( DrawMode::STENCIL );
-
-  Dali::ShaderEffect shaderEffect = AlphaDiscardEffect::New();
-  stencilActor.SetShaderEffect( shaderEffect );
-
-  return stencilActor;
+  return DoTilePress( actor, event.GetState( 0 ) );
 }
 
-bool DaliTableView::OnTilePressed( Actor actor, const TouchEvent& event )
+bool DaliTableView::DoTilePress( Actor actor, PointState::Type pointState )
 {
   bool consumed = false;
 
-  const TouchPoint& point = event.GetPoint( 0 );
-  if( TouchPoint::Down == point.state )
+  if( PointState::DOWN == pointState )
   {
     mPressedActor = actor;
     consumed = true;
@@ -587,21 +530,22 @@ bool DaliTableView::OnTilePressed( Actor actor, const TouchEvent& event )
 
   // A button press is only valid if the Down & Up events
   // both occurred within the button.
-  if( ( TouchPoint::Up == point.state ) &&
+  if( ( PointState::UP == pointState ) &&
       ( mPressedActor == actor ) )
   {
-    std::string name = actor.GetName();
-    ExampleMapConstIter iter = mExampleMap.find( name );
-
-    FocusManager focusManager = FocusManager::Get();
-
-    if( iter != mExampleMap.end() )
+    // ignore Example button presses when scrolling or button animating.
+    if( ( !mScrolling ) && ( !mPressedAnimation ) )
     {
-      // ignore Example button presses when scrolling or button animating.
-      if( ( !mScrolling ) && ( !mPressedAnimation ) )
+      std::string name = actor.GetName();
+      const ExampleListIter end = mExampleList.end();
+      for( ExampleListIter iter = mExampleList.begin(); iter != end; ++iter )
       {
-        // do nothing, until pressed animation finished.
-        consumed = true;
+        if( (*iter).name == name )
+        {
+          // do nothing, until pressed animation finished.
+          consumed = true;
+          break;
+        }
       }
     }
 
@@ -612,10 +556,14 @@ bool DaliTableView::OnTilePressed( Actor actor, const TouchEvent& event )
 
       // scale the content actor within the Tile, as to not affect the placement within the Table.
       Actor content = actor.GetChildAt(0);
-      mPressedAnimation.ScaleTo( content, Vector3( 0.9f, 0.9f, 1.0f ), AlphaFunctions::EaseInOut, 0.0f,
-                                 BUTTON_PRESS_ANIMATION_TIME * 0.5f );
-      mPressedAnimation.ScaleTo( content, Vector3::ONE, AlphaFunctions::EaseInOut, BUTTON_PRESS_ANIMATION_TIME * 0.5f,
-                                 BUTTON_PRESS_ANIMATION_TIME * 0.5f );
+      mPressedAnimation.AnimateTo( Property( content, Actor::Property::SCALE ), Vector3( 0.7f, 0.7f, 1.0f ), AlphaFunction::EASE_IN_OUT,
+                                 TimePeriod( 0.0f, BUTTON_PRESS_ANIMATION_TIME * 0.5f ) );
+      mPressedAnimation.AnimateTo( Property( content, Actor::Property::SCALE ), Vector3::ONE, AlphaFunction::EASE_IN_OUT,
+                                 TimePeriod( BUTTON_PRESS_ANIMATION_TIME * 0.5f, BUTTON_PRESS_ANIMATION_TIME * 0.5f ) );
+
+      // Rotate button on the Y axis when pressed.
+      mPressedAnimation.AnimateBy( Property( content, Actor::Property::ORIENTATION ), Quaternion( Degree( 0.0f ), Degree( 180.0f ), Degree( 0.0f ) ) );
+
       mPressedAnimation.Play();
       mPressedAnimation.FinishedSignal().Connect( this, &DaliTableView::OnPressedAnimationFinished );
     }
@@ -629,58 +577,38 @@ void DaliTableView::OnPressedAnimationFinished( Dali::Animation& source )
   if( mPressedActor )
   {
     std::string name = mPressedActor.GetName();
-    ExampleMapConstIter iter = mExampleMap.find( name );
 
-    if( iter == mExampleMap.end() )
+    std::stringstream stream;
+    stream << DEMO_EXAMPLE_BIN << name.c_str();
+    pid_t pid = fork();
+    if( pid == 0)
     {
-      if( name == BUTTON_QUIT )
-      {
-        // Move focus to the OK button
-        FocusManager focusManager = FocusManager::Get();
-
-        // Enable the group mode and wrap mode
-        focusManager.SetGroupMode( true );
-        focusManager.SetWrapMode( true );
-      }
-    }
-    else
-    {
-      const Example& example( iter->second );
-
-      std::stringstream stream;
-      stream << DALI_EXAMPLE_BIN << example.name.c_str();
-      pid_t pid = fork();
-      if( pid == 0)
-      {
-        execlp( stream.str().c_str(), example.name.c_str(), NULL );
-        DALI_ASSERT_ALWAYS(false && "exec failed!");
-      }
+      execlp( stream.str().c_str(), name.c_str(), NULL );
+      DALI_ASSERT_ALWAYS(false && "exec failed!");
     }
     mPressedActor.Reset();
   }
 }
 
-void DaliTableView::OnScrollStart( const Dali::Vector3& position )
+void DaliTableView::OnScrollStart( const Dali::Vector2& position )
 {
   mScrolling = true;
 
   PlayAnimation();
 }
 
-void DaliTableView::OnScrollComplete( const Dali::Vector3& position )
+void DaliTableView::OnScrollComplete( const Dali::Vector2& position )
 {
   mScrolling = false;
 
   // move focus to 1st item of new page
-  FocusManager focusManager = FocusManager::Get();
-  focusManager.SetCurrentFocusActor(mTableViewList[mScrollView.GetCurrentPage()].GetChildAt(TableView::CellPosition(1, 0)) );
-
+  AccessibilityManager accessibilityManager = AccessibilityManager::Get();
+  accessibilityManager.SetCurrentFocusActor(mPages[mScrollView.GetCurrentPage()].GetChildAt(0) );
 }
 
-bool DaliTableView::OnScrollTouched( Actor actor, const TouchEvent& event )
+bool DaliTableView::OnScrollTouched( Actor actor, const TouchData& event )
 {
-  const TouchPoint& point = event.GetPoint( 0 );
-  if( TouchPoint::Down == point.state )
+  if( PointState::DOWN == event.GetState( 0 ) )
   {
     mPressedActor = actor;
   }
@@ -705,38 +633,29 @@ void DaliTableView::ApplyScrollViewEffect()
 
 void DaliTableView::SetupInnerPageCubeEffect()
 {
-  ScrollViewCustomEffect customEffect;
-  mScrollViewEffect = customEffect = ScrollViewCustomEffect::New();
-  mScrollView.SetScrollSnapDuration( EFFECT_SNAP_DURATION );
-  mScrollView.SetScrollFlickDuration( EFFECT_FLICK_DURATION );
-  mScrollView.SetScrollSnapAlphaFunction( AlphaFunctions::EaseOutBack );
-  mScrollView.SetScrollFlickAlphaFunction( AlphaFunctions::EaseOutBack );
-  mScrollView.RemoveConstraintsFromChildren();
-
-  customEffect.SetPageSpacing( Vector2( 30.0f, 30.0f ) );
-  customEffect.SetAngledOriginPageRotation( ANGLE_CUBE_PAGE_ROTATE );
-  customEffect.SetSwingAngle( ANGLE_CUBE_PAGE_ROTATE.x, Vector3( 0, -1, 0 ) );
-  customEffect.SetOpacityThreshold( 0.5f );   // Make fade out on edges
-}
+  const Vector2 stageSize = Stage::GetCurrent().GetSize();
 
-void DaliTableView::ApplyEffectToPage( Actor page, const Vector3& tableRelativeSize )
-{
-  page.RemoveConstraints();
+  Dali::Path path = Dali::Path::New();
+  Dali::Property::Array points;
+  points.Resize(3);
+  points[0] = Vector3( stageSize.x*0.5, 0.0f,  stageSize.x*0.5f);
+  points[1] = Vector3( 0.0f, 0.0f, 0.0f );
+  points[2] = Vector3( -stageSize.x*0.5f, 0.0f, stageSize.x*0.5f);
+  path.SetProperty( Path::Property::POINTS, points );
 
-  Constraint constraint = Constraint::New<Vector3>( Actor::SCALE,
-                                                    LocalSource( Actor::SIZE ),
-                                                    ParentSource( Actor::SIZE ),
-                                                    ScaleToFitConstraint() );
-  page.ApplyConstraint(constraint);
+  Dali::Property::Array controlPoints;
+  controlPoints.Resize(4);
+  controlPoints[0] = Vector3( stageSize.x*0.5f, 0.0f, stageSize.x*0.3f );
+  controlPoints[1] = Vector3( stageSize.x*0.3f, 0.0f, 0.0f );
+  controlPoints[2] = Vector3(-stageSize.x*0.3f, 0.0f, 0.0f );
+  controlPoints[3] = Vector3(-stageSize.x*0.5f, 0.0f,  stageSize.x*0.3f );
+  path.SetProperty( Path::Property::CONTROL_POINTS, controlPoints );
 
-  ApplyCustomEffectToPage( page );
-}
 
-void DaliTableView::ApplyCustomEffectToPage( Actor page )
-{
-  ScrollViewCustomEffect customEffect = ScrollViewCustomEffect::DownCast( mScrollViewEffect );
-  Vector2 vStageSize( Stage::GetCurrent().GetSize() );
-  customEffect.ApplyToPage( page, Vector3( vStageSize.x, vStageSize.y, 1.0f ) );
+  mScrollViewEffect = ScrollViewPagePathEffect::New(path,
+                                                    Vector3(-1.0f,0.0f,0.0f),
+                                                    Toolkit::ScrollView::Property::SCROLL_FINAL_X,
+                                                    Vector3(stageSize.x*TABLE_RELATIVE_SIZE.x,stageSize.y*TABLE_RELATIVE_SIZE.y,0.0f),mTotalPages);
 }
 
 void DaliTableView::OnKeyEvent( const KeyEvent& event )
@@ -745,120 +664,95 @@ void DaliTableView::OnKeyEvent( const KeyEvent& event )
   {
     if ( IsKey( event, Dali::DALI_KEY_ESCAPE) || IsKey( event, Dali::DALI_KEY_BACK) )
     {
-      mApplication.Quit();
+      // If there's a Popup, Hide it if it's contributing to the display in any way (EG. transitioning in or out).
+      // Otherwise quit.
+      if ( mVersionPopup && ( mVersionPopup.GetDisplayState() != Toolkit::Popup::HIDDEN ) )
+      {
+        mVersionPopup.SetDisplayState( Popup::HIDDEN );
+      }
+      else
+      {
+        mApplication.Quit();
+      }
     }
   }
 }
 
-Actor CreateBackgroundActor( const Vector2& size )
+void DaliTableView::SetupBackground( Actor bubbleContainer )
 {
-  Actor layer = Actor::New();
-  layer.SetAnchorPoint( AnchorPoint::CENTER );
-  layer.SetParentOrigin( ParentOrigin::CENTER );
-  layer.SetSize( size );
-  return layer;
+  // Create distance field shapes.
+  BufferImage distanceFields[2];
+  Size imageSize( 512, 512 );
+
+  CreateShapeImage( CIRCLE, imageSize, distanceFields[0] );
+  CreateShapeImage( BUBBLE, imageSize, distanceFields[1] );
+
+  // Add bubbles to the bubbleContainer.
+  // Note: The bubbleContainer is parented externally to this function.
+  AddBackgroundActors( bubbleContainer, NUM_BACKGROUND_IMAGES, distanceFields );
 }
 
-void DaliTableView::SetupBackground( Actor addToLayer, const Vector2& size )
+void DaliTableView::InitialiseBackgroundActors( Actor actor )
 {
-  // Create distance field shape
-  BitmapImage distanceField;
-  Size imageSize( 512, 512 );
-  CreateShapeImage( CIRCLE, imageSize, distanceField );
+  // Delete current animations
+  mBackgroundAnimations.clear();
 
-  // Create layers
-  Actor backgroundAnimLayer0 = CreateBackgroundActor( size );
-  Actor backgroundAnimLayer1 = CreateBackgroundActor( size );
-  Actor backgroundAnimLayer2 = CreateBackgroundActor( size );
+  // Create new animations
+  const Vector3 size = actor.GetTargetSize();
 
-  // Add constraints
-  Constraint animConstraint0 = Constraint::New < Vector3 > ( Actor::POSITION,
-      Source( mScrollView, mScrollView.GetPropertyIndex( ScrollView::SCROLL_POSITION_PROPERTY_NAME ) ),
-      AnimScrollConstraint( backgroundAnimLayer0.GetCurrentPosition(), 0.75f ) );
-  backgroundAnimLayer0.ApplyConstraint( animConstraint0 );
+  for( unsigned int i = 0, childCount = actor.GetChildCount(); i < childCount; ++i )
+  {
+    Actor child = actor.GetChildAt( i );
 
-  Constraint animConstraint1 = Constraint::New < Vector3 > ( Actor::POSITION,
-      Source( mScrollView, mScrollView.GetPropertyIndex( ScrollView::SCROLL_POSITION_PROPERTY_NAME ) ),
-      AnimScrollConstraint( backgroundAnimLayer1.GetCurrentPosition(), 0.5f ) );
-  backgroundAnimLayer1.ApplyConstraint( animConstraint1 );
+    // Calculate a random position
+    Vector3 childPos( Random::Range( -size.x * 0.5f * BACKGROUND_SPREAD_SCALE, size.x * 0.85f * BACKGROUND_SPREAD_SCALE ),
+                      Random::Range( -size.y, size.y ),
+                      Random::Range( BUBBLE_MIN_Z, BUBBLE_MAX_Z ) );
 
-  Constraint animConstraint2 = Constraint::New < Vector3 > ( Actor::POSITION,
-      Source( mScrollView, mScrollView.GetPropertyIndex( ScrollView::SCROLL_POSITION_PROPERTY_NAME ) ),
-      AnimScrollConstraint( backgroundAnimLayer2.GetCurrentPosition(), 0.25f ) );
-  backgroundAnimLayer2.ApplyConstraint( animConstraint2 );
+    child.SetPosition( childPos );
 
-  // Background
-  ImageActor layer = Dali::Toolkit::CreateSolidColorActor( BACKGROUND_COLOR );
-  layer.SetAnchorPoint( AnchorPoint::CENTER );
-  layer.SetParentOrigin( ParentOrigin::CENTER );
-  layer.SetSize( size * BACKGROUND_SIZE_SCALE );
-  layer.SetZ( BACKGROUND_Z );
-  layer.SetPositionInheritanceMode( DONT_INHERIT_POSITION );
-
-  addToLayer.Add( layer );
-
-  // Parent the layers
-  addToLayer.Add( backgroundAnimLayer0 );
-  addToLayer.Add( backgroundAnimLayer1 );
-  addToLayer.Add( backgroundAnimLayer2 );
-
-  // Add all the children
-  AddBackgroundActors( backgroundAnimLayer0, NUM_BACKGROUND_IMAGES / 3, distanceField, size );
-  AddBackgroundActors( backgroundAnimLayer1, NUM_BACKGROUND_IMAGES / 3, distanceField, size );
-  AddBackgroundActors( backgroundAnimLayer2, NUM_BACKGROUND_IMAGES / 3, distanceField, size );
+    // Define bubble horizontal parallax and vertical wrapping
+    Constraint animConstraint = Constraint::New < Vector3 > ( child, Actor::Property::POSITION, AnimateBubbleConstraint( childPos, Random::Range( -0.85f, 0.25f ) ) );
+    animConstraint.AddSource( Source( mScrollView, ScrollView::Property::SCROLL_POSITION ) );
+    animConstraint.AddSource( Dali::ParentSource( Dali::Actor::Property::SIZE ) );
+    animConstraint.AddSource( Dali::LocalSource( Dali::Actor::Property::SIZE ) );
+    animConstraint.SetRemoveAction( Constraint::Discard );
+    animConstraint.Apply();
+
+    // Kickoff animation
+    Animation animation = Animation::New( Random::Range( 30.0f, 160.0f ) );
+    animation.AnimateBy( Property( child, Actor::Property::POSITION ), Vector3( 0.0f, -2000.0f, 0.0f ), AlphaFunction::LINEAR );
+    animation.SetLooping( true );
+    animation.Play();
+    mBackgroundAnimations.push_back( animation );
+  }
 }
 
-void DaliTableView::AddBackgroundActors( Actor layer, int count, BitmapImage distanceField, const Dali::Vector2& size )
+void DaliTableView::AddBackgroundActors( Actor layer, int count, BufferImage* distanceField )
 {
   for( int i = 0; i < count; ++i )
   {
     float randSize = Random::Range( 10.0f, 400.0f );
-    float hue = Random::Range( 0.3f, 1.0f );
-    Vector4 randColour( hue, hue*0.5, 0.0f, Random::Range( 0.3f, 0.6f ));
-
-    ImageActor dfActor = ImageActor::New( distanceField );
-    mBackgroundActors.push_back( dfActor );
+    int distanceFieldType = static_cast<int>( Random::Range( 0.0f, 1.0f ) + 0.5f );
+    ImageView dfActor = ImageView::New( distanceField[ distanceFieldType ] );
     dfActor.SetSize( Vector2( randSize, randSize ) );
     dfActor.SetParentOrigin( ParentOrigin::CENTER );
 
-    Toolkit::DistanceFieldEffect effect = Toolkit::DistanceFieldEffect::New();
-    dfActor.SetShaderEffect( effect );
-    dfActor.SetColor( randColour );
-    effect.SetOutlineParams( Vector2( 0.55f, 0.00f ) );
-    effect.SetSmoothingEdge( 0.5f );
-    layer.Add( dfActor );
-
-    // Setup animation
-    Vector3 actorPos(
-        Random::Range( -size.x * 0.5f * BACKGROUND_SPREAD_SCALE, size.x * 0.5f * BACKGROUND_SPREAD_SCALE ),
-        Random::Range( -size.y * 0.5f - randSize, size.y * 0.5f + randSize ),
-        Random::Range(-1.0f, 0.0f) );
-    dfActor.SetPosition( actorPos );
-
-    Constraint movementConstraint = Constraint::New < Vector3 > ( Actor::POSITION,
-        LocalSource( Actor::SIZE ),
-        ParentSource( Actor::SIZE ),
-        ShapeMovementConstraint );
-    dfActor.ApplyConstraint( movementConstraint );
+    Dali::Property::Map effect = Toolkit::CreateDistanceFieldEffect();
+    dfActor.SetProperty( Toolkit::ImageView::Property::IMAGE, effect );
+    dfActor.SetColor( BUBBLE_COLOR[ i%NUMBER_OF_BUBBLE_COLOR ] );
 
-    // Kickoff animation
-    Animation animation = Animation::New( Random::Range( 40.0f, 200.0f ) );
-    KeyFrames keyframes = KeyFrames::New();
-    keyframes.Add( 0.0f, actorPos );
-    Vector3 toPos( actorPos );
-    toPos.y -= ( size.y + randSize );
-    keyframes.Add( 1.0f, toPos );
-    animation.AnimateBetween( Property( dfActor, Actor::POSITION ), keyframes );
-    animation.SetLooping( true );
-    animation.Play();
-    mBackgroundAnimations.push_back( animation );
+    layer.Add( dfActor );
   }
+
+  // Positioning will occur when the layer is relaid out
+  layer.OnRelayoutSignal().Connect( this, &DaliTableView::InitialiseBackgroundActors );
 }
 
-void DaliTableView::CreateShapeImage( ShapeType shapeType, const Size& size, BitmapImage& distanceFieldOut )
+void DaliTableView::CreateShapeImage( ShapeType shapeType, const Size& size, BufferImage& distanceFieldOut )
 {
   // this bitmap will hold the alpha map for the distance field shader
-  distanceFieldOut = BitmapImage::New( size.width, size.height, Pixel::A8 );
+  distanceFieldOut = BufferImage::New( size.width, size.height, Pixel::A8 );
 
   // Generate bit pattern
   std::vector< unsigned char > imageDataA8;
@@ -869,8 +763,8 @@ void DaliTableView::CreateShapeImage( ShapeType shapeType, const Size& size, Bit
     case CIRCLE:
       GenerateCircle( size, imageDataA8 );
       break;
-    case SQUARE:
-      GenerateSquare( size, imageDataA8 );
+    case BUBBLE:
+      GenerateCircle( size, imageDataA8, true );
       break;
     default:
       break;
@@ -884,18 +778,7 @@ void DaliTableView::CreateShapeImage( ShapeType shapeType, const Size& size, Bit
   }
 }
 
-void DaliTableView::GenerateSquare( const Size& size, std::vector< unsigned char >& distanceFieldOut )
-{
-  for( int h = 0; h < size.height; ++h )
-  {
-    for( int w = 0; w < size.width; ++w )
-    {
-      distanceFieldOut.push_back( 0xFF );
-    }
-  }
-}
-
-void DaliTableView::GenerateCircle( const Size& size, std::vector< unsigned char >& distanceFieldOut )
+void DaliTableView::GenerateCircle( const Size& size, std::vector< unsigned char >& distanceFieldOut, bool hollow )
 {
   const float radius = size.width * 0.5f * size.width * 0.5f;
   Vector2 center( size.width / 2, size.height / 2 );
@@ -907,25 +790,22 @@ void DaliTableView::GenerateCircle( const Size& size, std::vector< unsigned char
       Vector2 pos( w, h );
       Vector2 dist = pos - center;
 
-      if( dist.x * dist.x + dist.y * dist.y > radius )
-      {
-        distanceFieldOut.push_back( 0x00 );
-      }
-      else
-      {
-        distanceFieldOut.push_back( 0xFF );
-      }
+      float distance = ( dist.x * dist.x ) + ( dist.y * dist.y );
+
+      // If hollow, check the distance against a min & max value, otherwise just use the max value.
+      unsigned char fillByte = ( hollow ? ( ( distance <= radius ) && ( distance > ( radius * 0.7f ) ) ) : ( distance <= radius ) ) ? 0xFF : 0x00;
+
+      distanceFieldOut.push_back( fillByte );
     }
   }
 }
 
-ImageActor DaliTableView::CreateLogo( std::string imagePath )
+ImageView DaliTableView::CreateLogo( std::string imagePath )
 {
-  Image image = Image::New( imagePath );
-  ImageActor logo = ImageActor::New( image );
+  ImageView logo = ImageView::New( imagePath );
 
   logo.SetAnchorPoint( AnchorPoint::CENTER );
-  logo.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
+  logo.SetParentOrigin( ParentOrigin::CENTER );
 
   return logo;
 }
@@ -945,7 +825,7 @@ void DaliTableView::PauseAnimation()
     {
       Animation anim = *animIter;
 
-      anim.Pause();
+      anim.Stop();
     }
 
     mBackgroundAnimsPlaying = false;
@@ -969,37 +849,37 @@ void DaliTableView::PlayAnimation()
   mAnimationTimer.SetInterval( BACKGROUND_ANIMATION_DURATION );
 }
 
-Dali::Actor DaliTableView::OnKeyboardPreFocusChange( Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction )
+Dali::Actor DaliTableView::OnKeyboardPreFocusChange( Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction )
 {
   Actor nextFocusActor = proposed;
 
-  if ( !current && !proposed  )
+  if( !current && !proposed  )
   {
     // Set the initial focus to the first tile in the current page should be focused.
-    nextFocusActor = mTableViewList[mScrollView.GetCurrentPage()].GetChildAt(TableView::CellPosition(0, 0));
+    nextFocusActor = mPages[mScrollView.GetCurrentPage()].GetChildAt(0);
   }
-  else if( !proposed || (proposed && proposed == mScrollViewLayer) )
+  else if( !proposed )
   {
     // ScrollView is being focused but nothing in the current page can be focused further
     // in the given direction. We should work out which page to scroll to next.
     int currentPage = mScrollView.GetCurrentPage();
     int newPage = currentPage;
-    if( direction == Dali::Toolkit::Control::Left )
+    if( direction == Dali::Toolkit::Control::KeyboardFocus::LEFT )
     {
       newPage--;
     }
-    else if( direction == Dali::Toolkit::Control::Right )
+    else if( direction == Dali::Toolkit::Control::KeyboardFocus::RIGHT )
     {
       newPage++;
     }
 
-    newPage = std::max(0, std::min(static_cast<int>(mScrollRulerX->GetTotalPages() - 1), newPage));
+    newPage = std::max(0, std::min(mTotalPages - 1, newPage));
     if( newPage == currentPage )
     {
-      if( direction == Dali::Toolkit::Control::Left )
+      if( direction == Dali::Toolkit::Control::KeyboardFocus::LEFT )
       {
-        newPage = mScrollRulerX->GetTotalPages() - 1;
-      } else if( direction == Dali::Toolkit::Control::Right )
+        newPage = mTotalPages - 1;
+      } else if( direction == Dali::Toolkit::Control::KeyboardFocus::RIGHT )
       {
         newPage = 0;
       }
@@ -1008,7 +888,7 @@ Dali::Actor DaliTableView::OnKeyboardPreFocusChange( Dali::Actor current, Dali::
     // Scroll to the page in the given direction
     mScrollView.ScrollTo(newPage);
 
-    if( direction == Dali::Toolkit::Control::Left )
+    if( direction == Dali::Toolkit::Control::KeyboardFocus::LEFT )
     {
       // Work out the cell position for the last tile
       int remainingExamples = mExampleList.size() - newPage * EXAMPLES_PER_PAGE;
@@ -1016,12 +896,12 @@ Dali::Actor DaliTableView::OnKeyboardPreFocusChange( Dali::Actor current, Dali::
       int colPos = remainingExamples >= EXAMPLES_PER_PAGE ? EXAMPLES_PER_ROW - 1 : ( remainingExamples % EXAMPLES_PER_PAGE - rowPos * EXAMPLES_PER_ROW - 1 );
 
       // Move the focus to the last tile in the new page.
-      nextFocusActor = mTableViewList[newPage].GetChildAt(TableView::CellPosition(rowPos, colPos));
+      nextFocusActor = mPages[newPage].GetChildAt(rowPos * EXAMPLES_PER_ROW + colPos);
     }
     else
     {
       // Move the focus to the first tile in the new page.
-      nextFocusActor = mTableViewList[newPage].GetChildAt(TableView::CellPosition(0, 0));
+      nextFocusActor = mPages[newPage].GetChildAt(0);
     }
   }
 
@@ -1035,9 +915,7 @@ void DaliTableView::OnFocusedActorActivated( Dali::Actor activatedActor )
     mPressedActor = activatedActor;
 
     // Activate the current focused actor;
-    TouchEvent touchEventUp;
-    touchEventUp.points.push_back( TouchPoint ( 0, TouchPoint::Up, 0.0f, 0.0f ) );
-    OnTilePressed(mPressedActor, touchEventUp);
+    DoTilePress( mPressedActor, PointState::UP );
   }
 }
 
@@ -1047,4 +925,50 @@ bool DaliTableView::OnTileHovered( Actor actor, const HoverEvent& event )
   return true;
 }
 
+void DaliTableView::OnLogoTapped( Dali::Actor actor, const Dali::TapGesture& tap )
+{
+  // Only show if currently fully hidden. If transitioning-out, the transition will not be interrupted.
+  if ( !mVersionPopup || ( mVersionPopup.GetDisplayState() == Toolkit::Popup::HIDDEN ) )
+  {
+    if ( !mVersionPopup )
+    {
+      std::ostringstream stream;
+      stream << "DALi Core: "    << CORE_MAJOR_VERSION << "." << CORE_MINOR_VERSION << "." << CORE_MICRO_VERSION << std::endl << "(" << CORE_BUILD_DATE << ")\n";
+      stream << "DALi Adaptor: " << ADAPTOR_MAJOR_VERSION << "." << ADAPTOR_MINOR_VERSION << "." << ADAPTOR_MICRO_VERSION << std::endl << "(" << ADAPTOR_BUILD_DATE << ")\n";
+      stream << "DALi Toolkit: " << TOOLKIT_MAJOR_VERSION << "." << TOOLKIT_MINOR_VERSION << "." << TOOLKIT_MICRO_VERSION << std::endl << "(" << TOOLKIT_BUILD_DATE << ")\n";
+
+      mVersionPopup = Dali::Toolkit::Popup::New();
+
+      Toolkit::TextLabel titleActor = Toolkit::TextLabel::New( "Version information" );
+      titleActor.SetName( "titleActor" );
+      titleActor.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
+
+      Toolkit::TextLabel contentActor = Toolkit::TextLabel::New( stream.str() );
+      contentActor.SetName( "contentActor" );
+      contentActor.SetProperty( Toolkit::TextLabel::Property::MULTI_LINE, true );
+      contentActor.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
+      contentActor.SetPadding( Padding( 0.0f, 0.0f, 20.0f, 0.0f ) );
 
+      mVersionPopup.SetTitle( titleActor );
+      mVersionPopup.SetContent( contentActor );
+
+      mVersionPopup.SetResizePolicy( ResizePolicy::SIZE_RELATIVE_TO_PARENT, Dimension::WIDTH );
+      mVersionPopup.SetSizeModeFactor( Vector3( 0.75f, 1.0f, 1.0f ) );
+      mVersionPopup.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::HEIGHT );
+
+      mVersionPopup.OutsideTouchedSignal().Connect( this, &DaliTableView::HideVersionPopup );
+      Stage::GetCurrent().Add( mVersionPopup );
+    }
+
+    mVersionPopup.SetDisplayState( Popup::SHOWN );
+  }
+}
+
+void DaliTableView::HideVersionPopup()
+{
+  // Only hide if currently fully shown. If transitioning-in, the transition will not be interrupted.
+  if ( mVersionPopup && ( mVersionPopup.GetDisplayState() == Toolkit::Popup::SHOWN ) )
+  {
+    mVersionPopup.SetDisplayState( Popup::HIDDEN );
+  }
+}