Add Scale transition for Page transition

Change-Id: Ib105de44c78aa8b9d4ab05541d98c303672d22a7
Signed-off-by: seungho <sbsh.baek@samsung.com>

diff --git a/automated-tests/src/dali-toolkit/CMakeLists.txt b/automated-tests/src/dali-toolkit/CMakeLists.txt
index c3ad8c8..8990a0f 100755 (executable)
--- a/automated-tests/src/dali-toolkit/CMakeLists.txt
+++ b/automated-tests/src/dali-toolkit/CMakeLists.txt
@@ -35,6 +35,7 @@ SET(TC_SOURCES
   utc-Dali-ScrollView.cpp
   utc-Dali-ShaderEffects.cpp
   utc-Dali-ShadowView.cpp
   utc-Dali-ScrollView.cpp
   utc-Dali-ShaderEffects.cpp
   utc-Dali-ShadowView.cpp

+  utc-Dali-ScaleTransition.cpp

   utc-Dali-SlideTransition.cpp
   utc-Dali-Slider.cpp
   utc-Dali-TableView.cpp
   utc-Dali-SlideTransition.cpp
   utc-Dali-Slider.cpp
   utc-Dali-TableView.cpp

diff --git a/automated-tests/src/dali-toolkit/utc-Dali-ScaleTransition.cpp b/automated-tests/src/dali-toolkit/utc-Dali-ScaleTransition.cpp
new file mode 100755 (executable)
index 0000000..5d2b40e
--- /dev/null
+++ b/automated-tests/src/dali-toolkit/utc-Dali-ScaleTransition.cpp
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <stdlib.h>
+#include <dali-toolkit-test-suite-utils.h>
+#include <dali-toolkit/dali-toolkit.h>
+#include <dali/devel-api/actors/actor-devel.h>
+#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
+#include <dali-toolkit/public-api/transition/transition-set.h>
+#include <dali-toolkit/public-api/transition/transition-base.h>
+#include <dali-toolkit/public-api/transition/scale-transition.h>
+
+using namespace Dali;
+using namespace Dali::Toolkit;
+
+// Functor to test whether a Finish signal is emitted
+struct TransitionFinishCheck
+{
+  TransitionFinishCheck(bool& signalReceived)
+  : mSignalReceived(signalReceived)
+  {
+  }
+
+  void operator()(TransitionSet& transitionSet)
+  {
+    mSignalReceived = true;
+  }
+
+  void Reset()
+  {
+    mSignalReceived = false;
+  }
+
+  void CheckSignalReceived()
+  {
+    if(!mSignalReceived)
+    {
+      tet_printf("Expected Finish signal was not received\n");
+      tet_result(TET_FAIL);
+    }
+    else
+    {
+      tet_result(TET_PASS);
+    }
+  }
+
+  void CheckSignalNotReceived()
+  {
+    if(mSignalReceived)
+    {
+      tet_printf("Unexpected Finish signal was received\n");
+      tet_result(TET_FAIL);
+    }
+    else
+    {
+      tet_result(TET_PASS);
+    }
+  }
+
+  bool& mSignalReceived; // owned by individual tests
+};
+
+int UtcDaliScaleTransitionSetGetProperty(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline("UtcDaliScaleTransitionSetGetProperty");
+
+  Control control = Control::New();
+
+  ScaleTransition scale = ScaleTransition::New(control, 0.5f, TimePeriod(-0.5f, -0.5f));
+
+  Vector2 scaleFactor = scale.GetScaleFactor();
+  DALI_TEST_EQUALS(0.5f, scaleFactor.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(0.5f, scaleFactor.y, TEST_LOCATION);
+
+
+  scale.SetScaleFactor(Vector2(1.5f, 1.2f));
+  scaleFactor = scale.GetScaleFactor();
+  DALI_TEST_EQUALS(1.5f, scaleFactor.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(1.2f, scaleFactor.y, TEST_LOCATION);
+
+  END_TEST;
+}
+
+int UtcDaliScaleTransitionWithOffScene(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline("UtcDaliScaleTransitionWithOffScene");
+
+  Control control = Control::New();
+  control.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+  control.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+  control.SetProperty(Actor::Property::SIZE, Vector3(150, 150, 0));
+  Property::Map controlProperty;
+  controlProperty.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::COLOR);
+  controlProperty.Insert(Toolkit::ColorVisual::Property::MIX_COLOR, Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+  control.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty);
+
+  application.SendNotification();
+  application.Render(20);
+
+  Vector3 currentScale = control.GetCurrentProperty<Vector3>(Actor::Property::SCALE);
+  DALI_TEST_CHECK(currentScale.x == 1.0f);
+  DALI_TEST_CHECK(currentScale.y == 1.0f);
+
+  ScaleTransition scale = ScaleTransition::New(control, 0.5f, TimePeriod(0.5f));
+  scale.SetAppearingTransition(false);
+  TransitionSet transitionSet = TransitionSet::New();
+  transitionSet.AddTransition(scale);
+  transitionSet.Play();
+
+  bool signalReceived(false);
+  TransitionFinishCheck finishCheck(signalReceived);
+  transitionSet.FinishedSignal().Connect(&application, finishCheck);
+
+  application.SendNotification();
+  application.Render(400);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  currentScale = control.GetCurrentProperty<Vector3>(Actor::Property::SCALE);
+  DALI_TEST_CHECK(currentScale.x == 1.0f);
+  DALI_TEST_CHECK(currentScale.y == 1.0f);
+
+  application.SendNotification();
+  application.Render(200);
+
+  // We did expect the animation to finish
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+
+  application.SendNotification();
+  application.Render(20);
+
+  currentScale = control.GetCurrentProperty<Vector3>(Actor::Property::SCALE);
+  DALI_TEST_CHECK(currentScale.x == 1.0f);
+  DALI_TEST_CHECK(currentScale.y == 1.0f);
+
+  END_TEST;
+}
+
+int UtcDaliScaleTransitionDisappearing(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline("UtcDaliScaleTransitionDisappearing");
+
+  Control control = Control::New();
+  control.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+  control.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+  control.SetProperty(Actor::Property::SIZE, Vector3(100, 100, 0));
+  control.SetProperty(Actor::Property::OPACITY, 1.0f);
+  Property::Map controlProperty;
+  controlProperty.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::COLOR);
+  controlProperty.Insert(Toolkit::ColorVisual::Property::MIX_COLOR, Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+  control.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty);
+
+  application.GetScene().Add(control);
+
+  application.SendNotification();
+  application.Render(20);
+
+  Vector3 currentScale = control.GetCurrentProperty<Vector3>(Actor::Property::SCALE);
+  DALI_TEST_CHECK(currentScale.x == 1.0f);
+  DALI_TEST_CHECK(currentScale.y == 1.0f);
+
+  ScaleTransition scale = ScaleTransition::New(control, 0.5f, TimePeriod(0.5f));
+  scale.SetAppearingTransition(false);
+
+  TransitionSet transitionSet = TransitionSet::New();
+  transitionSet.AddTransition(scale);
+  transitionSet.Play();
+
+  bool signalReceived(false);
+  TransitionFinishCheck finishCheck(signalReceived);
+  transitionSet.FinishedSignal().Connect(&application, finishCheck);
+
+  application.SendNotification();
+  application.Render(400);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  currentScale = control.GetCurrentProperty<Vector3>(Actor::Property::SCALE);
+  DALI_TEST_CHECK(currentScale.x > 0.55f && currentScale.x < 0.65f);
+  DALI_TEST_CHECK(currentScale.y > 0.55f && currentScale.y < 0.65f);
+
+  application.SendNotification();
+  application.Render(200);
+
+  // We did expect the animation to finish
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+
+  application.SendNotification();
+  application.Render(20);
+
+  // Property is reset after animation.
+  currentScale = control.GetCurrentProperty<Vector3>(Actor::Property::SCALE);
+  DALI_TEST_CHECK(currentScale.x == 1.0f);
+  DALI_TEST_CHECK(currentScale.y == 1.0f);
+
+  END_TEST;
+}
+
+int UtcDaliScaleTransitionAppearing(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline("UtcDaliScaleTransitionAppearing");
+
+  Control control = Control::New();
+  control.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+  control.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+  control.SetProperty(Actor::Property::SIZE, Vector3(100, 100, 0));
+  control.SetProperty(Actor::Property::OPACITY, 1.0f);
+  Property::Map controlProperty;
+  controlProperty.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::COLOR);
+  controlProperty.Insert(Toolkit::ColorVisual::Property::MIX_COLOR, Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+  control.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty);
+
+  application.GetScene().Add(control);
+
+  application.SendNotification();
+  application.Render(20);
+
+  Vector3 currentScale = control.GetCurrentProperty<Vector3>(Actor::Property::SCALE);
+  DALI_TEST_CHECK(currentScale.x == 1.0f);
+  DALI_TEST_CHECK(currentScale.y == 1.0f);
+
+  ScaleTransition scale = ScaleTransition::New(control, Vector2(2.0, 0.5), TimePeriod(0.5f));
+  scale.SetAppearingTransition(true);
+  TransitionSet transitionSet = TransitionSet::New();
+  transitionSet.AddTransition(scale);
+  transitionSet.Play();
+
+  bool signalReceived(false);
+  TransitionFinishCheck finishCheck(signalReceived);
+  transitionSet.FinishedSignal().Connect(&application, finishCheck);
+
+  application.SendNotification();
+  application.Render(400);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  currentScale = control.GetCurrentProperty<Vector3>(Actor::Property::SCALE);
+  DALI_TEST_CHECK(currentScale.x > 1.1f && currentScale.x < 1.3f);
+  DALI_TEST_CHECK(currentScale.y > 0.85f && currentScale.y < 0.95f);
+
+  application.SendNotification();
+  application.Render(200);
+
+  // We did expect the animation to finish
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+
+  application.SendNotification();
+  application.Render(20);
+
+  currentScale = control.GetCurrentProperty<Vector3>(Actor::Property::SCALE);
+  DALI_TEST_CHECK(currentScale.x == 1.0f);
+  DALI_TEST_CHECK(currentScale.y == 1.0f);
+
+  END_TEST;
+}

diff --git a/dali-toolkit/dali-toolkit.h b/dali-toolkit/dali-toolkit.h
index 418bf9d..1ec7fa3 100644 (file)
--- a/dali-toolkit/dali-toolkit.h
+++ b/dali-toolkit/dali-toolkit.h
@@ -62,6 +62,7 @@
 
 #include <dali-toolkit/public-api/transition/fade-transition.h>
 #include <dali-toolkit/public-api/transition/slide-transition.h>
 
 #include <dali-toolkit/public-api/transition/fade-transition.h>
 #include <dali-toolkit/public-api/transition/slide-transition.h>

+#include <dali-toolkit/public-api/transition/scale-transition.h>

 #include <dali-toolkit/public-api/transition/transition.h>
 #include <dali-toolkit/public-api/transition/transition-set.h>
 
 #include <dali-toolkit/public-api/transition/transition.h>
 #include <dali-toolkit/public-api/transition/transition-set.h>
 

diff --git a/dali-toolkit/internal/file.list b/dali-toolkit/internal/file.list
index 8deec87..7f02340 100644 (file)
--- a/dali-toolkit/internal/file.list
+++ b/dali-toolkit/internal/file.list
@@ -184,6 +184,7 @@ SET( toolkit_src_files
    ${toolkit_src_dir}/text/rendering/view-model.cpp
    ${toolkit_src_dir}/transition/fade-transition-impl.cpp
    ${toolkit_src_dir}/transition/slide-transition-impl.cpp
    ${toolkit_src_dir}/text/rendering/view-model.cpp
    ${toolkit_src_dir}/transition/fade-transition-impl.cpp
    ${toolkit_src_dir}/transition/slide-transition-impl.cpp

+   ${toolkit_src_dir}/transition/scale-transition-impl.cpp

    ${toolkit_src_dir}/transition/transition-base-impl.cpp
    ${toolkit_src_dir}/transition/transition-impl.cpp
    ${toolkit_src_dir}/transition/transition-lifecycle-controller.cpp
    ${toolkit_src_dir}/transition/transition-base-impl.cpp
    ${toolkit_src_dir}/transition/transition-impl.cpp
    ${toolkit_src_dir}/transition/transition-lifecycle-controller.cpp

diff --git a/dali-toolkit/internal/transition/scale-transition-impl.cpp b/dali-toolkit/internal/transition/scale-transition-impl.cpp
new file mode 100644 (file)
index 0000000..a374002
--- /dev/null
+++ b/dali-toolkit/internal/transition/scale-transition-impl.cpp
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali-toolkit/internal/transition/scale-transition-impl.h>
+
+// EXTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali/devel-api/actors/actor-devel.h>
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/object/type-registry.h>
+
+namespace Dali
+{
+namespace Toolkit
+{
+namespace Internal
+{
+
+ScaleTransitionPtr ScaleTransition::New(Dali::Toolkit::Control control, const Vector2& scaleFactor, TimePeriod timePeriod)
+{
+  float delaySeconds = timePeriod.delaySeconds;
+  if(delaySeconds < 0.0f)
+  {
+    DALI_LOG_WARNING("delay should be greater than 0.0f.\n");
+    delaySeconds = 0.0f;
+  }
+
+  float durationSeconds = timePeriod.durationSeconds;
+  if(durationSeconds < 0.0f)
+  {
+    DALI_LOG_WARNING("duration should be greater than 0.0f.\n");
+    durationSeconds = 0.0f;
+  }
+
+  ScaleTransitionPtr scaleTransition = new ScaleTransition(control, scaleFactor, TimePeriod(delaySeconds, durationSeconds));
+
+  // Second-phase construction
+  scaleTransition->Initialize();
+
+  return scaleTransition;
+}
+
+ScaleTransition::ScaleTransition(Dali::Toolkit::Control control, const Vector2& scaleFactor, TimePeriod timePeriod)
+: TransitionBase(),
+  mTargetControl(control),
+  mScaleFactor(scaleFactor)
+{
+  SetTarget(control);
+  SetTimePeriod(timePeriod);
+}
+
+ScaleTransition::~ScaleTransition()
+{
+}
+
+void ScaleTransition::SetScaleFactor(const Vector2& scaleFactor)
+{
+  mScaleFactor = scaleFactor;
+}
+
+Vector2 ScaleTransition::GetScaleFactor() const
+{
+  return mScaleFactor;
+}
+
+void ScaleTransition::OnPlay()
+{
+  Dali::Toolkit::Control targetControl = mTargetControl.GetHandle();
+  if(!targetControl || !targetControl[Dali::Actor::Property::CONNECTED_TO_SCENE])
+  {
+    DALI_LOG_ERROR("The Control is not added on the window\n");
+    return;
+  }
+
+  Property::Map startPropertyMap;
+  Property::Map finishPropertyMap;
+
+  Vector3 targetScale = targetControl[Dali::Actor::Property::SCALE];
+  Vector3 scaleFactor = Vector3(mScaleFactor.x, mScaleFactor.y, 1.0f);
+  if(IsAppearingTransition())
+  {
+    startPropertyMap.Insert(Dali::Actor::Property::SCALE, scaleFactor * targetScale);
+    finishPropertyMap.Insert(Dali::Actor::Property::SCALE, targetScale);
+  }
+  else
+  {
+    startPropertyMap.Insert(Dali::Actor::Property::SCALE, targetScale);
+    finishPropertyMap.Insert(Dali::Actor::Property::SCALE, scaleFactor * targetScale);
+  }
+
+  SetStartPropertyMap(startPropertyMap);
+  SetFinishPropertyMap(finishPropertyMap);
+}
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali

diff --git a/dali-toolkit/internal/transition/scale-transition-impl.h b/dali-toolkit/internal/transition/scale-transition-impl.h
new file mode 100644 (file)
index 0000000..27e173d
--- /dev/null
+++ b/dali-toolkit/internal/transition/scale-transition-impl.h
@@ -0,0 +1,116 @@
+#ifndef DALI_TOOLKIT_INTERNAL_SCALE_TRANSITION_H
+#define DALI_TOOLKIT_INTERNAL_SCALE_TRANSITION_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *Fade
+ */
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/transition/transition-base-impl.h>
+#include <dali-toolkit/public-api/controls/control.h>
+#include <dali-toolkit/public-api/transition/scale-transition.h>
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/weak-handle.h>
+
+namespace Dali
+{
+namespace Toolkit
+{
+namespace Internal
+{
+using ScaleTransitionPtr = IntrusivePtr<ScaleTransition>;
+
+class ScaleTransition : public TransitionBase
+{
+public:
+  /**
+   * @brief Create a new ScaleTransition object.
+   * @param[in] control A control of this transition.
+   * @param[in] scaleFactor A scale value to be applied on control during transition
+   * @param[in] timePeriod The duration of the animation.
+   * @return A smart-pointer to the newly allocated ScaleTransition.
+   */
+  static ScaleTransitionPtr New(Dali::Toolkit::Control control, const Vector2& scaleFactor, TimePeriod timePeriod);
+
+  /**
+   * @copydoc Dali::Toolkit::ScaleTransition::SetScaleFactor()
+   */
+  void SetScaleFactor(const Vector2& scaleFactor);
+
+  /**
+   * @copydoc Dali::Toolkit::ScaleTransition::GetDirection()
+   */
+  Vector2 GetScaleFactor() const;
+
+protected:
+  /**
+   * @copydoc Dali::Toolkit::ScaleTransition::OnPlay()
+   */
+  void OnPlay() override;
+
+protected:
+  /**
+   * @brief Construct a new ScaleTransition.
+   */
+  ScaleTransition(Dali::Toolkit::Control control,
+                  const Vector2&         scaleFactor,
+                  TimePeriod             timePeriod);
+
+  /**
+   * @brief A reference counted object may only be deleted by calling Unreference()
+   */
+  ~ScaleTransition() override;
+
+private:
+  // Undefined
+  ScaleTransition(const ScaleTransition&);
+
+  // Undefined
+  ScaleTransition& operator=(const ScaleTransition& rhs);
+
+private:
+  WeakHandle<Dali::Toolkit::Control> mTargetControl;
+  Vector2                            mScaleFactor;
+};
+
+} // namespace Internal
+
+// Helpers for public-api forwarding methods
+
+inline Internal::ScaleTransition& GetImplementation(Dali::Toolkit::ScaleTransition& scale)
+{
+  DALI_ASSERT_ALWAYS(scale && "ScaleTransition handle is empty");
+
+  BaseObject& handle = scale.GetBaseObject();
+
+  return static_cast<Internal::ScaleTransition&>(handle);
+}
+
+inline const Internal::ScaleTransition& GetImplementation(const Dali::Toolkit::ScaleTransition& scale)
+{
+  DALI_ASSERT_ALWAYS(scale && "ScaleTransition handle is empty");
+
+  const BaseObject& handle = scale.GetBaseObject();
+
+  return static_cast<const Internal::ScaleTransition&>(handle);
+}
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif // DALI_TOOLKIT_INTERNAL_FADE_H

diff --git a/dali-toolkit/public-api/file.list b/dali-toolkit/public-api/file.list
index 726285c..7b72745 100644 (file)
--- a/dali-toolkit/public-api/file.list
+++ b/dali-toolkit/public-api/file.list
@@ -34,6 +34,7 @@ SET( public_api_src_files
   ${public_api_src_dir}/styling/style-manager.cpp
   ${public_api_src_dir}/transition/fade-transition.cpp
   ${public_api_src_dir}/transition/slide-transition.cpp
   ${public_api_src_dir}/styling/style-manager.cpp
   ${public_api_src_dir}/transition/fade-transition.cpp
   ${public_api_src_dir}/transition/slide-transition.cpp

+  ${public_api_src_dir}/transition/scale-transition.cpp

   ${public_api_src_dir}/transition/transition-base.cpp
   ${public_api_src_dir}/transition/transition-set.cpp
   ${public_api_src_dir}/transition/transition.cpp
   ${public_api_src_dir}/transition/transition-base.cpp
   ${public_api_src_dir}/transition/transition-set.cpp
   ${public_api_src_dir}/transition/transition.cpp


@@ -154,6 +155,7 @@ SET( public_api_visuals_header_files
 SET( public_api_transition_header_files
   ${public_api_src_dir}/transition/fade-transition.h
   ${public_api_src_dir}/transition/slide-transition.h
 SET( public_api_transition_header_files
   ${public_api_src_dir}/transition/fade-transition.h
   ${public_api_src_dir}/transition/slide-transition.h

+  ${public_api_src_dir}/transition/scale-transition.h

   ${public_api_src_dir}/transition/transition-base.h
   ${public_api_src_dir}/transition/transition-set.h
   ${public_api_src_dir}/transition/transition.h
   ${public_api_src_dir}/transition/transition-base.h
   ${public_api_src_dir}/transition/transition-set.h
   ${public_api_src_dir}/transition/transition.h

diff --git a/dali-toolkit/public-api/transition/scale-transition.cpp b/dali-toolkit/public-api/transition/scale-transition.cpp
new file mode 100644 (file)
index 0000000..676cc63
--- /dev/null
+++ b/dali-toolkit/public-api/transition/scale-transition.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali-toolkit/public-api/transition/scale-transition.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/transition/scale-transition-impl.h>
+
+namespace Dali
+{
+namespace Toolkit
+{
+ScaleTransition::ScaleTransition() = default;
+
+ScaleTransition::ScaleTransition(Internal::ScaleTransition* scaleTransition)
+: TransitionBase(scaleTransition)
+{
+}
+
+ScaleTransition ScaleTransition::New(Dali::Toolkit::Control control, float scaleFactor, TimePeriod timePeriod)
+{
+  Internal::ScaleTransitionPtr internal = Dali::Toolkit::Internal::ScaleTransition::New(control, Vector2(scaleFactor, scaleFactor), timePeriod);
+
+  return ScaleTransition(internal.Get());
+}
+
+ScaleTransition ScaleTransition::New(Dali::Toolkit::Control control, const Vector2& scaleFactor, TimePeriod timePeriod)
+{
+  Internal::ScaleTransitionPtr internal = Dali::Toolkit::Internal::ScaleTransition::New(control, scaleFactor, timePeriod);
+
+  return ScaleTransition(internal.Get());
+}
+
+ScaleTransition ScaleTransition::DownCast(BaseHandle handle)
+{
+  return ScaleTransition(dynamic_cast<Dali::Toolkit::Internal::ScaleTransition*>(handle.GetObjectPtr()));
+}
+
+ScaleTransition::~ScaleTransition() = default;
+
+ScaleTransition::ScaleTransition(const ScaleTransition& handle) = default;
+
+ScaleTransition& ScaleTransition::operator=(const ScaleTransition& rhs) = default;
+
+ScaleTransition::ScaleTransition(ScaleTransition&& rhs) = default;
+
+ScaleTransition& ScaleTransition::operator=(ScaleTransition&& rhs) = default;
+
+void ScaleTransition::SetScaleFactor(const Vector2& scaleFactor)
+{
+  GetImplementation(*this).SetScaleFactor(scaleFactor);
+}
+
+Vector2 ScaleTransition::GetScaleFactor() const
+{
+  return GetImplementation(*this).GetScaleFactor();
+}
+
+} // namespace Toolkit
+
+} // namespace Dali

diff --git a/dali-toolkit/public-api/transition/scale-transition.h b/dali-toolkit/public-api/transition/scale-transition.h
new file mode 100644 (file)
index 0000000..8ce96c4
--- /dev/null
+++ b/dali-toolkit/public-api/transition/scale-transition.h
@@ -0,0 +1,149 @@
+#ifndef DALI_TOOLKIT_SCALE_TRANSITION_H
+#define DALI_TOOLKIT_SCALE_TRANSITION_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/control.h>
+#include <dali-toolkit/public-api/transition/transition-base.h>
+
+namespace Dali
+{
+namespace Toolkit
+{
+namespace Internal DALI_INTERNAL
+{
+class ScaleTransition;
+}
+
+/**
+ * @brief ScaleTransition provides smoothly appearing/disappearing effects for target Control.
+ * User of this scale transition can set scale factor for this transiton.
+ * The scale factor can be a single float value or Vector2 value.
+ * If it is a single float value, the value is applied to both x and y direction.
+ *
+ * If this transition is for appearing, the Control comes out with the scale factor applied
+ * and will be animated at its original scale.
+ * If this transition is for disappearing, the Control starts at its original size
+ * but will become the scale of scale factor and vanished.
+ */
+class DALI_TOOLKIT_API ScaleTransition : public TransitionBase
+{
+public:
+  /**
+   * @brief Creates an uninitialized ScaleTransition; this can be initialized with ScaleTransition::New().
+   *
+   * Calling member functions with an uninitialized ScaleTransition handle is not allowed.
+   */
+  ScaleTransition();
+
+  /**
+   * @brief Creates an initialized ScaleTransition.
+   *
+   * @param[in] control A control of this transition.
+   * @param[in] scaleFactor A scala scale factor that will be applied on both of width and height of the control
+   * @param[in] timePeriod The duration of the animation.
+   * @return A handle to a newly allocated Dali resource
+   */
+  static ScaleTransition New(Dali::Toolkit::Control control, float scaleFactor, TimePeriod timePeriod);
+
+  /**
+   * @brief Creates an initialized ScaleTransition.
+   *
+   * @param[in] control A control of this transition.
+   * @param[in] scaleFactor A scale vector to be applied on control during transition
+   * @param[in] timePeriod The duration of the animation.
+   * @return A handle to a newly allocated Dali resource
+   */
+  static ScaleTransition New(Dali::Toolkit::Control control, const Vector2& scaleFactor, TimePeriod timePeriod);
+
+  /**
+   * @brief Downcasts a handle to ScaleTransition handle.
+   *
+   * If handle points to an ScaleTransition object, the downcast produces valid handle.
+   * If not, the returned handle is left uninitialized.
+   *
+   * @param[in] handle Handle to an object
+   * @return Handle to an ScaleTransition object or an uninitialized handle
+   */
+  static ScaleTransition DownCast(BaseHandle handle);
+
+  /**
+   * @brief Destructor.
+   *
+   * This is non-virtual since derived Handle types must not contain data or virtual methods.
+   */
+  ~ScaleTransition();
+
+  /**
+   * @brief This copy constructor is required for (smart) pointer semantics.
+   *
+   * @param[in] handle A reference to the copied handle
+   */
+  ScaleTransition(const ScaleTransition& handle);
+
+  /**
+   * @brief This assignment operator is required for (smart) pointer semantics.
+   *
+   * @param[in] rhs A reference to the copied handle
+   * @return A reference to this
+   */
+  ScaleTransition& operator=(const ScaleTransition& rhs);
+
+  /**
+   * @brief Move constructor.
+   *
+   * @param[in] rhs A reference to the moved handle
+   */
+  ScaleTransition(ScaleTransition&& rhs);
+
+  /**
+   * @brief Move assignment operator.
+   *
+   * @param[in] rhs A reference to the moved handle
+   * @return A reference to this handle
+   */
+  ScaleTransition& operator=(ScaleTransition&& rhs);
+
+  /**
+   * @brief Sets scaleFactor to be used to scale target Control
+   *
+   * @param[in] scaleFactor Relative scaleFactor that will be used when the Control is appearing or disappearing.
+   */
+  void SetScaleFactor(const Vector2& scaleFactor);
+
+  /**
+   * @brief Retrieves scaleFactor that will be used when the Control is appearing or disappearing.
+   */
+  Vector2 GetScaleFactor() const;
+
+public: // Not intended for use by Application developers
+  /// @cond internal
+  /**
+   * @brief This constructor is used by ScaleTransition::New() methods.
+   * @param[in] scale A pointer to a newly allocated Dali resource
+   */
+  explicit DALI_INTERNAL ScaleTransition(Internal::ScaleTransition* scale);
+  /// @endcond
+};
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif // DALI_TOOLKIT_SCALE_TRANSITION_H

diff --git a/dali-toolkit/public-api/transition/slide-transition.h b/dali-toolkit/public-api/transition/slide-transition.h
index ee380e7..41af842 100644 (file)
--- a/dali-toolkit/public-api/transition/slide-transition.h
+++ b/dali-toolkit/public-api/transition/slide-transition.h
@@ -125,7 +125,7 @@ public:
 
   /**
    * @brief Retrieves direction to be used to move target Control
 
   /**
    * @brief Retrieves direction to be used to move target Control

-   * 
+   *

    * @note The direction is normalized Vector.
    */
   Vector2 GetDirection() const;
    * @note The direction is normalized Vector.
    */
   Vector2 GetDirection() const;