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
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);
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);
--- /dev/null
+/*
+ * 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/slide-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 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<Vector2>(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<Vector2>(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<Vector2>(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<Vector2>(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<Vector2>(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<Vector2>(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<Vector2>(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<Vector2>(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<Vector2>(Actor::Property::POSITION), TEST_LOCATION);
+
+ END_TEST;
+}
#include <dali-toolkit/public-api/text/text-enumerations.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/transition.h>
#include <dali-toolkit/public-api/transition/transition-set.h>
${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
--- /dev/null
+/*
+ * 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/slide-transition-impl.h>
+
+// EXTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali/devel-api/actors/actor-devel.h>
+#include <dali/devel-api/adaptor-framework/window-devel.h>
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/object/type-registry.h>
+#include <limits>
+
+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<float>::max()
+ : ((mDirection.x < 0.0f) ? checkPosition.x : windowSize.x - checkPosition.x) / std::abs(mDirection.x);
+ float yScale = (mDirection.y == 0.0f) ? std::numeric_limits<float>::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
--- /dev/null
+#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 <dali-toolkit/internal/transition/transition-base-impl.h>
+#include <dali-toolkit/public-api/controls/control.h>
+#include <dali-toolkit/public-api/transition/slide-transition.h>
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/weak-handle.h>
+
+namespace Dali
+{
+namespace Toolkit
+{
+namespace Internal
+{
+using SlideTransitionPtr = IntrusivePtr<SlideTransition>;
+
+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<Dali::Toolkit::Control> 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<Internal::SlideTransition&>(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<const Internal::SlideTransition&>(handle);
+}
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif // DALI_TOOLKIT_INTERNAL_SLIDE_TRANSITION_H
${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
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
--- /dev/null
+/*
+ * 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/slide-transition.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/transition/slide-transition-impl.h>
+
+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<Dali::Toolkit::Internal::SlideTransition*>(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
--- /dev/null
+#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 <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 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
projects / platform / core / uifw / dali-toolkit.git / commitdiff