From: seungho Date: Thu, 12 Aug 2021 12:44:31 +0000 (+0900) Subject: Add Scale transition for Page transition X-Git-Tag: dali_2.0.43~1^2 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=commitdiff_plain;h=998b3705068714201fcd9b1511f22441f3fd17bb Add Scale transition for Page transition Change-Id: Ib105de44c78aa8b9d4ab05541d98c303672d22a7 Signed-off-by: seungho --- diff --git a/automated-tests/src/dali-toolkit/CMakeLists.txt b/automated-tests/src/dali-toolkit/CMakeLists.txt index c3ad8c8..8990a0f 100755 --- 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-ScaleTransition.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 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 +#include +#include +#include +#include +#include +#include +#include +#include + +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(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(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(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(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(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(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(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(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(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 --- a/dali-toolkit/dali-toolkit.h +++ b/dali-toolkit/dali-toolkit.h @@ -62,6 +62,7 @@ #include #include +#include #include #include diff --git a/dali-toolkit/internal/file.list b/dali-toolkit/internal/file.list index 8deec87..7f02340 100644 --- 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}/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 diff --git a/dali-toolkit/internal/transition/scale-transition-impl.cpp b/dali-toolkit/internal/transition/scale-transition-impl.cpp new file mode 100644 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 + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include + +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 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 +#include +#include + +// EXTERNAL INCLUDES +#include + +namespace Dali +{ +namespace Toolkit +{ +namespace Internal +{ +using ScaleTransitionPtr = IntrusivePtr; + +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 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(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(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 --- 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}/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 @@ -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 + ${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 diff --git a/dali-toolkit/public-api/transition/scale-transition.cpp b/dali-toolkit/public-api/transition/scale-transition.cpp new file mode 100644 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 + +// INTERNAL INCLUDES +#include + +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(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 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 +#include + +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 --- 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 - * + * * @note The direction is normalized Vector. */ Vector2 GetDirection() const;