Merge "Refactored ControlRenderer so that derived classes are responsible for the...
authorKimmo Hoikka <kimmo.hoikka@samsung.com>
Tue, 27 Oct 2015 14:29:07 +0000 (07:29 -0700)
committerGerrit Code Review <gerrit@review.vlan103.tizen.org>
Tue, 27 Oct 2015 14:29:07 +0000 (07:29 -0700)
51 files changed:
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-imf-manager.cpp
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-imf-manager.h
automated-tests/src/dali-toolkit/utc-Dali-CubeTransitionEffect.cpp
automated-tests/src/dali-toolkit/utc-Dali-ShaderEffects.cpp
dali-toolkit/devel-api/controls/shadow-view/shadow-view.cpp
dali-toolkit/devel-api/controls/shadow-view/shadow-view.h
dali-toolkit/devel-api/controls/text-controls/text-selection-toolbar.h
dali-toolkit/devel-api/shader-effects/motion-blur-effect.h
dali-toolkit/devel-api/shader-effects/motion-stretch-effect.h
dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.cpp
dali-toolkit/devel-api/transition-effects/cube-transition-cross-effect.h
dali-toolkit/devel-api/transition-effects/cube-transition-effect.cpp
dali-toolkit/devel-api/transition-effects/cube-transition-effect.h
dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.cpp
dali-toolkit/devel-api/transition-effects/cube-transition-fold-effect.h
dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.cpp
dali-toolkit/devel-api/transition-effects/cube-transition-wave-effect.h
dali-toolkit/internal/controls/image-view/image-view-impl.cpp
dali-toolkit/internal/controls/model3d-view/model3d-view-impl.cpp
dali-toolkit/internal/controls/page-turn-view/page-turn-view-impl.cpp
dali-toolkit/internal/controls/page-turn-view/page-turn-view-impl.h
dali-toolkit/internal/controls/renderers/border/border-renderer.cpp
dali-toolkit/internal/controls/scroll-bar/scroll-bar-impl.cpp
dali-toolkit/internal/controls/scroll-bar/scroll-bar-impl.h
dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.cpp
dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h
dali-toolkit/internal/controls/scrollable/scroll-view/scroll-overshoot-indicator-impl.cpp
dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.cpp
dali-toolkit/internal/controls/shadow-view/shadow-view-impl.cpp
dali-toolkit/internal/controls/shadow-view/shadow-view-impl.h
dali-toolkit/internal/controls/text-controls/text-field-impl.cpp
dali-toolkit/internal/controls/text-controls/text-label-impl.cpp
dali-toolkit/internal/controls/text-controls/text-selection-toolbar-impl.cpp
dali-toolkit/internal/controls/text-controls/text-selection-toolbar-impl.h
dali-toolkit/internal/text/text-controller-impl.cpp
dali-toolkit/internal/text/text-controller-impl.h
dali-toolkit/internal/text/text-controller.cpp
dali-toolkit/internal/transition-effects/cube-transition-cross-effect-impl.cpp
dali-toolkit/internal/transition-effects/cube-transition-cross-effect-impl.h
dali-toolkit/internal/transition-effects/cube-transition-effect-impl.cpp
dali-toolkit/internal/transition-effects/cube-transition-effect-impl.h
dali-toolkit/internal/transition-effects/cube-transition-fold-effect-impl.cpp
dali-toolkit/internal/transition-effects/cube-transition-fold-effect-impl.h
dali-toolkit/internal/transition-effects/cube-transition-wave-effect-impl.cpp
dali-toolkit/internal/transition-effects/cube-transition-wave-effect-impl.h
dali-toolkit/public-api/controls/control-depth-index-ranges.h
dali-toolkit/public-api/controls/control-impl.cpp
dali-toolkit/public-api/dali-toolkit-version.cpp
dali-toolkit/styles/480x800/dali-toolkit-default-theme.json
dali-toolkit/styles/720x1280/dali-toolkit-default-theme.json
packaging/dali-toolkit.spec

index 0aee8ec..e35ce05 100644 (file)
@@ -21,7 +21,6 @@
 // EXTERNAL INCLUDES
 #include <dali/public-api/object/base-object.h>
 #include <dali/integration-api/debug.h>
-#include <dali/integration-api/events/key-event-integ.h>
 
 namespace Dali
 {
@@ -51,10 +50,10 @@ public:
   bool RestoreAfterFocusLost() const;
   void SetRestoreAfterFocusLost( bool toggle );
   void NotifyCursorPosition();
-  int GetCursorPosition();
   void SetCursorPosition( unsigned int cursorPosition );
-  void SetSurroundingText( std::string text );
-  std::string GetSurroundingText();
+  unsigned int GetCursorPosition() const;
+  void SetSurroundingText( const std::string& text );
+  const std::string& GetSurroundingText() const;
 
 public:  // Signals
   ImfManagerSignalType& ActivatedSignal() { return mActivatedSignal; }
@@ -78,7 +77,6 @@ private:
   bool mRestoreAfterFocusLost:1;             ///< Whether the keyboard needs to be restored (activated ) after focus regained.
   bool mIdleCallbackConnected:1;             ///< Whether the idle callback is already connected.
 
-  std::vector<Dali::Integration::KeyEvent> mKeyEvents; ///< Stores key events to be sent from idle call-back.
   ImfManagerSignalType      mActivatedSignal;
   ImfEventSignalType        mEventSignal;
 
@@ -120,10 +118,9 @@ Dali::ImfManager ImfManager::Get()
 
 ImfManager::ImfManager( /*Ecore_X_Window ecoreXwin*/ )
 : mIMFCursorPosition( 0 ),
-  mSurroundingText(""),
+  mSurroundingText(),
   mRestoreAfterFocusLost( false ),
-  mIdleCallbackConnected( false ),
-  mKeyEvents()
+  mIdleCallbackConnected( false )
 {
   CreateContext( /*ecoreXwin*/ );
   ConnectCallbacks();
@@ -178,22 +175,22 @@ void ImfManager::NotifyCursorPosition()
 {
 }
 
-int ImfManager::GetCursorPosition()
+void ImfManager::SetCursorPosition( unsigned int cursorPosition )
 {
-  return mIMFCursorPosition;
+  mIMFCursorPosition = static_cast< int >( cursorPosition );
 }
 
-void ImfManager::SetCursorPosition( unsigned int cursorPosition )
+unsigned int ImfManager::GetCursorPosition() const
 {
-  mIMFCursorPosition = ( int )cursorPosition;
+  return static_cast<unsigned int>( mIMFCursorPosition );
 }
 
-void ImfManager::SetSurroundingText( std::string text )
+void ImfManager::SetSurroundingText( const std::string& text )
 {
   mSurroundingText = text;
 }
 
-std::string ImfManager::GetSurroundingText()
+const std::string& ImfManager::GetSurroundingText() const
 {
   return mSurroundingText;
 }
@@ -220,11 +217,6 @@ ImfManager ImfManager::Get()
   return Internal::Adaptor::ImfManager::Get();
 }
 
-ImfContext ImfManager::GetContext()
-{
-  return NULL;
-}
-
 void ImfManager::Activate()
 {
   Internal::Adaptor::ImfManager::GetImplementation(*this).Activate();
@@ -260,17 +252,17 @@ void ImfManager::SetCursorPosition( unsigned int SetCursorPosition )
   Internal::Adaptor::ImfManager::GetImplementation(*this).SetCursorPosition( SetCursorPosition );
 }
 
-int ImfManager::GetCursorPosition()
+unsigned int ImfManager::GetCursorPosition() const
 {
   return Internal::Adaptor::ImfManager::GetImplementation(*this).GetCursorPosition();
 }
 
-void ImfManager::SetSurroundingText( std::string text )
+void ImfManager::SetSurroundingText( const std::string& text )
 {
   Internal::Adaptor::ImfManager::GetImplementation(*this).SetSurroundingText( text );
 }
 
-std::string ImfManager::GetSurroundingText()
+const std::string& ImfManager::GetSurroundingText() const
 {
   return Internal::Adaptor::ImfManager::GetImplementation(*this).GetSurroundingText();
 }
index 842078b..d90e9d4 100644 (file)
@@ -34,171 +34,198 @@ class ImfManager;
 }
 }
 
-typedef void* ImfContext;
-
 /**
  * @brief The ImfManager class
+ *
  * Specifically manages the ecore input method framework which enables the virtual or hardware keyboards.
  */
 class ImfManager : public BaseHandle
 {
 public:
 
+  /**
+   * @brief Events that are generated by the IMF.
+   */
   enum ImfEvent
   {
-    VOID,
-    PREEDIT,
-    COMMIT,
-    DELETESURROUNDING,
-    GETSURROUNDING
+    VOID,                ///< No event
+    PREEDIT,             ///< Pre-Edit changed
+    COMMIT,              ///< Commit recieved
+    DELETESURROUNDING,   ///< Event to delete a range of characters from the string
+    GETSURROUNDING       ///< Event to query string and cursor position
   };
 
   /**
-   * This structure is used to pass on data from the IMF regarding predictive text.
+   * @brief This structure is used to pass on data from the IMF regarding predictive text.
    */
   struct ImfEventData
   {
     /**
-     * Default Constructor.
+     * @brief Default Constructor.
      */
     ImfEventData()
-    : eventName( VOID ),
-      predictiveString(""),
+    : predictiveString(),
+      eventName( VOID ),
       cursorOffset( 0 ),
       numberOfChars ( 0 )
     {
     };
 
     /**
-     * Constructor
+     * @brief Constructor
+     *
      * @param[in] aEventName The name of the event from the IMF.
      * @param[in] aPredictiveString The pre-edit or commit string.
      * @param[in] aCursorOffset Start position from the current cursor position to start deleting characters.
      * @param[in] aNumberOfChars The number of characters to delete from the cursorOffset.
      */
-    ImfEventData(ImfEvent aEventName, const std::string& aPredictiveString, int aCursorOffset,int aNumberOfChars  )
-    : eventName(aEventName), predictiveString(aPredictiveString), cursorOffset( aCursorOffset ), numberOfChars( aNumberOfChars )
+    ImfEventData( ImfEvent aEventName, const std::string& aPredictiveString, int aCursorOffset, int aNumberOfChars )
+    : predictiveString( aPredictiveString ),
+      eventName( aEventName ),
+      cursorOffset( aCursorOffset ),
+      numberOfChars( aNumberOfChars )
     {
     }
 
     // Data
-    ImfEvent eventName; // The name of the event from the IMF.
-    std::string predictiveString; // The pre-edit or commit string.
-    int cursorOffset; // Start position from the current cursor position to start deleting characters.
-    int numberOfChars; //number of characters to delete from the cursorOffset.
+    std::string predictiveString; ///< The pre-edit or commit string.
+    ImfEvent eventName;           ///< The name of the event from the IMF.
+    int cursorOffset;             ///< Start position from the current cursor position to start deleting characters.
+    int numberOfChars;            ///< number of characters to delete from the cursorOffset.
   };
 
   /**
-   * Data required my IMF from the callback
+   * @brief Data required by IMF from the callback
    */
   struct ImfCallbackData
   {
-    ImfCallbackData( )
-    : update( false ), cursorPosition( 0 ), preeditResetRequired ( false )
+    /**
+     * @brief Constructor
+     */
+    ImfCallbackData()
+    : currentText(),
+      cursorPosition( 0 ),
+      update( false ),
+      preeditResetRequired( false )
     {
     }
 
-    ImfCallbackData(bool aUpdate, int aCursorPosition, std::string aCurrentText, bool aPreeditResetRequired )
-    : update(aUpdate), cursorPosition(aCursorPosition), currentText( aCurrentText ), preeditResetRequired( aPreeditResetRequired )
+    /**
+     * @brief Constructor
+     * @param[in] aUpdate True if cursor position needs to be updated
+     * @param[in] aCursorPosition new position of cursor
+     * @param[in] aCurrentText current text string
+     * @param[in] aPreeditResetRequired flag if preedit reset is required.
+     */
+    ImfCallbackData( bool aUpdate, int aCursorPosition, const std::string& aCurrentText, bool aPreeditResetRequired )
+    : currentText( aCurrentText ),
+      cursorPosition( aCursorPosition ),
+      update( aUpdate ),
+      preeditResetRequired( aPreeditResetRequired )
     {
     }
 
-    bool update; // if cursor position needs to be updated
-    int cursorPosition; // new position of cursor
-    std::string currentText; // current text string
-    bool preeditResetRequired; // flag if preedit reset is required.
+    std::string currentText;      ///< current text string
+    int cursorPosition;           ///< new position of cursor
+    bool update               :1; ///< if cursor position needs to be updated
+    bool preeditResetRequired :1; ///< flag if preedit reset is required.
   };
 
-  typedef Signal< void (ImfManager&) > ImfManagerSignalType;
-
-  typedef Signal< ImfCallbackData ( ImfManager&, const ImfEventData& ) > ImfEventSignalType;
+  typedef Signal< void (ImfManager&) > ImfManagerSignalType; ///< Keyboard actived signal
+  typedef Signal< ImfCallbackData ( ImfManager&, const ImfEventData& ) > ImfEventSignalType; ///< keyboard events
 
 public:
 
   /**
-   * Retrieve a handle to the instance of ImfManager.
+   * @brief Retrieve a handle to the instance of ImfManager.
    * @return A handle to the ImfManager.
    */
   static ImfManager Get();
 
   /**
-   * Get the current imf context.
-   * @return current imf context.
-   */
-  ImfContext GetContext();
-
-  /**
-   * Activate the IMF.
+   * @brief Activate the IMF.
+   *
    * It means that the text editing is started at somewhere.
    * If the H/W keyboard isn't connected then it will show the virtual keyboard.
    */
   void Activate();
 
   /**
-   * Deactivate the IMF.
+   * @brief Deactivate the IMF.
+   *
    * It means that the text editing is finished at somewhere.
    */
   void Deactivate();
 
   /**
-   * Get the restoration status, which controls if the keyboard is restored after the focus lost then regained.
+   * @brief Get the restoration status, which controls if the keyboard is restored after the focus lost then regained.
+   *
    * If true then keyboard will be restored (activated) after focus is regained.
    * @return restoration status.
    */
   bool RestoreAfterFocusLost() const;
 
   /**
-   * Set status whether the IMF has to restore the keyboard after losing focus.
+   * @brief Set status whether the IMF has to restore the keyboard after losing focus.
+   *
    * @param[in] toggle True means that keyboard should be restored after focus lost and regained.
    */
   void SetRestoreAfterFocusLost( bool toggle );
 
   /**
-   * Send message reset the pred-edit state / imf module.  Used to interupt pre-edit state maybe due to a touch input.
+   * @brief Send message reset the pred-edit state / imf module.
+   *
+   * Used to interupt pre-edit state maybe due to a touch input.
    */
   void Reset();
 
   /**
-   * Notifies IMF context that the cursor position has changed, required for features like auto-capitalisation
+   * @brief Notifies IMF context that the cursor position has changed, required for features like auto-capitalisation.
    */
   void NotifyCursorPosition();
 
   /**
-   * Sets cursor position stored in VirtualKeyboard, this is required by the IMF context
+   * @brief Sets cursor position stored in VirtualKeyboard, this is required by the IMF context.
+   *
    * @param[in] cursorPosition position of cursor
    */
   void SetCursorPosition( unsigned int cursorPosition );
 
   /**
-   * Gets cursor position stored in VirtualKeyboard, this is required by the IMF context
+   * @brief Gets cursor position stored in VirtualKeyboard, this is required by the IMF context.
+   *
    * @return current position of cursor
    */
-  int GetCursorPosition();
+  unsigned int GetCursorPosition() const;
 
   /**
-   * Method to store the string required by the IMF, this is used to provide predictive word suggestions.
+   * @brief Method to store the string required by the IMF, this is used to provide predictive word suggestions.
+   *
    * @param[in] text The text string surrounding the current cursor point.
    */
-  void SetSurroundingText( std::string text );
+  void SetSurroundingText( const std::string& text );
 
   /**
-   * Gets current text string set within the IMF manager, this is used to offer predictive suggestions
+   * @brief Gets current text string set within the IMF manager, this is used to offer predictive suggestions.
+   *
    * @return current position of cursor
    */
-  std::string GetSurroundingText();
+  const std::string& GetSurroundingText() const;
 
 public:
 
   // Signals
 
   /**
-   * This is emitted when the virtual keyboard is connected to or the hardware keyboard is activated.
+   * @brief This is emitted when the virtual keyboard is connected to or the hardware keyboard is activated.
+   *
    * @return The IMF Activated signal.
    */
   ImfManagerSignalType& ActivatedSignal();
 
   /**
-   * This is emitted when the IMF manager receives an event from the IMF
+   * @brief This is emitted when the IMF manager receives an event from the IMF.
+   *
    * @return The Event signal containing the event data.
    */
   ImfEventSignalType& EventReceivedSignal();
@@ -206,20 +233,23 @@ public:
   // Construction & Destruction
 
   /**
-   * Constructor
+   * @brief Constructor.
    */
   ImfManager();
 
   /**
-   * Non virtual destructor.
+   * @brief Destructor
+   *
+   * This is non-virtual since derived Handle types must not contain data or virtual methods.
    */
   ~ImfManager();
 
   /**
-   * This constructor is used by ImfManager::Get().
+   * @brief This constructor is used by ImfManager::Get().
+   *
    * @param[in] imfManager A pointer to the imf Manager.
    */
-  ImfManager( Internal::Adaptor::ImfManager* imfManager );
+  explicit ImfManager( Internal::Adaptor::ImfManager* imfManager );
 };
 
 } // namespace Dali
index 6e99611..e759409 100644 (file)
@@ -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/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 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 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)
@@ -73,18 +77,18 @@ void Wait(ToolkitTestApplication& application, float durationToPass)
 class TransitionCompletedCallback : public Dali::ConnectionTracker
 {
 public:
-  TransitionCompletedCallback( bool& signalReceived, CubeTransitionEffect& effect, ImageActor& imageActor )
+  TransitionCompletedCallback( bool& signalReceived, CubeTransitionEffect& effect, Image& image )
   : mSignalVerified( signalReceived ),
     mCurrentEffect( effect ),
-    mActorTransitTo( imageActor )
+    mActorTransitTo( image )
   {
   }
 
-  void Callback( CubeTransitionEffect effect, ImageActor imageActor )
+  void Callback( CubeTransitionEffect effect, Image image )
   {
     tet_infoline( "Verifying TransitionCompletedSignal" );
 
-    if( mCurrentEffect == effect && mActorTransitTo == imageActor )
+    if( mCurrentEffect == effect && mActorTransitTo == image )
     {
       mSignalVerified = true;
     }
@@ -97,7 +101,7 @@ public:
 
   bool&                  mSignalVerified;
   CubeTransitionEffect&  mCurrentEffect;
-  ImageActor&            mActorTransitTo;
+  Image&                 mActorTransitTo;
 };
 
 } // namespace
@@ -123,7 +127,8 @@ int UtcDaliCubeTransitionWaveEffectNew(void)
 
   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 );
 
@@ -136,7 +141,8 @@ int UtcDaliCubeTransitionWaveEffectNew(void)
   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;
@@ -151,7 +157,8 @@ int UtcDaliCubeTransitionCrossEffectNew(void)
 
   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 );
 
@@ -164,7 +171,8 @@ int UtcDaliCubeTransitionCrossEffectNew(void)
   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;
@@ -179,7 +187,8 @@ int UtcDaliCubeTransitionFoldEffectNew(void)
 
   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 );
 
@@ -192,7 +201,8 @@ int UtcDaliCubeTransitionFoldEffectNew(void)
   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;
@@ -203,15 +213,18 @@ int UtcDaliCubeTransitionEffectSetGetTransitionDuration(void)
   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.SetSize( VIEW_AREA_SIZE );
   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.SetSize( VIEW_AREA_SIZE );
   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;
@@ -222,11 +235,13 @@ int UtcDaliCubeTransitionEffectSetGetCubeDisplacement(void)
   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 );
 
-  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 );
 
@@ -242,70 +257,89 @@ int UtcDaliCubeTransitionEffectGetRoot(void)
 
   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;
-  DALI_TEST_CHECK( totalNum == rootActor.GetChildCount() );
+  Actor boxesRoot = waveEffect.GetChildAt(0);
+  DALI_TEST_CHECK( totalNum == boxesRoot.GetChildCount() );
 
   // 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;
 }
 
-int UtcDaliCubeTransitionEffectIsTransiting(void)
+int UtcDaliCubeTransitionEffectIsTransitioning(void)
 {
   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 );
-  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();
-  DALI_TEST_CHECK( waveEffect.IsTransiting() );
+  DALI_TEST_CHECK( waveEffect.IsTransitioning() );
   //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 );
-  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);
-  DALI_TEST_CHECK( crossEffect.IsTransiting() );
+  DALI_TEST_CHECK( crossEffect.IsTransitioning() );
   //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 );
-  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);
-  DALI_TEST_CHECK(foldEffect.IsTransiting() );
+  DALI_TEST_CHECK(foldEffect.IsTransitioning() );
   //transition is finished
   Wait( application, TRANSITION_DURATION );
-  DALI_TEST_CHECK( !foldEffect.IsTransiting() );
+  DALI_TEST_CHECK( !foldEffect.IsTransitioning() );
 
   END_TEST;
 }
@@ -317,23 +351,35 @@ int UtcDaliCubeTransitionEffectSetCurrentImage(void)
   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
-  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
-  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;
 }
 
@@ -344,27 +390,37 @@ int UtcDaliCubeTransitionEffectSetTargetImage(void)
   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
-  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
-  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;
 }
 
@@ -374,48 +430,50 @@ int UtcDaliCubeTransitionWaveEffectStartTransition(void)
   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 );
-  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);
-  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);
-  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);
-  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;
 }
 
@@ -425,54 +483,57 @@ int UtcDaliCubeTransitionCrossEffectStartTransition(void)
   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 );
-  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);
-  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);
-  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);
-  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);
-  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;
 }
 
@@ -482,52 +543,55 @@ int UtcDaliCubeTransitionFoldEffectStartTransition(void)
   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 );
-  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);
-  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);
-  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);
-  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);
-  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;
 }
 
@@ -537,84 +601,84 @@ int UtcDaliCubeTransitionEffectSignalTransitionCompleted(void)
   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 );
-  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 );
-  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 );
-  rootActor = foldEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
+  Stage::GetCurrent().Add( foldEffect );
 
   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 );
 
-  //check that the wave effect is used to transit to secondImageActor
+  //check that the wave effect is used to transit to secondImage
   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();
 
-  //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();
 
-  //check that the cross effect is used to transit to secondImageActor
+  //check that the cross effect is used to transit to secondImage
   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();
 
-  //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();
 
-  //check that the fold effect is used to transit to secondImageActor
+  //check that the fold effect is used to transit to secondImage
   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();
 
-  //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 );
@@ -627,38 +691,38 @@ int UtcDaliCubeTransitionEffectPauseResumeTransition(void)
   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 );
-  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 );
-  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 );
-  rootActor = crossEffect.GetRoot();
-  Stage::GetCurrent().Add( rootActor );
+  Stage::GetCurrent().Add( foldEffect );
 
   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;
-  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
@@ -680,9 +744,9 @@ int UtcDaliCubeTransitionEffectPauseResumeTransition(void)
   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
@@ -704,9 +768,9 @@ int UtcDaliCubeTransitionEffectPauseResumeTransition(void)
   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
@@ -734,60 +798,63 @@ int UtcDaliCubeTransitionWaveEffectStopTransition(void)
   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 );
-  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);
+
+  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);
-  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);
-  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);
-  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);
-  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;
 }
 
@@ -797,57 +864,59 @@ int UtcDaliCubeTransitionCrossEffectStopTransition(void)
   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 );
-  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);
+
+  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);
-  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);
-  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);
-  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();
@@ -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  );
-  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;
 }
 
@@ -866,55 +935,59 @@ int UtcDaliCubeTransitionFoldEffectStopTransition(void)
   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 );
-  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);
+
+  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);
-  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);
-  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);
-  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();
@@ -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  );
-  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;
 }
index 28de790..fde3088 100644 (file)
@@ -280,12 +280,61 @@ int UtcDaliCreateMotionBlurEffect(void)
 {
   ToolkitTestApplication application;
 
-  unsigned int sampleCount(4);
-  ShaderEffect effect = Toolkit::CreateMotionBlurEffect(sampleCount);
-  DALI_TEST_CHECK( effect );
+  Property::Map effect = Toolkit::CreateMotionBlurEffect();
+  DALI_TEST_CHECK( !effect.Empty() );
+
+  Property::Value* customShaderValue = effect.Find( "shader" );
+  DALI_TEST_CHECK( customShaderValue );
+
+  Property::Map customShader;
+  DALI_TEST_CHECK( customShaderValue->Get( customShader ) );
 
-  Property::Value value = effect.GetProperty( effect.GetPropertyIndex("uNumSamples"));
-  DALI_TEST_EQUALS( value.Get<float>(), (float)sampleCount, TEST_LOCATION );
+  Property::Value* vertexShaderValue = customShader.Find( "vertex-shader" );
+  DALI_TEST_CHECK( vertexShaderValue );
+
+  std::string vertexShader;
+  DALI_TEST_CHECK( vertexShaderValue->Get( vertexShader ) );
+  DALI_TEST_CHECK( !vertexShader.empty() );
+
+  Property::Value* fragmentShaderValue = customShader.Find( "fragment-shader" );
+  DALI_TEST_CHECK( fragmentShaderValue );
+
+  std::string fragmentShader;
+  DALI_TEST_CHECK( fragmentShaderValue->Get( fragmentShader ) );
+  DALI_TEST_CHECK( !fragmentShader.empty() );
+
+  Property::Value* gridXValue = customShader.Find( "subdivide-grid-x" );
+  DALI_TEST_CHECK( gridXValue );
+
+  int gridX = 0;
+  DALI_TEST_CHECK( gridXValue->Get( gridX ) );
+  DALI_TEST_CHECK( gridX > 1 );
+
+  Property::Value* gridYValue = customShader.Find( "subdivide-grid-y" );
+  DALI_TEST_CHECK( gridYValue );
+
+  int gridY = 0;
+  DALI_TEST_CHECK( gridYValue->Get( gridY ) );
+  DALI_TEST_CHECK( gridY > 1 );
+
+  Property::Value* hintsValue = customShader.Find( "hints" );
+  DALI_TEST_CHECK( hintsValue );
+
+  std::string hints;
+  DALI_TEST_CHECK( hintsValue->Get( hints ) );
+  DALI_TEST_CHECK( hints == "output-is-transparent" );
+
+  unsigned int sampleCount( 4 );
+  Actor actor = Actor::New();
+  Toolkit::SetMotionBlurProperties( actor, sampleCount );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uBlurTexCoordScale" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uGeometryStretchFactor" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uSpeedScalingFactor" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uObjectFadeStart" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uObjectFadeEnd" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uAlphaScale" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uNumSamples" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uModelLastFrame" ) != Property::INVALID_INDEX );
 
   END_TEST;
 }
@@ -294,8 +343,58 @@ int UtcDaliCreateMotionStretchEffect(void)
 {
   ToolkitTestApplication application;
 
-  ShaderEffect effect = Toolkit::CreateMotionStretchEffect();
-  DALI_TEST_CHECK( effect );
+  Property::Map effect = Toolkit::CreateMotionStretchEffect();
+  DALI_TEST_CHECK( !effect.Empty() );
+
+  Property::Value* customShaderValue = effect.Find( "shader" );
+  DALI_TEST_CHECK( customShaderValue );
+
+  Property::Map customShader;
+  DALI_TEST_CHECK( customShaderValue->Get( customShader ) );
+
+  Property::Value* vertexShaderValue = customShader.Find( "vertex-shader" );
+  DALI_TEST_CHECK( vertexShaderValue );
+
+  std::string vertexShader;
+  DALI_TEST_CHECK( vertexShaderValue->Get( vertexShader ) );
+  DALI_TEST_CHECK( !vertexShader.empty() );
+
+  Property::Value* fragmentShaderValue = customShader.Find( "fragment-shader" );
+  DALI_TEST_CHECK( fragmentShaderValue );
+
+  std::string fragmentShader;
+  DALI_TEST_CHECK( fragmentShaderValue->Get( fragmentShader ) );
+  DALI_TEST_CHECK( !fragmentShader.empty() );
+
+  Property::Value* gridXValue = customShader.Find( "subdivide-grid-x" );
+  DALI_TEST_CHECK( gridXValue );
+
+  int gridX = 0;
+  DALI_TEST_CHECK( gridXValue->Get( gridX ) );
+  DALI_TEST_CHECK( gridX > 1 );
+
+  Property::Value* gridYValue = customShader.Find( "subdivide-grid-y" );
+  DALI_TEST_CHECK( gridYValue );
+
+  int gridY = 0;
+  DALI_TEST_CHECK( gridYValue->Get( gridY ) );
+  DALI_TEST_CHECK( gridY > 1 );
+
+  Property::Value* hintsValue = customShader.Find( "hints" );
+  DALI_TEST_CHECK( hintsValue );
+
+  std::string hints;
+  DALI_TEST_CHECK( hintsValue->Get( hints ) );
+  DALI_TEST_CHECK( hints == "output-is-transparent" );
+
+  Actor actor = Actor::New();
+  Toolkit::SetMotionStretchProperties( actor );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uGeometryStretchFactor" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uSpeedScalingFactor" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uObjectFadeStart" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uObjectFadeEnd" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uAlphaScale" ) != Property::INVALID_INDEX );
+  DALI_TEST_CHECK( actor.GetPropertyIndex( "uModelLastFrame" ) != Property::INVALID_INDEX );
 
   END_TEST;
 }
index cb7ac5c..5afc638 100644 (file)
@@ -94,9 +94,9 @@ void ShadowView::Remove(Actor child)
   GetImpl(*this).Remove(child);
 }
 
-void ShadowView::SetShadowPlane(ImageActor shadowPlane)
+void ShadowView::SetShadowPlaneBackground(Actor shadowPlaneBackground)
 {
-  GetImpl(*this).SetShadowPlane(shadowPlane);
+  GetImpl(*this).SetShadowPlaneBackground(shadowPlaneBackground);
 }
 
 void ShadowView::SetPointLight(Actor pointLight)
index 63bb089..d6039f2 100644 (file)
@@ -178,15 +178,15 @@ public:
   void Remove(Actor child);
 
   /**
-   * Set the Shadow Plane for the shadow effect.
+   * Set the Shadow Plane Background for the shadow effect.
    *
-   * @param[in] shadowPlane An actor representing the shadow
+   * @param[in] shadowPlaneBackground An actor representing the shadow
    * plane. The position of the actor represents the origin of the
    * plane, and the orientation of the actor represents the direction
    * of the plane normal. Make the plane sufficiently large if the shadows are
    * clipped.
    */
-  void SetShadowPlane(ImageActor shadowPlane);
+  void SetShadowPlaneBackground(Actor shadowPlaneBackground);
 
   /**
    * Set the Point Light for the shadow effect. This is usually NOT a renderable actor.
index 5a510d7..1e48c56 100644 (file)
@@ -64,6 +64,7 @@ public:
     {
       MAX_SIZE =  PROPERTY_START_INDEX, ///< name "max-size",                The maximum size the Popup can be,              type VECTOR2
       ENABLE_OVERSHOOT,                 ///< name "enable-overshoot",        Whether the overshoot image is enabled,         type BOOLEAN
+      SCROLL_VIEW,                      ///< name "scroll-view",             Properties to set on scroll view                type Property::Map
     };
   };
 
index 17c2f65..aede5f1 100644 (file)
@@ -29,27 +29,33 @@ namespace Toolkit
 {
 
 /**
+ * @brief Set the properties for the motion blur
+ *
+ * @param numBlurSamples Number of samples used by the shader
+ */
+inline void SetMotionBlurProperties( Actor& actor, unsigned int numBlurSamples = 8 )
+{
+  actor.RegisterProperty( "uBlurTexCoordScale", 0.125f );
+  actor.RegisterProperty( "uGeometryStretchFactor", 0.05f );
+  actor.RegisterProperty( "uSpeedScalingFactor", 0.5f );
+  actor.RegisterProperty( "uObjectFadeStart", Vector2( 0.25f, 0.25f ) );
+  actor.RegisterProperty( "uObjectFadeEnd", Vector2( 0.5f, 0.5f ) );
+  actor.RegisterProperty( "uAlphaScale", 0.75f );
+  actor.RegisterProperty( "uNumSamples", static_cast<float>( numBlurSamples ) );
+  actor.RegisterProperty( "uRecipNumSamples", 1.0f / static_cast<float>( numBlurSamples ) );
+  actor.RegisterProperty( "uRecipNumSamplesMinusOne", 1.0f / static_cast<float>( numBlurSamples - 1.0f ) );
+  Property::Index uModelProperty = actor.RegisterProperty( "uModelLastFrame", Matrix::IDENTITY );
+
+  Constraint constraint = Constraint::New<Matrix>( actor, uModelProperty, EqualToConstraint() );
+  constraint.AddSource( Source( actor , Actor::Property::WORLD_MATRIX ) );
+  constraint.Apply();
+}
+
+/**
  * @brief Create a new MotionBlurEffect
  *
  * Motion blur shader works on a per object basis. Objects will
- * blur when they move, or if the camera moves. Can be applied to ImageActor or
- * TextActor only.
- *
- * Usage example:-
- *
- * // Create shader used for doing motion blur\n
- * ShaderEffect MotionBlurEffect = CreateMotionBlurEffect();
- *
- * // set actor shader to the blur one\n
- * Actor actor = Actor::New( ... );\n
- * actor.SetShaderEffect( MotionBlurEffect );
- *
- * // Constrain "uModelLastFrame" to be the same as the actor's world matrix\n
- * Dali::Property::Index uModelProperty = MotionBlurEffect.GetPropertyIndex( "uModelLastFrame" );
- * Constraint constraint = Constraint::New<Matrix>( MotionBlurEffect, uModelProperty, EqualToConstraint() );\n
- * constraint.AddSource( Source( actor , Actor::Property::WORLD_MATRIX ) );\n
- * constraint.Apply();\n
- *
+ * blur when they move, or if the camera moves.
  *
  * Animatable/Constrainable uniforms:
  *  "uBlurTexCoordScale"      - This scales the offset for texture samples along the motion velocity vector.
@@ -83,24 +89,22 @@ namespace Toolkit
  *                              at the cost of performance.
  *  "uModelLastFrame"         - The model to world space transformation matrix of the actor in the previous frame.
  *
- * @param numBlurSamples Number of samples used by the shader
- * @return A handle to a newly allocated ShaderEffect
+ * @return The newly created Property::Map with the motion blur effect
  */
-inline ShaderEffect CreateMotionBlurEffect( unsigned int numBlurSamples = 8 )
+inline Property::Map CreateMotionBlurEffect()
 {
-  // Dali vertexSource prefix for reference:
-  // precision highp float;
-  // attribute vec3  aPosition;
-  // attribute vec2  aTexCoord;
-  // uniform   mat4  uMvpMatrix;
-  // uniform   mat4  uModelView;
-  // uniform   mat3  uNormalMatrix;
-  // uniform   mat4  uProjection;
-  // uniform   vec4  uColor;
-  // varying   vec2  vTexCoord;
   std::string vertexSource;
   vertexSource =
       "precision mediump float;\n"
+
+      "attribute vec2 aPosition;\n"
+
+      "uniform mat4 uMvpMatrix;\n"
+      "uniform mat4 uModelView;\n"
+      "uniform mat4 uViewMatrix;\n"
+      "uniform mat4 uProjection;\n"
+      "uniform vec3 uSize;\n"
+
       "uniform mat4 uModelLastFrame;\n"
       "float timeDelta = 0.0167;\n"
 
@@ -111,20 +115,23 @@ inline ShaderEffect CreateMotionBlurEffect( unsigned int numBlurSamples = 8 )
       "varying vec2 vModelSpaceCenterToPos;\n"
       "varying vec2 vScreenSpaceVelocityVector;\n"
       "varying float vSpeed;\n"
+      "varying vec2 vTexCoord;\n"
 
       "void main()\n"
       "{\n"
       // get view space position of vertex this frame and last frame
-      " vec4 vertex = vec4(aPosition, 1.0);\n"
-      " vec4 viewSpaceVertex = uModelView * vertex;\n"
-      " vec4 viewSpaceVertexLastFrame = (uViewMatrix * uModelLastFrame) * vertex;\n"
+      " vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n"
+      " vertexPosition.xyz *= uSize;\n"
+
+      " vec4 viewSpaceVertex = uModelView * vertexPosition;\n"
+      " vec4 viewSpaceVertexLastFrame = (uViewMatrix * uModelLastFrame) * vertexPosition;\n"
       " float reciprocalTimeDelta = 1.0 / timeDelta;\n"
 
       // work out vertex's last movement in view space
       " vec3 viewSpacePosDelta = viewSpaceVertex.xyz - viewSpaceVertexLastFrame.xyz;\n"
 
       // get clip space position of vertex this frame and last frame
-      " vec4 clipSpaceVertex = uMvpMatrix * vertex;\n"
+      " vec4 clipSpaceVertex = uMvpMatrix * vertexPosition;\n"
       " vec4 clipSpaceVertexLastFrame = uProjection * viewSpaceVertexLastFrame;\n"
 
       // decide how much this vertex is 'trailing', i.e. at the back of the object relative to its direction of motion. We do this
@@ -133,7 +140,7 @@ inline ShaderEffect CreateMotionBlurEffect( unsigned int numBlurSamples = 8 )
       " float posDeltaLength = length(viewSpacePosDelta);\n"
       " if(posDeltaLength > 0.001)\n" // avoid div by 0 if object has barely moved
       " {\n"
-      "   vec4 viewSpaceCenterToPos = uModelView * vec4(aPosition, 0.0);\n"
+      "   vec4 viewSpaceCenterToPos = uModelView * vec4(vertexPosition.xy, 0.0, 0.0);\n"
       "   float centerToVertexDist = length(viewSpaceCenterToPos);\n"
       "   if(centerToVertexDist > 0.001)\n" // avoid div by 0 if object has vertex at model space origin
       "   {\n"
@@ -158,21 +165,20 @@ inline ShaderEffect CreateMotionBlurEffect( unsigned int numBlurSamples = 8 )
       " vSpeed = clamp(vSpeed, 0.0, 1.0);\n"
 
       // provide fragment shader with vector from center of object to pixel (assumes the objects model space origin is at its center and verts have same z)
-      " vModelSpaceCenterToPos = aPosition.xy;\n"
+      " vModelSpaceCenterToPos = viewSpaceVertex.xy;\n"
 
-      " vTexCoord = aTexCoord;\n"
+      " vec2 texCoord = aPosition + vec2(0.5);"
+      " vTexCoord = texCoord;\n"
       "}\n";
 
 
-  // Dali fragmentSource prefix for reference:
-  // precision highp     float;
-  // uniform   sampler2D sTexture;
-  // uniform   sampler2D sEffect;
-  // uniform   vec4      uColor;
-  // varying   vec2      vTexCoord;
   std::string fragmentSource;
   fragmentSource =
       "precision mediump float;\n"
+
+      "uniform sampler2D sTexture;\n"
+      "uniform vec4 uColor;\n"
+
       "uniform vec2 uObjectFadeStart;\n"
       "uniform vec2 uObjectFadeEnd;\n"
       "uniform float uAlphaScale;\n"
@@ -184,6 +190,7 @@ inline ShaderEffect CreateMotionBlurEffect( unsigned int numBlurSamples = 8 )
       "varying vec2 vModelSpaceCenterToPos;\n"
       "varying vec2 vScreenSpaceVelocityVector;\n"
       "varying float vSpeed;\n"
+      "varying vec2 vTexCoord;\n"
 
       "void main()\n"
       "{\n"
@@ -208,30 +215,25 @@ inline ShaderEffect CreateMotionBlurEffect( unsigned int numBlurSamples = 8 )
       "   col += texture2D(sTexture, vTexCoord + (velocity * t)) * uRecipNumSamples;\n"
       " }\n"
       " gl_FragColor = mix(colActor, col, vSpeed);\n" // lerp blurred and non-blurred actor based on speed of motion
-      " gl_FragColor.a = colActor.a * fadeToEdgesScale;\n" // fade blurred actor to its edges based on speed of motion
+      " gl_FragColor.a = fadeToEdgesScale;//colActor.a * fadeToEdgesScale;\n" // fade blurred actor to its edges based on speed of motion
       " gl_FragColor *= uColor;\n"
       "}\n";
 
+
+  Property::Map map;
+
+  Property::Map customShader;
+  customShader[ "vertex-shader" ] = vertexSource;
+  customShader[ "fragment-shader" ] = fragmentSource;
+
+  customShader[ "subdivide-grid-x" ] = 10;
+  customShader[ "subdivide-grid-y" ] = 10;
+
   // NOTE: we must turn on alpha blending for the actor (HINT_BLENDING)
-  ShaderEffect shader = ShaderEffect::New( vertexSource, fragmentSource,
-                                           ShaderEffect::GeometryHints( ShaderEffect::HINT_BLENDING | ShaderEffect::HINT_GRID) );
-
-  //////////////////////////////////////
-  // Register uniform properties
-  //
-  //
-  shader.SetUniform( "uBlurTexCoordScale", 0.125f );
-  shader.SetUniform( "uGeometryStretchFactor", 0.05f );
-  shader.SetUniform( "uSpeedScalingFactor", 0.5f );
-  shader.SetUniform( "uObjectFadeStart", Vector2( 0.25f, 0.25f ) );
-  shader.SetUniform( "uObjectFadeEnd", Vector2( 0.5f, 0.5f ) );
-  shader.SetUniform( "uAlphaScale", 0.75f );
-  shader.SetUniform( "uNumSamples", static_cast<float>( numBlurSamples ) );
-  shader.SetUniform( "uRecipNumSamples", 1.0f / static_cast<float>( numBlurSamples ) );
-  shader.SetUniform( "uRecipNumSamplesMinusOne", 1.0f / static_cast<float>( numBlurSamples - 1.0f ) );
-  shader.SetUniform( "uModelLastFrame", Matrix::IDENTITY );
-
-  return shader;
+  customShader[ "hints" ] = "output-is-transparent";
+
+  map[ "shader" ] = customShader;
+  return map;
 }
 
 }
index e16e2ef..5e43953 100644 (file)
@@ -29,25 +29,26 @@ namespace Toolkit
 {
 
 /**
+ * @brief Set the properties for the motion stretch
+ */
+inline void SetMotionStretchProperties( Actor& actor )
+{
+  actor.RegisterProperty( "uGeometryStretchFactor", 0.5f );
+  actor.RegisterProperty( "uSpeedScalingFactor", 0.5f );
+  actor.RegisterProperty( "uObjectFadeStart", Vector2( 0.25f, 0.25f ) );
+  actor.RegisterProperty( "uObjectFadeEnd", Vector2( 0.5f, 0.5f ) );
+  actor.RegisterProperty( "uAlphaScale", 0.75f );
+  Property::Index uModelProperty = actor.RegisterProperty( "uModelLastFrame", Matrix::IDENTITY );
+
+  Constraint constraint = Constraint::New<Matrix>( actor, uModelProperty, EqualToConstraint() );
+  constraint.AddSource( Source( actor , Actor::Property::WORLD_MATRIX ) );
+  constraint.Apply();
+}
+
+/**
  * @brief Creates a new MotionStretchEffect
  *
- * Motion stretch shader works on a per object basis. Objects will stretch in the direction of motion when they move, or if the camera moves. Can be applied
- * to ImageActor or TextActor only.
- *
- * Usage example:-
- *
- * // Create shader used for doing motion stretch\n
- * ShaderEffect MotionStretchEffect = CreateMotionStretchEffect();
- *
- * // set actor shader to the stretch one\n
- * Actor actor = Actor::New( ... );\n
- * actor.SetShaderEffect( MotionStretchEffect );
- *
- * // Constrain "uModelLastFrame" to be the same as the actor's world matrix\n
- * Dali::Property::Index uModelProperty = MotionBlurEffect.GetPropertyIndex( "uModelLastFrame" );
- * Constraint constraint = Constraint::New<Matrix>( MotionBlurEffect, uModelProperty, EqualToConstraint() );\n
- * constraint.AddSource( Source( actor , Actor::Property::WORLD_MATRIX ) );\n
- * constraint.Apply();\n
+ * Motion stretch shader works on a per object basis. Objects will stretch in the direction of motion when they move, or if the camera moves.
  *
  * Animatable/Constrainable uniforms:
  *  "uGeometryStretchFactor"  - This scales the amount the geometry stretches along the motion velocity vector.
@@ -68,25 +69,24 @@ namespace Toolkit
  *                              applied. Default 0.75.
  *  "uModelLastFrame"         - The model to world space transformation matrix of the actor in the previous frame.
  *
- * @return A handle to a newly allocated ShaderEffect
+ * @return The newly created Property::Map with the motion stretch effect
  */
-inline ShaderEffect CreateMotionStretchEffect()
+inline Property::Map CreateMotionStretchEffect()
 {
-  // Dali vertexSource prefix for reference:
-  // precision highp float;
-  // attribute vec3  aPosition;
-  // attribute vec2  aTexCoord;
-  // uniform   mat4  uMvpMatrix;
-  // uniform   mat4  uModelView;
-  // uniform   mat3  uNormalMatrix;
-  // uniform   mat4  uProjection;
-  // uniform   vec4  uColor;
-  // varying   vec2  vTexCoord;
   std::string vertexSource;
   vertexSource =
       "precision mediump float;\n"
+
+      "attribute vec2 aPosition;\n"
+
+      "uniform mat4 uMvpMatrix;\n"
+      "uniform mat4 uModelView;\n"
+      "uniform mat4 uViewMatrix;\n"
+      "uniform mat4 uProjection;\n"
+      "uniform vec3 uSize;\n"
+
       "uniform mat4  uModelLastFrame;\n"
-      "uniform float uTimeDelta;\n"
+      "float timeDelta = 0.0167;\n"
 
       "uniform float uGeometryStretchFactor;\n"
       "uniform float uSpeedScalingFactor;\n"
@@ -95,20 +95,23 @@ inline ShaderEffect CreateMotionStretchEffect()
       "varying vec2 vModelSpaceCenterToPos;\n"
       "varying vec2 vScreenSpaceVelocityVector;\n"
       "varying float vSpeed;\n"
+      "varying vec2 vTexCoord;\n"
 
       "void main()\n"
       "{\n"
       // get view space position of vertex this frame and last frame
-      " vec4 vertex = vec4(aPosition, 1.0);\n"
-      " vec4 viewSpaceVertex = uModelView * vertex;\n"
-      " vec4 viewSpaceVertexLastFrame = uViewMatrix * uModelLastFrame * vertex;\n"
+      " vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n"
+      " vertexPosition.xyz *= uSize;\n"
+
+      " vec4 viewSpaceVertex = uModelView * vertexPosition;\n"
+      " vec4 viewSpaceVertexLastFrame = uViewMatrix * uModelLastFrame * vertexPosition;\n"
 
       // work out vertex's last movement in view space
       " vec3 viewSpacePosDelta = viewSpaceVertex.xyz - viewSpaceVertexLastFrame.xyz;\n"
-      " float reciprocalTimeDelta = 1.0 / ((uTimeDelta > 0.0) ? uTimeDelta : 0.01);\n"
+      " float reciprocalTimeDelta = 1.0 / timeDelta;\n"
 
       // get clip space position of vertex this frame and last frame
-      " vec4 clipSpaceVertex = uMvpMatrix * vertex;\n"
+      " vec4 clipSpaceVertex = uMvpMatrix * vertexPosition;\n"
       " vec4 clipSpaceVertexLastFrame = uProjection * viewSpaceVertexLastFrame;\n"
 
       // decide how much this vertex is 'trailing', i.e. at the back of the object relative to its direction of motion. We do this
@@ -117,7 +120,7 @@ inline ShaderEffect CreateMotionStretchEffect()
       " float posDeltaLength = length(viewSpacePosDelta);\n"
       " if(posDeltaLength > 0.001)\n" // avoid div by 0 if object has barely moved
       " {\n"
-      "   vec4 viewSpaceCenterToPos = uModelView * vec4(aPosition, 0.0);\n"
+      "   vec4 viewSpaceCenterToPos = uModelView * vec4(aPosition, 0.0, 0.0);\n"
       "   float centerToVertexDist = length(viewSpaceCenterToPos);\n"
       "   if(centerToVertexDist > 0.001)\n" // avoid div by 0 if object has vertex at model space origin
       "   {\n"
@@ -143,22 +146,19 @@ inline ShaderEffect CreateMotionStretchEffect()
       " vSpeed = clamp(vSpeed, 0.0, 1.0);\n"
 
       // provide fragment shader with vector from center of object to pixel (assumes the objects model space origin is at its center and verts have same z)
-      " vModelSpaceCenterToPos = aPosition.xy;\n"
+      " vModelSpaceCenterToPos = viewSpaceVertex.xy;\n"
 
-      " vTexCoord = aTexCoord;\n"
+      " vec2 texCoord = aPosition + vec2(0.5);"
+      " vTexCoord = texCoord;\n"
       "}\n";
 
-
-  // Dali fragmentSource prefix for reference:
-  // precision highp     float;
-  // uniform   sampler2D sTexture;
-  // uniform   sampler2D sEffect;
-  // uniform   vec4      uColor;
-  // varying   vec2      vTexCoord;
   std::string fragmentSource;
   fragmentSource =
       "precision mediump float;\n"
 
+      "uniform sampler2D sTexture;\n"
+      "uniform vec4 uColor;\n"
+
       "uniform vec2 uObjectFadeStart;\n"
       "uniform vec2 uObjectFadeEnd;\n"
       "uniform float uAlphaScale;\n"
@@ -167,6 +167,7 @@ inline ShaderEffect CreateMotionStretchEffect()
       "varying vec2 vModelSpaceCenterToPos;\n"
       "varying vec2 vScreenSpaceVelocityVector;\n"
       "varying float vSpeed;\n"
+      "varying vec2 vTexCoord;\n"
 
       "void main()\n"
       "{\n"
@@ -184,24 +185,20 @@ inline ShaderEffect CreateMotionStretchEffect()
       " gl_FragColor *= uColor;\n"
       "}";
 
+  Property::Map map;
+
+  Property::Map customShader;
+  customShader[ "vertex-shader" ] = vertexSource;
+  customShader[ "fragment-shader" ] = fragmentSource;
+
+  customShader[ "subdivide-grid-x" ] = 10;
+  customShader[ "subdivide-grid-y" ] = 10;
+
   // NOTE: we must turn on alpha blending for the actor (HINT_BLENDING)
-  ShaderEffect shaderEffect = ShaderEffect::New(
-      vertexSource, fragmentSource,
-      ShaderEffect::GeometryHints( ShaderEffect::HINT_BLENDING | ShaderEffect::HINT_GRID ) );
-
-
-  //////////////////////////////////////
-  // Register uniform properties
-  //
-  //
-  shaderEffect.SetUniform( "uGeometryStretchFactor",  0.5f );
-  shaderEffect.SetUniform( "uSpeedScalingFactor",     0.5f );
-  shaderEffect.SetUniform( "uObjectFadeStart",        Vector2( 0.25f, 0.25f ) );
-  shaderEffect.SetUniform( "uObjectFadeEnd",          Vector2( 0.5f, 0.5f ) );
-  shaderEffect.SetUniform( "uAlphaScale",             0.75f );
-  shaderEffect.SetUniform( "uModelLastFrame",         Matrix::IDENTITY );
-
-  return shaderEffect;
+  customShader[ "hints" ] = "output-is-transparent";
+
+  map[ "shader" ] = customShader;
+  return map;
 }
 
 }
index 9af4758..a989b72 100644 (file)
@@ -27,14 +27,20 @@ namespace Dali
 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
index 9d318e9..11bcc2e 100644 (file)
@@ -37,7 +37,7 @@ namespace Internal DALI_INTERNAL
 
 /**
  * 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
 {
@@ -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
-   * @param[in] viewAreaSize The size of view area for this transition effect
    * @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
 
   /**
-   * 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
 
index 6ba444e..de78244 100644 (file)
@@ -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 )
 {
-  return CubeTransitionEffect( dynamic_cast< Dali::Toolkit::Internal::CubeTransitionEffect* >( handle.GetObjectPtr() ) );
+  return Control::DownCast<CubeTransitionEffect, Internal::CubeTransitionEffect>( handle );
 }
 
 void CubeTransitionEffect::SetTransitionDuration( float duration )
@@ -65,24 +71,19 @@ float CubeTransitionEffect::GetCubeDisplacement() const
   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 )
index 5afab34..7b915a6 100644 (file)
@@ -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
 {
@@ -39,7 +38,7 @@ class CubeTransitionEffect;
 } // 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
  *
@@ -49,7 +48,7 @@ class CubeTransitionEffect;
  *
  * //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 );
@@ -58,14 +57,14 @@ class CubeTransitionEffect;
  * cubeEffect.SetCubeDisplacement( cubeDisplacement  );
  *
  * // Add to stage
- * stage.Add( cubeEffect.GetRoot() );
+ * stage.Add( cubeEffect );
  *
  * // 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
- * cubeEffect.SetTargetimage( secondImageActor );
+ * cubeEffect.SetTargetimage( secondImage );
  * // 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() |
  */
-class DALI_IMPORT_API CubeTransitionEffect : public BaseHandle
+class DALI_IMPORT_API CubeTransitionEffect : public Control
 {
 public:
 
@@ -124,40 +123,34 @@ public:
   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 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
    */
-  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
-   * @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
-   * @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 );
 
@@ -183,7 +176,7 @@ public:
 
   /**
    * 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();
@@ -191,7 +184,7 @@ public:
 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
@@ -205,7 +198,19 @@ public: //Signal
 
 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
 
index 633d01b..7d47057 100644 (file)
@@ -27,14 +27,20 @@ namespace Dali
 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
index 789a30e..0543d27 100644 (file)
@@ -37,7 +37,7 @@ namespace Internal DALI_INTERNAL
 
 /**
  * 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
 {
@@ -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
-   * @param[in] viewAreaSize The size of view area for this transition effect
    * @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
 
   /**
-   * 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
 
index 33d292c..66315ad 100644 (file)
@@ -27,14 +27,20 @@ namespace Dali
 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
index a3b1dc1..b8a5c4f 100644 (file)
@@ -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
-   * @param[in] viewAreaSize The size of view area for this transition effect
    * @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
 
   /**
-   * 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
 
index 6f45e82..c7f1d8c 100644 (file)
@@ -127,7 +127,7 @@ Vector3 ImageView::GetNaturalSize()
   size.y = mImageSize.GetHeight();
   size.z = std::min(size.x, size.y);
 
-  if( size.x > 0 && size.x > 0 )
+  if( size.x > 0 && size.y > 0 )
   {
     return size;
   }
@@ -169,6 +169,8 @@ float ImageView::GetWidthForHeight( float height )
 
 void ImageView::OnStageConnection( int depth )
 {
+  Control::OnStageConnection( depth );
+
   if( mRenderer )
   {
     CustomActor self = Self();
@@ -183,6 +185,8 @@ void ImageView::OnStageDisconnection()
     CustomActor self = Self();
     mRenderer.SetOffStage( self );
   }
+
+  Control::OnStageDisconnection();
 }
 
 
index b44f4a1..9405ec0 100644 (file)
@@ -447,6 +447,8 @@ Property::Value Model3dView::GetProperty( BaseObject* object, Property::Index in
 
 void Model3dView::OnStageConnection( int depth )
 {
+  Control::OnStageConnection( depth );
+
   CustomActor self = Self();
   self.AddRenderer( mRenderer );
 
index 9edfc95..14e8405 100644 (file)
@@ -28,7 +28,6 @@
 #include <dali/public-api/render-tasks/render-task-list.h>
 
 // INTERNAL INCLUDES
-#include <dali-toolkit/public-api/controls/default-controls/solid-color-actor.h>
 #include <dali-toolkit/internal/controls/page-turn-view/page-turn-effect.h>
 #include <dali-toolkit/internal/controls/page-turn-view/page-turn-book-spine-effect.h>
 
@@ -340,11 +339,11 @@ void PageTurnView::SetupShadowView()
   mShadowView.SetPointLightFieldOfView( Math::PI / 2.0f);
   mShadowView.SetShadowColor(DEFAULT_SHADOW_COLOR);
 
-  mShadowPlane = CreateSolidColorActor( Vector4 (0.0f, 0.0f, 0.0f, 0.0f) );
-  mShadowPlane.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
-  mShadowPlane.SetSize( mControlSize );
-  Self().Add( mShadowPlane );
-  mShadowView.SetShadowPlane( mShadowPlane );
+  mShadowPlaneBackground = Actor::New();
+  mShadowPlaneBackground.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
+  mShadowPlaneBackground.SetSize( mControlSize );
+  Self().Add( mShadowPlaneBackground );
+  mShadowView.SetShadowPlaneBackground( mShadowPlaneBackground );
 
   mPointLight = Actor::New();
   mPointLight.SetAnchorPoint( origin );
@@ -359,6 +358,8 @@ void PageTurnView::SetupShadowView()
 
 void PageTurnView::OnStageConnection( int depth )
 {
+  Control::OnStageConnection( depth );
+
   SetupShadowView();
   mTurningPageLayer.Raise();
 }
@@ -368,7 +369,7 @@ void PageTurnView::OnStageDisconnection()
   if(mShadowView)
   {
     mPointLight.Unparent();
-    mShadowPlane.Unparent();
+    mShadowPlaneBackground.Unparent();
     mShadowView.Unparent();
   }
 
@@ -385,6 +386,8 @@ void PageTurnView::OnStageDisconnection()
 
     SetSpineEffect( mPanActor, mIsTurnBack[mPanActor] );
   }
+
+  Control::OnStageDisconnection();
 }
 
 void PageTurnView::SetPageSize( const Vector2& pageSize )
@@ -416,9 +419,9 @@ void PageTurnView::SetPageSize( const Vector2& pageSize )
 
   OnPageTurnViewInitialize();
 
-  if( mShadowPlane )
+  if( mShadowPlaneBackground )
   {
-    mShadowPlane.SetSize( mControlSize );
+    mShadowPlaneBackground.SetSize( mControlSize );
   }
 }
 
index 5209f00..5be63cf 100644 (file)
@@ -311,7 +311,7 @@ protected:
   Vector2                        mControlSize;             ///< The size of the control, it is decided by the page size, the SetSize from application can not change it
   Layer                          mTurningPageLayer;        ///< The layer for the turning page, to avoid possible depth conflict
   Toolkit::ShadowView            mShadowView;              ///< The shadow view control for shadow casting
-  ImageActor                     mShadowPlane;             ///< The plane for the shadow to cast on
+  Actor                          mShadowPlaneBackground;   ///< The plane for the shadow to cast on
   Actor                          mPointLight;              ///< The point light used for shadow casting
 
   PageFactory&                   mPageFactory;             ///< The page factory which provides the page actors
index 8e0d094..43c6bde 100644 (file)
@@ -136,14 +136,14 @@ void BorderRenderer::InitializeRenderer()
   if( !geometry )
   {
     geometry =  CreateBorderGeometry();
-    mFactoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, geometry );
+    mFactoryCache.SaveGeometry( RendererFactoryCache::BORDER_GEOMETRY, geometry );
   }
 
   Shader shader = mFactoryCache.GetShader( RendererFactoryCache::BORDER_SHADER );
   if( !shader )
   {
     shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
-    mFactoryCache.SaveShader( RendererFactoryCache::COLOR_SHADER, shader );
+    mFactoryCache.SaveShader( RendererFactoryCache::BORDER_SHADER, shader );
   }
 
   Material material = Material::New( shader );
index d2b699b..f92f721 100755 (executable)
@@ -152,6 +152,7 @@ const char* INDICATOR_HEIGHT_POLICY_NAME[] = {"Variable", "Fixed"};
 
 ScrollBar::ScrollBar(Toolkit::ScrollBar::Direction direction)
 : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
+  mIndicatorShowAlpha(1.0f),
   mDirection(direction),
   mScrollableObject(WeakHandleBase()),
   mPropertyScrollPosition(Property::INVALID_INDEX),
@@ -161,10 +162,11 @@ ScrollBar::ScrollBar(Toolkit::ScrollBar::Direction direction)
   mIndicatorShowDuration(DEFAULT_INDICATOR_SHOW_DURATION),
   mIndicatorHideDuration(DEFAULT_INDICATOR_HIDE_DURATION),
   mScrollStart(0.0f),
-  mIsPanning(false),
   mCurrentScrollPosition(0.0f),
   mIndicatorHeightPolicy(Toolkit::ScrollBar::Variable),
-  mIndicatorFixedHeight(DEFAULT_INDICATOR_FIXED_HEIGHT)
+  mIndicatorFixedHeight(DEFAULT_INDICATOR_FIXED_HEIGHT),
+  mIsPanning(false),
+  mIndicatorFirstShow(true)
 {
 }
 
@@ -218,6 +220,7 @@ void ScrollBar::SetScrollIndicator( Actor indicator )
   if( indicator )
   {
     mIndicator = indicator;
+    mIndicatorFirstShow = true;
     Self().Add(mIndicator);
 
     EnableGestureDetection(Gesture::Type(Gesture::Pan));
@@ -328,15 +331,22 @@ void ScrollBar::ShowIndicator()
     mAnimation.Reset();
   }
 
+  if( mIndicatorFirstShow )
+  {
+    // Preserve the alpha value from the stylesheet
+    mIndicatorShowAlpha = Self().GetCurrentColor().a;
+    mIndicatorFirstShow = false;
+  }
+
   if(mIndicatorShowDuration > 0.0f)
   {
     mAnimation = Animation::New( mIndicatorShowDuration );
-    mAnimation.AnimateTo( Property( mIndicator, Actor::Property::COLOR_ALPHA ), 1.0f, AlphaFunction::EASE_IN );
+    mAnimation.AnimateTo( Property( mIndicator, Actor::Property::COLOR_ALPHA ), mIndicatorShowAlpha, AlphaFunction::EASE_IN );
     mAnimation.Play();
   }
   else
   {
-    mIndicator.SetOpacity(1.0f);
+    mIndicator.SetOpacity(mIndicatorShowAlpha);
   }
 }
 
index 23d3fa7..1f9691d 100755 (executable)
@@ -265,6 +265,7 @@ private:
 private:
 
   Actor mIndicator;                                                  ///< Image of scroll indicator.
+  float mIndicatorShowAlpha;                                         ///< The alpha value when the indicator is fully shown
   Animation mAnimation;                                              ///< Scroll indicator Show/Hide Animation.
 
   Toolkit::ScrollBar::Direction mDirection;                          ///< The direction of scroll bar (vertical or horizontal)
@@ -282,7 +283,6 @@ private:
   float mScrollStart;                                                ///< Scroll Start position (start of drag)
   Vector3 mGestureDisplacement;                                      ///< Gesture Displacement.
 
-  bool mIsPanning;                                                  ///< Whether the scroll bar is being panned.
   float mCurrentScrollPosition;                                     ///< The current scroll position updated by the pan gesture
 
   Toolkit::ScrollBar::IndicatorHeightPolicy mIndicatorHeightPolicy;  ///< The height policy of scroll indicator (variable or fixed)
@@ -300,6 +300,9 @@ private:
   Constraint mIndicatorPositionConstraint;
   Constraint mIndicatorSizeConstraint;
   Constraint mScrollPositionInCurrentAxisConstraint;
+
+  bool mIsPanning          : 1;                                      ///< Whether the scroll bar is being panned.
+  bool mIndicatorFirstShow : 1;                                      ///< True if the indicator has never been shown
 };
 
 } // namespace Internal
index 91a9f97..a181c9a 100644 (file)
@@ -289,26 +289,27 @@ Dali::Toolkit::ItemView ItemView::New(ItemFactory& factory)
 ItemView::ItemView(ItemFactory& factory)
 : Scrollable( ControlBehaviour( DISABLE_SIZE_NEGOTIATION | REQUIRES_WHEEL_EVENTS | REQUIRES_KEYBOARD_NAVIGATION_SUPPORT ) ),
   mItemFactory(factory),
+  mItemsParentOrigin(ParentOrigin::CENTER),
+  mItemsAnchorPoint(AnchorPoint::CENTER),
+  mTotalPanDisplacement(Vector2::ZERO),
   mActiveLayout(NULL),
-  mAnimatingOvershootOn(false),
-  mAnimateOvershootOff(false),
-  mAnchoringEnabled(false),
   mAnchoringDuration(DEFAULT_ANCHORING_DURATION),
   mRefreshIntervalLayoutPositions(0.0f),
-  mRefreshOrderHint(true/*Refresh item 0 first*/),
   mMinimumSwipeSpeed(DEFAULT_MINIMUM_SWIPE_SPEED),
   mMinimumSwipeDistance(DEFAULT_MINIMUM_SWIPE_DISTANCE),
   mWheelScrollDistanceStep(0.0f),
   mScrollDistance(0.0f),
   mScrollSpeed(0.0f),
-  mTotalPanDisplacement(Vector2::ZERO),
   mScrollOvershoot(0.0f),
-  mIsFlicking(false),
   mGestureState(Gesture::Clear),
+  mAnimatingOvershootOn(false),
+  mAnimateOvershootOff(false),
+  mAnchoringEnabled(false),
+  mRefreshOrderHint(true/*Refresh item 0 first*/),
+  mIsFlicking(false),
   mAddingItems(false),
   mRefreshEnabled(true),
-  mItemsParentOrigin( ParentOrigin::CENTER),
-  mItemsAnchorPoint( AnchorPoint::CENTER)
+  mInAnimation(false)
 {
 }
 
@@ -1184,13 +1185,39 @@ void ItemView::OnPan( const PanGesture& gesture )
 
       self.SetProperty(Toolkit::ItemView::Property::LAYOUT_POSITION, firstItemScrollPosition );
 
-      if( (firstItemScrollPosition >= 0.0f && currentOvershoot < 1.0f) || (firstItemScrollPosition >= mActiveLayout->GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), layoutSize) && currentOvershoot > -1.0f) )
+      if( ( firstItemScrollPosition >= 0.0f &&
+            currentOvershoot < 1.0f ) ||
+          ( firstItemScrollPosition <= mActiveLayout->GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), layoutSize) &&
+            currentOvershoot > -1.0f ) )
       {
         mTotalPanDisplacement += gesture.displacement;
       }
 
       mScrollOvershoot = CalculateScrollOvershoot();
-      self.SetProperty( Toolkit::ItemView::Property::OVERSHOOT, mScrollOvershoot );
+
+      // If the view is moved in a direction against the overshoot indicator, then the indicator should be animated off.
+      // First make sure we are not in an animation, otherwise a previously started
+      // off-animation will be overwritten as the user continues scrolling.
+      if( !mInAnimation )
+      {
+        // Check if the movement is against the current overshoot amount (if we are currently displaying the indicator).
+        if( ( ( mScrollOvershoot > Math::MACHINE_EPSILON_0 ) && ( mScrollDistance < -Math::MACHINE_EPSILON_0 ) ) ||
+          ( ( mScrollOvershoot < Math::MACHINE_EPSILON_0 ) && ( mScrollDistance > Math::MACHINE_EPSILON_0 ) ) )
+        {
+          // The user has moved against the indicator direction.
+          // First, we reset the total displacement. This means the overshoot amount will become zero the next frame,
+          // and if the user starts dragging in the overshoot direction again, the indicator will appear once more.
+          mTotalPanDisplacement = Vector2::ZERO;
+          // Animate the overshoot indicator off.
+          AnimateScrollOvershoot( 0.0f, false );
+        }
+        else
+        {
+          // Only set the property directly if we are not animating the overshoot away,
+          // as otherwise this will overwrite the animation generated value.
+          self.SetProperty( Toolkit::ItemView::Property::OVERSHOOT, mScrollOvershoot );
+        }
+      }
     }
     break;
 
@@ -1328,6 +1355,7 @@ void ItemView::OnOvershootOnFinished(Animation& animation)
   {
     AnimateScrollOvershoot(0.0f);
   }
+  mInAnimation = false;
 }
 
 void ItemView::ScrollToItem(unsigned int itemId, float durationSeconds)
@@ -1574,13 +1602,14 @@ void ItemView::AnimateScrollOvershoot(float overshootAmount, bool animateBack)
       duration = mOvershootOverlay.GetCurrentSize().height * (animatingOn ? (1.0f - fabsf(currentOvershoot)) : fabsf(currentOvershoot)) / mOvershootAnimationSpeed;
     }
 
+    // Mark the animation as in progress to prevent manual property sets overwriting it.
+    mInAnimation = true;
+    mAnimatingOvershootOn = animatingOn;
     RemoveAnimation(mScrollOvershootAnimation);
     mScrollOvershootAnimation = Animation::New(duration);
     mScrollOvershootAnimation.FinishedSignal().Connect(this, &ItemView::OnOvershootOnFinished);
     mScrollOvershootAnimation.AnimateTo( Property(self, Toolkit::ItemView::Property::OVERSHOOT), overshootAmount, TimePeriod(0.0f, duration) );
     mScrollOvershootAnimation.Play();
-
-    mAnimatingOvershootOn = animatingOn;
   }
   else
   {
index 9fc58aa..2fe5e09 100644 (file)
@@ -561,58 +561,44 @@ private:
 
 private:
 
-  ItemFactory& mItemFactory;
-
   typedef std::map<unsigned int, Actor> ItemPool;
   typedef ItemPool::iterator            ItemPoolIter;
   typedef ItemPool::const_iterator      ConstItemPoolIter;
 
   ItemPool mItemPool;
-
-  std::vector< ItemLayoutPtr >  mLayouts;  ///<  Container of Dali::Toolkit::ItemLayout objects
-  ItemLayout* mActiveLayout;
-  Vector3 mActiveLayoutTargetSize;
-
+  ItemFactory& mItemFactory;
+  std::vector< ItemLayoutPtr > mLayouts;            ///< Container of Dali::Toolkit::ItemLayout objects
+  Actor mOvershootOverlay;                          ///< The overlay actor for overshoot effect
   Animation mResizeAnimation;
   Animation mScrollAnimation;
   Animation mScrollOvershootAnimation;
-  bool      mAnimatingOvershootOn;          ///< whether we are currently animating overshoot to 1.0f/-1.0f (on) or to 0.0f (off)
-  bool      mAnimateOvershootOff;         ///< whether we are currently animating overshoot to 1.0f/-1.0f (on) or to 0.0f (off)
+  Timer mWheelEventFinishedTimer;                   ///< The timer to determine whether there is no wheel event received for a certain period of time.
+  PropertyNotification mRefreshNotification;        ///< Stores the property notification used for item view refresh
+  LayoutActivatedSignalType mLayoutActivatedSignal;
+  Vector3 mActiveLayoutTargetSize;
+  Vector3 mItemsParentOrigin;
+  Vector3 mItemsAnchorPoint;
+  Vector2 mTotalPanDisplacement;
+  ItemLayout* mActiveLayout;
 
-  bool mAnchoringEnabled;
   float mAnchoringDuration;
-
-  float mRefreshIntervalLayoutPositions;  ///< Refresh item view when the layout position changes by this interval in both positive and negative directions.
-  PropertyNotification mRefreshNotification; // stores the property notification used for item view refresh
-  bool mRefreshOrderHint; ///< True if scrolling towards the last item
-
-  // Input handling
-
+  float mRefreshIntervalLayoutPositions;            ///< Refresh item view when the layout position changes by this interval in both positive and negative directions.
   float mMinimumSwipeSpeed;
   float mMinimumSwipeDistance;
-  float mWheelScrollDistanceStep; ///< The step of scroll distance in actor coordinates for each wheel event received.
-
+  float mWheelScrollDistanceStep;                   ///< The step of scroll distance in actor coordinates for each wheel event received.
   float mScrollDistance;
   float mScrollSpeed;
-  Vector2 mTotalPanDisplacement;
-
   float mScrollOvershoot;
-  bool mIsFlicking;
-
-  Timer mWheelEventFinishedTimer; ///< The timer to determine whether there is no wheel event received for a certain period of time.
-
-  Dali::Gesture::State mGestureState;
 
-  Actor mOvershootOverlay;           ///< The overlay actor for overshoot effect
-
-  bool mAddingItems;
-
-  bool mRefreshEnabled; ///< Whether to refresh the cache automatically
-
-  Vector3 mItemsParentOrigin;
-  Vector3 mItemsAnchorPoint;
-
-  LayoutActivatedSignalType mLayoutActivatedSignal;
+  Dali::Gesture::State mGestureState    : 3;
+  bool mAnimatingOvershootOn            : 1;        ///< Whether we are currently animating overshoot to 1.0f/-1.0f (on) or to 0.0f (off)
+  bool mAnimateOvershootOff             : 1;        ///< Whether we are currently animating overshoot to 1.0f/-1.0f (on) or to 0.0f (off)
+  bool mAnchoringEnabled                : 1;
+  bool mRefreshOrderHint                : 1;        ///< True if scrolling towards the last item
+  bool mIsFlicking                      : 1;
+  bool mAddingItems                     : 1;
+  bool mRefreshEnabled                  : 1;        ///< Whether to refresh the cache automatically
+  bool mInAnimation                     : 1;        ///< Keeps track of whether an animation is controlling the overshoot property.
 };
 
 } // namespace Internal
index bfc49c0..eff1b08 100644 (file)
@@ -146,6 +146,7 @@ void ScrollOvershootEffectRipple::Apply()
   mOvershootProperty = IsVertical() ? Toolkit::ScrollView::Property::OVERSHOOT_Y : Toolkit::ScrollView::Property::OVERSHOOT_X;
 
   // make sure height is set, since we only create a constraint for image width
+  mOvershootSize = mAttachedScrollView.GetOvershootSize();
   mOvershootOverlay.SetSize( mOvershootSize );
 
   mAttachedScrollView.AddOverlay(mOvershootOverlay);
index 81804c2..929cab2 100644 (file)
@@ -341,86 +341,96 @@ struct InternalPrePositionConstraint
   void operator()( Vector2& scrollPostPosition, const PropertyInputContainer& inputs )
   {
     const Vector2& panPosition = inputs[0]->GetVector2();
+    const bool& inGesture = inputs[1]->GetBoolean();
 
-    if(!mWasPanning)
+    // First check if we are within a gesture.
+    // The ScrollView may have received a start gesture from ::OnPan()
+    // while the finish gesture is received now in this constraint.
+    // This gesture must then be rejected as the value will be "old".
+    // Typically the last value from the end of the last gesture.
+    // If we are rejecting the gesture, we simply don't modify the constraint target.
+    if( inGesture )
     {
-      mPrePosition = scrollPostPosition;
-      mStartPosition = mPrePosition;
-      mCurrentPanMask = mInitialPanMask;
-      mWasPanning = true;
-    }
-
-    // Calculate Deltas...
-    const Vector2& currentPosition = panPosition;
-    Vector2 panDelta( currentPosition - mLocalStart );
-
-    // Axis Auto Lock - locks the panning to the horizontal or vertical axis if the pan
-    // appears mostly horizontal or mostly vertical respectively...
-    if( mAxisAutoLock )
-    {
-      mLockAxis = GetLockAxis(panDelta, mLockAxis, mAxisAutoLockGradient);
-      if( mLockAxis == ScrollView::LockVertical )
+      if( !mWasPanning )
       {
-        mCurrentPanMask.y = 0.0f;
+        mPrePosition = scrollPostPosition;
+        mStartPosition = mPrePosition;
+        mCurrentPanMask = mInitialPanMask;
+        mWasPanning = true;
       }
-      else if( mLockAxis == ScrollView::LockHorizontal )
+
+      // Calculate Deltas...
+      const Vector2& currentPosition = panPosition;
+      Vector2 panDelta( currentPosition - mLocalStart );
+
+      // Axis Auto Lock - locks the panning to the horizontal or vertical axis if the pan
+      // appears mostly horizontal or mostly vertical respectively...
+      if( mAxisAutoLock )
       {
-        mCurrentPanMask.x = 0.0f;
+        mLockAxis = GetLockAxis( panDelta, mLockAxis, mAxisAutoLockGradient );
+        if( mLockAxis == ScrollView::LockVertical )
+        {
+          mCurrentPanMask.y = 0.0f;
+        }
+        else if( mLockAxis == ScrollView::LockHorizontal )
+        {
+          mCurrentPanMask.x = 0.0f;
+        }
       }
-    }
 
-    // Restrict deltas based on ruler enable/disable and axis-lock state...
-    panDelta *= mCurrentPanMask;
+      // Restrict deltas based on ruler enable/disable and axis-lock state...
+      panDelta *= mCurrentPanMask;
 
-    // Perform Position transform based on input deltas...
-    scrollPostPosition = mPrePosition;
-    scrollPostPosition += panDelta;
+      // Perform Position transform based on input deltas...
+      scrollPostPosition = mPrePosition;
+      scrollPostPosition += panDelta;
 
-    // if no wrapping then clamp preposition to maximum overshoot amount
-    const Vector3& size = inputs[1]->GetVector3();
-    if( mClampX )
-    {
-      float newXPosition = Clamp(scrollPostPosition.x, (mDomainMax.x + size.x) - mMaxOvershoot.x, mDomainMin.x + mMaxOvershoot.x );
-      if( (newXPosition < scrollPostPosition.x - Math::MACHINE_EPSILON_1)
-              || (newXPosition > scrollPostPosition.x + Math::MACHINE_EPSILON_1) )
+      // if no wrapping then clamp preposition to maximum overshoot amount
+      const Vector3& size = inputs[2]->GetVector3();
+      if( mClampX )
       {
-        mPrePosition.x = newXPosition;
-        mLocalStart.x = panPosition.x;
+        float newXPosition = Clamp( scrollPostPosition.x, ( mDomainMax.x + size.x ) - mMaxOvershoot.x, mDomainMin.x + mMaxOvershoot.x );
+        if( (newXPosition < scrollPostPosition.x - Math::MACHINE_EPSILON_1)
+          || (newXPosition > scrollPostPosition.x + Math::MACHINE_EPSILON_1) )
+        {
+          mPrePosition.x = newXPosition;
+          mLocalStart.x = panPosition.x;
+        }
+        scrollPostPosition.x = newXPosition;
       }
-      scrollPostPosition.x = newXPosition;
-    }
-    if( mClampY )
-    {
-      float newYPosition = Clamp(scrollPostPosition.y, (mDomainMax.y + size.y) - mMaxOvershoot.y, mDomainMin.y + mMaxOvershoot.y );
-      if( (newYPosition < scrollPostPosition.y - Math::MACHINE_EPSILON_1)
-              || (newYPosition > scrollPostPosition.y + Math::MACHINE_EPSILON_1) )
+      if( mClampY )
       {
-        mPrePosition.y = newYPosition;
-        mLocalStart.y = panPosition.y;
+        float newYPosition = Clamp( scrollPostPosition.y, ( mDomainMax.y + size.y ) - mMaxOvershoot.y, mDomainMin.y + mMaxOvershoot.y );
+        if( ( newYPosition < scrollPostPosition.y - Math::MACHINE_EPSILON_1 )
+          || ( newYPosition > scrollPostPosition.y + Math::MACHINE_EPSILON_1 ) )
+        {
+          mPrePosition.y = newYPosition;
+          mLocalStart.y = panPosition.y;
+        }
+        scrollPostPosition.y = newYPosition;
       }
-      scrollPostPosition.y = newYPosition;
-    }
 
-    // If we are using a fixed ruler in a particular axis, limit the maximum pages scrolled on that axis.
-    if( mFixedRulerX || mFixedRulerY )
-    {
-      // Here we limit the maximum amount that can be moved from the starting position of the gesture to one page.
-      // We do this only if we have a fixed ruler (on that axis) and the mode is enabled.
-      // Note: 1.0f is subtracted to keep the value within one page size (otherwise we stray on to the page after).
-      // Note: A further 1.0f is subtracted to handle a compensation that happens later within the flick handling code in SnapWithVelocity().
-      //       When a flick is completed, an adjustment of 1.0f is sometimes made to allow for the scenario where:
-      //       A flick finishes before the update thread has advanced the scroll position past the previous snap point.
-      Vector2 pageSizeLimit( size.x - ( 1.0f + 1.0f ), size.y - ( 1.0f - 1.0f ) );
-      Vector2 minPosition( mStartPosition.x - pageSizeLimit.x, mStartPosition.y - pageSizeLimit.y );
-      Vector2 maxPosition( mStartPosition.x + pageSizeLimit.x, mStartPosition.y + pageSizeLimit.y );
-
-      if( mFixedRulerX )
-      {
-        scrollPostPosition.x = Clamp( scrollPostPosition.x, minPosition.x, maxPosition.x );
-      }
-      if( mFixedRulerY )
+      // If we are using a fixed ruler in a particular axis, limit the maximum pages scrolled on that axis.
+      if( mFixedRulerX || mFixedRulerY )
       {
-        scrollPostPosition.y = Clamp( scrollPostPosition.y, minPosition.y, maxPosition.y );
+        // Here we limit the maximum amount that can be moved from the starting position of the gesture to one page.
+        // We do this only if we have a fixed ruler (on that axis) and the mode is enabled.
+        // Note: 1.0f is subtracted to keep the value within one page size (otherwise we stray on to the page after).
+        // Note: A further 1.0f is subtracted to handle a compensation that happens later within the flick handling code in SnapWithVelocity().
+        //       When a flick is completed, an adjustment of 1.0f is sometimes made to allow for the scenario where:
+        //       A flick finishes before the update thread has advanced the scroll position past the previous snap point.
+        Vector2 pageSizeLimit( size.x - ( 1.0f + 1.0f ), size.y - ( 1.0f - 1.0f ) );
+        Vector2 minPosition( mStartPosition.x - pageSizeLimit.x, mStartPosition.y - pageSizeLimit.y );
+        Vector2 maxPosition( mStartPosition.x + pageSizeLimit.x, mStartPosition.y + pageSizeLimit.y );
+
+        if( mFixedRulerX )
+        {
+          scrollPostPosition.x = Clamp( scrollPostPosition.x, minPosition.x, maxPosition.x );
+        }
+        if( mFixedRulerY )
+        {
+          scrollPostPosition.y = Clamp( scrollPostPosition.y, minPosition.y, maxPosition.y );
+        }
       }
     }
   }
@@ -685,6 +695,8 @@ void ScrollView::OnInitialize()
 
 void ScrollView::OnStageConnection( int depth )
 {
+  ScrollBase::OnStageConnection( depth );
+
   DALI_LOG_SCROLL_STATE("[0x%X]", this);
 
   if ( mSensitive )
@@ -704,6 +716,8 @@ void ScrollView::OnStageDisconnection()
   DALI_LOG_SCROLL_STATE("[0x%X]", this);
 
   StopAnimation();
+
+  ScrollBase::OnStageDisconnection();
 }
 
 ScrollView::~ScrollView()
@@ -2692,6 +2706,7 @@ void ScrollView::UpdateMainInternalConstraint()
                                                                                                         mRulerX,
                                                                                                         mRulerY ) );
     mScrollMainInternalPrePositionConstraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
+    mScrollMainInternalPrePositionConstraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
     mScrollMainInternalPrePositionConstraint.AddSource( Source( self, Actor::Property::SIZE ) );
     mScrollMainInternalPrePositionConstraint.Apply();
   }
index 31174a2..80682f1 100644 (file)
@@ -86,18 +86,30 @@ const char* const BLUR_STRENGTH_PROPERTY_NAME = "BlurStrengthProperty";
 const char* const SHADOW_COLOR_PROPERTY_NAME = "ShadowColorProperty";
 
 const char* const RENDER_SHADOW_VERTEX_SOURCE =
+
+  " attribute mediump vec2 aPosition;\n"
+  " uniform mediump mat4 uMvpMatrix;\n"
+  " uniform mediump mat4 uModelMatrix;\n"
+  " uniform vec3 uSize;\n"
+  " varying vec2 vTexCoord;\n"
+
   " uniform mediump mat4 uLightCameraProjectionMatrix;\n"
   " uniform mediump mat4 uLightCameraViewMatrix;\n"
   "\n"
   "void main()\n"
   "{\n"
-    "  gl_Position = uProjection * uModelView * vec4(aPosition,1.0);\n"
-    "  vec4 textureCoords = uLightCameraProjectionMatrix * uLightCameraViewMatrix * uModelMatrix  * vec4(aPosition,1.0);\n"
+    "  mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n"
+    "  vertexPosition.xyz *= uSize;\n"
+    "  gl_Position = uMvpMatrix * vertexPosition;\n"
+    "  vec4 textureCoords = uLightCameraProjectionMatrix * uLightCameraViewMatrix * uModelMatrix  * vertexPosition;\n"
     "  vTexCoord = 0.5 + 0.5 * (textureCoords.xy/textureCoords.w);\n"
   "}\n";
 
 const char* const RENDER_SHADOW_FRAGMENT_SOURCE =
+  "varying mediump vec2 vTexCoord;\n"
   "uniform lowp vec4 uShadowColor;\n"
+  "uniform sampler2D sTexture;\n"
+
   "void main()\n"
   "{\n"
   "  lowp float alpha;\n"
@@ -149,17 +161,18 @@ void ShadowView::Remove(Actor child)
   mChildrenRoot.Remove(child);
 }
 
-void ShadowView::SetShadowPlane(Actor shadowPlane)
+void ShadowView::SetShadowPlaneBackground(Actor shadowPlaneBackground)
 {
-  mShadowPlaneBg = shadowPlane;
+  mShadowPlaneBg = shadowPlaneBackground;
 
-  mShadowPlane = ImageActor::New();
+  mShadowPlane = Toolkit::ImageView::New();
   mShadowPlane.SetName( "SHADOW_PLANE" );
   mShadowPlane.SetParentOrigin(ParentOrigin::CENTER);
   mShadowPlane.SetAnchorPoint(AnchorPoint::CENTER);
 
   mShadowPlane.SetImage(mOutputImage);
-  mShadowPlane.SetShaderEffect(mShadowRenderShader);
+  mShadowPlane.SetProperty( Toolkit::ImageView::Property::IMAGE, mShadowRenderShader );
+  SetShaderConstants();
 
   // Rather than parent the shadow plane drawable and have constraints to move it to the same
   // position, instead parent the shadow plane drawable on the shadow plane passed in.
@@ -193,7 +206,10 @@ void ShadowView::SetShadowColor(Vector4 color)
   mCachedBackgroundColor.g = color.g;
   mCachedBackgroundColor.b = color.b;
 
-  Self().SetProperty( mShadowColorPropertyIndex, mCachedShadowColor );
+  if( mShadowPlane )
+  {
+    mShadowPlane.SetProperty( mShadowColorPropertyIndex, mCachedShadowColor );
+  }
   if(mRenderSceneTask)
   {
     mRenderSceneTask.SetClearColor( mCachedBackgroundColor );
@@ -239,8 +255,17 @@ void ShadowView::OnInitialize()
   mCameraActor.SetOrientation(Radian(Degree(180)), Vector3::YAXIS);
   mCameraActor.SetPosition(DEFAULT_LIGHT_POSITION);
 
-  mShadowRenderShader = ShaderEffect::New( RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE,
-                                           ShaderEffect::GeometryHints( ShaderEffect::HINT_GRID | ShaderEffect::HINT_BLENDING ));
+
+  Property::Map customShader;
+  customShader[ "vertex-shader" ] = RENDER_SHADOW_VERTEX_SOURCE;
+  customShader[ "fragment-shader" ] = RENDER_SHADOW_FRAGMENT_SOURCE;
+
+  customShader[ "subdivide-grid-x" ] = 20;
+  customShader[ "subdivide-grid-y" ] = 20;
+
+  customShader[ "hints" ] = "output-is-transparent";
+
+  mShadowRenderShader[ "shader" ] = customShader;
 
   // Create render targets needed for rendering from light's point of view
   mSceneFromLightRenderTarget = FrameBufferImage::New( stageSize.width, stageSize.height, Pixel::RGBA8888 );
@@ -273,7 +298,13 @@ void ShadowView::OnInitialize()
   mBlurFilter.SetRootActor(mBlurRootActor);
   mBlurFilter.SetBackgroundColor(Vector4::ZERO);
 
-  SetShaderConstants();
+  CustomActor self = Self();
+  // Register a property that the user can use to control the blur in the internal object
+  mBlurStrengthPropertyIndex = self.RegisterProperty(BLUR_STRENGTH_PROPERTY_NAME, BLUR_STRENGTH_DEFAULT);
+
+  Constraint blurStrengthConstraint = Constraint::New<float>( mBlurFilter.GetHandleForAnimateBlurStrength(), mBlurFilter.GetBlurStrengthPropertyIndex(), EqualToConstraint() );
+  blurStrengthConstraint.AddSource( Source( self, mBlurStrengthPropertyIndex) );
+  blurStrengthConstraint.Apply();
 }
 
 void ShadowView::OnSizeSet(const Vector3& targetSize)
@@ -332,38 +363,17 @@ void ShadowView::RemoveRenderTasks()
 
 void ShadowView::SetShaderConstants()
 {
-  CustomActor self = Self();
-
-  mShadowRenderShader.SetUniform( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
-  mShadowRenderShader.SetUniform( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
-  mShadowRenderShader.SetUniform( SHADER_SHADOW_COLOR_PROPERTY_NAME, mCachedShadowColor );
-
-  Property::Index lightCameraProjectionMatrixPropertyIndex = mShadowRenderShader.GetPropertyIndex(SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME);
-  Property::Index lightCameraViewMatrixPropertyIndex = mShadowRenderShader.GetPropertyIndex(SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME);
-
-  Constraint projectionMatrixConstraint = Constraint::New<Dali::Matrix>( mShadowRenderShader, lightCameraProjectionMatrixPropertyIndex, EqualToConstraint() );
+  Property::Index lightCameraProjectionMatrixPropertyIndex = mShadowPlane.RegisterProperty( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
+  Constraint projectionMatrixConstraint = Constraint::New<Dali::Matrix>( mShadowPlane, lightCameraProjectionMatrixPropertyIndex, EqualToConstraint() );
   projectionMatrixConstraint.AddSource( Source( mCameraActor, CameraActor::Property::PROJECTION_MATRIX ) );
+  projectionMatrixConstraint.Apply();
 
-  Constraint viewMatrixConstraint = Constraint::New<Dali::Matrix>( mShadowRenderShader, lightCameraViewMatrixPropertyIndex, EqualToConstraint() );
+  Property::Index lightCameraViewMatrixPropertyIndex = mShadowPlane.RegisterProperty( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
+  Constraint viewMatrixConstraint = Constraint::New<Dali::Matrix>( mShadowPlane, lightCameraViewMatrixPropertyIndex, EqualToConstraint() );
   viewMatrixConstraint.AddSource( Source( mCameraActor, CameraActor::Property::VIEW_MATRIX ) );
-
-  projectionMatrixConstraint.Apply();
   viewMatrixConstraint.Apply();
 
-  // Register a property that the user can use to control the blur in the internal object
-  mBlurStrengthPropertyIndex = self.RegisterProperty(BLUR_STRENGTH_PROPERTY_NAME, BLUR_STRENGTH_DEFAULT);
-
-  Constraint blurStrengthConstraint = Constraint::New<float>( mBlurFilter.GetHandleForAnimateBlurStrength(), mBlurFilter.GetBlurStrengthPropertyIndex(), EqualToConstraint() );
-  blurStrengthConstraint.AddSource( Source( self, mBlurStrengthPropertyIndex) );
-  blurStrengthConstraint.Apply();
-
-  //  Register a property that the user can use to control the color of the shadow.
-  Property::Index index = mShadowRenderShader.GetPropertyIndex(SHADER_SHADOW_COLOR_PROPERTY_NAME);
-  mShadowColorPropertyIndex = self.RegisterProperty(SHADOW_COLOR_PROPERTY_NAME, mCachedShadowColor);
-
-  Constraint shadowRenderShaderConstraint = Constraint::New<Dali::Vector4>( mShadowRenderShader, index, EqualToConstraint() );
-  shadowRenderShaderConstraint.AddSource( Source( self, mShadowColorPropertyIndex ) );
-  shadowRenderShaderConstraint.Apply();
+  mShadowColorPropertyIndex = mShadowPlane.RegisterProperty( SHADER_SHADOW_COLOR_PROPERTY_NAME, mCachedShadowColor );
 }
 
 } // namespace Internal
index 5aa3595..68e1c33 100644 (file)
 #include <dali/public-api/animation/constraints.h>
 #include <dali/public-api/render-tasks/render-task.h>
 #include <dali/public-api/shader-effects/shader-effect.h>
+#include <dali/public-api/object/property-map.h>
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/devel-api/controls/shadow-view/shadow-view.h>
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
 #include <dali-toolkit/public-api/controls/control-impl.h>
 #include <dali-toolkit/internal/filters/blur-two-pass-filter.h>
 
@@ -80,9 +82,9 @@ public:
   void Remove(Actor child);
 
   /**
-   * @copydoc Dali::Toolkit::ShadowView::SetShadowPlane(Actor shadowPlane)
+   * @copydoc Dali::Toolkit::ShadowView::SetShadowPlaneBackground(Actor shadowPlaneBackground)
    */
-  void SetShadowPlane(Actor shadowPlane);
+  void SetShadowPlaneBackground(Actor shadowPlaneBackground);
 
   /**
    * @copydoc Dali::Toolkit::ShadowView::SetPointLight(Actor pointLight)
@@ -137,7 +139,7 @@ private:
   void CreateBlurFilter();
 
 private:
-  ImageActor mShadowPlane; // Shadow renders into this actor
+  Toolkit::ImageView mShadowPlane; // Shadow renders into this actor
   Actor mShadowPlaneBg; // mShadowPlane renders directly in front of this actor
   Actor mPointLight;  // Shadow is cast from this point light
 
@@ -148,12 +150,11 @@ private:
 
   Actor mChildrenRoot; // Subtree for all user added child actors that should be rendered normally
   Actor mBlurRootActor; // Root actor for blur filter processing
-  ImageActor mShadowPlaneDrawable; // Positioned on top of mShadowPlane for drawing shadow image
   RenderTask mRenderSceneTask;
 
   CameraActor mCameraActor; // Constrained to same position as mPointLight and pointing at mShadowPlane
 
-  ShaderEffect mShadowRenderShader;
+  Property::Map mShadowRenderShader;
   BlurTwoPassFilter mBlurFilter;
 
   Vector4 mCachedShadowColor;                               ///< Cached Shadow color.
index 9fe5771..5a6ce62 100644 (file)
@@ -28,6 +28,7 @@
 #include <dali/integration-api/debug.h>
 
 // INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/control-depth-index-ranges.h>
 #include <dali-toolkit/public-api/text/rendering-backend.h>
 #include <dali-toolkit/internal/controls/text-controls/text-font-style.h>
 #include <dali-toolkit/internal/text/rendering/text-backend.h>
@@ -987,7 +988,7 @@ void TextField::RenderText()
   Actor renderableActor;
   if( mRenderer )
   {
-    renderableActor = mRenderer->Render( mController->GetView(), self.GetHierarchyDepth() );
+    renderableActor = mRenderer->Render( mController->GetView(), TEXT_DEPTH_INDEX );
   }
 
   if( renderableActor != mRenderableActor )
index be24d2b..12de684 100644 (file)
@@ -23,6 +23,7 @@
 #include <dali/integration-api/debug.h>
 
 // INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/control-depth-index-ranges.h>
 #include <dali-toolkit/public-api/text/rendering-backend.h>
 #include <dali-toolkit/internal/controls/text-controls/text-font-style.h>
 #include <dali-toolkit/internal/text/rendering/text-backend.h>
@@ -518,7 +519,7 @@ void TextLabel::RenderText()
   Actor renderableActor;
   if( mRenderer )
   {
-    renderableActor = mRenderer->Render( mController->GetView(), self.GetHierarchyDepth() );
+    renderableActor = mRenderer->Render( mController->GetView(), TEXT_DEPTH_INDEX );
   }
 
   if( renderableActor != mRenderableActor )
index e26614d..5995cee 100644 (file)
@@ -26,6 +26,7 @@
 #include <dali/public-api/images/resource-image.h>
 #include <dali/public-api/math/vector2.h>
 #include <dali/public-api/math/vector4.h>
+#include <dali/public-api/object/property-map.h>
 #include <dali/devel-api/object/type-registry-helper.h>
 #include <cfloat>
 
@@ -40,7 +41,6 @@ namespace Internal
 
 namespace
 {
-const Dali::Vector2 DEFAULT_MAX_SIZE( 400.0f, 65.0f ); ///< The maximum size of the Toolbar.
 
 BaseHandle Create()
 {
@@ -53,6 +53,7 @@ DALI_TYPE_REGISTRATION_BEGIN( Toolkit::TextSelectionToolbar, Toolkit::Control, C
 
 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionToolbar, "max-size", VECTOR2, MAX_SIZE )
 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionToolbar, "enable-overshoot", BOOLEAN, ENABLE_OVERSHOOT )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionToolbar, "scroll-view", MAP, SCROLL_VIEW )
 
 DALI_TYPE_REGISTRATION_END()
 
@@ -90,9 +91,23 @@ void TextSelectionToolbar::SetProperty( BaseObject* object, Property::Index inde
       }
       case Toolkit::TextSelectionToolbar::Property::ENABLE_OVERSHOOT:
       {
+        if( !impl.mScrollView )
+        {
+          impl.mScrollView  = Toolkit::ScrollView::New();
+        }
         impl.mScrollView.SetOvershootEnabled( value.Get< bool >() );
         break;
       }
+      case Toolkit::TextSelectionToolbar::Property::SCROLL_VIEW:
+      {
+        // Get a Property::Map from the property if possible.
+        Property::Map setPropertyMap;
+        if( value.Get( setPropertyMap ) )
+        {
+          impl.ConfigureScrollview( setPropertyMap );
+        }
+        break;
+      }
     } // switch
   } // TextSelectionToolbar
 }
@@ -212,7 +227,10 @@ void TextSelectionToolbar::SetUp()
   stencil.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
   stencil.SetParentOrigin( ParentOrigin::CENTER );
 
-  mScrollView  = Toolkit::ScrollView::New();
+  if ( !mScrollView )
+  {
+    mScrollView  = Toolkit::ScrollView::New();
+  }
   SetUpScrollView();
 
   // Toolbar must start with at least one option, adding further options with increase it's size
@@ -221,7 +239,6 @@ void TextSelectionToolbar::SetUp()
   mTableOfButtons.SetParentOrigin( ParentOrigin::CENTER_LEFT );
   mTableOfButtons.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 
-
   mStencilLayer.Add( stencil );
   mStencilLayer.Add( mScrollView );
   mScrollView.Add( mTableOfButtons );
@@ -266,6 +283,27 @@ void TextSelectionToolbar::RaiseAbove( Layer target )
   mStencilLayer.RaiseAbove( target );
 }
 
+void TextSelectionToolbar::ConfigureScrollview( const Property::Map& properties )
+{
+  // Set any properties specified for the label by iterating through all property key-value pairs.
+  for( unsigned int i = 0, mapCount = properties.Count(); i < mapCount; ++i )
+  {
+    const StringValuePair& propertyPair( properties.GetPair( i ) );
+
+    // Convert the property string to a property index.
+    Property::Index setPropertyIndex = mScrollView.GetPropertyIndex( propertyPair.first );
+    if( setPropertyIndex != Property::INVALID_INDEX )
+    {
+      // If the conversion worked, we have a valid property index,
+      // Set the property to the new value.
+      mScrollView.SetProperty( setPropertyIndex, propertyPair.second );
+    }
+  }
+
+  RelayoutRequest();
+}
+
+
 TextSelectionToolbar::TextSelectionToolbar()
 : Control( ControlBehaviour( ControlBehaviour( REQUIRES_STYLE_CHANGE_SIGNALS ) ) ),
   mMaxSize (),
index 29d25db..92aa391 100644 (file)
@@ -118,6 +118,13 @@ private: // From Control
    */
   const Dali::Vector2& GetPopupMaxSize() const;
 
+private: // Implementation
+
+  /**
+   * @copydoc Toolkit::TextSelectionToolbar::ConfigureScrollview()
+   */
+  void ConfigureScrollview( const Property::Map& properties );
+
   /**
    * @brief Set up scrollview to scroll Toolbar horizontally
    */
@@ -140,8 +147,6 @@ private: // From Control
    */
   void OnScrollCompleted( const Vector2& position );
 
-private: // Implementation
-
   /**
    * Construct a new TextField.
    */
index e6a8b18..b262e99 100644 (file)
@@ -106,6 +106,7 @@ void GetGlyphsMetrics( GlyphIndex glyphIndex,
 
 EventData::EventData( DecoratorPtr decorator )
 : mDecorator( decorator ),
+  mImfManager(),
   mPlaceholderTextActive(),
   mPlaceholderTextInactive(),
   mPlaceholderTextColor( 0.8f, 0.8f, 0.8f, 0.8f ),
@@ -132,7 +133,9 @@ EventData::EventData( DecoratorPtr decorator )
   mScrollAfterUpdatePosition( false ),
   mScrollAfterDelete( false ),
   mAllTextSelected( false )
-{}
+{
+  mImfManager = ImfManager::Get();
+}
 
 EventData::~EventData()
 {}
@@ -575,6 +578,13 @@ void Controller::Impl::OnTapEvent( const Event& event )
 
       mEventData->mUpdateCursorPosition = true;
       mEventData->mScrollAfterUpdatePosition = true;
+
+      // Notify the cursor position to the imf manager.
+      if( mEventData->mImfManager )
+      {
+        mEventData->mImfManager.SetCursorPosition( mEventData->mPrimaryCursorPosition );
+        mEventData->mImfManager.NotifyCursorPosition();
+      }
     }
   }
 }
@@ -1438,7 +1448,6 @@ CharacterIndex Controller::Impl::GetClosestCursorIndex( float visualX,
 
   // Get the glyphs per character table.
   const Length* const glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin();
-  const Length* const charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin();
 
   // If the vector is void, there is no right to left characters.
   const bool hasRightToLeftCharacters = NULL != visualToLogicalBuffer;
@@ -1452,6 +1461,7 @@ CharacterIndex Controller::Impl::GetClosestCursorIndex( float visualX,
 
   // Traverses glyphs in visual order. To do that use the visual to logical conversion table.
   CharacterIndex visualIndex = startCharacter;
+  Length numberOfCharacters = 0u;
   for( ; !matched && ( visualIndex < endCharacter ); ++visualIndex )
   {
     // The character in logical order.
@@ -1460,44 +1470,59 @@ CharacterIndex Controller::Impl::GetClosestCursorIndex( float visualX,
     // Get the script of the character.
     const Script script = mLogicalModel->GetScript( characterLogicalOrderIndex );
 
-    // The first glyph for that character in logical order.
-    const GlyphIndex glyphLogicalOrderIndex = *( charactersToGlyphBuffer + characterLogicalOrderIndex );
     // The number of glyphs for that character
     const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + characterLogicalOrderIndex );
+    ++numberOfCharacters;
 
-    // Get the metrics for the group of glyphs.
-    GlyphMetrics glyphMetrics;
-    GetGlyphsMetrics( glyphLogicalOrderIndex,
-                      numberOfGlyphs,
-                      glyphMetrics,
-                      mVisualModel,
-                      mMetrics );
 
-    const Vector2& position = *( positionsBuffer + glyphLogicalOrderIndex );
+    if( 0u != numberOfGlyphs )
+    {
+      // Get the first character/glyph of the group of glyphs.
+      const CharacterIndex firstVisualCharacterIndex = 1u + visualIndex - numberOfCharacters;
+      const CharacterIndex firstLogicalCharacterIndex = hasRightToLeftCharacters ? *( visualToLogicalBuffer + firstVisualCharacterIndex ) : firstVisualCharacterIndex;
+      const GlyphIndex firstLogicalGlyphIndex = *( charactersToGlyphBuffer + firstLogicalCharacterIndex );
 
-    // Prevents to jump the whole Latin ligatures like fi, ff, or Arabic ï»»...
-    const Length numberOfCharactersInLigature = HasLigatureMustBreak( script ) ? *( charactersPerGlyphBuffer + glyphLogicalOrderIndex ) : 1u;
-    const float glyphAdvance = glyphMetrics.advance / static_cast<float>( numberOfCharactersInLigature );
+      // Get the metrics for the group of glyphs.
+      GlyphMetrics glyphMetrics;
+      GetGlyphsMetrics( firstLogicalGlyphIndex,
+                        numberOfGlyphs,
+                        glyphMetrics,
+                        mVisualModel,
+                        mMetrics );
 
-    for( GlyphIndex index = 0u; !matched && ( index < numberOfCharactersInLigature ); ++index )
-    {
-      // Find the mid-point of the area containing the glyph
-      const float glyphCenter = -glyphMetrics.xBearing + position.x + ( static_cast<float>( index ) + 0.5f ) * glyphAdvance;
+      // Get the position of the first glyph.
+      const Vector2& position = *( positionsBuffer + firstLogicalGlyphIndex );
 
-      if( visualX < glyphCenter )
+      // Whether the glyph can be split, like Latin ligatures fi, ff or Arabic ï»». 
+      const bool isInterglyphIndex = ( numberOfCharacters > numberOfGlyphs ) && HasLigatureMustBreak( script );
+      const Length numberOfBlocks = isInterglyphIndex ? numberOfCharacters : 1u;
+      const float glyphAdvance = glyphMetrics.advance / static_cast<float>( numberOfBlocks );
+
+      GlyphIndex index = 0u;
+      for( ; !matched && ( index < numberOfBlocks ); ++index )
+      {
+        // Find the mid-point of the area containing the glyph
+        const float glyphCenter = -glyphMetrics.xBearing + position.x + ( static_cast<float>( index ) + 0.5f ) * glyphAdvance;
+
+        if( visualX < glyphCenter )
+        {
+          matched = true;
+          break;
+        }
+      }
+
+      if( matched )
       {
-        visualIndex += index;
-        matched = true;
+        visualIndex = firstVisualCharacterIndex + index;
         break;
       }
-    }
 
-    if( matched )
-    {
-      break;
+      numberOfCharacters = 0u;
     }
+
   }
 
+
   // Return the logical position of the cursor in characters.
 
   if( !matched )
index f1c4bc4..2e2c240 100644 (file)
@@ -115,10 +115,11 @@ struct EventData
 
   ~EventData();
 
-  DecoratorPtr       mDecorator;               ///< Pointer to the decorator
-  std::string        mPlaceholderTextActive;   ///< The text to display when the TextField is empty with key-input focus
-  std::string        mPlaceholderTextInactive; ///< The text to display when the TextField is empty and inactive
-  Vector4            mPlaceholderTextColor;    ///< The in/active placeholder text color
+  DecoratorPtr       mDecorator;               ///< Pointer to the decorator.
+  ImfManager         mImfManager;              ///< The Input Method Framework Manager.
+  std::string        mPlaceholderTextActive;   ///< The text to display when the TextField is empty with key-input focus.
+  std::string        mPlaceholderTextInactive; ///< The text to display when the TextField is empty and inactive.
+  Vector4            mPlaceholderTextColor;    ///< The in/active placeholder text color.
 
   /**
    * This is used to delay handling events until after the model has been updated.
@@ -332,10 +333,9 @@ struct Controller::Impl
     if( mEventData )
     {
       // Reset incase we are in a pre-edit state.
-      ImfManager imfManager = ImfManager::Get();
-      if ( imfManager )
+      if( mEventData->mImfManager )
       {
-        imfManager.Reset(); // Will trigger a commit message
+        mEventData->mImfManager.Reset(); // Will trigger a message ( commit, get surrounding )
       }
 
       ClearPreEditFlag();
index bcac025..eddde06 100644 (file)
@@ -453,12 +453,12 @@ bool Controller::RemoveText( int cursorOffset, int numberOfChars )
       cursorIndex = oldCursorIndex + cursorOffset;
     }
 
-    if( (cursorIndex + numberOfChars) > currentText.Count() )
+    if( ( cursorIndex + numberOfChars ) > currentText.Count() )
     {
       numberOfChars = currentText.Count() - cursorIndex;
     }
 
-    if( (cursorIndex + numberOfChars) <= currentText.Count() )
+    if( ( cursorIndex + numberOfChars ) <= currentText.Count() )
     {
       Vector<Character>::Iterator first = currentText.Begin() + cursorIndex;
       Vector<Character>::Iterator last  = first + numberOfChars;
@@ -1520,7 +1520,7 @@ void Controller::TapEvent( unsigned int tapCount, float x, float y )
       else if( EventData::EDITING                  != mImpl->mEventData->mState &&
                EventData::EDITING_WITH_GRAB_HANDLE != mImpl->mEventData->mState )
       {
-        if( mImpl->IsShowingPlaceholderText() &&  ! mImpl->IsFocusedPlaceholderAvailable() )
+        if( mImpl->IsShowingPlaceholderText() &&  !mImpl->IsFocusedPlaceholderAvailable() )
         {
           // Hide placeholder text
           ResetText();
@@ -1716,8 +1716,14 @@ void Controller::PasteText( const std::string& stringToPaste )
 
 void Controller::PasteClipboardItemEvent()
 {
+  // Retrieve the clipboard contents first
   ClipboardEventNotifier notifier( ClipboardEventNotifier::Get() );
   std::string stringToPaste( notifier.GetContent() );
+
+  // Commit the current pre-edit text; the contents of the clipboard should be appended
+  mImpl->ResetImfManager();
+
+  // Paste
   PasteText( stringToPaste );
 }
 
@@ -1800,7 +1806,7 @@ void Controller::TextPopupButtonTouched( Dali::Toolkit::TextSelectionPopup::Butt
 
 ImfManager::ImfCallbackData Controller::OnImfEvent( ImfManager& imfManager, const ImfManager::ImfEventData& imfEvent )
 {
-  bool update( false );
+  bool update = false;
   bool requestRelayout = false;
 
   std::string text;
@@ -1928,17 +1934,15 @@ void Controller::NotifyImfManager()
 {
   if( mImpl->mEventData )
   {
-    ImfManager imfManager = ImfManager::Get();
-
-    if( imfManager )
+    if( mImpl->mEventData->mImfManager )
     {
       // Notifying IMF of a cursor change triggers a surrounding text request so updating it now.
       std::string text;
       GetText( text );
-      imfManager.SetSurroundingText( text );
+      mImpl->mEventData->mImfManager.SetSurroundingText( text );
 
-      imfManager.SetCursorPosition( GetLogicalCursorPosition() );
-      imfManager.NotifyCursorPosition();
+      mImpl->mEventData->mImfManager.SetCursorPosition( GetLogicalCursorPosition() );
+      mImpl->mEventData->mImfManager.NotifyCursorPosition();
     }
   }
 }
index 6196d91..10ffbff 100644 (file)
@@ -27,19 +27,19 @@ namespace Toolkit
 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
-  CubeTransitionCrossEffect* internalCubeTransEffect = new CubeTransitionCrossEffect( numRows, numColumns, viewAreaSize );
+  IntrusivePtr< CubeTransitionCrossEffect > internalCubeTransEffect = new CubeTransitionCrossEffect( numRows, numColumns );
 
   // Pass ownership to CustomActor handle
-  Toolkit::CubeTransitionCrossEffect cubeTransEffect( internalCubeTransEffect );
+  Toolkit::CubeTransitionCrossEffect cubeTransEffect( *internalCubeTransEffect );
 
   //Initialization
   internalCubeTransEffect->Initialize();
@@ -49,89 +49,107 @@ Toolkit::CubeTransitionCrossEffect CubeTransitionCrossEffect::New(unsigned int n
 
 void CubeTransitionCrossEffect::OnInitialize()
 {
-  float offsetX = -mTileSize.width*0.5f;
-  float offsetY = -mTileSize.height*0.5f;
   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 )
 {
-  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;
-  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
index d1416e4..8f6fda9 100644 (file)
@@ -45,7 +45,7 @@ public:
   /**
    * @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:
 
@@ -59,34 +59,36 @@ protected:
     */
    virtual void OnStartTransition( Vector2 panPosition, Vector2 panDisplacement );
 
-   /**
-    * @copydoc Toolkit::Internal::CubeTransitionEffect::OnStopTransition
-    */
-   virtual void OnStopTransition();
-
 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] 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] 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:
 
-   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
 
@@ -94,22 +96,22 @@ private:
 
 // 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
index 444a3fd..f633607 100644 (file)
 
 // 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/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
 {
@@ -45,26 +44,86 @@ DALI_SIGNAL_REGISTRATION( Toolkit, CubeTransitionEffect, "transition-completed",
 
 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 );
 
-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 ),
-  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();
 }
 
-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 )
@@ -169,92 +328,101 @@ float CubeTransitionEffect::GetCubeDisplacement() const
   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 )
 {
+  Vector3 size = Self().GetCurrentSize();
   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
   {
-    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 )
 {
-  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();
   }
+
   mAnimation = Animation::New( mAnimationDuration );
-  mAnimation.FinishedSignal().Connect(this, &CubeTransitionEffect::OnTransitionFinished);
+  mAnimation.FinishedSignal().Connect( this, &CubeTransitionEffect::OnTransitionFinished );
 
   OnStartTransition( panPosition, panDisplacement );
 }
@@ -279,90 +447,61 @@ void CubeTransitionEffect::ResumeTransition()
 
 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)
 {
-  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
-  Toolkit::CubeTransitionEffect handle( this );
+  Toolkit::CubeTransitionEffect handle( GetOwner() );
   mTransitionCompletedSignal.Emit( handle, mCurrentImage );
 }
 
index 5642749..25d1e1c 100644 (file)
 
 // 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>
+#include <dali-toolkit/public-api/controls/control-impl.h>
 
 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
  */
-class CubeTransitionEffect : public Dali::BaseObject, public ConnectionTracker
+class CubeTransitionEffect : public Control
 {
 
 public:
@@ -159,24 +71,19 @@ public:
   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
    */
-  void SetCurrentImage(ImageActor imageActor);
+  void SetCurrentImage( Image image );
 
   /**
    * @copydoc Toolkit::CubeTransitionEffect::SetTargetImage
    */
-  void SetTargetImage(ImageActor imageActor);
+  void SetTargetImage( Image image );
 
   /**
    * @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:
+  /**
+   * @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
-   * @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,
@@ -238,36 +155,14 @@ protected:
    */
   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
@@ -297,40 +192,40 @@ private:
    */
   virtual void OnStopTransition() {}
 
+  virtual void OnRelayout( const Vector2& size, RelayoutContainer& container );
+
+  void ResetToInitialState();
+
 
 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;
+
+  Vector2                    mTileSize;
+
   bool                       mIsAnimating;
   bool                       mIsPaused;
 
+  float                      mAnimationDuration;
   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;
 
@@ -348,7 +243,7 @@ inline Internal::CubeTransitionEffect& GetImpl(Dali::Toolkit::CubeTransitionEffe
 {
   DALI_ASSERT_ALWAYS(obj);
 
-  Dali::BaseObject& handle = obj.GetBaseObject();
+  Dali::RefObject& handle = obj.GetImplementation();
 
   return static_cast<Internal::CubeTransitionEffect&>(handle);
 }
@@ -357,7 +252,7 @@ inline const Internal::CubeTransitionEffect& GetImpl(const Dali::Toolkit::CubeTr
 {
   DALI_ASSERT_ALWAYS(obj);
 
-  const Dali::BaseObject& handle = obj.GetBaseObject();
+  const Dali::RefObject& handle = obj.GetImplementation();
 
   return static_cast<const Internal::CubeTransitionEffect&>(handle);
 }
index 6989478..8cd84be 100644 (file)
@@ -26,20 +26,18 @@ namespace Toolkit
 
 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
-  CubeTransitionFoldEffect* internalCubeTransEffect = new CubeTransitionFoldEffect( numRows, numColumns, viewAreaSize );
+  IntrusivePtr< CubeTransitionFoldEffect > internalCubeTransEffect = new CubeTransitionFoldEffect( numRows, numColumns );
 
   // Pass ownership to CustomActor handle
-  Toolkit::CubeTransitionFoldEffect cubeTransEffect( internalCubeTransEffect );
+  Toolkit::CubeTransitionFoldEffect cubeTransEffect( *internalCubeTransEffect );
 
   //Initialization
   internalCubeTransEffect->Initialize();
@@ -49,87 +47,97 @@ Toolkit::CubeTransitionFoldEffect CubeTransitionFoldEffect::New(unsigned int num
 
 void CubeTransitionFoldEffect::OnInitialize()
 {
-  float offset = mTileSize.width*0.5f;
   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 )
 {
-  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;
-
-  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
index 0afee71..336557f 100644 (file)
@@ -45,7 +45,7 @@ public:
   /**
    * @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:
 
@@ -59,32 +59,21 @@ protected:
     */
    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
-    * @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
-    * @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
 
@@ -92,22 +81,22 @@ private:
 
 // 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
index 818e670..d4ce91d 100644 (file)
@@ -27,21 +27,21 @@ namespace Toolkit
 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 )
 {
 }
 
-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
-  CubeTransitionWaveEffect* internalCubeTransEffect = new CubeTransitionWaveEffect( numRows, numColumns, viewAreaSize );
+  IntrusivePtr< CubeTransitionWaveEffect > internalCubeTransEffect = new CubeTransitionWaveEffect( numRows, numColumns );
 
   // Pass ownership to CustomActor handle
-  Toolkit::CubeTransitionWaveEffect cubeTransEffect( internalCubeTransEffect );
+  Toolkit::CubeTransitionWaveEffect cubeTransEffect( *internalCubeTransEffect );
 
   //Initialization
   internalCubeTransEffect->Initialize();
@@ -51,59 +51,54 @@ Toolkit::CubeTransitionWaveEffect CubeTransitionWaveEffect::New(unsigned int num
 
 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 )
 {
-  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 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;
-  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
-      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 ) );
-      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 ) );
-      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 ) );
     }
   }
@@ -112,18 +107,9 @@ void CubeTransitionWaveEffect::OnStartTransition( Vector2 panPosition, Vector2 p
   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 )
 {
+  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;
@@ -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
-    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
-    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
-    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
-    float distanceTopRight = fabsf(coefA*mViewAreaSize.x+coefC) * inversedSqrtAABB;
+    float distanceTopRight = fabsf(coefA*size.x+coefC) * inversedSqrtAABB;
     //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
-    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);
   }
@@ -184,13 +170,13 @@ void  CubeTransitionWaveEffect::CalculateSaddleSurfaceParameters( Vector2 positi
   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;
-  if(!mIsToNextImage) // to previous image
+  if( !forward ) // to previous image
   {
     valueX = mSaddleB - valueX;
   }
index baa0a14..d53ccc4 100644 (file)
@@ -45,7 +45,7 @@ public:
   /**
    * @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:
 
@@ -59,20 +59,14 @@ protected:
    */
   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
-   * @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
@@ -81,7 +75,7 @@ private:
    * @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
@@ -89,7 +83,7 @@ private:
    * @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:
 
@@ -108,22 +102,22 @@ private:
 
 // 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
index 5651b04..95e8624 100644 (file)
@@ -30,9 +30,10 @@ namespace Toolkit
 
 enum ControlDepthIndexRanges
 {
-    BACKGROUND_DEPTH_INDEX    = static_cast<int>( -Dali::Layer::TREE_DEPTH_MULTIPLIER * 0.1f ),
+    BACKGROUND_DEPTH_INDEX    = -Dali::Layer::TREE_DEPTH_MULTIPLIER / 10,
     CONTENT_DEPTH_INDEX       = 0,
-    DECORATION_DEPTH_INDEX    = static_cast<int>( Dali::Layer::TREE_DEPTH_MULTIPLIER * 0.1f )
+    TEXT_DEPTH_INDEX          = Dali::Layer::TREE_DEPTH_MULTIPLIER / 100,
+    DECORATION_DEPTH_INDEX    = Dali::Layer::TREE_DEPTH_MULTIPLIER / 10
 };
 
 /**
index 429648b..771114b 100644 (file)
@@ -796,16 +796,6 @@ void Control::EmitKeyInputFocusSignal( bool focusGained )
 
 void Control::OnStageConnection( int depth )
 {
-  unsigned int controlRendererCount = Self().GetRendererCount();
-  for( unsigned int i(0); i<controlRendererCount; ++i )
-  {
-    Renderer controlRenderer = Self().GetRendererAt(i);
-    if( controlRenderer )
-    {
-      controlRenderer.SetDepthIndex( CONTENT_DEPTH_INDEX+depth );
-    }
-  }
-
   if( mImpl->mBackgroundRenderer)
   {
     mImpl->mBackgroundRenderer.SetDepthIndex( BACKGROUND_DEPTH_INDEX );
index 795e9cf..b3b265f 100644 (file)
@@ -31,7 +31,7 @@ namespace Toolkit
 
 const unsigned int TOOLKIT_MAJOR_VERSION = 1;
 const unsigned int TOOLKIT_MINOR_VERSION = 1;
-const unsigned int TOOLKIT_MICRO_VERSION = 6;
+const unsigned int TOOLKIT_MICRO_VERSION = 7;
 const char * const TOOLKIT_BUILD_DATE    = __DATE__ " " __TIME__;
 
 #ifdef DEBUG_ENABLED
index 3484c8c..5682ba1 100644 (file)
@@ -113,7 +113,12 @@ distributing this software or its derivatives.
     },
     "textselectiontoolbar":
     {
-      "enable-overshoot":true
+      "enable-overshoot":true,
+      "scroll-view":
+      {
+        "overshoot-animation-speed":120.0,
+        "overshoot-size":[480.0,42.0]
+      }
     },
     "scrollview":
     {
index 0c20938..ff98976 100644 (file)
@@ -113,7 +113,12 @@ distributing this software or its derivatives.
     },
     "textselectiontoolbar":
     {
-      "enable-overshoot":true
+      "enable-overshoot":true,
+      "scroll-view":
+      {
+        "overshoot-animation-speed":360.0,
+        "overshoot-size":[720.0,130.0]
+      }
     },
     "scrollview":
     {
index 9939f2c..8e5b5c9 100644 (file)
@@ -1,6 +1,6 @@
 Name:       dali-toolkit
 Summary:    The OpenGLES Canvas Core Library Toolkit
-Version:    1.1.6
+Version:    1.1.7
 Release:    1
 Group:      System/Libraries
 License:    Apache-2.0, BSD-2.0, MIT