Reimplemented CubeTransitionEffect to use renderers and removed usage of ImageActor.

Change-Id: If242a45c76a21046feea94af5ce3bac2290b3c2c

diff --git a/automated-tests/src/dali-toolkit/utc-Dali-CubeTransitionEffect.cpp b/automated-tests/src/dali-toolkit/utc-Dali-CubeTransitionEffect.cpp
index 6e99611..e759409 100644 (file)
--- a/automated-tests/src/dali-toolkit/utc-Dali-CubeTransitionEffect.cpp
+++ b/automated-tests/src/dali-toolkit/utc-Dali-CubeTransitionEffect.cpp
@@ -23,6 +23,7 @@
 #include <dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.h>
 #include <dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.h>
 #include <dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.h>
 #include <dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.h>
 #include <dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.h>
 #include <dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.h>

+#include <dali/public-api/images/buffer-image.h>

 
 
 
 
 
 


@@ -41,9 +42,12 @@ const Vector2 PAN_POSITION1( VIEW_AREA_SIZE.x * 0.75f, VIEW_AREA_SIZE.y * 0.25f
 const Vector2 PAN_DISPLACEMENT1( -5.f, 5.f );
 const Vector2 PAN_POSITION2( VIEW_AREA_SIZE.x * 0.25f, VIEW_AREA_SIZE.y * 0.75f );
 const Vector2 PAN_DISPLACEMENT2( 5.f, 5.f );
 const Vector2 PAN_DISPLACEMENT1( -5.f, 5.f );
 const Vector2 PAN_POSITION2( VIEW_AREA_SIZE.x * 0.25f, VIEW_AREA_SIZE.y * 0.75f );
 const Vector2 PAN_DISPLACEMENT2( 5.f, 5.f );

+const Vector4 FULL_BRIGHTNESS(1.f,1.f,1.f,1.f);
+const Vector4 HALF_BRIGHTNESS(0.5f, 0.5f, 0.5f, 1.f);

 const int RENDER_FRAME_INTERVAL = 16;
 static const float FLT_EPISILON = 0.0001f;
 const int RENDER_FRAME_INTERVAL = 16;
 static const float FLT_EPISILON = 0.0001f;

-const float OFFSCREEN_RENDER_DURATION = 0.05f;
+static const float EPISILON = 0.05f;
+const float TRANSITION_BEFORE_END_DURATION = TRANSITION_DURATION - 0.05f;

 
 static bool gObjectCreatedCallBackCalled;
 static void TestCallback(BaseHandle handle)
 
 static bool gObjectCreatedCallBackCalled;
 static void TestCallback(BaseHandle handle)


@@ -73,18 +77,18 @@ void Wait(ToolkitTestApplication& application, float durationToPass)
 class TransitionCompletedCallback : public Dali::ConnectionTracker
 {
 public:
 class TransitionCompletedCallback : public Dali::ConnectionTracker
 {
 public:

-  TransitionCompletedCallback( bool& signalReceived, CubeTransitionEffect& effect, ImageActor& imageActor )
+  TransitionCompletedCallback( bool& signalReceived, CubeTransitionEffect& effect, Image& image )

   : mSignalVerified( signalReceived ),
     mCurrentEffect( effect ),
   : mSignalVerified( signalReceived ),
     mCurrentEffect( effect ),

-    mActorTransitTo( imageActor )
+    mActorTransitTo( image )

   {
   }
 
   {
   }
 

-  void Callback( CubeTransitionEffect effect, ImageActor imageActor )
+  void Callback( CubeTransitionEffect effect, Image image )

   {
     tet_infoline( "Verifying TransitionCompletedSignal" );
 
   {
     tet_infoline( "Verifying TransitionCompletedSignal" );
 

-    if( mCurrentEffect == effect && mActorTransitTo == imageActor )
+    if( mCurrentEffect == effect && mActorTransitTo == image )

     {
       mSignalVerified = true;
     }
     {
       mSignalVerified = true;
     }


@@ -97,7 +101,7 @@ public:
 
   bool&                  mSignalVerified;
   CubeTransitionEffect&  mCurrentEffect;
 
   bool&                  mSignalVerified;
   CubeTransitionEffect&  mCurrentEffect;

-  ImageActor&            mActorTransitTo;
+  Image&                 mActorTransitTo;

 };
 
 } // namespace
 };
 
 } // namespace


@@ -123,7 +127,8 @@ int UtcDaliCubeTransitionWaveEffectNew(void)
 
   DALI_TEST_CHECK( !waveEffect );
 
 
   DALI_TEST_CHECK( !waveEffect );
 

-  waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS );
+  waveEffect.SetSize( VIEW_AREA_SIZE );

 
   DALI_TEST_CHECK( waveEffect );
 
 
   DALI_TEST_CHECK( waveEffect );
 


@@ -136,7 +141,8 @@ int UtcDaliCubeTransitionWaveEffectNew(void)
   gObjectCreatedCallBackCalled = false;
   registry.ObjectCreatedSignal().Connect( &TestCallback );
   {
   gObjectCreatedCallBackCalled = false;
   registry.ObjectCreatedSignal().Connect( &TestCallback );
   {

-    CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+    CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS );
+    waveEffect.SetSize( VIEW_AREA_SIZE );

   }
   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
   END_TEST;
   }
   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
   END_TEST;


@@ -151,7 +157,8 @@ int UtcDaliCubeTransitionCrossEffectNew(void)
 
   DALI_TEST_CHECK( !crossEffect );
 
 
   DALI_TEST_CHECK( !crossEffect );
 

-  crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS );
+  crossEffect.SetSize( VIEW_AREA_SIZE );

 
   DALI_TEST_CHECK( crossEffect );
 
 
   DALI_TEST_CHECK( crossEffect );
 


@@ -164,7 +171,8 @@ int UtcDaliCubeTransitionCrossEffectNew(void)
   gObjectCreatedCallBackCalled = false;
   registry.ObjectCreatedSignal().Connect( &TestCallback );
   {
   gObjectCreatedCallBackCalled = false;
   registry.ObjectCreatedSignal().Connect( &TestCallback );
   {

-    CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+    CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS );
+    crossEffect.SetSize( VIEW_AREA_SIZE );

   }
   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
   END_TEST;
   }
   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
   END_TEST;


@@ -179,7 +187,8 @@ int UtcDaliCubeTransitionFoldEffectNew(void)
 
   DALI_TEST_CHECK( !foldEffect );
 
 
   DALI_TEST_CHECK( !foldEffect );
 

-  foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS );
+  foldEffect.SetSize( VIEW_AREA_SIZE );

 
   DALI_TEST_CHECK( foldEffect );
 
 
   DALI_TEST_CHECK( foldEffect );
 


@@ -192,7 +201,8 @@ int UtcDaliCubeTransitionFoldEffectNew(void)
   gObjectCreatedCallBackCalled = false;
   registry.ObjectCreatedSignal().Connect( &TestCallback );
   {
   gObjectCreatedCallBackCalled = false;
   registry.ObjectCreatedSignal().Connect( &TestCallback );
   {

-    CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+    CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS );
+    foldEffect.SetSize( VIEW_AREA_SIZE );

   }
   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
   END_TEST;
   }
   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
   END_TEST;


@@ -203,15 +213,18 @@ int UtcDaliCubeTransitionEffectSetGetTransitionDuration(void)
   ToolkitTestApplication application;
   tet_infoline(" UtcDaliCubeTransitionEffectSetGetTransitionDuration ");
 
   ToolkitTestApplication application;
   tet_infoline(" UtcDaliCubeTransitionEffectSetGetTransitionDuration ");
 

-  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS );

   waveEffect.SetTransitionDuration( TRANSITION_DURATION );
   waveEffect.SetTransitionDuration( TRANSITION_DURATION );

+  waveEffect.SetSize( VIEW_AREA_SIZE );

   DALI_TEST_EQUALS( TRANSITION_DURATION, waveEffect.GetTransitionDuration(), TEST_LOCATION );
 
   DALI_TEST_EQUALS( TRANSITION_DURATION, waveEffect.GetTransitionDuration(), TEST_LOCATION );
 

-  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS );

   crossEffect.SetTransitionDuration( TRANSITION_DURATION );
   crossEffect.SetTransitionDuration( TRANSITION_DURATION );

+  crossEffect.SetSize( VIEW_AREA_SIZE );

   DALI_TEST_EQUALS( TRANSITION_DURATION, crossEffect.GetTransitionDuration(), TEST_LOCATION );
 
   DALI_TEST_EQUALS( TRANSITION_DURATION, crossEffect.GetTransitionDuration(), TEST_LOCATION );
 

-  CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS );
+  foldEffect.SetSize( VIEW_AREA_SIZE );

   foldEffect.SetTransitionDuration( TRANSITION_DURATION );
   DALI_TEST_EQUALS( TRANSITION_DURATION, foldEffect.GetTransitionDuration(), TEST_LOCATION );
   END_TEST;
   foldEffect.SetTransitionDuration( TRANSITION_DURATION );
   DALI_TEST_EQUALS( TRANSITION_DURATION, foldEffect.GetTransitionDuration(), TEST_LOCATION );
   END_TEST;


@@ -222,11 +235,13 @@ int UtcDaliCubeTransitionEffectSetGetCubeDisplacement(void)
   ToolkitTestApplication application;
   tet_infoline(" UtcDaliCubeTransitionEffectSetGetTransitionDuration ");
 
   ToolkitTestApplication application;
   tet_infoline(" UtcDaliCubeTransitionEffectSetGetTransitionDuration ");
 

-  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS);
+  waveEffect.SetSize( VIEW_AREA_SIZE );

   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   DALI_TEST_EQUALS( CUBE_DISPLACEMENT, waveEffect.GetCubeDisplacement(), TEST_LOCATION );
 
   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   DALI_TEST_EQUALS( CUBE_DISPLACEMENT, waveEffect.GetCubeDisplacement(), TEST_LOCATION );
 

-  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS );
+  crossEffect.SetSize( VIEW_AREA_SIZE );

   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   DALI_TEST_EQUALS( CUBE_DISPLACEMENT, crossEffect.GetCubeDisplacement(), TEST_LOCATION );
 
   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   DALI_TEST_EQUALS( CUBE_DISPLACEMENT, crossEffect.GetCubeDisplacement(), TEST_LOCATION );
 


@@ -242,70 +257,89 @@ int UtcDaliCubeTransitionEffectGetRoot(void)
 
   unsigned int totalNum = NUM_ROWS*NUM_COLUMNS;
 
 
   unsigned int totalNum = NUM_ROWS*NUM_COLUMNS;
 

-  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
-  Actor rootActor = waveEffect.GetRoot();
+  Image image = BufferImage::New( 40, 40 ) ;
+
+  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS );
+  waveEffect.SetSize( VIEW_AREA_SIZE );
+  Stage::GetCurrent().Add( waveEffect );
+  waveEffect.SetCurrentImage( image );
+  waveEffect.SetTargetImage( image );
+
+  application.SendNotification();
+  application.Render();
+
+  waveEffect.StartTransition();
+
+  Wait( application, TRANSITION_DURATION * 0.5f );

 
   // check that we have a total of NUM_ROWS*NUM_COLUMNS cubes;
 
   // check that we have a total of NUM_ROWS*NUM_COLUMNS cubes;

-  DALI_TEST_CHECK( totalNum == rootActor.GetChildCount() );
+  Actor boxesRoot = waveEffect.GetChildAt(0);
+  DALI_TEST_CHECK( totalNum == boxesRoot.GetChildCount() );

 
   // check that every cube has two children
 
   // check that every cube has two children

-  DALI_TEST_CHECK( 2 == rootActor.GetChildAt(0).GetChildCount() );
-  DALI_TEST_CHECK( 2 == rootActor.GetChildAt(totalNum/2).GetChildCount() );
-  DALI_TEST_CHECK( 2 == rootActor.GetChildAt(totalNum-1).GetChildCount() );
+  DALI_TEST_CHECK( 2 == boxesRoot.GetChildAt(0).GetChildCount() );
+  DALI_TEST_CHECK( 2 == boxesRoot.GetChildAt(totalNum/2).GetChildCount() );
+  DALI_TEST_CHECK( 2 == boxesRoot.GetChildAt(totalNum-1).GetChildCount() );

   END_TEST;
 }
 
   END_TEST;
 }
 

-int UtcDaliCubeTransitionEffectIsTransiting(void)
+int UtcDaliCubeTransitionEffectIsTransitioning(void)

 {
   ToolkitTestApplication application;
   tet_infoline(" UtcDaliCubeTransitionEffectIsTransiting ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
 {
   ToolkitTestApplication application;
   tet_infoline(" UtcDaliCubeTransitionEffectIsTransiting ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );

-  ImageActor imageActor = CreateSolidColorImageActor(application, Color::BLUE,30,30);
+  Image image = BufferImage::New( 40, 40 ) ;

 
 

-  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
-  Actor rootActor = waveEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
+  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS );
+  waveEffect.SetSize( VIEW_AREA_SIZE );
+  Stage::GetCurrent().Add( waveEffect );

 
   waveEffect.SetTransitionDuration( TRANSITION_DURATION );
   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
 
   waveEffect.SetTransitionDuration( TRANSITION_DURATION );
   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );

-  DALI_TEST_CHECK( !waveEffect.IsTransiting() );
+  DALI_TEST_CHECK( !waveEffect.IsTransitioning() );

 
 

-  waveEffect.SetCurrentImage(imageActor);
-  waveEffect.SetTargetImage(imageActor);
+  waveEffect.SetCurrentImage( image );
+  waveEffect.SetTargetImage( image );

   //transition is started
   waveEffect.StartTransition();
   //transition is started
   waveEffect.StartTransition();

-  DALI_TEST_CHECK( waveEffect.IsTransiting() );
+  DALI_TEST_CHECK( waveEffect.IsTransitioning() );

   //transition is finished
   Wait( application, TRANSITION_DURATION );
   //transition is finished
   Wait( application, TRANSITION_DURATION );

-  DALI_TEST_CHECK( !waveEffect.IsTransiting() );
+  DALI_TEST_CHECK( !waveEffect.IsTransitioning() );
+
+  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS );
+  crossEffect.SetSize( VIEW_AREA_SIZE );
+  Stage::GetCurrent().Add( crossEffect );

 
 

-  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );

   crossEffect.SetTransitionDuration( TRANSITION_DURATION );
   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   crossEffect.SetTransitionDuration( TRANSITION_DURATION );
   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );

-  DALI_TEST_CHECK( !crossEffect.IsTransiting() );
+  DALI_TEST_CHECK( !crossEffect.IsTransitioning() );

 
 

-  crossEffect.SetCurrentImage(imageActor);
-  crossEffect.SetTargetImage(imageActor);
+  crossEffect.SetCurrentImage( image );
+  crossEffect.SetTargetImage( image );

   //transition is started
   crossEffect.StartTransition(false);
   //transition is started
   crossEffect.StartTransition(false);

-  DALI_TEST_CHECK( crossEffect.IsTransiting() );
+  DALI_TEST_CHECK( crossEffect.IsTransitioning() );

   //transition is finished
   Wait( application, TRANSITION_DURATION );
   //transition is finished
   Wait( application, TRANSITION_DURATION );

-  DALI_TEST_CHECK( !crossEffect.IsTransiting() );
+  DALI_TEST_CHECK( !crossEffect.IsTransitioning() );
+
+  CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS );
+  foldEffect.SetSize( VIEW_AREA_SIZE );
+  Stage::GetCurrent().Add( foldEffect );

 
 

-  CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );

   foldEffect.SetTransitionDuration( TRANSITION_DURATION );
   foldEffect.SetTransitionDuration( TRANSITION_DURATION );

-  DALI_TEST_CHECK( !foldEffect.IsTransiting() );
+  DALI_TEST_CHECK( !foldEffect.IsTransitioning() );

 
 

-  foldEffect.SetCurrentImage( imageActor );
-  foldEffect.SetTargetImage( imageActor );
+  foldEffect.SetCurrentImage( image );
+  foldEffect.SetTargetImage( image );

   //transition is started
   foldEffect.StartTransition(true);
   //transition is started
   foldEffect.StartTransition(true);

-  DALI_TEST_CHECK(foldEffect.IsTransiting() );
+  DALI_TEST_CHECK(foldEffect.IsTransitioning() );

   //transition is finished
   Wait( application, TRANSITION_DURATION );
   //transition is finished
   Wait( application, TRANSITION_DURATION );

-  DALI_TEST_CHECK( !foldEffect.IsTransiting() );
+  DALI_TEST_CHECK( !foldEffect.IsTransitioning() );

 
   END_TEST;
 }
 
   END_TEST;
 }


@@ -317,23 +351,35 @@ int UtcDaliCubeTransitionEffectSetCurrentImage(void)
   tet_infoline(" UtcDaliCubeTransitionEffectSetCurrentImage ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
   tet_infoline(" UtcDaliCubeTransitionEffectSetCurrentImage ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );

-  ImageActor imageActor = CreateSolidColorImageActor(application, Color::BLUE,40,40) ;
+  Image image = BufferImage::New( 40, 40 ) ;

 
 

-  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
-  waveEffect.SetCurrentImage( imageActor );
+  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS );
+  waveEffect.SetSize( VIEW_AREA_SIZE );
+  waveEffect.SetCurrentImage( image );
+
+  Stage::GetCurrent().Add( waveEffect );
+
+  application.SendNotification();
+  application.Render();
+
+  waveEffect.StartTransition();

 
   // the current image content is set to the tiles facing the camera
 
   // the current image content is set to the tiles facing the camera

-  ImageActor tile = ImageActor::DownCast( (waveEffect.GetRoot().GetChildAt(0).GetChildAt(0)));
+  Actor currentTile = waveEffect.GetChildAt(0).GetChildAt(0).GetChildAt(0);
+  Actor targetTile = waveEffect.GetChildAt(0).GetChildAt(0).GetChildAt(1);

 
   //check the pixel area set to the cube
 
   //check the pixel area set to the cube

-  ImageActor::PixelArea pixelAreaDef( 0, 0, VIEW_AREA_SIZE.x / NUM_COLUMNS, VIEW_AREA_SIZE.y / NUM_ROWS);
-  ImageActor::PixelArea pixelArea = tile.GetPixelArea();
-  DALI_TEST_CHECK ( pixelAreaDef == pixelArea );
-
-  //check the size of the off screen rendered image
-  Wait( application, OFFSCREEN_RENDER_DURATION );
-  DALI_TEST_EQUALS( tile.GetImage().GetWidth(), VIEW_AREA_SIZE.x, TEST_LOCATION  );
-  DALI_TEST_EQUALS( tile.GetImage().GetHeight(), VIEW_AREA_SIZE.y, TEST_LOCATION  );
+  Vector4 pixelAreaDef( 0.f, 0.f, 1.f / NUM_COLUMNS, 1.f / NUM_ROWS);
+
+  Property::Index textureRectIndex = currentTile.GetPropertyIndex( "uTextureRect" );
+  DALI_TEST_CHECK( textureRectIndex != Property::INVALID_INDEX );
+  Property::Value textureRectValue = currentTile.GetProperty( textureRectIndex );
+  DALI_TEST_CHECK( textureRectValue.GetType() == Property::VECTOR4 );
+  Vector4 pixelArea;
+  DALI_TEST_CHECK( textureRectValue.Get( pixelArea ) );
+
+  DALI_TEST_EQUALS( pixelAreaDef, pixelArea, FLT_EPISILON, TEST_LOCATION );
+

   END_TEST;
 }
 
   END_TEST;
 }
 


@@ -344,27 +390,37 @@ int UtcDaliCubeTransitionEffectSetTargetImage(void)
   tet_infoline(" UtcDaliCubeTransitionEffectSetTargetImage ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
   tet_infoline(" UtcDaliCubeTransitionEffectSetTargetImage ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );

- ImageActor imageActor = CreateSolidColorImageActor(application, Color::BLUE,30,30);
+  Image image = BufferImage::New( 30, 30 );
+
+  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS );
+  waveEffect.SetSize( VIEW_AREA_SIZE );
+  Stage::GetCurrent().Add( waveEffect );
+
+  waveEffect.SetCurrentImage( image );
+  waveEffect.SetTargetImage( image );
+
+  Stage::GetCurrent().Add( waveEffect );

 
 

-  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
-  Actor rootActor = waveEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
+  application.SendNotification();
+  application.Render();

 
 

-  waveEffect.SetCurrentImage( imageActor );
-  waveEffect.SetTargetImage( imageActor );
+  waveEffect.StartTransition();

 
   // the target image content is set to the tiles currently invisible to the camera
 
   // the target image content is set to the tiles currently invisible to the camera

-  ImageActor tile = ImageActor::DownCast( (rootActor.GetChildAt(0).GetChildAt(1)));
+  Actor tile = waveEffect.GetChildAt(0).GetChildAt(0).GetChildAt(1);

 
   //check the pixel area set to the cube
 
   //check the pixel area set to the cube

-  ImageActor::PixelArea pixelAreaDef( 0, 0, VIEW_AREA_SIZE.x / NUM_COLUMNS, VIEW_AREA_SIZE.y / NUM_ROWS);
-  ImageActor::PixelArea pixelArea = tile.GetPixelArea();
-  DALI_TEST_CHECK ( pixelAreaDef == pixelArea );
-
-  //check the size of the off screen rendered image
-  Wait( application, OFFSCREEN_RENDER_DURATION );
-  DALI_TEST_EQUALS( tile.GetImage().GetWidth(), VIEW_AREA_SIZE.x, TEST_LOCATION  );
-  DALI_TEST_EQUALS( tile.GetImage().GetHeight(), VIEW_AREA_SIZE.y, TEST_LOCATION  );
+  Vector4 pixelAreaDef( 0.f, 0.f, 1.f / NUM_COLUMNS, 1.f / NUM_ROWS);
+
+  Property::Index textureRectIndex = tile.GetPropertyIndex( "uTextureRect" );
+  DALI_TEST_CHECK( textureRectIndex != -1 );
+  Property::Value textureRectValue = tile.GetProperty( textureRectIndex );
+  DALI_TEST_CHECK( textureRectValue.GetType() == Property::VECTOR4 );
+  Vector4 pixelArea;
+  DALI_TEST_CHECK( textureRectValue.Get( pixelArea ) );
+
+  DALI_TEST_EQUALS( pixelAreaDef, pixelArea, FLT_EPISILON, TEST_LOCATION );
+

   END_TEST;
 }
 
   END_TEST;
 }
 


@@ -374,48 +430,50 @@ int UtcDaliCubeTransitionWaveEffectStartTransition(void)
   tet_infoline(" UtcDaliCubeTransitionWaveEffectStartTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
   tet_infoline(" UtcDaliCubeTransitionWaveEffectStartTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );

-  ImageActor imageActor = ImageActor::New(ResourceImage::New("Image.jpg"));
+  Image image = ResourceImage::New( "Image.jpg" );

 
 

-  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS );
+  waveEffect.SetSize( VIEW_AREA_SIZE );

   waveEffect.SetTransitionDuration( TRANSITION_DURATION );
   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   waveEffect.SetTransitionDuration( TRANSITION_DURATION );
   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );

-  Actor rootActor = waveEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
-  Actor cube = rootActor.GetChildAt(0);
+  waveEffect.SetCurrentImage( image );

 
 

-  waveEffect.SetCurrentImage( imageActor );
+  Stage::GetCurrent().Add( waveEffect );

 
 

-  Vector4 fullBrightness = Vector4(1.f,1.f,1.f,1.f);
-  Vector4 halfBrightness = Vector4(0.5f, 0.5f, 0.5f, 1.f);
+  application.SendNotification();
+  application.Render();

 
 

-  //check the cube rotation value and color values after different transitions
-  waveEffect.SetTargetImage( imageActor );
-  waveEffect.StartTransition(true);
-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
+  waveEffect.StartTransition( true );
+
+  Actor cube = waveEffect.GetChildAt(0).GetChildAt(0);
+
+  //check the cube rotation value and color values just before the end of different transitions
+  waveEffect.SetTargetImage( image );
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );

 
 

-  waveEffect.SetTargetImage( imageActor );
+  waveEffect.SetTargetImage( image );

   waveEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);
   waveEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);

-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_180,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );

 
 

-  waveEffect.SetTargetImage( imageActor );
+  waveEffect.SetTargetImage( image );

   waveEffect.StartTransition(false);
   waveEffect.StartTransition(false);

-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );

 
 

-  waveEffect.SetTargetImage( imageActor );
+  waveEffect.SetTargetImage( image );

   waveEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);
   waveEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);

-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );

   END_TEST;
 }
 
   END_TEST;
 }
 


@@ -425,54 +483,57 @@ int UtcDaliCubeTransitionCrossEffectStartTransition(void)
   tet_infoline(" UtcDaliCubeTransitionCrossEffectStartTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
   tet_infoline(" UtcDaliCubeTransitionCrossEffectStartTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );

-  ImageActor imageActor = ImageActor::New(ResourceImage::New("Image.jpg"));
+  Image image = ResourceImage::New( "Image.jpg" );

 
 

-  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS );
+  crossEffect.SetSize( VIEW_AREA_SIZE );

   crossEffect.SetTransitionDuration( TRANSITION_DURATION );
   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   crossEffect.SetTransitionDuration( TRANSITION_DURATION );
   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );

-  Actor rootActor = crossEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
-  crossEffect.SetCurrentImage( imageActor );
-  Actor cube0 = rootActor.GetChildAt(0);
-  Actor cube1 = rootActor.GetChildAt(1);
+  crossEffect.SetCurrentImage( image );
+  crossEffect.SetTargetImage( image );

 
 

-  Vector4 fullBrightness = Vector4(1.f,1.f,1.f,1.f);
-  Vector4 halfBrightness = Vector4(0.5f, 0.5f, 0.5f, 1.f);
+  Stage::GetCurrent().Add( crossEffect );
+
+  application.SendNotification();
+  application.Render();

 
 

-  //check the cube rotation values and color values after different transitions
-  crossEffect.SetTargetImage( imageActor );

   crossEffect.StartTransition(true);
   crossEffect.StartTransition(true);

-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );

 
 

+  Actor cube0 = crossEffect.GetChildAt(0).GetChildAt(0);
+  Actor cube1 = crossEffect.GetChildAt(0).GetChildAt(1);
+
+  //check the cube rotation value and color values just before the end of different transitions
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::XAXIS), EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );

 
 

-  crossEffect.SetTargetImage( imageActor );
+
+  crossEffect.SetTargetImage( image );

   crossEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);
   crossEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);

-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_180,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_180,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::XAXIS), EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );

 
 
 
 

-  crossEffect.SetTargetImage( imageActor );
+  crossEffect.SetTargetImage( image );

   crossEffect.StartTransition(false);
   crossEffect.StartTransition(false);

-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::XAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );

 
 

-  crossEffect.SetTargetImage( imageActor );
+  crossEffect.SetTargetImage( image );

   crossEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);
   crossEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);

-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::XAXIS), EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );

   END_TEST;
 }
 
   END_TEST;
 }
 


@@ -482,52 +543,55 @@ int UtcDaliCubeTransitionFoldEffectStartTransition(void)
   tet_infoline(" UtcDaliCubeTransitionFoldEffectStartTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
   tet_infoline(" UtcDaliCubeTransitionFoldEffectStartTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );

-  ImageActor imageActor = CreateSolidColorImageActor(application, Color::BLUE,30,30);
+  Image image = BufferImage::New( 30, 30 );

 
 

-  CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS );
+  foldEffect.SetSize( VIEW_AREA_SIZE );

   foldEffect.SetTransitionDuration( TRANSITION_DURATION );
   foldEffect.SetTransitionDuration( TRANSITION_DURATION );

-  Actor rootActor = foldEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
-  foldEffect.SetCurrentImage( imageActor );
-  Actor cube0 = rootActor.GetChildAt(0);
-  Actor cube1 = rootActor.GetChildAt(1);
+  foldEffect.SetCurrentImage( image );
+  foldEffect.SetTargetImage( image );
+
+  Stage::GetCurrent().Add( foldEffect );

 
 

-  Vector4 fullBrightness = Vector4(1.f,1.f,1.f,1.f);
-  Vector4 halfBrightness = Vector4(0.5f, 0.5f, 0.5f, 1.f);
+  application.SendNotification();
+  application.Render();

 
 

-  //check the cube rotation values and color values after different transitions
-  foldEffect.SetTargetImage( imageActor );

   foldEffect.StartTransition(true);
   foldEffect.StartTransition(true);

-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );

 
 

-  foldEffect.SetTargetImage( imageActor );
+  Actor cube0 = foldEffect.GetChildAt(0).GetChildAt(0);
+  Actor cube1 = foldEffect.GetChildAt(0).GetChildAt(1);
+
+  //check the cube rotation value and color values just before the end of different transitions
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );
+
+  foldEffect.SetTargetImage( image );

   foldEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);
   foldEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);

-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_180,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_180,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );

 
 
 
 

-  foldEffect.SetTargetImage( imageActor );
+  foldEffect.SetTargetImage( image );

   foldEffect.StartTransition(false);
   foldEffect.StartTransition(false);

-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(),fullBrightness, FLT_EPISILON, TEST_LOCATION );
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(),FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );

 
 

-  foldEffect.SetTargetImage( imageActor );
+  foldEffect.SetTargetImage( image );

   foldEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);
   foldEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);

-  Wait( application, TRANSITION_DURATION );
-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  Wait( application, TRANSITION_BEFORE_END_DURATION );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), HALF_BRIGHTNESS, EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), FULL_BRIGHTNESS, EPISILON, TEST_LOCATION );

   END_TEST;
 }
 
   END_TEST;
 }
 


@@ -537,84 +601,84 @@ int UtcDaliCubeTransitionEffectSignalTransitionCompleted(void)
   tet_infoline(" UtcDaliCubeTransitionEffectSignalTransitionCompleted ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
   tet_infoline(" UtcDaliCubeTransitionEffectSignalTransitionCompleted ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );

-  ImageActor firstImageActor = CreateSolidColorImageActor(application, Color::RED,30,30);
-  ImageActor secondImageActor = CreateSolidColorImageActor(application, Color::GREEN,20,20);
-  ImageActor thirdImageActor = CreateSolidColorImageActor(application, Color::BLUE,40,40);
+  Image firstImage = BufferImage::New( 30, 30 );
+  Image secondImage = BufferImage::New( 20, 20 );
+  Image thirdImage = BufferImage::New( 40, 40 );

 
 

-  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS );
+  waveEffect.SetSize( VIEW_AREA_SIZE );

   waveEffect.SetTransitionDuration( TRANSITION_DURATION );
   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   waveEffect.SetTransitionDuration( TRANSITION_DURATION );
   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );

-  Actor rootActor = waveEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
+  Stage::GetCurrent().Add( waveEffect );

 
 

-  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS );
+  crossEffect.SetSize( VIEW_AREA_SIZE );

   crossEffect.SetTransitionDuration( TRANSITION_DURATION );
   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   crossEffect.SetTransitionDuration( TRANSITION_DURATION );
   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );

-  rootActor = crossEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
+  Stage::GetCurrent().Add( crossEffect );

 
 

-  CubeTransitionEffect foldEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect foldEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS );
+  foldEffect.SetSize( VIEW_AREA_SIZE );

   foldEffect.SetTransitionDuration( TRANSITION_DURATION );
   foldEffect.SetTransitionDuration( TRANSITION_DURATION );

-  rootActor = foldEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
+  Stage::GetCurrent().Add( foldEffect );

 
   bool signalVerified = false;
   CubeTransitionEffect currentEffect;
 
   bool signalVerified = false;
   CubeTransitionEffect currentEffect;

-  ImageActor actorTransitTo;
+  Image actorTransitTo;

   TransitionCompletedCallback callback(signalVerified, currentEffect, actorTransitTo);
   waveEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
   crossEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
   foldEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
 
   TransitionCompletedCallback callback(signalVerified, currentEffect, actorTransitTo);
   waveEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
   crossEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
   foldEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
 

-  //check that the wave effect is used to transit to secondImageActor
+  //check that the wave effect is used to transit to secondImage

   currentEffect = waveEffect;
   currentEffect = waveEffect;

-  actorTransitTo = secondImageActor;
-  waveEffect.SetCurrentImage( firstImageActor );
-  waveEffect.SetTargetImage( secondImageActor );
+  actorTransitTo = secondImage;
+  waveEffect.SetCurrentImage( firstImage );
+  waveEffect.SetTargetImage( secondImage );

   waveEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK(callback.mSignalVerified);
   callback.Reset();
 
   waveEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK(callback.mSignalVerified);
   callback.Reset();
 

-  //check that the wave effect is used to transit to thirdImageActor
-  actorTransitTo = thirdImageActor;
-  waveEffect.SetTargetImage( thirdImageActor );
+  //check that the wave effect is used to transit to thirdImage
+  actorTransitTo = thirdImage;
+  waveEffect.SetTargetImage( thirdImage );

   waveEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK(callback.mSignalVerified);
   callback.Reset();
 
   waveEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK(callback.mSignalVerified);
   callback.Reset();
 

-  //check that the cross effect is used to transit to secondImageActor
+  //check that the cross effect is used to transit to secondImage

   currentEffect = crossEffect;
   currentEffect = crossEffect;

-  actorTransitTo = secondImageActor;
-  crossEffect.SetCurrentImage( thirdImageActor );
-  crossEffect.SetTargetImage( secondImageActor );
+  actorTransitTo = secondImage;
+  crossEffect.SetCurrentImage( thirdImage );
+  crossEffect.SetTargetImage( secondImage );

   crossEffect.StartTransition(true);
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK(callback.mSignalVerified);
   callback.Reset();
 
   crossEffect.StartTransition(true);
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK(callback.mSignalVerified);
   callback.Reset();
 

-  //check that the cross effect is used to transit to firstImageActor
-  actorTransitTo = firstImageActor;
-  crossEffect.SetTargetImage( firstImageActor );
+  //check that the cross effect is used to transit to firstImage
+  actorTransitTo = firstImage;
+  crossEffect.SetTargetImage( firstImage );

   crossEffect.StartTransition(false);
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK(callback.mSignalVerified);
   callback.Reset();
 
   crossEffect.StartTransition(false);
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK(callback.mSignalVerified);
   callback.Reset();
 

-  //check that the fold effect is used to transit to secondImageActor
+  //check that the fold effect is used to transit to secondImage

   currentEffect = foldEffect;
   currentEffect = foldEffect;

-  actorTransitTo = secondImageActor;
-  foldEffect.SetCurrentImage( firstImageActor );
-  foldEffect.SetTargetImage( secondImageActor );
+  actorTransitTo = secondImage;
+  foldEffect.SetCurrentImage( firstImage );
+  foldEffect.SetTargetImage( secondImage );

   foldEffect.StartTransition();
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK( callback.mSignalVerified );
   callback.Reset();
 
   foldEffect.StartTransition();
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK( callback.mSignalVerified );
   callback.Reset();
 

-  //check that the fold effect is used to transit to thirdImageActor
-  actorTransitTo = thirdImageActor;
-  foldEffect.SetTargetImage( thirdImageActor );
+  //check that the fold effect is used to transit to thirdImage
+  actorTransitTo = thirdImage;
+  foldEffect.SetTargetImage( thirdImage );

   foldEffect.StartTransition( false );
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK( callback.mSignalVerified );
   foldEffect.StartTransition( false );
   Wait( application, TRANSITION_DURATION );
   DALI_TEST_CHECK( callback.mSignalVerified );


@@ -627,38 +691,38 @@ int UtcDaliCubeTransitionEffectPauseResumeTransition(void)
   tet_infoline(" UtcDaliCubeTransitionEffectPauseResumeTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
   tet_infoline(" UtcDaliCubeTransitionEffectPauseResumeTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );

-  ImageActor firstImageActor = CreateSolidColorImageActor(application, Color::RED,30,30);
-  ImageActor secondImageActor = CreateSolidColorImageActor(application, Color::GREEN,20,20);
+  Image firstImage = BufferImage::New( 30, 30 );
+  Image secondImage = BufferImage::New( 20, 20 );

 
 

-  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS );
+  waveEffect.SetSize( VIEW_AREA_SIZE );

   waveEffect.SetTransitionDuration( TRANSITION_DURATION );
   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   waveEffect.SetTransitionDuration( TRANSITION_DURATION );
   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );

-  Actor rootActor = waveEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
+  Stage::GetCurrent().Add( waveEffect );

 
 

-  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS );
+  crossEffect.SetSize( VIEW_AREA_SIZE );

   crossEffect.SetTransitionDuration( TRANSITION_DURATION );
   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   crossEffect.SetTransitionDuration( TRANSITION_DURATION );
   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );

-  rootActor = crossEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
+  Stage::GetCurrent().Add( crossEffect );

 
 

-  CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS );
+  foldEffect.SetSize( VIEW_AREA_SIZE );

   foldEffect.SetTransitionDuration( TRANSITION_DURATION );
   foldEffect.SetTransitionDuration( TRANSITION_DURATION );

-  rootActor = crossEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
+  Stage::GetCurrent().Add( foldEffect );

 
   bool signalVerified = false;
   CubeTransitionEffect currentEffect;
 
   bool signalVerified = false;
   CubeTransitionEffect currentEffect;

-  ImageActor actorTransitTo;
+  Image actorTransitTo;

   TransitionCompletedCallback callback(signalVerified, currentEffect, actorTransitTo);
   waveEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
   crossEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
   foldEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
 
   currentEffect = waveEffect;
   TransitionCompletedCallback callback(signalVerified, currentEffect, actorTransitTo);
   waveEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
   crossEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
   foldEffect.TransitionCompletedSignal().Connect( &callback, &TransitionCompletedCallback::Callback );
 
   currentEffect = waveEffect;

-  actorTransitTo = secondImageActor;
-  waveEffect.SetCurrentImage( firstImageActor );
-  waveEffect.SetTargetImage( secondImageActor );
+  actorTransitTo = secondImage;
+  waveEffect.SetCurrentImage( firstImage );
+  waveEffect.SetTargetImage( secondImage );

   // start transition; transit for 0.5*duration; pause for 0.5*duration;
   // resume for 0.25*duration; pause for 0.25*duration; resume for another 0.25*duration;
   // only until now the transition finished signal can be received
   // start transition; transit for 0.5*duration; pause for 0.5*duration;
   // resume for 0.25*duration; pause for 0.25*duration; resume for another 0.25*duration;
   // only until now the transition finished signal can be received


@@ -680,9 +744,9 @@ int UtcDaliCubeTransitionEffectPauseResumeTransition(void)
   callback.Reset();
 
   currentEffect = crossEffect;
   callback.Reset();
 
   currentEffect = crossEffect;

-  actorTransitTo = firstImageActor;
-  crossEffect.SetCurrentImage( secondImageActor );
-  crossEffect.SetTargetImage( firstImageActor );
+  actorTransitTo = firstImage;
+  crossEffect.SetCurrentImage( secondImage );
+  crossEffect.SetTargetImage( firstImage );

   // start transition; transit for 0.25*duration; pause for 0.2*duration;
   // resume for 0.5*duration; pause for 0.2*duration; resume for another 0.25*duration;
   // only until now the transition finished signal can be received
   // start transition; transit for 0.25*duration; pause for 0.2*duration;
   // resume for 0.5*duration; pause for 0.2*duration; resume for another 0.25*duration;
   // only until now the transition finished signal can be received


@@ -704,9 +768,9 @@ int UtcDaliCubeTransitionEffectPauseResumeTransition(void)
   callback.Reset();
 
   currentEffect = foldEffect;
   callback.Reset();
 
   currentEffect = foldEffect;

-  actorTransitTo = secondImageActor;
-  foldEffect.SetCurrentImage( firstImageActor );
-  foldEffect.SetTargetImage( secondImageActor );
+  actorTransitTo = secondImage;
+  foldEffect.SetCurrentImage( firstImage );
+  foldEffect.SetTargetImage( secondImage );

   // start transition; transit for 0.5*duration; pause for 0.5*duration;
   // resume for 0.25*duration; pause for 0.25*duration; resume for another 0.25*duration;
   // only until now the transition finished signal can be received
   // start transition; transit for 0.5*duration; pause for 0.5*duration;
   // resume for 0.25*duration; pause for 0.25*duration; resume for another 0.25*duration;
   // only until now the transition finished signal can be received


@@ -734,60 +798,63 @@ int UtcDaliCubeTransitionWaveEffectStopTransition(void)
   tet_infoline(" UtcDaliCubeTransitionWaveEffectStopTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
   tet_infoline(" UtcDaliCubeTransitionWaveEffectStopTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );

-  ImageActor firstImageActor = CreateSolidColorImageActor(application, Color::RED,30,30);
-  ImageActor secondImageActor = CreateSolidColorImageActor(application, Color::GREEN,20,20);
+  Image firstImage = BufferImage::New( 30, 30 );
+  Image secondImage = BufferImage::New( 20, 20 );

 
 

-  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS );
+  waveEffect.SetSize( VIEW_AREA_SIZE );

   waveEffect.SetTransitionDuration( TRANSITION_DURATION );
   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   waveEffect.SetTransitionDuration( TRANSITION_DURATION );
   waveEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );

-  Actor rootActor = waveEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
-  Actor cube = rootActor.GetChildAt(0);
-  waveEffect.SetCurrentImage( firstImageActor );
+  waveEffect.SetCurrentImage( firstImage );
+  waveEffect.SetTargetImage( secondImage );

 
 

-  Vector4 fullBrightness = Vector4(1.f,1.f,1.f,1.f);
-  Vector4 halfBrightness = Vector4(0.5f, 0.5f, 0.5f, 1.f);
+  Stage::GetCurrent().Add( waveEffect );
+
+  application.SendNotification();
+  application.Render();

 
 

-  //check the cube rotation value and color values after stopping different transitions in the middle
-  waveEffect.SetTargetImage( secondImageActor );

   waveEffect.StartTransition(true);
   waveEffect.StartTransition(true);

+
+  Actor cube = waveEffect.GetChildAt(0).GetChildAt(0);
+
+  //check the cube rotation value and color values reset after stopping different transitions in the middle

   Wait( application, TRANSITION_DURATION*0.2f );
   waveEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);
   Wait( application, TRANSITION_DURATION*0.2f );
   waveEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);

-  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::ZERO), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );

 
 

-  waveEffect.SetTargetImage( firstImageActor );
+  waveEffect.SetTargetImage( firstImage );

   waveEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);
   Wait( application, TRANSITION_DURATION*0.4f );
   waveEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);
   waveEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);
   Wait( application, TRANSITION_DURATION*0.4f );
   waveEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);

-  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_180,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::ZERO), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );

 
 

-  waveEffect.SetTargetImage( secondImageActor );
+  waveEffect.SetTargetImage( secondImage );

   waveEffect.StartTransition(false);
   Wait( application, TRANSITION_DURATION*0.6f );
   waveEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);
   waveEffect.StartTransition(false);
   Wait( application, TRANSITION_DURATION*0.6f );
   waveEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);

-  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::ZERO), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );

 
 

-  waveEffect.SetTargetImage( firstImageActor );
+  waveEffect.SetTargetImage( firstImage );

   waveEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);
   Wait( application, TRANSITION_DURATION*0.8f );
   waveEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);
   waveEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);
   Wait( application, TRANSITION_DURATION*0.8f );
   waveEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);

-  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::ZERO), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );

   END_TEST;
 }
 
   END_TEST;
 }
 


@@ -797,57 +864,59 @@ int UtcDaliCubeTransitionCrossEffectStopTransition(void)
   tet_infoline(" UtcDaliCubeTransitionCrossEffectStopTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
   tet_infoline(" UtcDaliCubeTransitionCrossEffectStopTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );

-  ImageActor firstImageActor = CreateSolidColorImageActor(application, Color::RED,30,30);
-  ImageActor secondImageActor = CreateSolidColorImageActor(application, Color::GREEN,20,20);
+  Image firstImage = BufferImage::New( 30, 30 );
+  Image secondImage = BufferImage::New( 20, 20 );

 
 

-  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS );
+  crossEffect.SetSize( VIEW_AREA_SIZE );

   crossEffect.SetTransitionDuration( TRANSITION_DURATION );
   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );
   crossEffect.SetTransitionDuration( TRANSITION_DURATION );
   crossEffect.SetCubeDisplacement( CUBE_DISPLACEMENT );

-  Actor rootActor = crossEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
-  crossEffect.SetCurrentImage( firstImageActor );
-  Actor cube0 = rootActor.GetChildAt(0);
-  Actor cube1 = rootActor.GetChildAt(1);
+  crossEffect.SetCurrentImage( firstImage );
+  crossEffect.SetTargetImage( secondImage );

 
 

-  Vector4 fullBrightness = Vector4(1.f,1.f,1.f,1.f);
-  Vector4 halfBrightness = Vector4(0.5f, 0.5f, 0.5f, 1.f);
+  Stage::GetCurrent().Add( crossEffect );
+
+  application.SendNotification();
+  application.Render();

 
 

-  //check the cube rotation values and color values after stop the different transitions in the middle
-  crossEffect.SetTargetImage( secondImageActor );

   crossEffect.StartTransition(true);
   crossEffect.StartTransition(true);

+
+  Actor cube0 = crossEffect.GetChildAt(0).GetChildAt(0);
+  Actor cube1 = crossEffect.GetChildAt(0).GetChildAt(1);
+
+  //check the cube rotation values and color values reset after stop the different transitions in the middle

   Wait( application, TRANSITION_DURATION*0.2f );
   crossEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);
   Wait( application, TRANSITION_DURATION*0.2f );
   crossEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);

-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION  );
-
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::ZERO), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::ZERO), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );

 
 

-  crossEffect.SetTargetImage( firstImageActor );
+  crossEffect.SetTargetImage( firstImage );

   crossEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);
   Wait( application, TRANSITION_DURATION*0.4f );
   crossEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);
   crossEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);
   Wait( application, TRANSITION_DURATION*0.4f );
   crossEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);

-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_180,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_180,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::ZERO), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::ZERO), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );

 
 

-  crossEffect.SetTargetImage( secondImageActor );
+  crossEffect.SetTargetImage( secondImage );

   crossEffect.StartTransition(false);
   Wait( application, TRANSITION_DURATION*0.6f );
   crossEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);
   crossEffect.StartTransition(false);
   Wait( application, TRANSITION_DURATION*0.6f );
   crossEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);

-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::ZERO), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::ZERO), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );

 
 

-  crossEffect.SetTargetImage( firstImageActor );
+  crossEffect.SetTargetImage( firstImage );

   crossEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);
   Wait( application, TRANSITION_DURATION*0.8f );
   crossEffect.StopTransition();
   crossEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);
   Wait( application, TRANSITION_DURATION*0.8f );
   crossEffect.StopTransition();


@@ -855,8 +924,8 @@ int UtcDaliCubeTransitionCrossEffectStopTransition(void)
   application.Render(RENDER_FRAME_INTERVAL);
   DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
   DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION  );
   application.Render(RENDER_FRAME_INTERVAL);
   DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
   DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION  );

-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );

   END_TEST;
 }
 
   END_TEST;
 }
 


@@ -866,55 +935,59 @@ int UtcDaliCubeTransitionFoldEffectStopTransition(void)
   tet_infoline(" UtcDaliCubeTransitionFoldEffectStopTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
   tet_infoline(" UtcDaliCubeTransitionFoldEffectStopTransition ");
 
   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );

-  ImageActor firstImageActor = CreateSolidColorImageActor(application, Color::RED,30,30);
-  ImageActor secondImageActor = CreateSolidColorImageActor(application, Color::GREEN,20,20);
+  Image firstImage = BufferImage::New( 30, 30 );
+  Image secondImage = BufferImage::New( 20, 20 );

 
 

-  CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
+  CubeTransitionEffect foldEffect = CubeTransitionFoldEffect::New( NUM_ROWS, NUM_COLUMNS );
+  foldEffect.SetSize( VIEW_AREA_SIZE );

   foldEffect.SetTransitionDuration( TRANSITION_DURATION );
   foldEffect.SetTransitionDuration( TRANSITION_DURATION );

-  Actor rootActor = foldEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
-  foldEffect.SetCurrentImage( firstImageActor );
-  Actor cube0 = rootActor.GetChildAt(0);
-  Actor cube1 = rootActor.GetChildAt(1);
+  foldEffect.SetCurrentImage( firstImage );
+  foldEffect.SetTargetImage( secondImage );

 
 

-  Vector4 fullBrightness = Vector4(1.f,1.f,1.f,1.f);
-  Vector4 halfBrightness = Vector4(0.5f, 0.5f, 0.5f, 1.f);
+  Stage::GetCurrent().Add( foldEffect );
+
+  application.SendNotification();
+  application.Render();

 
 

-  //check the cube rotation values and color values after stop the different transitions in the middle
-  foldEffect.SetTargetImage( secondImageActor );

   foldEffect.StartTransition(true);
   foldEffect.StartTransition(true);

+
+  Actor cube0 = foldEffect.GetChildAt(0).GetChildAt(0);
+  Actor cube1 = foldEffect.GetChildAt(0).GetChildAt(1);
+
+  //check the cube rotation values and color values after stop the different transitions in the middle

   Wait( application, TRANSITION_DURATION*0.2f );
   foldEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);
   Wait( application, TRANSITION_DURATION*0.2f );
   foldEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);

-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );

 
 

-  foldEffect.SetTargetImage( firstImageActor );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+
+  foldEffect.SetTargetImage( firstImage );

   foldEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);
   Wait( application, TRANSITION_DURATION*0.4f );
   foldEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);
   foldEffect.StartTransition(PAN_POSITION1, PAN_DISPLACEMENT1);
   Wait( application, TRANSITION_DURATION*0.4f );
   foldEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);

-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_180,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_180,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );

 
 

-  foldEffect.SetTargetImage( secondImageActor );
+  foldEffect.SetTargetImage( secondImage );

   foldEffect.StartTransition(false);
   Wait( application, TRANSITION_DURATION*0.6f );
   foldEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);
   foldEffect.StartTransition(false);
   Wait( application, TRANSITION_DURATION*0.6f );
   foldEffect.StopTransition();
   application.SendNotification();
   application.Render(RENDER_FRAME_INTERVAL);

-  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( -Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_90,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::XAXIS), FLT_EPISILON, TEST_LOCATION  );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );

 
 

-  foldEffect.SetTargetImage( firstImageActor );
+  foldEffect.SetTargetImage( firstImage );

   foldEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);
   Wait( application, TRANSITION_DURATION*0.8f );
   foldEffect.StopTransition();
   foldEffect.StartTransition(PAN_POSITION2, PAN_DISPLACEMENT2);
   Wait( application, TRANSITION_DURATION*0.8f );
   foldEffect.StopTransition();


@@ -922,7 +995,7 @@ int UtcDaliCubeTransitionFoldEffectStopTransition(void)
   application.Render(RENDER_FRAME_INTERVAL);
   DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
   DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
   application.Render(RENDER_FRAME_INTERVAL);
   DALI_TEST_EQUALS( cube1.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );
   DALI_TEST_EQUALS( cube0.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0,  Vector3::YAXIS), FLT_EPISILON, TEST_LOCATION  );

-  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), fullBrightness, FLT_EPISILON, TEST_LOCATION );
-  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), halfBrightness, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(0).GetCurrentColor(), FULL_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( cube0.GetChildAt(1).GetCurrentColor(), HALF_BRIGHTNESS, FLT_EPISILON, TEST_LOCATION );

   END_TEST;
 }
   END_TEST;
 }

diff --git a/dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.cpp b/dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.cpp
index 9af4758..a989b72 100644 (file)
--- a/dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.cpp
+++ b/dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.cpp
@@ -27,14 +27,20 @@ namespace Dali
 namespace Toolkit
 {
 
 namespace Toolkit
 {
 

-CubeTransitionCrossEffect::CubeTransitionCrossEffect(Internal::CubeTransitionCrossEffect* impl)
-: CubeTransitionEffect(impl)
+CubeTransitionCrossEffect::CubeTransitionCrossEffect( Internal::CubeTransitionCrossEffect& implementation )
+: CubeTransitionEffect( implementation )

 {
 }
 
 {
 }
 

-CubeTransitionCrossEffect CubeTransitionCrossEffect::New(unsigned int numRows, unsigned int numColumns, Size viewAreaSize)
+CubeTransitionCrossEffect::CubeTransitionCrossEffect( Dali::Internal::CustomActor* internal )
+: CubeTransitionEffect( internal )

 {
 {

-  return Internal::CubeTransitionCrossEffect::New( numRows, numColumns, viewAreaSize );
+  VerifyCustomActorPointer< Internal::CubeTransitionCrossEffect >( internal );
+}
+
+CubeTransitionCrossEffect CubeTransitionCrossEffect::New( unsigned int numRows, unsigned int numColumns )
+{
+  return Internal::CubeTransitionCrossEffect::New( numRows, numColumns );

 }
 
 } // namespace Toolkit
 }
 
 } // namespace Toolkit

diff --git a/dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.h b/dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.h
index 9d318e9..11bcc2e 100644 (file)
--- a/dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.h
+++ b/dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.h
@@ -37,7 +37,7 @@ namespace Internal DALI_INTERNAL
 
 /**
  * SubClass of CubeTransitionEffect
 
 /**
  * SubClass of CubeTransitionEffect

- * Rotate the neighboring cubes in perpendicular directions to transite from one image to another
+ * Rotate the neighboring cubes in perpendicular directions to transition from one image to another

  */
 class DALI_IMPORT_API CubeTransitionCrossEffect : public CubeTransitionEffect
 {
  */
 class DALI_IMPORT_API CubeTransitionCrossEffect : public CubeTransitionEffect
 {


@@ -48,19 +48,24 @@ public:
    * Create an initialized CubeTransitionCrossEffect
    * @param[in] numRows How many rows of cubes
    * @param[in] numColumns How many columns of cubes
    * Create an initialized CubeTransitionCrossEffect
    * @param[in] numRows How many rows of cubes
    * @param[in] numColumns How many columns of cubes

-   * @param[in] viewAreaSize The size of view area for this transition effect

    * @return The initialized CubeTransitionCrossEffect object
    */
    * @return The initialized CubeTransitionCrossEffect object
    */

-  static CubeTransitionCrossEffect New( unsigned int numRows, unsigned int numColumns, Size viewAreaSize );
+  static CubeTransitionCrossEffect New( unsigned int numRows, unsigned int numColumns );

 
 
 public: // Not intended for developer use
 
   /**
 
 
 public: // Not intended for developer use
 
   /**

-   * This constructor is used by Dali New() methods.
-   * @param [in] impl A pointer to a newly allocated Dali resource
+   * Creates a handle using the Toolkit::Internal implementation.
+   * @param[in]  implementation  The Control implementation.

    */
    */

-  explicit DALI_INTERNAL CubeTransitionCrossEffect( Internal::CubeTransitionCrossEffect* impl );
+  DALI_INTERNAL CubeTransitionCrossEffect( Internal::CubeTransitionCrossEffect& implementation );
+
+  /**
+   * Allows the creation of this Control from an Internal::CustomActor pointer.
+   * @param[in]  internal  A pointer to the internal CustomActor.
+   */
+  DALI_INTERNAL CubeTransitionCrossEffect( Dali::Internal::CustomActor* internal );

 
 }; // class CubeTransitionCrossEffect
 
 
 }; // class CubeTransitionCrossEffect
 

diff --git a/dali-toolkit/devel-api/transition-effects/cube-transition-effect.cpp b/dali-toolkit/devel-api/transition-effects/cube-transition-effect.cpp
index 6ba444e..de78244 100644 (file)
--- a/dali-toolkit/devel-api/transition-effects/cube-transition-effect.cpp
+++ b/dali-toolkit/devel-api/transition-effects/cube-transition-effect.cpp
@@ -35,14 +35,20 @@ CubeTransitionEffect::~CubeTransitionEffect()
 {
 }
 
 {
 }
 

-CubeTransitionEffect::CubeTransitionEffect(Internal::CubeTransitionEffect* impl)
-: BaseHandle(impl)
+CubeTransitionEffect::CubeTransitionEffect( Internal::CubeTransitionEffect& implementation )
+: Control( implementation )

 {
 }
 
 {
 }
 

+CubeTransitionEffect::CubeTransitionEffect( Dali::Internal::CustomActor* internal )
+: Control( internal )
+{
+  VerifyCustomActorPointer<Internal::CubeTransitionEffect>(internal);
+}
+

 CubeTransitionEffect CubeTransitionEffect::DownCast( BaseHandle handle )
 {
 CubeTransitionEffect CubeTransitionEffect::DownCast( BaseHandle handle )
 {

-  return CubeTransitionEffect( dynamic_cast< Dali::Toolkit::Internal::CubeTransitionEffect* >( handle.GetObjectPtr() ) );
+  return Control::DownCast<CubeTransitionEffect, Internal::CubeTransitionEffect>( handle );

 }
 
 void CubeTransitionEffect::SetTransitionDuration( float duration )
 }
 
 void CubeTransitionEffect::SetTransitionDuration( float duration )


@@ -65,24 +71,19 @@ float CubeTransitionEffect::GetCubeDisplacement() const
   return GetImpl(*this).GetCubeDisplacement();
 }
 
   return GetImpl(*this).GetCubeDisplacement();
 }
 

-Actor CubeTransitionEffect::GetRoot()
-{
-  return GetImpl(*this).GetRoot();
-}
-
-bool CubeTransitionEffect::IsTransiting()
+bool CubeTransitionEffect::IsTransitioning()

 {
 {

-  return GetImpl(*this).IsTransiting();
+  return GetImpl(*this).IsTransitioning();

 }
 
 }
 

-void CubeTransitionEffect::SetCurrentImage(ImageActor imageActor)
+void CubeTransitionEffect::SetCurrentImage( Image image )

 {
 {

-  GetImpl(*this).SetCurrentImage( imageActor );
+  GetImpl(*this).SetCurrentImage( image );

 }
 
 }
 

-void CubeTransitionEffect::SetTargetImage(ImageActor imageActor)
+void CubeTransitionEffect::SetTargetImage( Image image )

 {
 {

-  GetImpl(*this).SetTargetImage( imageActor );
+  GetImpl(*this).SetTargetImage( image );

 }
 
 void CubeTransitionEffect::StartTransition( bool toNextImage )
 }
 
 void CubeTransitionEffect::StartTransition( bool toNextImage )

diff --git a/dali-toolkit/devel-api/transition-effects/cube-transition-effect.h b/dali-toolkit/devel-api/transition-effects/cube-transition-effect.h
index 5afab34..7b915a6 100644 (file)
--- a/dali-toolkit/devel-api/transition-effects/cube-transition-effect.h
+++ b/dali-toolkit/devel-api/transition-effects/cube-transition-effect.h
@@ -18,9 +18,8 @@
  *
  */
 
  *
  */
 

-// EXTERNAL INCLUDES
-#include <dali/public-api/actors/actor.h>
-#include <dali/public-api/actors/image-actor.h>
+// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/control.h>

 
 namespace Dali
 {
 
 namespace Dali
 {


@@ -39,7 +38,7 @@ class CubeTransitionEffect;
 } // namespace Internal
 
 /**
 } // namespace Internal
 
 /**

- * CubeTransitionEffect is a base class of custom transition effect on Image actors
+ * CubeTransitionEffect is a base class of custom transition effect on Images

  * The two images are partitioned into tiles and serves as two perpendicular faces of cubes
  * By rotating these cubes to transit from one image to another
  *
  * The two images are partitioned into tiles and serves as two perpendicular faces of cubes
  * By rotating these cubes to transit from one image to another
  *


@@ -49,7 +48,7 @@ class CubeTransitionEffect;
  *
  * //create a new CubeTransitionEffect
  * //use the New funtion of subclass ( CubeTransitionWaveEffect or CubeTransitionCrossEffect )
  *
  * //create a new CubeTransitionEffect
  * //use the New funtion of subclass ( CubeTransitionWaveEffect or CubeTransitionCrossEffect )

- * CubeTransitionEffect cubeEffect = CubeTransitionWaveEffect::New(numRows, numColumns, viewAreaSize);
+ * CubeTransitionEffect cubeEffect = CubeTransitionWaveEffect::New(numRows, numColumns);

  *
  * //set the duration of transition animation
  * cubeEffect.SetTransitionDuration( animationDuration );
  *
  * //set the duration of transition animation
  * cubeEffect.SetTransitionDuration( animationDuration );


@@ -58,14 +57,14 @@ class CubeTransitionEffect;
  * cubeEffect.SetCubeDisplacement( cubeDisplacement  );
  *
  * // Add to stage
  * cubeEffect.SetCubeDisplacement( cubeDisplacement  );
  *
  * // Add to stage

- * stage.Add( cubeEffect.GetRoot() );
+ * stage.Add( cubeEffect );

  *
  * // Set the current image,
  *
  * // Set the current image,

- * // only need to set at beginning or when the current image was transited to with no effect or other effect
- * cubeEffect.SetCurrentImage( firstImageActor );
+ * // only need to set at beginning or when the current image was transitioned to with no effect or other effect
+ * cubeEffect.SetCurrentImage( firstImage );

  *
  * // Set target image, paired with startTransition. These two steps would be repeated as needed
  *
  * // Set target image, paired with startTransition. These two steps would be repeated as needed

- * cubeEffect.SetTargetimage( secondImageActor );
+ * cubeEffect.SetTargetimage( secondImage );

  * // Activate the effect
  * //   no param / param ture: default horizontally left panGesture
  * //   or param false:  default horizontally right panGesture
  * // Activate the effect
  * //   no param / param ture: default horizontally left panGesture
  * //   or param false:  default horizontally right panGesture


@@ -79,7 +78,7 @@ class CubeTransitionEffect;
  * |----------------------|----------------------------------|
  * | transition-completed | @ref TransitionCompletedSignal() |
  */
  * |----------------------|----------------------------------|
  * | transition-completed | @ref TransitionCompletedSignal() |
  */

-class DALI_IMPORT_API CubeTransitionEffect : public BaseHandle
+class DALI_IMPORT_API CubeTransitionEffect : public Control

 {
 public:
 
 {
 public:
 


@@ -124,40 +123,34 @@ public:
   void SetCubeDisplacement( float displacement );
 
   /**
   void SetCubeDisplacement( float displacement );
 
   /**

-   * Getet the displacement of bouncing animation during cube's rotation
+   * Get the displacement of bouncing animation during cube's rotation

    * @return displacement The displacement of bouncing animation
    */
   float GetCubeDisplacement() const;
 
   /**
    * @return displacement The displacement of bouncing animation
    */
   float GetCubeDisplacement() const;
 
   /**

-   * Return the transition effect root actor, should then be added to stage
-   * @return The transition effect root actor
-   */
-  Actor GetRoot();
-
-  /**

    * Return the transition status
    * @return True if the transition is under processing; false if finished
    */
    * Return the transition status
    * @return True if the transition is under processing; false if finished
    */

-  bool IsTransiting();
+  bool IsTransitioning();

 
   /**
 
   /**

-   * Set the current image to transite from
-   * if using this same effect continuely, only need to set once
-   * @param[in] imageActor The current imageActor
+   * Set the current image to transition from
+   * if using this same effect continually, only need to set once
+   * @param[in] image The current image

    */
    */

-  void SetCurrentImage(ImageActor imageActor);
+  void SetCurrentImage(Image image);

 
   /**
    * Set the target image to transit to
 
   /**
    * Set the target image to transit to

-   * @param[in] imageActor The new imageActor showing on stage
+   * @param[in] image The new Image showing on stage

    */
    */

-  void SetTargetImage(ImageActor imageActor);
+  void SetTargetImage(Image image);

 
   /**
    * Activate the transition animation with horizontally left/right panGesture
    * @pre target image is set
 
   /**
    * Activate the transition animation with horizontally left/right panGesture
    * @pre target image is set

-   * @param[in] toNextImage Horizontally left panGesture if ture, horizontally right if false
+   * @param[in] toNextImage Horizontally left panGesture if true, horizontally right if false

    */
   void StartTransition( bool toNextImage = true );
 
    */
   void StartTransition( bool toNextImage = true );
 


@@ -183,7 +176,7 @@ public:
 
   /**
    * Inactivate the transition animation if it is running.
 
   /**
    * Inactivate the transition animation if it is running.

-   * Also set the rotation and position of cubes, colors of tile to the same as the final state when the animation if finished completely
+   * Also set the rotation and position of cubes, colors of tile to the same as the start state when the animation if finished completely

    * It does nothing if the animation is not running.
    */
   void StopTransition();
    * It does nothing if the animation is not running.
    */
   void StopTransition();


@@ -191,7 +184,7 @@ public:
 public: //Signal
 
   //Transition animation completed signal
 public: //Signal
 
   //Transition animation completed signal

-  typedef Signal< void ( CubeTransitionEffect, ImageActor ) > TransitionCompletedSignalType;
+  typedef Signal< void ( CubeTransitionEffect, Image ) > TransitionCompletedSignalType;

 
   /**
    * Signal emitted when the transition has completed animation
 
   /**
    * Signal emitted when the transition has completed animation


@@ -205,7 +198,19 @@ public: //Signal
 
 public: // Not intended for developer use
 
 
 public: // Not intended for developer use
 

-  explicit DALI_INTERNAL CubeTransitionEffect( Internal::CubeTransitionEffect* impl );
+  /**
+   * @brief Creates a handle using the Toolkit::Internal implementation.
+   *
+   * @param[in]  implementation  The Control implementation.
+   */
+  DALI_INTERNAL CubeTransitionEffect( Internal::CubeTransitionEffect& implementation );
+
+  /**
+   * @brief Allows the creation of this Control from an Internal::CustomActor pointer.
+   *
+   * @param[in]  internal  A pointer to the internal CustomActor.
+   */
+  DALI_INTERNAL CubeTransitionEffect( Dali::Internal::CustomActor* internal );

 
 }; //class CubeTransitionEffect
 
 
 }; //class CubeTransitionEffect
 

diff --git a/dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.cpp b/dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.cpp
index 633d01b..7d47057 100644 (file)
--- a/dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.cpp
+++ b/dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.cpp
@@ -27,14 +27,20 @@ namespace Dali
 namespace Toolkit
 {
 
 namespace Toolkit
 {
 

-CubeTransitionFoldEffect::CubeTransitionFoldEffect(Internal::CubeTransitionFoldEffect* impl)
-: CubeTransitionEffect(impl)
+CubeTransitionFoldEffect::CubeTransitionFoldEffect( Internal::CubeTransitionFoldEffect& implementation )
+: CubeTransitionEffect( implementation )

 {
 }
 
 {
 }
 

-CubeTransitionFoldEffect CubeTransitionFoldEffect::New(unsigned int numRows, unsigned int numColumns, Size viewAreaSize)
+CubeTransitionFoldEffect::CubeTransitionFoldEffect( Dali::Internal::CustomActor* internal )
+: CubeTransitionEffect( internal )

 {
 {

-  return Internal::CubeTransitionFoldEffect::New( numRows, numColumns, viewAreaSize );
+  VerifyCustomActorPointer< Internal::CubeTransitionFoldEffect >( internal );
+}
+
+CubeTransitionFoldEffect CubeTransitionFoldEffect::New(unsigned int numRows, unsigned int numColumns )
+{
+  return Internal::CubeTransitionFoldEffect::New( numRows, numColumns );

 }
 
 } // namespace Toolkit
 }
 
 } // namespace Toolkit

diff --git a/dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.h b/dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.h
index 789a30e..0543d27 100644 (file)
--- a/dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.h
+++ b/dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.h
@@ -37,7 +37,7 @@ namespace Internal DALI_INTERNAL
 
 /**
  * SubClass of CubeTransitionEffect
 
 /**
  * SubClass of CubeTransitionEffect

- * Rotate the neighboring cubes in opposite directions to transite from one image to another
+ * Rotate the neighboring cubes in opposite directions to transition from one image to another

  */
 class DALI_IMPORT_API CubeTransitionFoldEffect : public CubeTransitionEffect
 {
  */
 class DALI_IMPORT_API CubeTransitionFoldEffect : public CubeTransitionEffect
 {


@@ -48,19 +48,24 @@ public:
    * Create an initialized CubeTransitionFoldEffect
    * @param[in] numRows How many rows of cubes
    * @param[in] numColumns How many columns of cubes
    * Create an initialized CubeTransitionFoldEffect
    * @param[in] numRows How many rows of cubes
    * @param[in] numColumns How many columns of cubes

-   * @param[in] viewAreaSize The size of view area for this transition effect

    * @return The initialized CubeTransitionFoldEffect object
    */
    * @return The initialized CubeTransitionFoldEffect object
    */

-  static CubeTransitionFoldEffect New( unsigned int numRows, unsigned int numColumns, Size viewAreaSize );
+  static CubeTransitionFoldEffect New( unsigned int numRows, unsigned int numColumns );

 
 
 public: // Not intended for developer use
 
   /**
 
 
 public: // Not intended for developer use
 
   /**

-   * This constructor is used by Dali New() methods.
-   * @param [in] impl A pointer to a newly allocated Dali resource
+   * Creates a handle using the Toolkit::Internal implementation.
+   * @param[in]  implementation  The Control implementation.

    */
    */

-  explicit DALI_INTERNAL CubeTransitionFoldEffect( Internal::CubeTransitionFoldEffect* impl );
+  DALI_INTERNAL CubeTransitionFoldEffect( Internal::CubeTransitionFoldEffect& implementation );
+
+  /**
+   * Allows the creation of this Control from an Internal::CustomActor pointer.
+   * @param[in]  internal  A pointer to the internal CustomActor.
+   */
+  DALI_INTERNAL CubeTransitionFoldEffect( Dali::Internal::CustomActor* internal );

 
 }; // class CubeTransitionFoldEffect
 
 
 }; // class CubeTransitionFoldEffect
 

diff --git a/dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.cpp b/dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.cpp
index 33d292c..66315ad 100644 (file)
--- a/dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.cpp
+++ b/dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.cpp
@@ -27,14 +27,20 @@ namespace Dali
 namespace Toolkit
 {
 
 namespace Toolkit
 {
 

-CubeTransitionWaveEffect::CubeTransitionWaveEffect(Internal::CubeTransitionWaveEffect* impl)
-: CubeTransitionEffect(impl)
+CubeTransitionWaveEffect::CubeTransitionWaveEffect( Internal::CubeTransitionWaveEffect& implementation )
+: CubeTransitionEffect( implementation )

 {
 }
 
 {
 }
 

-CubeTransitionWaveEffect CubeTransitionWaveEffect::New(unsigned int numRows, unsigned int numColumns, Size viewAreaSize)
+CubeTransitionWaveEffect::CubeTransitionWaveEffect( Dali::Internal::CustomActor* internal )
+: CubeTransitionEffect( internal )

 {
 {

-  return Internal::CubeTransitionWaveEffect::New( numRows, numColumns, viewAreaSize );
+  VerifyCustomActorPointer< Internal::CubeTransitionWaveEffect >( internal );
+}
+
+CubeTransitionWaveEffect CubeTransitionWaveEffect::New(unsigned int numRows, unsigned int numColumns )
+{
+  return Internal::CubeTransitionWaveEffect::New( numRows, numColumns );

 }
 
 } // namespace Toolkit
 }
 
 } // namespace Toolkit

diff --git a/dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.h b/dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.h
index a3b1dc1..b8a5c4f 100644 (file)
--- a/dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.h
+++ b/dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.h
@@ -48,19 +48,24 @@ public:
    * Create an initialized CubeTransitionWaveEffect
    * @param[in] numRows How many rows of cubes
    * @param[in] numColumns How many columns of cubes
    * Create an initialized CubeTransitionWaveEffect
    * @param[in] numRows How many rows of cubes
    * @param[in] numColumns How many columns of cubes

-   * @param[in] viewAreaSize The size of view area for this transition effect

    * @return The initialized CubeTransitionWaveEffect object
    */
    * @return The initialized CubeTransitionWaveEffect object
    */

-  static CubeTransitionWaveEffect New( unsigned int numRows, unsigned int numColumns, Size viewAreaSize );
+  static CubeTransitionWaveEffect New( unsigned int numRows, unsigned int numColumns );

 
 
 public: // Not intended for developer use
 
   /**
 
 
 public: // Not intended for developer use
 
   /**

-   * This constructor is used by Dali New() methods.
-   * @param[in] impl A pointer to a newly allocated Dali resource
+   * Creates a handle using the Toolkit::Internal implementation.
+   * @param[in]  implementation  The Control implementation.

    */
    */

-  explicit DALI_INTERNAL CubeTransitionWaveEffect( Internal::CubeTransitionWaveEffect* impl );
+  DALI_INTERNAL CubeTransitionWaveEffect( Internal::CubeTransitionWaveEffect& implementation );
+
+  /**
+   * Allows the creation of this Control from an Internal::CustomActor pointer.
+   * @param[in]  internal  A pointer to the internal CustomActor.
+   */
+  DALI_INTERNAL CubeTransitionWaveEffect( Dali::Internal::CustomActor* internal );

 
 }; // class CubeTransitionWaveEffect
 
 
 }; // class CubeTransitionWaveEffect
 

diff --git a/dali-toolkit/internal/transition-effects/cube-transition-cross-effect-impl.cpp b/dali-toolkit/internal/transition-effects/cube-transition-cross-effect-impl.cpp
index 6196d91..10ffbff 100644 (file)
--- a/dali-toolkit/internal/transition-effects/cube-transition-cross-effect-impl.cpp
+++ b/dali-toolkit/internal/transition-effects/cube-transition-cross-effect-impl.cpp
@@ -27,19 +27,19 @@ namespace Toolkit
 namespace Internal
 {
 
 namespace Internal
 {
 

-CubeTransitionCrossEffect::CubeTransitionCrossEffect( unsigned int numRows, unsigned int numColumns, Size viewAreaSize )
-: CubeTransitionEffect( numRows, numColumns, viewAreaSize),
-  mDisplacementRatio( 1.f )
+CubeTransitionCrossEffect::CubeTransitionCrossEffect( unsigned int numRows, unsigned int numColumns )
+: CubeTransitionEffect( numRows, numColumns ),
+  mDisplacementSpreadFactor( 0.008f )

 {
 }
 
 {
 }
 

-Toolkit::CubeTransitionCrossEffect CubeTransitionCrossEffect::New(unsigned int numRows, unsigned int numColumns, Size viewAreaSize)
+Toolkit::CubeTransitionCrossEffect CubeTransitionCrossEffect::New(unsigned int numRows, unsigned int numColumns )

 {
   // Create the implementation
 {
   // Create the implementation

-  CubeTransitionCrossEffect* internalCubeTransEffect = new CubeTransitionCrossEffect( numRows, numColumns, viewAreaSize );
+  IntrusivePtr< CubeTransitionCrossEffect > internalCubeTransEffect = new CubeTransitionCrossEffect( numRows, numColumns );

 
   // Pass ownership to CustomActor handle
 
   // Pass ownership to CustomActor handle

-  Toolkit::CubeTransitionCrossEffect cubeTransEffect( internalCubeTransEffect );
+  Toolkit::CubeTransitionCrossEffect cubeTransEffect( *internalCubeTransEffect );

 
   //Initialization
   internalCubeTransEffect->Initialize();
 
   //Initialization
   internalCubeTransEffect->Initialize();


@@ -49,89 +49,107 @@ Toolkit::CubeTransitionCrossEffect CubeTransitionCrossEffect::New(unsigned int n
 
 void CubeTransitionCrossEffect::OnInitialize()
 {
 
 void CubeTransitionCrossEffect::OnInitialize()
 {

-  float offsetX = -mTileSize.width*0.5f;
-  float offsetY = -mTileSize.height*0.5f;

   unsigned int idx;
   unsigned int idx;

-  for( unsigned int y = 0; y < mNumRows; y++ )
+  for( unsigned int y = 0; y < mRows; y++ )

   {
   {

-    idx = y*mNumColumns;
-    for( unsigned int x = y%2; x < mNumColumns; x=x+2)
+    for( unsigned int x = y % 2; x < mColumns; x += 2 )

     {
     {

-      mBoxes[idx+x].SetZ( offsetY );
-      mTiles[0][idx+x].SetZ( -offsetY );
-      mTiles[1][idx+x].SetY( offsetY );
+      idx = y * mColumns + x;
+      SetTargetTop( idx );

     }
     }

-    for( unsigned int x = (y+1)%2; x < mNumColumns; x=x+2)
+    for( unsigned int x = ( y + 1 ) % 2; x < mColumns; x += 2 )

     {
     {

-      mTiles[0][idx+x].SetZ( -offsetX );
-      mTiles[1][idx+x].SetX( offsetX );
+      idx = y * mColumns + x;
+      SetTargetRight( idx );

     }
   }
 }
 
 void CubeTransitionCrossEffect::OnStartTransition( Vector2 panPosition, Vector2 panDisplacement )
 {
     }
   }
 }
 
 void CubeTransitionCrossEffect::OnStartTransition( Vector2 panPosition, Vector2 panDisplacement )
 {

-  float angle = mRotateIndex * Math::PI_2 ;
-  Vector3 translation0 = mTiles[mContainerIndex][ 0 ].GetCurrentPosition()*(-2.f);
-  Vector3 translation1 = mTiles[mContainerIndex][ mNumColumns ].GetCurrentPosition()*(-2.f);
-
+  float angle = Math::PI_2;

   unsigned int idx;
   unsigned int idx;

-  mDisplacementRatio = 1.f + mCubeDisplacement / (mTileSize.width + mTileSize.height);

 
 

-  for( unsigned int y = 0; y < mNumRows; y++ )
+  if( panDisplacement.x < 0 )

   {
   {

-    for( unsigned int x = y%2; x < mNumColumns; x=x+2) // rotate vertically
+    for( unsigned int y = 0; y < mRows; y++ )

     {
     {

-      idx = y*mNumColumns + x;
-      SetupAnimation( idx, -angle, Vector3::XAXIS, translation0 );
+      for( unsigned int x = y % 2; x < mColumns; x += 2 )
+      {
+        idx = y * mColumns + x;
+        SetTargetTop( idx );
+      }
+      for( unsigned int x = ( y + 1 ) % 2; x < mColumns; x += 2 )
+      {
+        idx = y * mColumns + x;
+        SetTargetRight( idx );
+      }

     }
     }

-    for( unsigned int x = (y+1)%2; x < mNumColumns; x=x+2) // rotate horizontally
+  }
+  else
+  {
+    angle = -angle;
+
+    for( unsigned int y = 0; y < mRows; y++ )

     {
     {

-      idx = y*mNumColumns + x;
-      SetupAnimation( idx, angle, Vector3::YAXIS, translation1 );
+      for( unsigned int x = y % 2; x < mColumns; x += 2 )
+      {
+        idx = y * mColumns + x;
+        SetTargetBottom( idx );
+      }
+      for( unsigned int x = ( y + 1 ) % 2; x < mColumns; x += 2 )
+      {
+        idx = y * mColumns + x;
+        SetTargetLeft( idx );
+      }

     }
   }
 
     }
   }
 

-  mAnimation.Play();
-  mIsAnimating = true;
-}
+  const Vector2& size = Self().GetCurrentSize().GetVectorXY();
+  Vector2 halfSize = size * 0.5f;
+  //the centre to "explode" the tiles outwards from
+  Vector3 centre( halfSize.x, halfSize.y, -1.0f / mDisplacementSpreadFactor );

 
 

-void CubeTransitionCrossEffect::OnStopTransition()
-{
-  float angle = mRotateIndex * Math::PI_2 ;
-  unsigned int idx;
-  for( unsigned int y = 0; y < mNumRows; y++ )
+  for( unsigned int y = 0; y < mRows; y++ )

   {
   {

-    for( unsigned int x = y%2; x < mNumColumns; x=x+2)
+    for( unsigned int x = y%2; x < mColumns; x=x+2) // rotate vertically

     {
     {

-      idx = y*mNumColumns + x;
-      mBoxes[idx].SetOrientation( Radian(angle), Vector3::XAXIS );
+      idx = y*mColumns + x;
+      SetupAnimation( idx, x, y, -angle, Vector3::XAXIS, centre );

     }
     }

-    for( unsigned int x = (y+1)%2; x < mNumColumns; x=x+2)
+    for( unsigned int x = (y+1)%2; x < mColumns; x=x+2) // rotate horizontally

     {
     {

-      idx = y*mNumColumns + x;
-      mBoxes[idx].SetOrientation( Radian(-angle), Vector3::YAXIS );
+      idx = y*mColumns + x;
+      SetupAnimation( idx, x, y, angle, Vector3::YAXIS, centre );

     }
   }
     }
   }

+
+  mAnimation.Play();
+  mIsAnimating = true;

 }
 
 }
 

-void CubeTransitionCrossEffect::SetupAnimation(unsigned int actorIndex, float angle,
-                                               const Vector3 axis, Vector3 resetTranslation)
+void CubeTransitionCrossEffect::SetupAnimation( unsigned int actorIndex, unsigned int x, unsigned int y, float angle, const Vector3 axis, const Vector3& displacementCentre )

 {
 {

-  if ( mFirstTransition && (!mIsToNextImage) ) // for the first transition and it is going to previous image
-  {
-    mTiles[mContainerIndex][actorIndex].SetOrientation( Radian( angle),  axis );
-  }
-  else if( !mChangeTurningDirection )   // reset rotation, translation and color
-  {
-    mTiles[mContainerIndex][actorIndex].TranslateBy( resetTranslation );
-    mTiles[mContainerIndex][actorIndex].SetOrientation( Radian( angle),  axis );
-  }
-  mAnimation.AnimateTo( Property( mBoxes[actorIndex], Actor::Property::ORIENTATION ), Quaternion( Radian( -angle ), axis ), AlphaFunction::EASE_IN_OUT_SINE );
-  Vector3 position(mBoxes[actorIndex].GetCurrentPosition());
-  mAnimation.AnimateTo( Property( mBoxes[actorIndex], Actor::Property::POSITION ), position * mDisplacementRatio + Vector3( 0.f, 0.f, mCubeDisplacement ), AlphaFunction::BOUNCE );
-  mAnimation.AnimateTo( Property( mTiles[mContainerIndex^1][actorIndex], Actor::Property::COLOR ), HALF_BRIGHTNESS, AlphaFunction::EASE_OUT );
-  mAnimation.AnimateTo( Property( mTiles[mContainerIndex][actorIndex], Actor::Property::COLOR ), FULL_BRIGHTNESS, AlphaFunction::EASE_IN );
+  const Vector2& size = Self().GetCurrentSize().GetVectorXY();
+  Vector2 halfSize = size * 0.5f;
+
+  //the position of the centre of the front face tile
+  Vector3 position( halfSize.x * (2.0f * x + 1.0f) / mColumns, halfSize.y * (2.0f * y + 1.0f ) / mRows, 0.0f );
+
+  Vector3 direction = position - displacementCentre;
+  float length = direction.Length();
+  direction.Normalize();
+
+  float deltaLength = mCubeDisplacement / direction.z; //the length along the direction vector such that the projected direction onto the z axis is equal to mCubeDisplacement
+
+  Vector3 newPosition = ( direction * (length + deltaLength ) ) + displacementCentre;
+  Vector3 newLocalPosition = newPosition - position;
+
+  mAnimation.AnimateTo( Property( mBoxes[ actorIndex ], Actor::Property::ORIENTATION ), Quaternion( Radian( -angle ), axis ), AlphaFunction::EASE_IN_OUT_SINE );
+  mAnimation.AnimateTo( Property( mBoxes[ actorIndex ], Actor::Property::POSITION ), newLocalPosition, AlphaFunction::BOUNCE );
+
+  mAnimation.AnimateTo( Property( mCurrentTiles[ actorIndex ], Actor::Property::COLOR ), HALF_BRIGHTNESS, AlphaFunction::EASE_OUT );
+  mAnimation.AnimateTo( Property( mTargetTiles[ actorIndex ], Actor::Property::COLOR ), FULL_BRIGHTNESS, AlphaFunction::EASE_IN );

 }
 
 } // namespace Internal
 }
 
 } // namespace Internal

diff --git a/dali-toolkit/internal/transition-effects/cube-transition-cross-effect-impl.h b/dali-toolkit/internal/transition-effects/cube-transition-cross-effect-impl.h
index d1416e4..8f6fda9 100644 (file)
--- a/dali-toolkit/internal/transition-effects/cube-transition-cross-effect-impl.h
+++ b/dali-toolkit/internal/transition-effects/cube-transition-cross-effect-impl.h
@@ -45,7 +45,7 @@ public:
   /**
    * @copydoc Toolkit::CubeTransitionCrossEffect::New
    */
   /**
    * @copydoc Toolkit::CubeTransitionCrossEffect::New
    */

-  static Toolkit::CubeTransitionCrossEffect New(unsigned int numRows, unsigned int numColumns, Size viewAreaSize);
+  static Toolkit::CubeTransitionCrossEffect New( unsigned int numRows, unsigned int numColumns );

 
 protected:
 
 
 protected:
 


@@ -59,34 +59,36 @@ protected:
     */
    virtual void OnStartTransition( Vector2 panPosition, Vector2 panDisplacement );
 
     */
    virtual void OnStartTransition( Vector2 panPosition, Vector2 panDisplacement );
 

-   /**
-    * @copydoc Toolkit::Internal::CubeTransitionEffect::OnStopTransition
-    */
-   virtual void OnStopTransition();
-

 private:
 
    /**
 private:
 
    /**

-    * Construct a new CubeTransitionCrossEffect object
+    * @brief Construct a new CubeTransitionCrossEffect object
+    *

     * @param[in] numRows How many rows of cubes
     * @param[in] numColumns How many columns of cubes
     * @param[in] numRows How many rows of cubes
     * @param[in] numColumns How many columns of cubes

-    * @param[in] viewAreaSize The size of view area for this transition effect

     */
     */

-   CubeTransitionCrossEffect( unsigned int numRows, unsigned int numColumns, Size viewAreaSize );
+   CubeTransitionCrossEffect( unsigned int numRows, unsigned int numColumns );

 
    /**
 
    /**

-    * Set up animation to an Actor
+    * @brief Set up animation to an Actor
+    * This will also displace the cubes in the z direction by mCubeDisplacement and spread them apart on the xy plane
+    * given by the closeness of displacementCentre to the XY plane at 0.
+    *

     * @param[in] actorIndex The index of the cube in the cube array
     * @param[in] angle The angle of the rotation animation
     * @param[in] actorIndex The index of the cube in the cube array
     * @param[in] angle The angle of the rotation animation

-    * @param[in] axis The axis of the rotation animation
-    * @param[in] resetTranslation The translation used to reset the actor position before animation
+    * @param[in] the centre to "explode" the tiles outwards from

     */
     */

-
-   void SetupAnimation( unsigned int actorIndex, float angle, const Vector3 axis, Vector3 resetTranslation );
+   void SetupAnimation( unsigned int actorIndex, unsigned int x, unsigned int y, float angle, const Vector3 axis, const Vector3& displacementCentre );

 
 private:
 
 
 private:
 

-   float  mDisplacementRatio;
+   /**
+    * The factor that determines how spread apart from each other the cubes will go
+    * when they are displaced during the transition animation.
+    * The larger the value the more the spread apart the cubes will be.
+    * it should be in the range (0.0, +infinity)
+    */
+   float  mDisplacementSpreadFactor;

 
 }; //class CubeTransitionCrossEffect
 
 
 }; //class CubeTransitionCrossEffect
 


@@ -94,22 +96,22 @@ private:
 
 // Helpers for public-api forwarding methods
 
 
 // Helpers for public-api forwarding methods
 

-inline Internal::CubeTransitionCrossEffect& GetImpl(Dali::Toolkit::CubeTransitionCrossEffect& obj)
+inline Internal::CubeTransitionCrossEffect& GetImpl( Dali::Toolkit::CubeTransitionCrossEffect& obj )

 {
 {

-  DALI_ASSERT_ALWAYS(obj);
+  DALI_ASSERT_ALWAYS( obj );

 
 

-  Dali::BaseObject& handle = obj.GetBaseObject();
+  Dali::RefObject& handle = obj.GetImplementation();

 
 

-  return static_cast<Internal::CubeTransitionCrossEffect&>(handle);
+  return static_cast< Internal::CubeTransitionCrossEffect& >( handle );

 }
 
 }
 

-inline const Internal::CubeTransitionCrossEffect& GetImpl(const Dali::Toolkit::CubeTransitionCrossEffect& obj)
+inline const Internal::CubeTransitionCrossEffect& GetImpl( const Dali::Toolkit::CubeTransitionCrossEffect& obj )

 {
 {

-  DALI_ASSERT_ALWAYS(obj);
+  DALI_ASSERT_ALWAYS( obj );

 
 

-  const Dali::BaseObject& handle = obj.GetBaseObject();
+  const Dali::RefObject& handle = obj.GetImplementation();

 
 

-  return static_cast<const Internal::CubeTransitionCrossEffect&>(handle);
+  return static_cast< const Internal::CubeTransitionCrossEffect& >( handle );

 }
 
 } // namespace Toolkit
 }
 
 } // namespace Toolkit

diff --git a/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.cpp b/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.cpp
index 444a3fd..f633607 100644 (file)
--- a/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.cpp
+++ b/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.cpp
@@ -20,11 +20,10 @@
 
 // EXTERNAL INCLUDES
 #include <cstring> // for strcmp
 
 // EXTERNAL INCLUDES
 #include <cstring> // for strcmp

-#include <dali/public-api/common/stage.h>
-#include <dali/public-api/images/buffer-image.h>

 #include <dali/public-api/object/type-registry.h>
 #include <dali/devel-api/object/type-registry-helper.h>
 #include <dali/public-api/object/type-registry.h>
 #include <dali/devel-api/object/type-registry-helper.h>

-#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
+#include <dali/integration-api/debug.h>

 
 namespace Dali
 {
 
 namespace Dali
 {


@@ -45,26 +44,86 @@ DALI_SIGNAL_REGISTRATION( Toolkit, CubeTransitionEffect, "transition-completed",
 
 DALI_TYPE_REGISTRATION_END()
 
 
 DALI_TYPE_REGISTRATION_END()
 

+const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
+  attribute mediump vec2 aPosition;\n
+  varying mediump vec2 vTexCoord;\n
+  uniform mediump mat4 uMvpMatrix;\n
+  uniform mediump vec3 uSize;\n
+  uniform mediump vec4 uTextureRect;\n
+  \n
+  void main()\n
+  {\n
+    mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
+    vertexPosition.xyz *= uSize;\n
+    vertexPosition = uMvpMatrix * vertexPosition;\n
+    \n
+    vTexCoord = aPosition + vec2(0.5);\n
+    vTexCoord = mix(uTextureRect.xy, uTextureRect.zw, vTexCoord);\n
+
+    gl_Position = vertexPosition;\n
+  }\n
+);
+
+const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
+  varying mediump vec2 vTexCoord;\n
+  uniform sampler2D sTexture;\n
+  uniform lowp vec4 uColor;\n
+  uniform lowp vec4 uSamplerRect;
+  \n
+  void main()\n
+  {\n
+    gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
+  }\n
+);
+
+Actor CreateTile( const Vector4& samplerRect )
+{
+ Actor tile = Actor::New();
+  tile.SetAnchorPoint( AnchorPoint::CENTER );
+  tile.RegisterProperty( "uTextureRect", samplerRect );
+  return tile;
+}
+
+
+Geometry CreateQuadGeometry()
+{
+  const float halfWidth = 0.5f;
+  const float halfHeight = 0.5f;
+  struct QuadVertex { Vector2 position;};
+  QuadVertex quadVertexData[4] =
+  {
+      { Vector2(-halfWidth, -halfHeight) },
+      { Vector2( halfWidth, -halfHeight) },
+      { Vector2(-halfWidth, halfHeight)  },
+      { Vector2( halfWidth, halfHeight)  }
+  };
+
+  Property::Map quadVertexFormat;
+  quadVertexFormat["aPosition"] = Property::VECTOR2;
+  PropertyBuffer quadVertices = PropertyBuffer::New( quadVertexFormat, 4 );
+  quadVertices.SetData(quadVertexData);
+
+  // Create the geometry object
+  Geometry geometry = Geometry::New();
+  geometry.AddVertexBuffer( quadVertices );
+  geometry.SetGeometryType( Geometry::TRIANGLE_STRIP );
+
+  return geometry;
+}
+

 }
 
 const Vector4 CubeTransitionEffect::FULL_BRIGHTNESS( 1.0f, 1.0f, 1.0f, 1.0f );
 const Vector4 CubeTransitionEffect::HALF_BRIGHTNESS( 0.5f, 0.5f, 0.5f, 1.0f );
 
 }
 
 const Vector4 CubeTransitionEffect::FULL_BRIGHTNESS( 1.0f, 1.0f, 1.0f, 1.0f );
 const Vector4 CubeTransitionEffect::HALF_BRIGHTNESS( 0.5f, 0.5f, 0.5f, 1.0f );
 

-CubeTransitionEffect::CubeTransitionEffect( unsigned int numRows, unsigned int numColumns, Size viewAreaSize )
-: mNumRows( numRows ),
-  mNumColumns( numColumns ),
-  mViewAreaSize( viewAreaSize ),
-  mRotateIndex( 0 ),
-  mContainerIndex( 0 ),
-  mChangeTurningDirection( false ),
-  mIsToNextImage( true ),
-  mIsImageLoading( false ),
-  mAnimationDuration( 1.f ),
+CubeTransitionEffect::CubeTransitionEffect( unsigned int rows, unsigned int columns )
+: Control( ControlBehaviour( 0 ) ),
+  mRows( rows ),
+  mColumns( columns ),

   mIsAnimating( false ),
   mIsPaused( false ),
   mIsAnimating( false ),
   mIsPaused( false ),

-  mCubeDisplacement( 0.f ),
-  mFirstTransition( true ),
-  mBufferIndex( 0 )
+  mAnimationDuration( 1.f ),
+  mCubeDisplacement( 0.f )

 {
 }
 
 {
 }
 


@@ -72,81 +131,181 @@ CubeTransitionEffect::~CubeTransitionEffect()
 {
 }
 
 {
 }
 

-void CubeTransitionEffect::Initialize()
+void CubeTransitionEffect::SetTargetRight( unsigned int idx )
+{
+  mBoxType[ idx ] = RIGHT;
+
+  mBoxes[ idx ].SetProperty(Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.x * 0.5f );
+
+  mTargetTiles[ idx ].SetParentOrigin( Vector3( 1.f, 0.5f, 0.5f) );
+  mTargetTiles[ idx ].SetOrientation( Degree( 90.f ), Vector3::YAXIS );
+}
+
+void CubeTransitionEffect::SetTargetLeft( unsigned int idx )

 {
 {

-  //create root actor for the cube transition effect, only visible during the transition
-  mRoot = Actor::New();
-  mRoot.SetParentOrigin( ParentOrigin::CENTER );
-  mRoot.SetAnchorPoint( AnchorPoint::CENTER );
-  mRoot.SetVisible(false);
-
-  // create two groups of tiles,
-  // and one group of actors (cubes) serving as parents of every two tiles (one from each image).
-  unsigned int totalNum = mNumColumns* mNumRows;
-  mBoxes.resize( totalNum );
-  mTiles[0].resize( totalNum );
-  mTiles[1].resize( totalNum );
-  mTileSize = Vector2( mViewAreaSize.width / mNumColumns, mViewAreaSize.height / mNumRows );
-  const Vector3 basePosition( (-mViewAreaSize.width + mTileSize.width) * 0.5f,
-                              (-mViewAreaSize.height + mTileSize.height) * 0.5f,
-                              -mTileSize.width * 0.5f );
-
-  Image placeHolder = BufferImage::WHITE();
-  for( unsigned int y = 0; y < mNumRows; y++ )
+  mBoxType[ idx ] = LEFT;
+
+  mBoxes[ idx ].SetProperty(Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.x * 0.5f );
+
+  mTargetTiles[ idx ].SetParentOrigin( Vector3( 0.f, 0.5f, 0.5f) );
+  mTargetTiles[ idx ].SetOrientation( Degree( -90.f ), Vector3::YAXIS );
+}
+
+void CubeTransitionEffect::SetTargetBottom( unsigned int idx )
+{
+  mBoxType[ idx ] = BOTTOM;
+
+  mBoxes[ idx ].SetProperty(Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.y * 0.5f );
+
+  mTargetTiles[ idx ].SetParentOrigin( Vector3( 0.5f, 0.f, 0.5f) );
+  mTargetTiles[ idx ].SetOrientation( Degree( 90.f ), Vector3::XAXIS );
+}
+
+void CubeTransitionEffect::SetTargetTop( unsigned int idx )
+{
+  mBoxType[ idx ] = TOP;
+
+  mBoxes[ idx ].SetProperty(Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.y * 0.5f );
+
+  mTargetTiles[ idx ].SetParentOrigin( Vector3( 0.5f, 1.f, 0.5f) );
+  mTargetTiles[ idx ].SetOrientation( Degree( -90.f ), Vector3::XAXIS );
+}
+
+void CubeTransitionEffect::OnRelayout( const Vector2& size, RelayoutContainer& container )
+{
+  mTileSize = Vector2( size.x / mColumns, size.y / mRows );
+
+  mBoxRoot.SetProperty( Actor::Property::SIZE_WIDTH, size.x );
+  mBoxRoot.SetProperty( Actor::Property::SIZE_HEIGHT, size.y );
+  mBoxRoot.SetProperty( Actor::Property::SIZE_DEPTH, 1.0f );
+
+  for( size_t i = 0; i < mBoxes.size(); ++i )

   {
   {

-    float positionY = y * mTileSize.height + basePosition.y;
-    for( unsigned int x = 0; x < mNumColumns; x++)
+    mBoxes[ i ].SetProperty( Actor::Property::SIZE_WIDTH, mTileSize.x );
+    mBoxes[ i ].SetProperty( Actor::Property::SIZE_HEIGHT, mTileSize.y );
+
+    switch( mBoxType[i] )

     {
     {

-      unsigned int idx = y*mNumColumns + x;
-      Actor actor( Actor::New() );
-      mBoxes[idx] = actor;
-      actor.SetParentOrigin( ParentOrigin::CENTER );
-      actor.SetAnchorPoint( AnchorPoint::CENTER );
-      actor.SetPosition( x * mTileSize.width + basePosition.x,
-                         positionY,
-                         basePosition.z );
-      mRoot.Add( actor );
-
-      mTiles[ 0 ][idx] = CreateTile( placeHolder, FULL_BRIGHTNESS );
-      actor.Add( mTiles[ 0 ][idx] );
-
-      mTiles[ 1 ][idx] = CreateTile( placeHolder, HALF_BRIGHTNESS );
-      actor.Add( mTiles[ 1 ][idx] );
+      case LEFT:
+      case RIGHT:
+      {
+        mBoxes[ i ].SetProperty( Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.x * 0.5f );
+        mBoxes[ i ].SetProperty( Actor::Property::SIZE_DEPTH, mTileSize.x );
+        break;
+      }
+      case BOTTOM:
+      case TOP:
+      {
+        mBoxes[ i ].SetProperty( Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.y * 0.5f );
+        mBoxes[ i ].SetProperty( Actor::Property::SIZE_DEPTH, mTileSize.y );
+        break;
+      }

     }
   }
 
     }
   }
 

-  // helper actor to create a off-screen image using shader effect
-  mEmptyImage = ImageActor::New( placeHolder );
-  mEmptyImage.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
-  mEmptyImage.SetParentOrigin( ParentOrigin::CENTER );
-  mEmptyImage.SetAnchorPoint( AnchorPoint::CENTER );
-  mFullImageCreator = FullAreaImageCreator::New();
-  mEmptyImage.SetShaderEffect( mFullImageCreator );
-  Stage::GetCurrent().Add(mEmptyImage);
-
-  // set up off-screen render task
-  RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
-  mOffScreenTask = taskList.CreateTask();
-  mOffScreenTask.SetSourceActor(mEmptyImage);
-  mOffScreenTask.SetExclusive(true);
-  mOffScreenBuffer[0] = FrameBufferImage::New(mViewAreaSize.x, mViewAreaSize.y);
-  mOffScreenBuffer[1] = FrameBufferImage::New(mViewAreaSize.x, mViewAreaSize.y);
-  mOffScreenTask.SetTargetFrameBuffer(mOffScreenBuffer[mBufferIndex]);
-  mOffScreenTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
+  for( ActorArray::iterator it = mCurrentTiles.begin(); it != mCurrentTiles.end(); ++it )
+  {
+    it->SetProperty( Actor::Property::SIZE_WIDTH, mTileSize.x );
+    it->SetProperty( Actor::Property::SIZE_HEIGHT, mTileSize.y );
+  }
+  for( ActorArray::iterator it = mTargetTiles.begin(); it != mTargetTiles.end(); ++it )
+  {
+    it->SetProperty( Actor::Property::SIZE_WIDTH, mTileSize.x );
+    it->SetProperty( Actor::Property::SIZE_HEIGHT, mTileSize.y );
+  }
+}
+
+void CubeTransitionEffect::Initialize()
+{
+  Self().RegisterProperty( "uTextureRect", Vector4( 0.0f, 0.0f, 1.0f, 1.0f ) );
+
+  mBoxType.Resize(mColumns * mRows);
+
+  //create the box parents
+  mBoxRoot = Actor::New();
+  mBoxRoot.SetParentOrigin( ParentOrigin::CENTER );
+  mBoxRoot.SetAnchorPoint( AnchorPoint::CENTER );
+
+  mCurrentTiles.clear();
+  mTargetTiles.clear();
+
+  mCurrentTiles.reserve( mColumns * mRows );
+  mTargetTiles.reserve( mColumns * mRows );
+
+  Vector2 gridSizeInv( 1.0f / mColumns, 1.0f / mRows );
+  Vector3 offset( 0.5f * gridSizeInv.x, 0.5f * gridSizeInv.y, 0.0f );
+
+  Vector3 anchor;
+  for( unsigned int y = 0; y < mRows; ++y, anchor.y += 1.0f / mRows )
+  {
+    anchor.x = 0.0f;
+    for( unsigned int x = 0; x <mColumns; ++x, anchor.x += 1.0f / mColumns )
+    {
+      Vector4 textureRect( anchor.x, anchor.y, anchor.x + gridSizeInv.x, anchor.y + gridSizeInv.y );
+
+      Actor currentTile = CreateTile( textureRect );
+      currentTile.SetProperty( Actor::Property::COLOR, FULL_BRIGHTNESS );
+      currentTile.SetParentOrigin( ParentOrigin::CENTER );
+      mCurrentTiles.push_back( currentTile );
+
+      Actor targetTile = CreateTile( textureRect );
+      targetTile.SetProperty( Actor::Property::COLOR, HALF_BRIGHTNESS );
+      mTargetTiles.push_back( targetTile );
+
+      Actor box = Actor::New();
+      box.SetParentOrigin( anchor + offset );
+      box.SetAnchorPoint( AnchorPoint::CENTER );
+
+      box.Add( currentTile );
+      box.Add( targetTile );
+
+      mBoxRoot.Add( box );
+
+      mBoxes.push_back( box );
+    }
+  }

 
   OnInitialize();
 }
 
 
   OnInitialize();
 }
 

-ImageActor CubeTransitionEffect::CreateTile( Image image, const Vector4& color )
+void CubeTransitionEffect::OnStageConnection( int depth )

 {
 {

-  ImageActor tile = ImageActor::New( image );
-  tile.SetParentOrigin( ParentOrigin::CENTER );
-  tile.SetAnchorPoint( AnchorPoint::CENTER );
-  tile.SetSize( mTileSize );
-  tile.SetColorMode( Dali::USE_OWN_COLOR );
-  tile.SetColor( color );
+  Geometry geometry = CreateQuadGeometry();
+  Shader shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );

 
 

-  return tile;
+  Material material = Material::New( shader );
+
+  if( mCurrentImage )
+  {
+    material.AddTexture( mCurrentImage, "sTexture" );
+  }
+  mCurrentRenderer = Renderer::New( geometry, material );
+
+  mCurrentRenderer.SetDepthIndex( depth );
+  Self().AddRenderer( mCurrentRenderer );
+}
+
+void CubeTransitionEffect::OnStageDisconnection()
+{
+  if( mCurrentRenderer )
+  {
+    Self().RemoveRenderer( mCurrentRenderer );
+
+    for( ActorArray::iterator it = mCurrentTiles.begin(); it != mCurrentTiles.end(); ++it )
+    {
+      it->RemoveRenderer( mCurrentRenderer );
+    }
+    mCurrentRenderer.Reset();
+  }
+
+  if( mTargetRenderer )
+  {
+    for( ActorArray::iterator it = mTargetTiles.begin(); it != mTargetTiles.end(); ++it )
+    {
+      it->RemoveRenderer( mTargetRenderer );
+    }
+    mTargetRenderer.Reset();
+  }

 }
 
 void CubeTransitionEffect::SetTransitionDuration( float duration )
 }
 
 void CubeTransitionEffect::SetTransitionDuration( float duration )


@@ -169,92 +328,101 @@ float CubeTransitionEffect::GetCubeDisplacement() const
   return mCubeDisplacement;
 }
 
   return mCubeDisplacement;
 }
 

-Actor CubeTransitionEffect::GetRoot()
+bool CubeTransitionEffect::IsTransitioning()

 {
 {

-  return mRoot;
+  return mIsAnimating;

 }
 
 }
 

-bool CubeTransitionEffect::IsTransiting()
+void CubeTransitionEffect::SetCurrentImage( Image image )

 {
 {

-  return mIsImageLoading || mIsAnimating;
-}
+  mCurrentImage = image;

 
 

-void CubeTransitionEffect::SetCurrentImage( ImageActor imageActor )
-{
-  mContainerIndex = std::abs(mRotateIndex) % 2;
-  SetImage( imageActor );
-}
+  if( mCurrentRenderer )
+  {
+    Material material = mCurrentRenderer.GetMaterial();

 
 

-void CubeTransitionEffect::SetTargetImage( ImageActor imageActor )
-{
-  mContainerIndex = std::abs( mRotateIndex+1 ) % 2;
-  SetImage( imageActor );
+    int index = material.GetTextureIndex("sTexture" );
+    if( index != -1 )
+    {
+      material.SetTextureImage( index, mCurrentImage );
+    }
+    else
+    {
+      material.AddTexture( mCurrentImage, "sTexture" );
+    }
+  }

 }
 
 }
 

-void CubeTransitionEffect::SetImage( ImageActor imageActor )
+void CubeTransitionEffect::SetTargetImage( Image image )

 {
 {

-  mCurrentImage = imageActor;
+  mTargetImage = image;

 
 

-  Image image = imageActor.GetImage();
-  ResourceImage resourceImage = ResourceImage::DownCast( image );
-  mBufferIndex = mBufferIndex^1;
-
-  //must make sure the image is already loaded before using its attributes
-  if( resourceImage && resourceImage.GetLoadingState() != ResourceLoadingSucceeded )
+  if( mTargetRenderer )

   {
   {

-    mIsImageLoading = true;
-    resourceImage.LoadingFinishedSignal().Connect( this, &CubeTransitionEffect::OnImageLoaded );
-  }
-  else
-  {
-    mIsImageLoading = false;
-    PrepareTiles( image );
+    Material material = mTargetRenderer.GetMaterial();
+    material.AddTexture( mTargetImage, "sTexture" );

   }
 }
 
 void CubeTransitionEffect::StartTransition( bool toNextImage )
 {
   }
 }
 
 void CubeTransitionEffect::StartTransition( bool toNextImage )
 {

+  Vector3 size = Self().GetCurrentSize();

   if( toNextImage )
   {
   if( toNextImage )
   {

-    StartTransition( Vector2( mViewAreaSize.width, mViewAreaSize.height*0.5f ), Vector2( -10.f, 0.f ) );
+    StartTransition( Vector2(size.x* 0.5f, size.y*0.5f), Vector2( -10.f, 0.f ) );

   }
   else
   {
   }
   else
   {

-    StartTransition( Vector2( 0, mViewAreaSize.height*0.5f ), Vector2( 10.f, 0.f ));
+    StartTransition( Vector2(size.x* 0.5f, size.y*0.5f), Vector2( 10.f, 0.f ));

   }
 }
 
 void CubeTransitionEffect::StartTransition( Vector2 panPosition, Vector2 panDisplacement )
 {
   }
 }
 
 void CubeTransitionEffect::StartTransition( Vector2 panPosition, Vector2 panDisplacement )
 {

-  mRoot.SetVisible( true );
-  mCurrentImage.SetVisible( false );
-  bool toNextImage = ( panDisplacement.x < 0 ) ? true : false;
-  if( mIsToNextImage != toNextImage )
+  if( !mCurrentRenderer )

   {
   {

-    mChangeTurningDirection = true;
+    DALI_LOG_ERROR( "Trying to transition a cube transition without an image set" );
+    return;

   }
   }

-  else
+
+  //create the target renderer
+  Material material = Material::New( mCurrentRenderer.GetMaterial().GetShader() );
+  if( mTargetImage )

   {
   {

-    mChangeTurningDirection = false;
+    material.AddTexture( mTargetImage, "sTexture" );

   }
   }

-  mIsToNextImage = toNextImage;
+  Geometry geometry = mCurrentRenderer.GetGeometry();
+  mTargetRenderer = Renderer::New( geometry, material );

 
 

-  if( mIsToNextImage )
+  mTargetRenderer.SetDepthIndex( mCurrentRenderer.GetDepthIndex() );
+
+  for( size_t i = 0; i < mBoxes.size(); ++i )

   {
   {

-    mRotateIndex += 1.f;
+    mBoxes[ i ].SetProperty( Actor::Property::ORIENTATION, Quaternion( Radian( 0.0f ), Vector3::XAXIS ) );

   }
   }

-  else
+
+  for( ActorArray::iterator it = mCurrentTiles.begin(); it != mCurrentTiles.end(); ++it )
+  {
+    it->SetParentOrigin( Vector3( 0.5f, 0.5f, 1.0f) );
+    it->SetProperty( Actor::Property::ORIENTATION, Quaternion( Radian( 0.0f ), Vector3::XAXIS ) );
+    it->AddRenderer( mCurrentRenderer );
+  }
+  for( ActorArray::iterator it = mTargetTiles.begin(); it != mTargetTiles.end(); ++it )

   {
   {

-    mRotateIndex -= 1.f;
+    it->AddRenderer( mTargetRenderer );

   }
 
   }
 

+  Self().RemoveRenderer( mCurrentRenderer );
+  Self().Add( mBoxRoot );
+

   if(mAnimation)
   {
     mAnimation.Clear();
     mAnimation.Reset();
   }
   if(mAnimation)
   {
     mAnimation.Clear();
     mAnimation.Reset();
   }

+

   mAnimation = Animation::New( mAnimationDuration );
   mAnimation = Animation::New( mAnimationDuration );

-  mAnimation.FinishedSignal().Connect(this, &CubeTransitionEffect::OnTransitionFinished);
+  mAnimation.FinishedSignal().Connect( this, &CubeTransitionEffect::OnTransitionFinished );

 
   OnStartTransition( panPosition, panDisplacement );
 }
 
   OnStartTransition( panPosition, panDisplacement );
 }


@@ -279,90 +447,61 @@ void CubeTransitionEffect::ResumeTransition()
 
 void CubeTransitionEffect::StopTransition()
 {
 
 void CubeTransitionEffect::StopTransition()
 {

-  if( mIsAnimating )
-  {
-    mAnimation.Clear();
-    mAnimation.Reset();
-    mIsPaused = false;
-
-    //reset the position of the cubes
-    //reset the color of the tiles
-    //all these status should be the same as the final state when the transition animation is finished completely
-    const Vector3 basePosition( (-mViewAreaSize.width + mTileSize.width) * 0.5f,
-                                (-mViewAreaSize.height + mTileSize.height) * 0.5f,
-                                 -mTileSize.width * 0.5f );
-    unsigned int anotherIndex = mContainerIndex^1;
-    for( unsigned int y = 0; y < mNumRows; y++ )
-    {
-      float positionY = y * mTileSize.height + basePosition.y;
-      for( unsigned int x = 0; x < mNumColumns; x++)
-      {
-        unsigned int idx = y*mNumColumns + x;
-        mBoxes[idx].SetPosition( x * mTileSize.width + basePosition.x,
-                                 positionY,
-                                 basePosition.z );
-        mTiles[mContainerIndex][idx].SetColor( FULL_BRIGHTNESS );
-        mTiles[anotherIndex][idx].SetColor( HALF_BRIGHTNESS);
-      }
-    }
-
-    // reset the rotation of the cubes, which is different process for different derived classes
-    OnStopTransition();
-
-    mRoot.SetVisible(false);
-    mCurrentImage.SetVisible(true);
-    mIsAnimating = false;
-    mFirstTransition = false;
-  }
-}
-
-void CubeTransitionEffect::OnImageLoaded(ResourceImage image)
-{
-  mIsImageLoading = false;
-  PrepareTiles( image );
+  ResetToInitialState();

 }
 
 }
 

-/**
- * Set sub-image to each tile.
- * @param[in] image The image content of the imageActor for transition
- */
-void CubeTransitionEffect::PrepareTiles( Image image )
+void CubeTransitionEffect::ResetToInitialState()

 {
 {

-  // Fit the image to view area, while keeping the aspect; FitKeepAspectRatio(imageSize, viewAreaSize)
-  float scale = std::min(  mViewAreaSize.width / image.GetWidth(), mViewAreaSize.height / image.GetHeight() );
-  Vector2 imageSize(image.GetWidth()*scale, image.GetHeight()*scale);
+  mAnimation.Clear();
+  mAnimation.Reset();
+  mIsAnimating = false;

 
 

-  mFullImageCreator.SetEffectImage(image);
-  mFullImageCreator.SetRegionSize(mViewAreaSize, imageSize);
+  Self().Remove( mBoxRoot );

 
 

-  mOffScreenTask.SetTargetFrameBuffer(mOffScreenBuffer[mBufferIndex]);
-  mOffScreenTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
+  for( size_t i = 0; i < mBoxes.size(); ++i )
+  {
+    mBoxes[ i ].SetProperty( Actor::Property::ORIENTATION, Quaternion( Radian( 0.0f ), Vector3::XAXIS ) );
+  }

 
 

-  ImageActor::PixelArea pixelArea( 0, 0, mViewAreaSize.x / mNumColumns, mViewAreaSize.y / mNumRows);
+  for( ActorArray::iterator it = mCurrentTiles.begin(); it != mCurrentTiles.end(); ++it )
+  {
+    it->SetParentOrigin( Vector3( 0.5f, 0.5f, 1.0f) );
+    it->SetProperty( Actor::Property::ORIENTATION, Quaternion( Radian( 0.0f ), Vector3::XAXIS ) );
+    it->SetProperty( Actor::Property::COLOR, FULL_BRIGHTNESS );
+  }
+  if( mCurrentRenderer )
+  {
+    for( ActorArray::iterator it = mCurrentTiles.begin(); it != mCurrentTiles.end(); ++it )
+    {
+      it->RemoveRenderer( mCurrentRenderer );
+    }
+    Self().AddRenderer( mCurrentRenderer );
+  }

 
 

-  for( unsigned int y = 0; y < mNumRows; y++ )
+  for( ActorArray::iterator it = mTargetTiles.begin(); it != mTargetTiles.end(); ++it )
+  {
+    it->SetProperty( Actor::Property::COLOR, HALF_BRIGHTNESS );
+  }
+  if( mTargetRenderer )

   {
   {

-    pixelArea.y = y * pixelArea.height;
-    for( unsigned int x = 0; x < mNumColumns; x++)
+    for( ActorArray::iterator it = mTargetTiles.begin(); it != mTargetTiles.end(); ++it )

     {
     {

-      pixelArea.x = x * pixelArea.width;
-      unsigned int idx = y*mNumColumns + x;
-      mTiles[mContainerIndex][idx].SetImage( mOffScreenBuffer[mBufferIndex]);
-      mTiles[mContainerIndex][idx].SetPixelArea( pixelArea );
+      it->RemoveRenderer( mTargetRenderer );

     }
   }
 }
 
     }
   }
 }
 

-

 void CubeTransitionEffect::OnTransitionFinished(Animation& source)
 {
 void CubeTransitionEffect::OnTransitionFinished(Animation& source)
 {

-  mRoot.SetVisible(false);
-  mCurrentImage.SetVisible(true);
-  mIsAnimating = false;
-  mFirstTransition = false;
+
+  std::swap( mCurrentTiles, mTargetTiles );
+  std::swap( mCurrentRenderer, mTargetRenderer );
+  std::swap( mCurrentImage, mTargetImage );
+
+  ResetToInitialState();

 
   //Emit signal
 
   //Emit signal

-  Toolkit::CubeTransitionEffect handle( this );
+  Toolkit::CubeTransitionEffect handle( GetOwner() );

   mTransitionCompletedSignal.Emit( handle, mCurrentImage );
 }
 
   mTransitionCompletedSignal.Emit( handle, mCurrentImage );
 }
 

diff --git a/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.h b/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.h
index 5642749..25d1e1c 100644 (file)
--- a/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.h
+++ b/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.h
@@ -20,15 +20,11 @@
 
 // EXTERNAL INCLUDES
 #include <dali/public-api/animation/animation.h>
 
 // EXTERNAL INCLUDES
 #include <dali/public-api/animation/animation.h>

-
-#include <dali/public-api/images/frame-buffer-image.h>
-#include <dali/public-api/object/base-object.h>
-#include <dali/public-api/render-tasks/render-task.h>
-#include <dali/public-api/shader-effects/shader-effect.h>
-#include <dali/public-api/images/resource-image.h>
+#include <dali/devel-api/rendering/renderer.h>

 
 // INTERNAL INCLUDES
 #include <dali-toolkit/devel-api/transition-effects/cube-transition-effect.h>
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/devel-api/transition-effects/cube-transition-effect.h>

+#include <dali-toolkit/public-api/controls/control-impl.h>

 
 namespace Dali
 {
 
 namespace Dali
 {


@@ -42,93 +38,9 @@ namespace Internal
 {
 
 /**
 {
 
 /**

- * Create a image with size of viewAreaSize
- * with the effect image as its center part and (0,0,0,1) at other parts
- */
-class FullAreaImageCreator : public ShaderEffect
-{
-
-public:
-
-  /**
-   * Create an uninitialized FullAreaImageCreator
-   * this can be initialized with FullAreaImageCreator::New()
-   */
-  FullAreaImageCreator(){}
-
-  /**
-   * @brief Destructor
-   *
-   * This is non-virtual since derived Handle types must not contain data or virtual methods.
-   */
-  ~FullAreaImageCreator(){}
-
-  /**
-   * Create an initialized FullAreaImageCreator.
-   * @return A handle to a newly allocated Dali resource.
-   */
-  static FullAreaImageCreator New()
-  {
-    std::string vertexShader(
-      "uniform mediump vec4 uRegion; \n"
-       "void main() \n"
-      "{\n"
-      "  gl_Position = uProjection * uModelView * vec4(aPosition, 1.0);\n"
-      "  vTexCoord.s = (aTexCoord.s - uRegion.s) / uRegion.p;"
-      "  vTexCoord.t = ( 1.0 - aTexCoord.t - uRegion.t) / uRegion.q;"
-      "}\n"
-    );
-
-    std::string fragmentShader(
-      "uniform mediump vec4 uRegion; \n"
-      "void main() \n"
-      "{\n"
-      "  if( vTexCoord.s > 0.0 && vTexCoord.s < 1.0 && vTexCoord.t > 0.0 && vTexCoord.t < 1.0) \n"
-      "  { \n"
-      "    gl_FragColor = texture2D( sEffect, vTexCoord ) * uColor ; \n"
-      "  } \n"
-      "  else \n"
-      "  { \n"
-      "    gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 ); \n"
-      "  } \n"
-      "}\n"
-    );
-
-    ShaderEffect shaderEffectCustom = ShaderEffect::New(vertexShader, fragmentShader);
-    FullAreaImageCreator handle( shaderEffectCustom );
-
-    return handle;
-  }
-
-  /**
-   * Set up the position and size of the effect texture
-   * @param[in] viewArea the size of full-area image to create
-   * @param[in] size the size of effect texture
-   */
-  void SetRegionSize( const Vector2& viewArea, const Vector2& size )
-  {
-    Vector2 sizeRatio( std::min(1.f, size.x / viewArea.x), std::min(1.f, size.y / viewArea.y) );
-    Vector4 region( (1.f-sizeRatio.x)*0.5f,
-                    (1.f-sizeRatio.y)*0.5f,
-                    sizeRatio.x,
-                    sizeRatio.y  );
-    SetUniform( "uRegion", region );
-  }
-
-private:
-
-  FullAreaImageCreator( ShaderEffect handle )
-  : ShaderEffect( handle )
-  {}
-
-};
-
-
-
-/**

  * CubeTransitionEffect implementation class
  */
  * CubeTransitionEffect implementation class
  */

-class CubeTransitionEffect : public Dali::BaseObject, public ConnectionTracker
+class CubeTransitionEffect : public Control

 {
 
 public:
 {
 
 public:


@@ -159,24 +71,19 @@ public:
   float GetCubeDisplacement() const;
 
   /**
   float GetCubeDisplacement() const;
 
   /**

-   * @copydoc Toolkit::CubeTransitionEffect::GetRoot
-   */
-  Actor GetRoot();
-
-  /**
-   * @copydoc Toolkit::CubeTransitionEffect::IsTransiting
+   * @copydoc Toolkit::CubeTransitionEffect::IsTransitioning

    */
    */

-  bool IsTransiting();
+  bool IsTransitioning();

 
   /**
    * @copydoc Toolkit::CubeTransitionEffect::SetFirstImage
    */
 
   /**
    * @copydoc Toolkit::CubeTransitionEffect::SetFirstImage
    */

-  void SetCurrentImage(ImageActor imageActor);
+  void SetCurrentImage( Image image );

 
   /**
    * @copydoc Toolkit::CubeTransitionEffect::SetTargetImage
    */
 
   /**
    * @copydoc Toolkit::CubeTransitionEffect::SetTargetImage
    */

-  void SetTargetImage(ImageActor imageActor);
+  void SetTargetImage( Image image );

 
   /**
    * @copydoc Toolkit::CubeTransitionEffect::StartTransition(bool)
 
   /**
    * @copydoc Toolkit::CubeTransitionEffect::StartTransition(bool)


@@ -222,15 +129,25 @@ public: //Signal
   static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
 
 protected:
   static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
 
 protected:

+  /**
+   * @copydoc CustomActorImpl::OnStageConnection()
+   */
+  virtual void OnStageConnection( int depth );
+
+  /**
+   * @copydoc CustomActorImpl::OnStageDisconnection()
+   */
+  virtual void OnStageDisconnection();
+
+protected:

 
   /**
    * Construct a new CubeTransitionEffect object
    * Called in the constructor of subclasses
    * @param[in] numRows How many rows of cubes
    * @param[in] numColumns How many columns of cubes
 
   /**
    * Construct a new CubeTransitionEffect object
    * Called in the constructor of subclasses
    * @param[in] numRows How many rows of cubes
    * @param[in] numColumns How many columns of cubes

-   * @param[in] viewAreaSize The size of view area for this transition effect

    */
    */

-  CubeTransitionEffect( unsigned int numRows, unsigned int numColumns, Size viewAreaSize );
+  CubeTransitionEffect( unsigned int numRows, unsigned int numColumns );

 
   /**
    * Initialization steps: creating a layer, two groups of tiles,
 
   /**
    * Initialization steps: creating a layer, two groups of tiles,


@@ -238,36 +155,14 @@ protected:
    */
   void Initialize();
 
    */
   void Initialize();
 

-private:

 
 

-  /**
-   * Create an image actor to serve as a face of the cube
-   * @param[in] image The image to display.
-   * @param[in] color The color to set to the actor
-   * @return The tile actor created
-   */
-  ImageActor CreateTile( Image image, const Vector4& color );
-
-  /**
-   * Set Image content to tiles
-   * As only when the image ready, can we get correct image attributes
-   * so inside this function, the process needs to be passed to callBack of image resource loading succeed.
-   * @param[in] imageActor The imageActor whose image content will be set to the tiles
-   */
-  void SetImage(ImageActor imageActor);
-
-  /**
-   * Callback function of image resource loading succeed
-   * Set image and pixelArea to tiles
-   * @param[in] image The image content of the imageActor for transition
-   */
-  void OnImageLoaded(ResourceImage image);
+protected:
+  void SetTargetLeft( unsigned int idx );
+  void SetTargetRight( unsigned int idx );
+  void SetTargetTop( unsigned int idx );
+  void SetTargetBottom( unsigned int idx );

 
 

-  /**
-   * Set sub-image to each tile.
-   * @param[in] image The image content of the imageActor for transition
-   */
-  void PrepareTiles( Image image );
+private:

 
   /**
    * Callback function of transition animation finished
 
   /**
    * Callback function of transition animation finished


@@ -297,40 +192,40 @@ private:
    */
   virtual void OnStopTransition() {}
 
    */
   virtual void OnStopTransition() {}
 

+  virtual void OnRelayout( const Vector2& size, RelayoutContainer& container );
+
+  void ResetToInitialState();
+

 
 protected:
 
 protected:

+  typedef std::vector< Actor > ActorArray;
+  enum FACE { TOP, BOTTOM, LEFT, RIGHT };

 
 

-  unsigned int               mNumRows;
-  unsigned int               mNumColumns;
-  Size                       mViewAreaSize;
-  std::vector< Actor >       mBoxes;
-  std::vector< ImageActor >  mTiles[2];
-  int                        mRotateIndex;
-  Size                       mTileSize;
-  Actor                      mRoot;
+  ActorArray                 mBoxes;
+  Vector< FACE >             mBoxType;
+  ActorArray                 mCurrentTiles;
+  ActorArray                 mTargetTiles;

 
 

-  ImageActor                 mCurrentImage;
-  unsigned int               mContainerIndex;           //have the value 0 or 1, refer to mTiles[0] or mTiles[1]
+  Actor                      mBoxRoot;

 
 

-  bool                       mChangeTurningDirection;
-  bool                       mIsToNextImage;            //if true, cubes rotate counter-clockwise; else clockwise
-  bool                       mIsImageLoading;
+  unsigned int               mRows;
+  unsigned int               mColumns;

 
 

-  float                      mAnimationDuration;
+  Renderer                   mCurrentRenderer;
+  Renderer                   mTargetRenderer;
+
+  Image                      mCurrentImage;
+  Image                      mTargetImage;

   Animation                  mAnimation;
   Animation                  mAnimation;

+
+  Vector2                    mTileSize;
+

   bool                       mIsAnimating;
   bool                       mIsPaused;
 
   bool                       mIsAnimating;
   bool                       mIsPaused;
 

+  float                      mAnimationDuration;

   float                      mCubeDisplacement;
 
   float                      mCubeDisplacement;
 

-  bool                       mFirstTransition;
-
-  RenderTask                 mOffScreenTask;
-  FrameBufferImage           mOffScreenBuffer[2];
-  ImageActor                 mEmptyImage;
-  FullAreaImageCreator       mFullImageCreator;
-  unsigned int               mBufferIndex;
-

   static const Vector4       FULL_BRIGHTNESS;
   static const Vector4       HALF_BRIGHTNESS;
 
   static const Vector4       FULL_BRIGHTNESS;
   static const Vector4       HALF_BRIGHTNESS;
 


@@ -348,7 +243,7 @@ inline Internal::CubeTransitionEffect& GetImpl(Dali::Toolkit::CubeTransitionEffe
 {
   DALI_ASSERT_ALWAYS(obj);
 
 {
   DALI_ASSERT_ALWAYS(obj);
 

-  Dali::BaseObject& handle = obj.GetBaseObject();
+  Dali::RefObject& handle = obj.GetImplementation();

 
   return static_cast<Internal::CubeTransitionEffect&>(handle);
 }
 
   return static_cast<Internal::CubeTransitionEffect&>(handle);
 }


@@ -357,7 +252,7 @@ inline const Internal::CubeTransitionEffect& GetImpl(const Dali::Toolkit::CubeTr
 {
   DALI_ASSERT_ALWAYS(obj);
 
 {
   DALI_ASSERT_ALWAYS(obj);
 

-  const Dali::BaseObject& handle = obj.GetBaseObject();
+  const Dali::RefObject& handle = obj.GetImplementation();

 
   return static_cast<const Internal::CubeTransitionEffect&>(handle);
 }
 
   return static_cast<const Internal::CubeTransitionEffect&>(handle);
 }

diff --git a/dali-toolkit/internal/transition-effects/cube-transition-fold-effect-impl.cpp b/dali-toolkit/internal/transition-effects/cube-transition-fold-effect-impl.cpp
index 6989478..8cd84be 100644 (file)
--- a/dali-toolkit/internal/transition-effects/cube-transition-fold-effect-impl.cpp
+++ b/dali-toolkit/internal/transition-effects/cube-transition-fold-effect-impl.cpp
@@ -26,20 +26,18 @@ namespace Toolkit
 
 namespace Internal
 {
 
 namespace Internal
 {

-const float CubeTransitionFoldEffect::mDisplacementRatio = 1.4142f; //sqrt(2)
-
-CubeTransitionFoldEffect::CubeTransitionFoldEffect( unsigned int numRows, unsigned int numColumns, Size viewAreaSize )
-: CubeTransitionEffect( numRows, numColumns, viewAreaSize)
+CubeTransitionFoldEffect::CubeTransitionFoldEffect( unsigned int numRows, unsigned int numColumns )
+: CubeTransitionEffect( numRows, numColumns )

 {
 }
 
 {
 }
 

-Toolkit::CubeTransitionFoldEffect CubeTransitionFoldEffect::New(unsigned int numRows, unsigned int numColumns, Size viewAreaSize)
+Toolkit::CubeTransitionFoldEffect CubeTransitionFoldEffect::New(unsigned int numRows, unsigned int numColumns )

 {
   // Create the implementation
 {
   // Create the implementation

-  CubeTransitionFoldEffect* internalCubeTransEffect = new CubeTransitionFoldEffect( numRows, numColumns, viewAreaSize );
+  IntrusivePtr< CubeTransitionFoldEffect > internalCubeTransEffect = new CubeTransitionFoldEffect( numRows, numColumns );

 
   // Pass ownership to CustomActor handle
 
   // Pass ownership to CustomActor handle

-  Toolkit::CubeTransitionFoldEffect cubeTransEffect( internalCubeTransEffect );
+  Toolkit::CubeTransitionFoldEffect cubeTransEffect( *internalCubeTransEffect );

 
   //Initialization
   internalCubeTransEffect->Initialize();
 
   //Initialization
   internalCubeTransEffect->Initialize();


@@ -49,87 +47,97 @@ Toolkit::CubeTransitionFoldEffect CubeTransitionFoldEffect::New(unsigned int num
 
 void CubeTransitionFoldEffect::OnInitialize()
 {
 
 void CubeTransitionFoldEffect::OnInitialize()
 {

-  float offset = mTileSize.width*0.5f;

   unsigned int idx;
   unsigned int idx;

-  for( unsigned int y = 0; y < mNumRows; y++ )
+  for( unsigned int y = 0; y < mRows; y++ )

   {
   {

-    idx = y*mNumColumns;
-    for( unsigned int x = y%2; x < mNumColumns; x=x+2)
+    idx = y*mColumns;
+    for( unsigned int x = y%2; x < mColumns; x=x+2)

     {
     {

-      mTiles[0][idx+x].SetZ( offset );
-      mTiles[1][idx+x].SetX( offset );
+      SetTargetLeft( idx + x );

     }
     }

-    for( unsigned int x = (y+1)%2; x < mNumColumns; x=x+2)
+    for( unsigned int x = (y+1)%2; x < mColumns; x=x+2)

     {
     {

-      mTiles[0][idx+x].SetZ( offset );
-      mTiles[1][idx+x].SetX( -offset );
+      SetTargetRight( idx + x );

     }
   }
 }
 
 void CubeTransitionFoldEffect::OnStartTransition( Vector2 panPosition, Vector2 panDisplacement )
 {
     }
   }
 }
 
 void CubeTransitionFoldEffect::OnStartTransition( Vector2 panPosition, Vector2 panDisplacement )
 {

-  float angle = mRotateIndex * Math::PI_2 ;
-  Vector3 translation0 = mTiles[mContainerIndex][ 0 ].GetCurrentPosition()*(-2.f);
-  Vector3 translation1 = mTiles[mContainerIndex][ mNumColumns ].GetCurrentPosition()*(-2.f);
+  float angle = Math::PI_2;

 
   unsigned int idx;
 
   unsigned int idx;

-
-  for( unsigned int y = 0; y < mNumRows; y++ )
+  if( panDisplacement.x < 0 )

   {
   {

-    for( unsigned int x = y%2; x < mNumColumns; x=x+2)
+    for( unsigned int y = 0; y < mRows; y++ )

     {
     {

-      idx = y*mNumColumns + x;
-      SetupAnimation( idx, -angle, translation0 );
+      idx = y*mColumns;
+      for( unsigned int x = y%2; x < mColumns; x=x+2)
+      {
+        SetTargetLeft( idx + x );
+      }
+      for( unsigned int x = (y+1)%2; x < mColumns; x=x+2)
+      {
+        SetTargetRight( idx + x );
+      }

     }
     }

-    for( unsigned int x = (y+1)%2; x < mNumColumns; x=x+2)
+  }
+  else
+  {
+    angle = -angle;
+
+    for( unsigned int y = 0; y < mRows; y++ )

     {
     {

-      idx = y*mNumColumns + x;
-      SetupAnimation( idx, angle, translation1 );
+      idx = y*mColumns;
+      for( unsigned int x = y%2; x < mColumns; x=x+2)
+      {
+        SetTargetRight( idx + x );
+      }
+      for( unsigned int x = (y+1)%2; x < mColumns; x=x+2)
+      {
+        SetTargetLeft( idx + x );
+      }

     }
   }
 
     }
   }
 

-  mAnimation.Play();
-  mIsAnimating = true;
-}
-
-void CubeTransitionFoldEffect::OnStopTransition()
-{
-  float angle = mRotateIndex * Math::PI_2 ;
-  unsigned int idx;
-  for( unsigned int y = 0; y < mNumRows; y++ )
+  for( unsigned int y = 0; y < mRows; y++ )

   {
   {

-    idx = y*mNumColumns;
-    for( unsigned int x = y%2; x < mNumColumns; x=x+2)
+    idx = y*mColumns;
+    for( unsigned int x = y%2; x < mColumns; x=x+2)

     {
     {

-      mBoxes[idx+x].SetOrientation( Radian(angle), Vector3::YAXIS );
+      SetupAnimation( idx + x, x, angle );

     }
     }

-    for( unsigned int x = (y+1)%2; x < mNumColumns; x=x+2)
+    for( unsigned int x = (y+1)%2; x < mColumns; x=x+2)

     {
     {

-      mBoxes[idx+x].SetOrientation( Radian(-angle), Vector3::YAXIS );
+      SetupAnimation( idx + x, x, -angle );

     }
   }
     }
   }

+
+  mAnimation.Play();
+  mIsAnimating = true;

 }
 
 }
 

-void CubeTransitionFoldEffect::SetupAnimation(unsigned int actorIndex, float angle, Vector3 resetTranslation)
+void CubeTransitionFoldEffect::SetupAnimation( unsigned int actorIndex, unsigned int x, float angle )

 {
 {

-  Actor currentCube = mBoxes[actorIndex];
-  ImageActor sideTile = mTiles[mContainerIndex][actorIndex];
-  ImageActor frontTile = mTiles[mContainerIndex^1][actorIndex];
-  if ( mFirstTransition && (!mIsToNextImage) ) // for the first transition, it is going to previous image
-  {
-    sideTile.SetOrientation( Radian( angle),   Vector3::YAXIS );
-  }
-  else if( !mChangeTurningDirection )   // reset rotation, translation and color
-  {
-    sideTile.TranslateBy( resetTranslation );
-    sideTile.SetOrientation( Radian( angle),   Vector3::YAXIS );
-  }
-  mAnimation.AnimateTo( Property( currentCube, Actor::Property::ORIENTATION ), Quaternion( Radian( -angle ), Vector3::YAXIS ), AlphaFunction::LINEAR );
-  Vector3 position(currentCube.GetCurrentPosition());
-  mAnimation.AnimateTo( Property( currentCube, Actor::Property::POSITION ), Vector3( position.x*mDisplacementRatio, position.y, position.z ), AlphaFunction::BOUNCE );
-  mAnimation.AnimateTo( Property( frontTile, Actor::Property::COLOR ), HALF_BRIGHTNESS, AlphaFunction::EASE_OUT );
-  mAnimation.AnimateTo( Property( sideTile, Actor::Property::COLOR ), FULL_BRIGHTNESS, AlphaFunction::EASE_IN );
+  //rotate and translate the cube such that the edges remain in constant contact
+  //calculate the maximum distance the cube has to move when it the box has rotated 45 degrees
+  //ie distance from of centre of square to a vertex is given by:
+  //  distance = width / sqrt(2)
+  //therefore the delta distance the cube should move is given by:
+  //  delta_distance = ( width / 2 ) - distance
+  //re-arranging we get:
+  //  delta_distance = ( width / 2 ) * ( sqrt(2) - 1 )
+  //accumulating over the length of the row we get:
+  //  delta_distance_at_x = x * delta_distance;
+
+  float delta = (float)x * mTileSize.x * ( 1.4142f - 1.0f );
+
+  Vector3 position( mBoxes[ actorIndex ].GetCurrentPosition() );
+  mAnimation.AnimateTo( Property( mBoxes[ actorIndex ], Actor::Property::ORIENTATION ), Quaternion( Radian( angle ), Vector3::YAXIS ), AlphaFunction::LINEAR );
+  mAnimation.AnimateTo( Property( mBoxes[ actorIndex ], Actor::Property::POSITION_X ), position.x + delta, AlphaFunction::BOUNCE );
+
+  mAnimation.AnimateTo( Property( mCurrentTiles[ actorIndex ], Actor::Property::COLOR ), HALF_BRIGHTNESS, AlphaFunction::EASE_OUT );
+  mAnimation.AnimateTo( Property( mTargetTiles[ actorIndex ], Actor::Property::COLOR ), FULL_BRIGHTNESS, AlphaFunction::EASE_IN );

 }
 
 } // namespace Internal
 }
 
 } // namespace Internal

diff --git a/dali-toolkit/internal/transition-effects/cube-transition-fold-effect-impl.h b/dali-toolkit/internal/transition-effects/cube-transition-fold-effect-impl.h
index 0afee71..336557f 100644 (file)
--- a/dali-toolkit/internal/transition-effects/cube-transition-fold-effect-impl.h
+++ b/dali-toolkit/internal/transition-effects/cube-transition-fold-effect-impl.h
@@ -45,7 +45,7 @@ public:
   /**
    * @copydoc Toolkit::CubeTransitionFoldEffect::New
    */
   /**
    * @copydoc Toolkit::CubeTransitionFoldEffect::New
    */

-  static Toolkit::CubeTransitionFoldEffect New(unsigned int numRows, unsigned int numColumns, Size viewAreaSize);
+  static Toolkit::CubeTransitionFoldEffect New( unsigned int numRows, unsigned int numColumns );

 
 protected:
 
 
 protected:
 


@@ -59,32 +59,21 @@ protected:
     */
    virtual void OnStartTransition( Vector2 panPosition, Vector2 panDisplacement );
 
     */
    virtual void OnStartTransition( Vector2 panPosition, Vector2 panDisplacement );
 

-   /**
-    * @copydoc Toolkit::Internal::CubeTransitionEffect::OnStopTransition
-    */
-   virtual void OnStopTransition();

 private:
 
    /**
     * Construct a new CubeTransitionFoldEffect object
     * @param[in] numRows How many rows of cubes
     * @param[in] numColumns How many columns of cubes
 private:
 
    /**
     * Construct a new CubeTransitionFoldEffect object
     * @param[in] numRows How many rows of cubes
     * @param[in] numColumns How many columns of cubes

-    * @param[in] viewAreaSize The size of view area for this transition effect

     */
     */

-   CubeTransitionFoldEffect( unsigned int numRows, unsigned int numColumns, Size viewAreaSize );
+   CubeTransitionFoldEffect( unsigned int numRows, unsigned int numColumns );

 
    /**
     * Set up animation to an Actor
     * @param[in] actorIndex The index of the cube in the cube array
     * @param[in] angle The angle of the rotation animation
 
    /**
     * Set up animation to an Actor
     * @param[in] actorIndex The index of the cube in the cube array
     * @param[in] angle The angle of the rotation animation

-    * @param[in] resetTranslation The translation used to reset the actor position before animation

     */
     */

-
-   void SetupAnimation( unsigned int actorIndex, float angle, Vector3 resetTranslation );
-
-private:
-
-   static const float  mDisplacementRatio;
+   void SetupAnimation( unsigned int actorIndex, unsigned int x, float angle );

 
 }; //class CubeTransitionFoldEffect
 
 
 }; //class CubeTransitionFoldEffect
 


@@ -92,22 +81,22 @@ private:
 
 // Helpers for public-api forwarding methods
 
 
 // Helpers for public-api forwarding methods
 

-inline Internal::CubeTransitionFoldEffect& GetImpl(Dali::Toolkit::CubeTransitionFoldEffect& obj)
+inline Internal::CubeTransitionFoldEffect& GetImpl( Dali::Toolkit::CubeTransitionFoldEffect& obj )

 {
 {

-  DALI_ASSERT_ALWAYS(obj);
+  DALI_ASSERT_ALWAYS( obj );

 
 

-  Dali::BaseObject& handle = obj.GetBaseObject();
+  Dali::RefObject& handle = obj.GetImplementation();

 
 

-  return static_cast<Internal::CubeTransitionFoldEffect&>(handle);
+  return static_cast< Internal::CubeTransitionFoldEffect& >( handle );

 }
 
 }
 

-inline const Internal::CubeTransitionFoldEffect& GetImpl(const Dali::Toolkit::CubeTransitionFoldEffect& obj)
+inline const Internal::CubeTransitionFoldEffect& GetImpl( const Dali::Toolkit::CubeTransitionFoldEffect& obj )

 {
 {

-  DALI_ASSERT_ALWAYS(obj);
+  DALI_ASSERT_ALWAYS( obj );

 
 

-  const Dali::BaseObject& handle = obj.GetBaseObject();
+  const Dali::RefObject& handle = obj.GetImplementation();

 
 

-  return static_cast<const Internal::CubeTransitionFoldEffect&>(handle);
+  return static_cast< const Internal::CubeTransitionFoldEffect& >( handle );

 }
 
 } // namespace Toolkit
 }
 
 } // namespace Toolkit

diff --git a/dali-toolkit/internal/transition-effects/cube-transition-wave-effect-impl.cpp b/dali-toolkit/internal/transition-effects/cube-transition-wave-effect-impl.cpp
index 818e670..d4ce91d 100644 (file)
--- a/dali-toolkit/internal/transition-effects/cube-transition-wave-effect-impl.cpp
+++ b/dali-toolkit/internal/transition-effects/cube-transition-wave-effect-impl.cpp
@@ -27,21 +27,21 @@ namespace Toolkit
 namespace Internal
 {
 
 namespace Internal
 {
 

-CubeTransitionWaveEffect::CubeTransitionWaveEffect( unsigned int numRows, unsigned int numColumns, Size viewAreaSize )
-: CubeTransitionEffect( numRows, numColumns, viewAreaSize),
+CubeTransitionWaveEffect::CubeTransitionWaveEffect( unsigned int numRows, unsigned int numColumns )
+: CubeTransitionEffect( numRows, numColumns ),

   mSaddleAA( 1.f ),
   mSaddleBB( 1.f ),
   mSaddleB( 1.f )
 {
 }
 
   mSaddleAA( 1.f ),
   mSaddleBB( 1.f ),
   mSaddleB( 1.f )
 {
 }
 

-Toolkit::CubeTransitionWaveEffect CubeTransitionWaveEffect::New(unsigned int numRows, unsigned int numColumns, Size viewAreaSize)
+Toolkit::CubeTransitionWaveEffect CubeTransitionWaveEffect::New(unsigned int numRows, unsigned int numColumns )

 {
   // Create the implementation
 {
   // Create the implementation

-  CubeTransitionWaveEffect* internalCubeTransEffect = new CubeTransitionWaveEffect( numRows, numColumns, viewAreaSize );
+  IntrusivePtr< CubeTransitionWaveEffect > internalCubeTransEffect = new CubeTransitionWaveEffect( numRows, numColumns );

 
   // Pass ownership to CustomActor handle
 
   // Pass ownership to CustomActor handle

-  Toolkit::CubeTransitionWaveEffect cubeTransEffect( internalCubeTransEffect );
+  Toolkit::CubeTransitionWaveEffect cubeTransEffect( *internalCubeTransEffect );

 
   //Initialization
   internalCubeTransEffect->Initialize();
 
   //Initialization
   internalCubeTransEffect->Initialize();


@@ -51,59 +51,54 @@ Toolkit::CubeTransitionWaveEffect CubeTransitionWaveEffect::New(unsigned int num
 
 void CubeTransitionWaveEffect::OnInitialize()
 {
 
 void CubeTransitionWaveEffect::OnInitialize()
 {

-  float offset = -mTileSize.width * 0.5f;
-  unsigned int totalNum = mNumColumns* mNumRows;
-  for( unsigned int idx = 0; idx < totalNum; idx++ )
+  for( unsigned int idx = 0; idx < mTargetTiles.size(); idx++ )

   {
   {

-    mTiles[ 0 ][idx].SetZ( -offset );
-    mTiles[ 1 ][idx].SetX( offset );
+    SetTargetRight( idx );

   }
 }
 
 void CubeTransitionWaveEffect::OnStartTransition( Vector2 panPosition, Vector2 panDisplacement )
 {
   }
 }
 
 void CubeTransitionWaveEffect::OnStartTransition( Vector2 panPosition, Vector2 panDisplacement )
 {

-  float direc = mIsToNextImage ? 1.f : -1.f;
-  CalculateSaddleSurfaceParameters( panPosition, panDisplacement*direc );
+  bool forward = panDisplacement.x < 0.0;
+  CalculateSaddleSurfaceParameters( panPosition, forward ? panDisplacement : -panDisplacement );

 
 

-  float angle = mRotateIndex * 90.0f ;
-  Vector3 translation = mTiles[mContainerIndex][ 0 ].GetCurrentPosition()*(-2.f);
+  float angle = Math::PI_2;

 
   unsigned int idx;
 
   unsigned int idx;

-  unsigned int totalNum = mNumColumns* mNumRows;
-  if( mFirstTransition && (!mIsToNextImage) ) // the first transition is transiting to previous image
+  if( forward )

   {
   {

-    for( unsigned int idx = 0; idx < totalNum; idx++ )
+    for( idx = 0; idx < mTargetTiles.size(); idx++ )

     {
     {

-      mTiles[mContainerIndex][idx].SetOrientation( Degree( angle),  Vector3::YAXIS );
+      SetTargetRight( idx );

     }
   }
     }
   }

-  else if(!mChangeTurningDirection)  // reset rotation, translation
+  else

   {
   {

-    for( unsigned int idx = 0; idx < totalNum; idx++ )
+    angle = -angle;
+    for( idx = 0; idx < mTargetTiles.size(); idx++ )

     {
     {

-      mTiles[mContainerIndex][idx].TranslateBy( translation );
-      mTiles[mContainerIndex][idx].SetOrientation( Degree( angle),  Vector3::YAXIS );
+      SetTargetLeft( idx );

     }
   }
 
   float thirdAnimationDuration = mAnimationDuration / 3.f;
     }
   }
 
   float thirdAnimationDuration = mAnimationDuration / 3.f;

-  unsigned int anotherIndex = mContainerIndex^1;

 
 

-  for( unsigned int y = 0; y < mNumRows; y++ )
+  for( unsigned int y = 0; y < mRows; y++ )

   {
   {

-    for( unsigned int x = 0; x < mNumColumns; x++)
+    idx = y * mColumns;
+    for( unsigned int x = 0; x < mColumns; x++, idx++)

     {
     {

-      idx = y*mNumColumns + x;

       // the delay value is within 0.f ~ 2.f*thirdAnimationDuration
       // the delay value is within 0.f ~ 2.f*thirdAnimationDuration

-      float delay = thirdAnimationDuration * CalculateDelay(x*mTileSize.width,y*mTileSize.height);
+      float delay = thirdAnimationDuration * CalculateDelay( x * mTileSize.width, y * mTileSize.height, forward );

 
 

-      mAnimation.AnimateTo( Property( mBoxes[idx], Actor::Property::ORIENTATION ), Quaternion( Radian( Degree( -angle ) ), Vector3::YAXIS ),
+      mAnimation.AnimateTo( Property( mBoxes[ idx ], Actor::Property::ORIENTATION ), Quaternion( Radian( -angle ), Vector3::YAXIS ),

                             AlphaFunction::EASE_OUT_SINE, TimePeriod( delay, thirdAnimationDuration ) );
       mAnimation.AnimateBy( Property( mBoxes[idx], Actor::Property::POSITION ), Vector3( 0.f, 0.f, -mCubeDisplacement ),
                          AlphaFunction::BOUNCE, TimePeriod( delay, thirdAnimationDuration ) );
                             AlphaFunction::EASE_OUT_SINE, TimePeriod( delay, thirdAnimationDuration ) );
       mAnimation.AnimateBy( Property( mBoxes[idx], Actor::Property::POSITION ), Vector3( 0.f, 0.f, -mCubeDisplacement ),
                          AlphaFunction::BOUNCE, TimePeriod( delay, thirdAnimationDuration ) );

-      mAnimation.AnimateTo( Property( mTiles[anotherIndex][idx], Actor::Property::COLOR ), HALF_BRIGHTNESS,
+
+      mAnimation.AnimateTo( Property( mCurrentTiles[ idx ], Actor::Property::COLOR ), HALF_BRIGHTNESS,

                           AlphaFunction::EASE_OUT, TimePeriod( delay, thirdAnimationDuration ) );
                           AlphaFunction::EASE_OUT, TimePeriod( delay, thirdAnimationDuration ) );

-      mAnimation.AnimateTo( Property( mTiles[mContainerIndex][idx], Actor::Property::COLOR ), FULL_BRIGHTNESS,
+      mAnimation.AnimateTo( Property( mTargetTiles[ idx ], Actor::Property::COLOR ), FULL_BRIGHTNESS,

                           AlphaFunction::EASE_IN, TimePeriod( delay, thirdAnimationDuration ) );
     }
   }
                           AlphaFunction::EASE_IN, TimePeriod( delay, thirdAnimationDuration ) );
     }
   }


@@ -112,18 +107,9 @@ void CubeTransitionWaveEffect::OnStartTransition( Vector2 panPosition, Vector2 p
   mIsAnimating = true;
 }
 
   mIsAnimating = true;
 }
 

-void CubeTransitionWaveEffect::OnStopTransition()
-{
-  float angle = - mRotateIndex * 90.0f ;
-  unsigned int totalNum = mNumRows * mNumColumns;
-  for( unsigned int idx = 0; idx < totalNum; idx++ )
-  {
-    mBoxes[idx].SetOrientation( Degree( angle ), Vector3::YAXIS );
-  }
-}
-

 void  CubeTransitionWaveEffect::CalculateSaddleSurfaceParameters( Vector2 position, Vector2 displacement )
 {
 void  CubeTransitionWaveEffect::CalculateSaddleSurfaceParameters( Vector2 position, Vector2 displacement )
 {

+  const Vector2& size = Self().GetCurrentSize().GetVectorXY();

   // the line passes through 'position' and has the direction of 'displacement'
   float coefA, coefB, coefC; //line equation: Ax+By+C=0;
   coefA = displacement.y;
   // the line passes through 'position' and has the direction of 'displacement'
   float coefA, coefB, coefC; //line equation: Ax+By+C=0;
   coefA = displacement.y;


@@ -139,31 +125,31 @@ void  CubeTransitionWaveEffect::CalculateSaddleSurfaceParameters( Vector2 positi
     //distance from (0,0) to the line
     float distanceTopLeft =  fabsf(coefC) * inversedSqrtAABB;
     //distance from (viewAreaSize.x, viewAreaSize.y) to the line
     //distance from (0,0) to the line
     float distanceTopLeft =  fabsf(coefC) * inversedSqrtAABB;
     //distance from (viewAreaSize.x, viewAreaSize.y) to the line

-    float distanceBottomRight = fabsf(coefA*mViewAreaSize.x+coefB*mViewAreaSize.y+coefC) * inversedSqrtAABB;
+    float distanceBottomRight = fabsf(coefA*size.x+coefB*size.y+coefC) * inversedSqrtAABB;

     saddleA = std::max( distanceTopLeft, distanceBottomRight );
 
     //foot of a perpendicular: (viewAreaSize.x,0) to the line
     saddleA = std::max( distanceTopLeft, distanceBottomRight );
 
     //foot of a perpendicular: (viewAreaSize.x,0) to the line

-    float footX1 = ( coefB*coefB*mViewAreaSize.x - coefA*coefC) * inversedAABB;
-    float footY1 = (-coefA*coefB*mViewAreaSize.x - coefB*coefC) * inversedAABB;
+    float footX1 = ( coefB*coefB*size.x - coefA*coefC) * inversedAABB;
+    float footY1 = (-coefA*coefB*size.x - coefB*coefC) * inversedAABB;

     //foot of a perpendicular: (0,viewAreaSize.y) to the line
     //foot of a perpendicular: (0,viewAreaSize.y) to the line

-    float footX2 = (-coefA*coefB*mViewAreaSize.y - coefA*coefC) * inversedAABB;
-    float footY2 = ( coefA*coefA*mViewAreaSize.y - coefB*coefC) * inversedAABB;
+    float footX2 = (-coefA*coefB*size.y - coefA*coefC) * inversedAABB;
+    float footY2 = ( coefA*coefA*size.y - coefB*coefC) * inversedAABB;

     mSaddleBB = (footX1-footX2)*(footX1-footX2) + (footY1-footY2)*(footY1-footY2);
     mTranslation = Vector2(-footX2,-footY2);
   }
   else
   {
     //distance from(viewAreaSize.x,0) to the line
     mSaddleBB = (footX1-footX2)*(footX1-footX2) + (footY1-footY2)*(footY1-footY2);
     mTranslation = Vector2(-footX2,-footY2);
   }
   else
   {
     //distance from(viewAreaSize.x,0) to the line

-    float distanceTopRight = fabsf(coefA*mViewAreaSize.x+coefC) * inversedSqrtAABB;
+    float distanceTopRight = fabsf(coefA*size.x+coefC) * inversedSqrtAABB;

     //distance from(0,viewAreaSize.y) to the line
     //distance from(0,viewAreaSize.y) to the line

-    float distanceBottomLeft = fabsf(coefB*mViewAreaSize.y+coefC) * inversedSqrtAABB;
+    float distanceBottomLeft = fabsf(coefB*size.y+coefC) * inversedSqrtAABB;

     saddleA = std::max( distanceTopRight, distanceBottomLeft );
     //foot of a perpendicular: (0,0) to the line
     float footX3 = (-coefA*coefC) * inversedAABB;
     float footY3 = (-coefB*coefC) * inversedAABB;
     //foot of a perpendicular: (viewAreaSize.x,viewAreaSize.y) to the line
     saddleA = std::max( distanceTopRight, distanceBottomLeft );
     //foot of a perpendicular: (0,0) to the line
     float footX3 = (-coefA*coefC) * inversedAABB;
     float footY3 = (-coefB*coefC) * inversedAABB;
     //foot of a perpendicular: (viewAreaSize.x,viewAreaSize.y) to the line

-    float footX4 = ( coefB*coefB*mViewAreaSize.x - coefA*coefB*mViewAreaSize.y - coefA*coefC) * inversedAABB;
-    float footY4 = (-coefA*coefB*mViewAreaSize.x + coefA*coefA*mViewAreaSize.y - coefB*coefC) * inversedAABB;
+    float footX4 = ( coefB*coefB*size.x - coefA*coefB*size.y - coefA*coefC) * inversedAABB;
+    float footY4 = (-coefA*coefB*size.x + coefA*coefA*size.y - coefB*coefC) * inversedAABB;

     mSaddleBB = (footX3-footX4)*(footX3-footX4) + (footY3-footY4)*(footY3-footY4);
     mTranslation = Vector2(-footX3, -footY3);
   }
     mSaddleBB = (footX3-footX4)*(footX3-footX4) + (footY3-footY4)*(footY3-footY4);
     mTranslation = Vector2(-footX3, -footY3);
   }


@@ -184,13 +170,13 @@ void  CubeTransitionWaveEffect::CalculateSaddleSurfaceParameters( Vector2 positi
   mRotation.Normalize();
 }
 
   mRotation.Normalize();
 }
 

-float CubeTransitionWaveEffect::CalculateDelay(float x, float y)
+float CubeTransitionWaveEffect::CalculateDelay( float x, float y, bool forward )

 {
   float tx = x + mTranslation.x;
   float ty = y + mTranslation.y;
   float valueX = mRotation.x * tx - mRotation.y * ty;
   float valueY = mRotation.y * tx + mRotation.x * ty;
 {
   float tx = x + mTranslation.x;
   float ty = y + mTranslation.y;
   float valueX = mRotation.x * tx - mRotation.y * ty;
   float valueY = mRotation.y * tx + mRotation.x * ty;

-  if(!mIsToNextImage) // to previous image
+  if( !forward ) // to previous image

   {
     valueX = mSaddleB - valueX;
   }
   {
     valueX = mSaddleB - valueX;
   }

diff --git a/dali-toolkit/internal/transition-effects/cube-transition-wave-effect-impl.h b/dali-toolkit/internal/transition-effects/cube-transition-wave-effect-impl.h
index baa0a14..d53ccc4 100644 (file)
--- a/dali-toolkit/internal/transition-effects/cube-transition-wave-effect-impl.h
+++ b/dali-toolkit/internal/transition-effects/cube-transition-wave-effect-impl.h
@@ -45,7 +45,7 @@ public:
   /**
    * @copydoc Toolkit::CubeTransitionWaveEffect::New
    */
   /**
    * @copydoc Toolkit::CubeTransitionWaveEffect::New
    */

-  static Toolkit::CubeTransitionWaveEffect New(unsigned int numRows, unsigned int numColumns, Size viewAreaSize);
+  static Toolkit::CubeTransitionWaveEffect New(unsigned int numRows, unsigned int numColumns );

 
 protected:
 
 
 protected:
 


@@ -59,20 +59,14 @@ protected:
    */
   virtual void OnStartTransition( Vector2 panPosition, Vector2 panDisplacement );
 
    */
   virtual void OnStartTransition( Vector2 panPosition, Vector2 panDisplacement );
 

-  /**
-   * @copydoc Toolkit::Internal::CubeTransitionEffect::OnStopTransition
-   */
-  virtual void OnStopTransition();
-

 private:
 
   /**
    * Construct a new CubeTransitionWaveEffect object
    * @param[in] numRows How many rows of cubes
    * @param[in] numColumns How many columns of cubes
 private:
 
   /**
    * Construct a new CubeTransitionWaveEffect object
    * @param[in] numRows How many rows of cubes
    * @param[in] numColumns How many columns of cubes

-   * @param[in] viewAreaSize The size of view area for this transition effect

    */
    */

-  CubeTransitionWaveEffect( unsigned int numRows, unsigned int numColumns, Size viewAreaSize );
+  CubeTransitionWaveEffect( unsigned int numRows, unsigned int numColumns );

 
   /**
    * The Saddle surface (Hyperbolic paraboloid)function is used to calculate the delay of rotating animation for each cube
 
   /**
    * The Saddle surface (Hyperbolic paraboloid)function is used to calculate the delay of rotating animation for each cube


@@ -81,7 +75,7 @@ private:
    * @param[in] position The press down position of panGesture
    * @param[in] displacement The displacement vector of panGesture
    */
    * @param[in] position The press down position of panGesture
    * @param[in] displacement The displacement vector of panGesture
    */

-  void CalculateSaddleSurfaceParameters( Vector2 position, Vector2 displacement );
+  void CalculateSaddleSurfaceParameters( Vector2 position, Vector2 displacement);

 
   /**
    * Calculate the delay of the animation for each cube
 
   /**
    * Calculate the delay of the animation for each cube


@@ -89,7 +83,7 @@ private:
    * @param[in] y The Y coordinate of the cube
    * @return The delay time of the animation
    */
    * @param[in] y The Y coordinate of the cube
    * @return The delay time of the animation
    */

-  float CalculateDelay(float x, float y);
+  float CalculateDelay( float x, float y, bool forward );

 
 private:
 
 
 private:
 


@@ -108,22 +102,22 @@ private:
 
 // Helpers for public-api forwarding methods
 
 
 // Helpers for public-api forwarding methods
 

-inline Internal::CubeTransitionWaveEffect& GetImpl(Dali::Toolkit::CubeTransitionWaveEffect& obj)
+inline Internal::CubeTransitionWaveEffect& GetImpl( Dali::Toolkit::CubeTransitionWaveEffect& obj )

 {
 {

-  DALI_ASSERT_ALWAYS(obj);
+  DALI_ASSERT_ALWAYS( obj );

 
 

-  Dali::BaseObject& handle = obj.GetBaseObject();
+  Dali::RefObject& handle = obj.GetImplementation();

 
 

-  return static_cast<Internal::CubeTransitionWaveEffect&>(handle);
+  return static_cast< Internal::CubeTransitionWaveEffect& >( handle );

 }
 
 }
 

-inline const Internal::CubeTransitionWaveEffect& GetImpl(const Dali::Toolkit::CubeTransitionWaveEffect& obj)
+inline const Internal::CubeTransitionWaveEffect& GetImpl( const Dali::Toolkit::CubeTransitionWaveEffect& obj )

 {
 {

-  DALI_ASSERT_ALWAYS(obj);
+  DALI_ASSERT_ALWAYS( obj );

 
 

-  const Dali::BaseObject& handle = obj.GetBaseObject();
+  const Dali::RefObject& handle = obj.GetImplementation();

 
 

-  return static_cast<const Internal::CubeTransitionWaveEffect&>(handle);
+  return static_cast< const Internal::CubeTransitionWaveEffect& >( handle );

 }
 
 } // namespace Toolkit
 }
 
 } // namespace Toolkit