From b2a500fa60691e1c3407febcb5d74fc6c2e4f817 Mon Sep 17 00:00:00 2001 From: seungho Date: Tue, 27 Jul 2021 13:02:45 +0900 Subject: [PATCH] Slide transition for Page transition Change-Id: I527778eafc9b9de64ed0cf7cd008dca81343d522 Signed-off-by: seungho --- automated-tests/src/dali-toolkit/CMakeLists.txt | 1 + .../dali-toolkit-test-utils/toolkit-window-impl.h | 5 +- .../dali-toolkit-test-utils/toolkit-window.cpp | 7 + .../src/dali-toolkit/utc-Dali-SlideTransition.cpp | 271 +++++++++++++++++++++ dali-toolkit/dali-toolkit.h | 1 + dali-toolkit/internal/file.list | 1 + .../internal/transition/slide-transition-impl.cpp | 139 +++++++++++ .../internal/transition/slide-transition-impl.h | 116 +++++++++ dali-toolkit/public-api/file.list | 2 + .../public-api/transition/slide-transition.cpp | 69 ++++++ .../public-api/transition/slide-transition.h | 147 +++++++++++ 11 files changed, 757 insertions(+), 2 deletions(-) create mode 100755 automated-tests/src/dali-toolkit/utc-Dali-SlideTransition.cpp create mode 100644 dali-toolkit/internal/transition/slide-transition-impl.cpp create mode 100644 dali-toolkit/internal/transition/slide-transition-impl.h create mode 100644 dali-toolkit/public-api/transition/slide-transition.cpp create mode 100644 dali-toolkit/public-api/transition/slide-transition.h diff --git a/automated-tests/src/dali-toolkit/CMakeLists.txt b/automated-tests/src/dali-toolkit/CMakeLists.txt index 3d00833..c3ad8c8 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-SlideTransition.cpp utc-Dali-Slider.cpp utc-Dali-TableView.cpp utc-Dali-TextEditor.cpp diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-window-impl.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-window-impl.h index a61569f..dc7a206 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-window-impl.h +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-window-impl.h @@ -45,8 +45,9 @@ public: virtual ~Window() = default; static Window* New(const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent); - WindowPosition GetPosition() const; - PositionSize GetPositionSize() const; + WindowPosition GetPosition() const; + PositionSize GetPositionSize() const; + Dali::Window::WindowSize GetSize() const; void SetPositionSize(PositionSize positionSize); diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-window.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-window.cpp index cfdee85..d0a3e4f 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-window.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-window.cpp @@ -69,6 +69,13 @@ PositionSize Window::GetPositionSize() const return mRenderSurface.GetPositionSize(); } +Dali::Window::WindowSize Window::GetSize() const +{ + PositionSize positionSize = mRenderSurface.GetPositionSize(); + + return Dali::Window::WindowSize(positionSize.width, positionSize.height); +} + void Window::SetPositionSize(PositionSize positionSize) { mRenderSurface.MoveResize(positionSize); diff --git a/automated-tests/src/dali-toolkit/utc-Dali-SlideTransition.cpp b/automated-tests/src/dali-toolkit/utc-Dali-SlideTransition.cpp new file mode 100755 index 0000000..1e12912 --- /dev/null +++ b/automated-tests/src/dali-toolkit/utc-Dali-SlideTransition.cpp @@ -0,0 +1,271 @@ +/* + * 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 UtcDaliSlideTransitionSetGetProperty(void) +{ + ToolkitTestApplication application; + tet_infoline("UtcDaliSlideTransitionSetGetProperty"); + + Control control = Control::New(); + + SlideTransition slide = SlideTransition::New(control, Dali::Toolkit::SlideTransitionDirection::TOP, TimePeriod(-0.5f, -0.5f)); + + TimePeriod timePeriod = slide.GetTimePeriod(); + DALI_TEST_EQUALS(0.0f, timePeriod.delaySeconds, TEST_LOCATION); + DALI_TEST_EQUALS(0.0f, timePeriod.durationSeconds, TEST_LOCATION); + + DALI_TEST_EQUALS(Dali::Toolkit::SlideTransitionDirection::TOP, slide.GetDirection(), TEST_LOCATION); + + slide.SetDirection(Dali::Toolkit::SlideTransitionDirection::BOTTOM); + DALI_TEST_EQUALS(Dali::Toolkit::SlideTransitionDirection::BOTTOM, slide.GetDirection(), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSlideTransitionWithOffScene(void) +{ + ToolkitTestApplication application; + tet_infoline("UtcDaliSlideTransitionWithOffScene"); + + 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); + + DALI_TEST_EQUALS(Vector2(0, 0), control.GetCurrentProperty(Actor::Property::POSITION), TEST_LOCATION); + + SlideTransition slide = SlideTransition::New(control, Dali::Toolkit::SlideTransitionDirection::BOTTOM, TimePeriod(0.5f)); + slide.SetAppearingTransition(false); + TransitionSet transitionSet = TransitionSet::New(); + transitionSet.AddTransition(slide); + 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(); + + DALI_TEST_EQUALS(Vector2(0, 0), control.GetCurrentProperty(Actor::Property::POSITION), TEST_LOCATION); + + application.SendNotification(); + application.Render(200); + + // We did expect the animation to finish + application.SendNotification(); + finishCheck.CheckSignalReceived(); + + application.SendNotification(); + application.Render(20); + + DALI_TEST_EQUALS(Vector2(0, 0), control.GetCurrentProperty(Actor::Property::POSITION), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSlideTransitionOut(void) +{ + ToolkitTestApplication application; + tet_infoline("UtcDaliSlideTransitionOut"); + + 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); + + DALI_TEST_EQUALS(Vector2(0, 0), control.GetCurrentProperty(Actor::Property::POSITION), TEST_LOCATION); + + Vector2 windowSize = application.GetScene().GetSize(); + SlideTransition slide = SlideTransition::New(control, Dali::Toolkit::SlideTransitionDirection::BOTTOM, TimePeriod(0.5f)); + slide.SetAppearingTransition(false); + + TransitionSet transitionSet = TransitionSet::New(); + transitionSet.AddTransition(slide); + 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(); + + Vector2 currentPosition = control.GetCurrentProperty(Actor::Property::POSITION); + currentPosition += (windowSize / 2.0f) - Vector2(50, 50); + DALI_TEST_CHECK(currentPosition.y >= 0.7 * windowSize.y && currentPosition.y <= 0.9 * windowSize.y); + + 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. + DALI_TEST_EQUALS(Vector2(0, 0), control.GetCurrentProperty(Actor::Property::POSITION), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSlideTransitionIn(void) +{ + ToolkitTestApplication application; + tet_infoline("UtcDaliSlideTransitionIn"); + + 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); + + DALI_TEST_EQUALS(Vector2(0, 0), control.GetCurrentProperty(Actor::Property::POSITION), TEST_LOCATION); + + Vector2 windowSize = application.GetScene().GetSize(); + + SlideTransition slide = SlideTransition::New(control, Dali::Toolkit::SlideTransitionDirection::RIGHT, TimePeriod(0.5f)); + slide.SetAppearingTransition(true); + TransitionSet transitionSet = TransitionSet::New(); + transitionSet.AddTransition(slide); + 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(); + + Vector2 currentPosition = control.GetCurrentProperty(Actor::Property::POSITION); + currentPosition += (windowSize / 2.0f) - Vector2(50, 50); + DALI_TEST_CHECK(currentPosition.x >= 0.1 * windowSize.x && currentPosition.x <= 0.3 * windowSize.x); + + application.SendNotification(); + application.Render(200); + + // We did expect the animation to finish + application.SendNotification(); + finishCheck.CheckSignalReceived(); + + application.SendNotification(); + application.Render(20); + + DALI_TEST_EQUALS(Vector2(0, 0), control.GetCurrentProperty(Actor::Property::POSITION), TEST_LOCATION); + + END_TEST; +} diff --git a/dali-toolkit/dali-toolkit.h b/dali-toolkit/dali-toolkit.h index 10d4ac8..418bf9d 100644 --- a/dali-toolkit/dali-toolkit.h +++ b/dali-toolkit/dali-toolkit.h @@ -61,6 +61,7 @@ #include #include +#include #include #include diff --git a/dali-toolkit/internal/file.list b/dali-toolkit/internal/file.list index d2176db..8deec87 100644 --- a/dali-toolkit/internal/file.list +++ b/dali-toolkit/internal/file.list @@ -183,6 +183,7 @@ SET( toolkit_src_files ${toolkit_src_dir}/text/rendering/text-typesetter.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/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/slide-transition-impl.cpp b/dali-toolkit/internal/transition/slide-transition-impl.cpp new file mode 100644 index 0000000..21b9977 --- /dev/null +++ b/dali-toolkit/internal/transition/slide-transition-impl.cpp @@ -0,0 +1,139 @@ +/* + * 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 +#include +#include + +namespace Dali +{ +namespace Toolkit +{ +namespace Internal +{ +SlideTransitionPtr SlideTransition::New(Dali::Toolkit::Control control, const Vector2& direction, 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; + } + + SlideTransitionPtr slideTransition = new SlideTransition(control, direction, TimePeriod(delaySeconds, durationSeconds)); + + // Second-phase construction + slideTransition->Initialize(); + + return slideTransition; +} + +SlideTransition::SlideTransition(Dali::Toolkit::Control control, const Vector2& direction, TimePeriod timePeriod) +: TransitionBase(), + mTargetControl(control), + mDirection(direction) +{ + SetTarget(control); + SetTimePeriod(timePeriod); +} + +SlideTransition::~SlideTransition() +{ +} + +void SlideTransition::SetDirection(const Vector2& direction) +{ + mDirection = direction; + mDirection.Normalize(); +} + +Vector2 SlideTransition::GetDirection() const +{ + return mDirection; +} + +void SlideTransition::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 currentPosition = targetControl[Dali::Actor::Property::POSITION]; + Vector3 currentScale = targetControl[Dali::Actor::Property::SCALE]; + + Vector3 size = targetControl[Dali::Actor::Property::SIZE]; + size *= currentScale; + + Vector2 windowSize = DevelWindow::Get(targetControl).GetSize(); + // This checkPosition go outside of window(by following the direction), this targetControl will be out of window. + Vector2 checkPosition = windowSize / 2.0f + + Vector2(currentPosition.x + ((mDirection.x < 0.0f) ? size.x / 2.0f : -size.x / 2.0f), + currentPosition.y + ((mDirection.y < 0.0f) ? size.y / 2.0f : -size.y / 2.0f)); + + float xScale = (mDirection.x == 0.0f) ? std::numeric_limits::max() + : ((mDirection.x < 0.0f) ? checkPosition.x : windowSize.x - checkPosition.x) / std::abs(mDirection.x); + float yScale = (mDirection.y == 0.0f) ? std::numeric_limits::max() + : ((mDirection.y < 0.0f) ? checkPosition.y : windowSize.y - checkPosition.y) / std::abs(mDirection.y); + + Vector2 displacement = mDirection * std::min(xScale, yScale); + + Vector3 startPosition; + Vector3 finishPosition; + if(IsAppearingTransition()) + { + startPosition = currentPosition + Vector3(displacement); + finishPosition = currentPosition; + } + else + { + startPosition = currentPosition; + finishPosition = currentPosition + Vector3(displacement); + } + + startPropertyMap.Insert(Dali::Actor::Property::POSITION, startPosition); + finishPropertyMap.Insert(Dali::Actor::Property::POSITION, finishPosition); + + SetStartPropertyMap(startPropertyMap); + SetFinishPropertyMap(finishPropertyMap); +} + +} // namespace Internal + +} // namespace Toolkit + +} // namespace Dali diff --git a/dali-toolkit/internal/transition/slide-transition-impl.h b/dali-toolkit/internal/transition/slide-transition-impl.h new file mode 100644 index 0000000..b0fbf36 --- /dev/null +++ b/dali-toolkit/internal/transition/slide-transition-impl.h @@ -0,0 +1,116 @@ +#ifndef DALI_TOOLKIT_INTERNAL_SLIDE_TRANSITION_H +#define DALI_TOOLKIT_INTERNAL_SLIDE_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 +#include + +// EXTERNAL INCLUDES +#include + +namespace Dali +{ +namespace Toolkit +{ +namespace Internal +{ +using SlideTransitionPtr = IntrusivePtr; + +class SlideTransition : public TransitionBase +{ +public: + /** + * @brief Create a new SlideTransition object. + * @param[in] control A control of this transition. + * @param[in] direction Relative direction that the control is comming from or going to. + * @param[in] timePeriod The duration of the animation. + * @return A smart-pointer to the newly allocated SlideTransition. + */ + static SlideTransitionPtr New(Dali::Toolkit::Control control, const Vector2& direction, TimePeriod timePeriod); + + /** + * @copydoc Dali::Toolkit::SlideTransition::SetDirection() + */ + void SetDirection(const Vector2& direction); + + /** + * @copydoc Dali::Toolkit::SlideTransition::GetDirection() + */ + Vector2 GetDirection() const; + +protected: + /** + * @copydoc Dali::Toolkit::SlideTransition::OnPlay() + */ + void OnPlay() override; + +protected: + /** + * @brief Construct a new SlideTransition. + */ + SlideTransition(Dali::Toolkit::Control control, + const Vector2& direction, + TimePeriod timePeriod); + + /** + * @brief A reference counted object may only be deleted by calling Unreference() + */ + ~SlideTransition() override; + +private: + // Undefined + SlideTransition(const SlideTransition&); + + // Undefined + SlideTransition& operator=(const SlideTransition& rhs); + +private: + WeakHandle mTargetControl; + Vector2 mDirection; +}; + +} // namespace Internal + +// Helpers for public-api forwarding methods + +inline Internal::SlideTransition& GetImplementation(Dali::Toolkit::SlideTransition& slide) +{ + DALI_ASSERT_ALWAYS(slide && "SlideTransition handle is empty"); + + BaseObject& handle = slide.GetBaseObject(); + + return static_cast(handle); +} + +inline const Internal::SlideTransition& GetImplementation(const Dali::Toolkit::SlideTransition& slide) +{ + DALI_ASSERT_ALWAYS(slide && "SlideTransition handle is empty"); + + const BaseObject& handle = slide.GetBaseObject(); + + return static_cast(handle); +} + +} // namespace Toolkit + +} // namespace Dali + +#endif // DALI_TOOLKIT_INTERNAL_SLIDE_TRANSITION_H diff --git a/dali-toolkit/public-api/file.list b/dali-toolkit/public-api/file.list index 71cbc3a..726285c 100644 --- a/dali-toolkit/public-api/file.list +++ b/dali-toolkit/public-api/file.list @@ -33,6 +33,7 @@ SET( public_api_src_files ${public_api_src_dir}/image-loader/sync-image-loader.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/transition-base.cpp ${public_api_src_dir}/transition/transition-set.cpp ${public_api_src_dir}/transition/transition.cpp @@ -152,6 +153,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/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/slide-transition.cpp b/dali-toolkit/public-api/transition/slide-transition.cpp new file mode 100644 index 0000000..e68da58 --- /dev/null +++ b/dali-toolkit/public-api/transition/slide-transition.cpp @@ -0,0 +1,69 @@ +/* + * 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 +{ +SlideTransition::SlideTransition() = default; + +SlideTransition::SlideTransition(Internal::SlideTransition* slideTransition) +: TransitionBase(slideTransition) +{ +} + +SlideTransition SlideTransition::New(Dali::Toolkit::Control control, const Vector2& direction, TimePeriod timePeriod) +{ + Internal::SlideTransitionPtr internal = Dali::Toolkit::Internal::SlideTransition::New(control, direction, timePeriod); + + return SlideTransition(internal.Get()); +} + +SlideTransition SlideTransition::DownCast(BaseHandle handle) +{ + return SlideTransition(dynamic_cast(handle.GetObjectPtr())); +} + +SlideTransition::~SlideTransition() = default; + +SlideTransition::SlideTransition(const SlideTransition& handle) = default; + +SlideTransition& SlideTransition::operator=(const SlideTransition& rhs) = default; + +SlideTransition::SlideTransition(SlideTransition&& rhs) = default; + +SlideTransition& SlideTransition::operator=(SlideTransition&& rhs) = default; + +void SlideTransition::SetDirection(const Vector2& direction) +{ + GetImplementation(*this).SetDirection(direction); +} + +Vector2 SlideTransition::GetDirection() const +{ + return GetImplementation(*this).GetDirection(); +} + +} // namespace Toolkit + +} // namespace Dali diff --git a/dali-toolkit/public-api/transition/slide-transition.h b/dali-toolkit/public-api/transition/slide-transition.h new file mode 100644 index 0000000..ee380e7 --- /dev/null +++ b/dali-toolkit/public-api/transition/slide-transition.h @@ -0,0 +1,147 @@ +#ifndef DALI_TOOLKIT_SLIDE_TRANSITION_H +#define DALI_TOOLKIT_SLIDE_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 SlideTransition; +} + +/** + * @brief Pre-defined directions to define where the control is comming from or going to. + */ +namespace SlideTransitionDirection +{ + static constexpr Vector2 TOP(0, -1); // TOP + static constexpr Vector2 BOTTOM(0, 1); // BOTTOM + static constexpr Vector2 LEFT(-1, 0); // LEFT + static constexpr Vector2 RIGHT(1, 0); // RIGHT +} + +/** + * @brief SlideTransition provides smoothly appearing/disappearing effects for target Control. + * The direction the target Control is comming from or going to can be selected in the pre-defined directions. {UP, DOWN, LEFT, RIGHT} + * And, to use custom direction, the direction can be set CUSTOM and use SetDirection(Vector2) method. + */ +class DALI_TOOLKIT_API SlideTransition : public TransitionBase +{ +public: + + /** + * @brief Creates an uninitialized SlideTransition; this can be initialized with SlideTransition::New(). + * + * Calling member functions with an uninitialized SlideTransition handle is not allowed. + */ + SlideTransition(); + + /** + * @brief Creates an initialized SlideTransition. + * + * @param[in] control A control of this transition. + * @param[in] direction Relative direction that the control is comming from or going to. + * @param[in] timePeriod The duration of the animation. + * @return A handle to a newly allocated Dali resource + */ + static SlideTransition New(Dali::Toolkit::Control control, const Vector2& direction, TimePeriod timePeriod); + + /** + * @brief Downcasts a handle to SlideTransition handle. + * + * If handle points to an SlideTransition 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 SlideTransition object or an uninitialized handle + */ + static SlideTransition DownCast(BaseHandle handle); + + /** + * @brief Destructor. + * + * This is non-virtual since derived Handle types must not contain data or virtual methods. + */ + ~SlideTransition(); + + /** + * @brief This copy constructor is required for (smart) pointer semantics. + * + * @param[in] handle A reference to the copied handle + */ + SlideTransition(const SlideTransition& 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 + */ + SlideTransition& operator=(const SlideTransition& rhs); + + /** + * @brief Move constructor. + * + * @param[in] rhs A reference to the moved handle + */ + SlideTransition(SlideTransition&& rhs); + + /** + * @brief Move assignment operator. + * + * @param[in] rhs A reference to the moved handle + * @return A reference to this handle + */ + SlideTransition& operator=(SlideTransition&& rhs); + + /** + * @brief Sets direction to be used to move target Control + * + * @param[in] direction Relative direction that the control is comming from or going to. + */ + void SetDirection(const Vector2& direction); + + /** + * @brief Retrieves direction to be used to move target Control + * + * @note The direction is normalized Vector. + */ + Vector2 GetDirection() const; + +public: // Not intended for use by Application developers + /// @cond internal + /** + * @brief This constructor is used by SlideTransition::New() methods. + * @param[in] slideTransition A pointer to a newly allocated Dali resource + */ + explicit DALI_INTERNAL SlideTransition(Internal::SlideTransition* slideTransition); + /// @endcond +}; + +} // namespace Toolkit + +} // namespace Dali + +#endif // DALI_TOOLKIT_SLIDE_TRANSITION_H -- 2.7.4