utc-Dali-ConfirmationPopup.cpp
utc-Dali-CubeTransitionEffect.cpp
utc-Dali-EffectsView.cpp
- utc-Dali-Fade.cpp
+ utc-Dali-FadeTransition.cpp
utc-Dali-FlexContainer.cpp
utc-Dali-FlexNode.cpp
utc-Dali-GaussianBlurView.cpp
}
else
{
- mGl.BufferData(GetTarget(), size, &memory[0], GL_STATIC_DRAW); //@todo Query - do we need other usages?
+ mGl.BufferData(GetTarget(), GLsizeiptr(size), &memory[0], GL_STATIC_DRAW); //@todo Query - do we need other usages?
mCreated = true;
}
}
#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/fade.h>
+#include <dali-toolkit/public-api/transition/fade-transition.h>
using namespace Dali;
using namespace Dali::Toolkit;
bool& mSignalReceived; // owned by individual tests
};
-int UtcDaliFadeSetGetProperty(void)
+int UtcDaliFadeTransitionSetGetProperty(void)
{
ToolkitTestApplication application;
- tet_infoline("UtcDaliFadeSetGetProperty");
+ tet_infoline("UtcDaliFadeTransitionSetGetProperty");
Control control = Control::New();
- Fade fade = Fade::New(control, 0.5, TimePeriod(-0.5f, -0.5f));
+ FadeTransition fade = FadeTransition::New(control, 0.5, TimePeriod(-0.5f, -0.5f));
TimePeriod timePeriod = fade.GetTimePeriod();
DALI_TEST_EQUALS(0.0f, timePeriod.delaySeconds, TEST_LOCATION);
END_TEST;
}
-int UtcDaliFadeWithOffScene(void)
+int UtcDaliFadeTransitionWithOffScene(void)
{
ToolkitTestApplication application;
- tet_infoline("UtcDaliFadeWithOffScene");
+ tet_infoline("UtcDaliFadeTransitionWithOffScene");
Control control = Control::New();
control.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
DALI_TEST_EQUALS(1.0f, control.GetCurrentProperty<float>(Actor::Property::OPACITY), TEST_LOCATION);
- Fade fade = Fade::New(control, 0.5, TimePeriod(0.5f));
+ FadeTransition fade = FadeTransition::New(control, 0.5, TimePeriod(0.5f));
fade.SetAppearingTransition(false); // set fade out
TransitionSet transitionSet = TransitionSet::New();
transitionSet.AddTransition(fade);
END_TEST;
}
-int UtcDaliFadeOut(void)
+int UtcDaliFadeTransitionDisappearing(void)
{
ToolkitTestApplication application;
- tet_infoline("UtcDaliFadeOut");
+ tet_infoline("UtcDaliFadeTransitionOut");
Control control = Control::New();
control.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
DALI_TEST_EQUALS(1.0f, control.GetCurrentProperty<float>(Actor::Property::OPACITY), TEST_LOCATION);
- Fade fade = Fade::New(control, 0.5, TimePeriod(0.5f));
+ FadeTransition fade = FadeTransition::New(control, 0.5, TimePeriod(0.5f));
fade.SetAppearingTransition(false); // set fade out
TransitionSet transitionSet = TransitionSet::New();
transitionSet.AddTransition(fade);
END_TEST;
}
-int UtcDaliFadeIn(void)
+int UtcDaliFadeTransitionAppearing(void)
{
ToolkitTestApplication application;
- tet_infoline("UtcDaliFadeIn");
+ tet_infoline("UtcDaliFadeTransitionIn");
Control control = Control::New();
control.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
DALI_TEST_EQUALS(1.0f, control.GetCurrentProperty<float>(Actor::Property::OPACITY), TEST_LOCATION);
- Fade fade = Fade::New(control, 0.5, TimePeriod(0.5f));
+ FadeTransition fade = FadeTransition::New(control, 0.5, TimePeriod(0.5f));
fade.SetAppearingTransition(true); // set fade in
TransitionSet transitionSet = TransitionSet::New();
transitionSet.AddTransition(fade);
END_TEST;
}
+
+
+int UtcDaliFadeTransitionAppearingWithDelay(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline("UtcDaliFadeTransitionIn");
+
+ 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::POSITION, Vector3(100, 200, 0));
+ control.SetProperty(Actor::Property::SIZE, Vector3(150, 150, 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(1.0f, control.GetCurrentProperty<float>(Actor::Property::OPACITY), TEST_LOCATION);
+
+ FadeTransition fade = FadeTransition::New(control, 0.5, TimePeriod(0.5f, 0.5f));
+ fade.SetAppearingTransition(true); // set fade in
+ TransitionSet transitionSet = TransitionSet::New();
+ transitionSet.AddTransition(fade);
+ 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();
+
+ float currentOpacity = control.GetCurrentProperty<float>(Actor::Property::OPACITY);
+ DALI_TEST_CHECK(currentOpacity <= 0.01f);
+
+ application.SendNotification();
+ application.Render(500);
+
+ // We didn't expect the animation to finish yet
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+
+ currentOpacity = control.GetCurrentProperty<float>(Actor::Property::OPACITY);
+ DALI_TEST_CHECK(currentOpacity <= 1.0 && currentOpacity >= 0.8);
+
+ application.SendNotification();
+ application.Render(200);
+
+ // We did expect the animation to finish
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+
+ application.SendNotification();
+ application.Render(20);
+
+ DALI_TEST_EQUALS(1.0f, control.GetCurrentProperty<float>(Actor::Property::OPACITY), TEST_LOCATION);
+
+ END_TEST;
+}
DALI_TEST_EQUALS(startWorldPosition, control2.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
-
application.SendNotification();
application.Render(400);
#include <dali-toolkit/public-api/text/text-enumerations.h>
-#include <dali-toolkit/public-api/transition/fade.h>
+#include <dali-toolkit/public-api/transition/fade-transition.h>
#include <dali-toolkit/public-api/transition/transition.h>
#include <dali-toolkit/public-api/transition/transition-set.h>
// Forward input events to controller
EnableGestureDetection(static_cast<GestureType::Value>(GestureType::TAP | GestureType::PAN | GestureType::LONG_PRESS));
GetTapGestureDetector().SetMaximumTapsRequired(2);
+ GetTapGestureDetector().ReceiveAllTapEvents(true);
self.TouchedSignal().Connect(this, &TextEditor::OnTouched);
// Forward input events to controller
EnableGestureDetection(static_cast<GestureType::Value>(GestureType::TAP | GestureType::PAN | GestureType::LONG_PRESS));
GetTapGestureDetector().SetMaximumTapsRequired(2);
+ GetTapGestureDetector().ReceiveAllTapEvents(true);
self.TouchedSignal().Connect(this, &TextField::OnTouched);
${toolkit_src_dir}/text/rendering/text-backend-impl.cpp
${toolkit_src_dir}/text/rendering/text-typesetter.cpp
${toolkit_src_dir}/text/rendering/view-model.cpp
- ${toolkit_src_dir}/transition/fade-impl.cpp
+ ${toolkit_src_dir}/transition/fade-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
*/
// CLASS HEADER
-#include <dali-toolkit/internal/transition/fade-impl.h>
+#include <dali-toolkit/internal/transition/fade-transition-impl.h>
// EXTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control-impl.h>
{
namespace Internal
{
-namespace
-{
-const Dali::AlphaFunction DEFAULT_ALPHA_FUNCTION(Dali::AlphaFunction::DEFAULT);
-
-} // anonymous namespace
-FadePtr Fade::New(Dali::Toolkit::Control control, float opacity, TimePeriod timePeriod)
+FadeTransitionPtr FadeTransition::New(Dali::Toolkit::Control control, float opacity, TimePeriod timePeriod)
{
float delaySeconds = timePeriod.delaySeconds;
if(delaySeconds < 0.0f)
durationSeconds = 0.0f;
}
- FadePtr fade = new Fade(control, Dali::Clamp(opacity, 0.0f, 1.0f), TimePeriod(delaySeconds, durationSeconds));
+ FadeTransitionPtr fadeTransition = new FadeTransition(control, Dali::Clamp(opacity, 0.0f, 1.0f), TimePeriod(delaySeconds, durationSeconds));
// Second-phase construction
- fade->Initialize();
+ fadeTransition->Initialize();
- return fade;
+ return fadeTransition;
}
-Fade::Fade(Dali::Toolkit::Control control, float opacity, TimePeriod timePeriod)
+FadeTransition::FadeTransition(Dali::Toolkit::Control control, float opacity, TimePeriod timePeriod)
: TransitionBase(),
mTargetControl(control),
mOpacity(opacity)
SetTimePeriod(timePeriod);
}
-Fade::~Fade()
+FadeTransition::~FadeTransition()
{
}
-void Fade::OnPlay()
+void FadeTransition::OnPlay()
{
Dali::Toolkit::Control targetControl = mTargetControl.GetHandle();
if(!targetControl || !targetControl[Dali::Actor::Property::CONNECTED_TO_SCENE])
return;
}
- Property::Map initialPropertyMap;
Property::Map startPropertyMap;
Property::Map finishPropertyMap;
- float targetOpacity = GetWorldColor(targetControl).a;
- targetControl[Dali::Actor::Property::COLOR_MODE] = Dali::ColorMode::USE_OWN_COLOR;
-
+ float targetOpacity = targetControl[Dali::Actor::Property::OPACITY];
if(IsAppearingTransition())
{
- initialPropertyMap.Insert(Dali::Actor::Property::OPACITY, 0.0f);
startPropertyMap.Insert(Dali::Actor::Property::OPACITY, mOpacity * targetOpacity);
finishPropertyMap.Insert(Dali::Actor::Property::OPACITY, targetOpacity);
}
else
{
- initialPropertyMap.Insert(Dali::Actor::Property::OPACITY, targetOpacity);
startPropertyMap.Insert(Dali::Actor::Property::OPACITY, targetOpacity);
finishPropertyMap.Insert(Dali::Actor::Property::OPACITY, mOpacity * targetOpacity);
}
- SetInitialPropertyMap(initialPropertyMap);
SetStartPropertyMap(startPropertyMap);
SetFinishPropertyMap(finishPropertyMap);
}
-#ifndef DALI_TOOLKIT_INTERNAL_FADE_H
-#define DALI_TOOLKIT_INTERNAL_FADE_H
+#ifndef DALI_TOOLKIT_INTERNAL_FADE_TRANSITION_H
+#define DALI_TOOLKIT_INTERNAL_FADE_TRANSITION_H
/*
* Copyright (c) 2021 Samsung Electronics Co., Ltd.
// 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/fade.h>
+#include <dali-toolkit/public-api/transition/fade-transition.h>
// EXTERNAL INCLUDES
#include <dali/public-api/object/weak-handle.h>
{
namespace Internal
{
-using FadePtr = IntrusivePtr<Fade>;
+using FadeTransitionPtr = IntrusivePtr<FadeTransition>;
-class Fade : public TransitionBase
+class FadeTransition : public TransitionBase
{
public:
/**
- * @brief Create a new Fade object.
+ * @brief Create a new FadeTransition object.
* @param[in] control A control of this transition.
* @param[in] opacity opacity value the control Opacity property will be changed from/to.
* @param[in] timePeriod The duration of the animation.
- * @return A smart-pointer to the newly allocated Fade.
+ * @return A smart-pointer to the newly allocated FadeTransition.
*/
- static FadePtr New(Dali::Toolkit::Control control, float opacity, TimePeriod timePeriod);
+ static FadeTransitionPtr New(Dali::Toolkit::Control control, float opacity, TimePeriod timePeriod);
protected:
/**
- * @copydoc Dali::Toolkit::Fade::OnPlay()
+ * @copydoc Dali::Toolkit::FadeTransition::OnPlay()
*/
void OnPlay() override;
protected:
/**
- * @brief Construct a new Fade.
+ * @brief Construct a new FadeTransition.
*/
- Fade(Dali::Toolkit::Control control,
- float opacity,
- TimePeriod timePeriod);
+ FadeTransition(Dali::Toolkit::Control control,
+ float opacity,
+ TimePeriod timePeriod);
/**
* @brief A reference counted object may only be deleted by calling Unreference()
*/
- ~Fade() override;
+ ~FadeTransition() override;
private:
// Undefined
- Fade(const Fade&);
+ FadeTransition(const FadeTransition&);
// Undefined
- Fade& operator=(const Fade& rhs);
+ FadeTransition& operator=(const FadeTransition& rhs);
private:
WeakHandle<Dali::Toolkit::Control> mTargetControl;
- float mOpacity;
+ float mOpacity;
};
} // namespace Internal
// Helpers for public-api forwarding methods
-inline Internal::Fade& GetImplementation(Dali::Toolkit::Fade& fade)
+inline Internal::FadeTransition& GetImplementation(Dali::Toolkit::FadeTransition& fade)
{
- DALI_ASSERT_ALWAYS(fade && "Fade handle is empty");
+ DALI_ASSERT_ALWAYS(fade && "FadeTransition handle is empty");
BaseObject& handle = fade.GetBaseObject();
- return static_cast<Internal::Fade&>(handle);
+ return static_cast<Internal::FadeTransition&>(handle);
}
-inline const Internal::Fade& GetImplementation(const Dali::Toolkit::Fade& fade)
+inline const Internal::FadeTransition& GetImplementation(const Dali::Toolkit::FadeTransition& fade)
{
- DALI_ASSERT_ALWAYS(fade && "Fade handle is empty");
+ DALI_ASSERT_ALWAYS(fade && "FadeTransition handle is empty");
const BaseObject& handle = fade.GetBaseObject();
- return static_cast<const Internal::Fade&>(handle);
+ return static_cast<const Internal::FadeTransition&>(handle);
}
} // namespace Toolkit
} // namespace Dali
-#endif // DALI_TOOLKIT_INTERNAL_FADE_H
+#endif // DALI_TOOLKIT_INTERNAL_FADE_TRANSITION_H
{
namespace
{
+static constexpr float OPACITY_TRANSPARENT = 0.0f;
+
const Dali::AlphaFunction DEFAULT_ALPHA_FUNCTION(Dali::AlphaFunction::DEFAULT);
+const Property::Map PROPERTY_MAP_INDEPENDENT_CONTROL{
+ {Dali::Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER},
+ {Dali::Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER},
+ {Dali::Actor::Property::POSITION_USES_ANCHOR_POINT, true},
+ {Dali::Actor::Property::INHERIT_POSITION, false},
+ {Dali::Actor::Property::INHERIT_ORIENTATION, false},
+ {Dali::Actor::Property::INHERIT_SCALE, false},
+ {Dali::Actor::Property::COLOR_MODE, Dali::ColorMode::USE_OWN_COLOR},
+};
+
Property::Map GetOriginalProperties(Dali::Toolkit::Control control)
{
Property::Map propertyMap;
mTimePeriod(TimePeriod(0.0f)),
mTransitionWithChild(false),
mMoveTargetChildren(false),
- mIsAppearingTransition(true)
+ mIsAppearingTransition(true),
+ mIsPairTransition(false)
{
}
return;
}
+ // Set world transform and color to the target control to make it independent of the parent control and its transition.
+ // The properties will be returned at the TransitionFinished() method.
+ Matrix targetWorldTransform = GetWorldTransform(mTarget);
+ Vector3 targetPosition, targetScale;
+ Quaternion targetOrientation;
+ targetWorldTransform.GetTransformComponents(targetPosition, targetOrientation, targetScale);
+ Vector4 targetColor = GetWorldColor(mTarget);
+
+ mTarget.SetProperties(PROPERTY_MAP_INDEPENDENT_CONTROL);
+ mTarget[Dali::Actor::Property::POSITION] = targetPosition;
+ mTarget[Dali::Actor::Property::SCALE] = targetScale;
+ mTarget[Dali::Actor::Property::ORIENTATION] = targetOrientation;
+ mTarget[Dali::Actor::Property::COLOR] = targetColor;
+
OnPlay();
SetAnimation();
return;
}
+ // If this transition is not a transition from a Control to another Control
+ // and a transition effect to appear with delay,
+ // the mTarget should not be shown until delay seconds.
+ if(!IsPairTransition() && mIsAppearingTransition && mAnimation && mTimePeriod.delaySeconds > Dali::Math::MACHINE_EPSILON_10)
+ {
+ Dali::KeyFrames initialKeyframes = Dali::KeyFrames::New();
+ initialKeyframes.Add(0.0f, OPACITY_TRANSPARENT);
+ initialKeyframes.Add(1.0f, OPACITY_TRANSPARENT);
+ mAnimation.AnimateBetween(Property(mTarget, Dali::Actor::Property::OPACITY), initialKeyframes, TimePeriod(mTimePeriod.delaySeconds));
+ }
+
for(uint32_t i = 0; i < mStartPropertyMap.Count(); ++i)
{
- Property::Value* initialValuePointer = mInitialPropertyMap.Find(mStartPropertyMap.GetKeyAt(i).indexKey);
Property::Value* finishValue = mFinishPropertyMap.Find(mStartPropertyMap.GetKeyAt(i).indexKey);
if(finishValue)
{
- Property::Value initialValue = mStartPropertyMap.GetValue(i);
- if(initialValuePointer)
- {
- initialValue = *initialValuePointer;
- }
- AnimateBetween(mTarget, mStartPropertyMap.GetKeyAt(i).indexKey, initialValue, mStartPropertyMap.GetValue(i), *finishValue);
+ AnimateBetween(mTarget, mStartPropertyMap.GetKeyAt(i).indexKey, mStartPropertyMap.GetValue(i), *finishValue);
}
}
}
-void TransitionBase::AnimateBetween(Dali::Toolkit::Control target, Property::Index index, Property::Value initialValue, Property::Value sourceValue, Property::Value destinationValue)
+void TransitionBase::AnimateBetween(Dali::Toolkit::Control target, Property::Index index, Property::Value sourceValue, Property::Value destinationValue)
{
if(mAnimation)
{
- if(mTimePeriod.delaySeconds>0.0f)
+ // To make each property keep start value during delay time.
+ // When this transition is not Pair transition, it is not required.
+ // (For appearing transition, the mTarget control will not be shown during delay time,
+ // For disapplearing transition, the property of mTarget control keeps current value during delay time)
+ if(IsPairTransition() && mTimePeriod.delaySeconds > Dali::Math::MACHINE_EPSILON_10)
{
Dali::KeyFrames initialKeyframes = Dali::KeyFrames::New();
- initialKeyframes.Add(0.0f, initialValue);
- initialKeyframes.Add(1.0f, initialValue);
+ initialKeyframes.Add(0.0f, sourceValue);
+ initialKeyframes.Add(1.0f, sourceValue);
mAnimation.AnimateBetween(Property(target, index), initialKeyframes, TimePeriod(mTimePeriod.delaySeconds));
}
Dali::KeyFrames keyframes = Dali::KeyFrames::New();
}
protected:
- /**
- * @brief Set property map which will be used as a initial properties.
- * @param[in] propertyMap propertyMap that will be used as a start value of transition.
- */
- void SetInitialPropertyMap(const Property::Map& propertyMap)
- {
- mInitialPropertyMap = propertyMap;
- }
+
/**
* @brief Set property map which will be used as a animation start properties.
* @param[in] propertyMap propertyMap that will be used as a start value of transition.
return mIsAppearingTransition;
}
+ /**
+ * @brief Set whether this transition is a transition from a Control to another Control or effect to appearing or disappearing.
+ * @param[in] pairTransition True if this transition is appearing transition.
+ */
+ void SetPairTransition(bool pairTransition)
+ {
+ mIsPairTransition = pairTransition;
+ }
+
+ /**
+ * @brief Returns whether this transition is a transition from a Control to another Control or effect to appearing or disappearing.
+ */
+ bool IsPairTransition() const
+ {
+ return mIsPairTransition;
+ }
+
protected:
/**
* Construct a new TransitionBase.
* @brief Adds a property on an animation between sourceValue and destimationValue.
* @param[in] target target control to be animated.
* @param[in] index property index for animation.
- * @param[in] initialValue initial value of animation.
* @param[in] sourceValue source value of animation.
* @param[in] destinationValue destination value of animation.
*/
- void AnimateBetween(Dali::Toolkit::Control target, Property::Index index, Property::Value initialValue, Property::Value sourceValue, Property::Value destinationValue);
+ void AnimateBetween(Dali::Toolkit::Control target, Property::Index index, Property::Value sourceValue, Property::Value destinationValue);
/**
* @brief Copy target to make clone for the child Actors
Dali::Actor mCopiedActor; ///< Copied View that will replace mTarget during transition
Dali::Animation mAnimation; ///< Property animations for the transition of mTarget
AlphaFunction mAlphaFunction; ///< Alpha function that will applied for the property animation
- Property::Map mInitialPropertyMap; ///< Initial properties to be animated. (world transform)
Property::Map mStartPropertyMap; ///< Start properties to be animated. (world transform)
Property::Map mFinishPropertyMap; ///< Finish properties to be animated. (world transform)
Property::Map mOriginalPropertyMap; ///< Original properties of mTarget to be used to restore after the transition is finished.
///< If this is false, the child Actors are moved to the child of mCopiedActor that will have original properties of target Actor during Transition.
bool mMoveTargetChildren; ///< Flag, if mTransitionWithChild is false and mTarget has children than True.
bool mIsAppearingTransition; ///< True, if this transition is appearing transition.
+ bool mIsPairTransition; ///< True, if this transition is started from a Control to another Control.
};
} // namespace Internal
{
SetTarget(destination);
SetTimePeriod(timePeriod);
+ SetPairTransition(true);
}
Transition::~Transition()
Quaternion sourceOrientation;
sourceWorldTransform.GetTransformComponents(sourcePosition, sourceOrientation, sourceScale);
- Matrix destinationWorldTransform = GetWorldTransform(destinationControl);
- Vector3 destinationPosition, destinationScale;
- Quaternion destinationOrientation;
- destinationWorldTransform.GetTransformComponents(destinationPosition, destinationOrientation, destinationScale);
+ Vector3 destinationPosition = destinationControl[Dali::Actor::Property::POSITION];
+ Vector3 destinationScale = destinationControl[Dali::Actor::Property::SCALE];
+ Quaternion destinationOrientation = destinationControl[Dali::Actor::Property::ORIENTATION];
+ Vector4 targetColor = destinationControl[Dali::Actor::Property::COLOR];
+ Vector3 targetSize = destinationControl[Dali::Actor::Property::SIZE];
- Vector3 targetSize = destinationControl[Dali::Actor::Property::SIZE];
- Vector4 targetColor = GetWorldColor(destinationControl);
Property::Map startPropertyMap;
Property::Map finishPropertyMap;
- // Use world transform if this transition requires animation of transform.
- destinationControl[Dali::Actor::Property::ANCHOR_POINT] = AnchorPoint::CENTER;
- destinationControl[Dali::Actor::Property::PARENT_ORIGIN] = ParentOrigin::CENTER;
- destinationControl[Dali::Actor::Property::POSITION_USES_ANCHOR_POINT] = true;
- destinationControl[Dali::Actor::Property::INHERIT_POSITION] = false;
- destinationControl[Dali::Actor::Property::INHERIT_ORIENTATION] = false;
- destinationControl[Dali::Actor::Property::INHERIT_SCALE] = false;
- destinationControl[Dali::Actor::Property::COLOR_MODE] = Dali::ColorMode::USE_OWN_COLOR;
-
// Set animation of Transform
startPropertyMap.Insert(Dali::Actor::Property::POSITION, sourcePosition);
finishPropertyMap.Insert(Dali::Actor::Property::POSITION, destinationPosition);
void TransitionSet::TransitionFinished(Dali::Animation& source)
{
- for(auto&& transition : mTransitions)
+ // Call TransitionFinished() in reverse order.
+ // This let the first copied original properties will be return again at the final.
+ std::vector<TransitionBasePtr>::reverse_iterator riter;
+ for(riter = mTransitions.rbegin(); riter != mTransitions.rend(); riter++)
{
- transition->TransitionFinished();
+ (*riter)->TransitionFinished();
}
EmitFinishedSignal();
{
const unsigned int TOOLKIT_MAJOR_VERSION = 2;
const unsigned int TOOLKIT_MINOR_VERSION = 0;
-const unsigned int TOOLKIT_MICRO_VERSION = 40;
+const unsigned int TOOLKIT_MICRO_VERSION = 41;
const char* const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
${public_api_src_dir}/image-loader/async-image-loader.cpp
${public_api_src_dir}/image-loader/sync-image-loader.cpp
${public_api_src_dir}/styling/style-manager.cpp
- ${public_api_src_dir}/transition/fade.cpp
+ ${public_api_src_dir}/transition/fade-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.h
+ ${public_api_src_dir}/transition/fade-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/fade-transition.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/transition/fade-transition-impl.h>
+
+namespace Dali
+{
+namespace Toolkit
+{
+FadeTransition::FadeTransition() = default;
+
+FadeTransition::FadeTransition(Internal::FadeTransition* fadeTransition)
+: TransitionBase(fadeTransition)
+{
+}
+
+FadeTransition FadeTransition::New(Dali::Toolkit::Control control, float opacity, TimePeriod timePeriod)
+{
+ Internal::FadeTransitionPtr internal = Dali::Toolkit::Internal::FadeTransition::New(control, opacity, timePeriod);
+
+ return FadeTransition(internal.Get());
+}
+
+FadeTransition FadeTransition::DownCast(BaseHandle handle)
+{
+ return FadeTransition(dynamic_cast<Dali::Toolkit::Internal::FadeTransition*>(handle.GetObjectPtr()));
+}
+
+FadeTransition::~FadeTransition() = default;
+
+FadeTransition::FadeTransition(const FadeTransition& handle) = default;
+
+FadeTransition& FadeTransition::operator=(const FadeTransition& rhs) = default;
+
+FadeTransition::FadeTransition(FadeTransition&& rhs) = default;
+
+FadeTransition& FadeTransition::operator=(FadeTransition&& rhs) = default;
+
+} // namespace Toolkit
+
+} // namespace Dali
-#ifndef DALI_TOOLKIT_FADE_H
-#define DALI_TOOLKIT_FADE_H
+#ifndef DALI_TOOLKIT_FADE_TRANSITION_H
+#define DALI_TOOLKIT_FADE_TRANSITION_H
/*
* Copyright (c) 2021 Samsung Electronics Co., Ltd.
{
namespace Internal DALI_INTERNAL
{
-class Fade;
+class FadeTransition;
}
/**
* @brief Fade provides smoothly appearing/disappearing effects for target Control.
*/
-class DALI_TOOLKIT_API Fade : public TransitionBase
+class DALI_TOOLKIT_API FadeTransition : public TransitionBase
{
public:
/**
- * @brief Creates an uninitialized Fade; this can be initialized with Fade::New().
+ * @brief Creates an uninitialized FadeTransition; this can be initialized with FadeTransition::New().
*
- * Calling member functions with an uninitialized Fade handle is not allowed.
+ * Calling member functions with an uninitialized FadeTransition handle is not allowed.
*/
- Fade();
+ FadeTransition();
/**
- * @brief Creates an initialized Fade.
+ * @brief Creates an initialized FadeTransition.
*
* @param[in] control A control of this transition.
* @param[in] opacity opacity value the control Opacity property will be changed from/to. Opacity must be between [0, 1].
* @param[in] timePeriod The duration of the animation.
* @return A handle to a newly allocated Dali resource
*/
- static Fade New(Dali::Toolkit::Control control, float opacity, TimePeriod timePeriod);
+ static FadeTransition New(Dali::Toolkit::Control control, float opacity, TimePeriod timePeriod);
/**
- * @brief Downcasts a handle to Fade handle.
+ * @brief Downcasts a handle to FadeTransition handle.
*
- * If handle points to an Fade object, the downcast produces valid handle.
+ * If handle points to an FadeTransition 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 Fade object or an uninitialized handle
+ * @return Handle to an FadeTransition object or an uninitialized handle
*/
- static Fade DownCast(BaseHandle handle);
+ static FadeTransition DownCast(BaseHandle handle);
/**
* @brief Destructor.
*
* This is non-virtual since derived Handle types must not contain data or virtual methods.
*/
- ~Fade();
+ ~FadeTransition();
/**
* @brief This copy constructor is required for (smart) pointer semantics.
*
* @param[in] handle A reference to the copied handle
*/
- Fade(const Fade& handle);
+ FadeTransition(const FadeTransition& 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
*/
- Fade& operator=(const Fade& rhs);
+ FadeTransition& operator=(const FadeTransition& rhs);
/**
* @brief Move constructor.
*
* @param[in] rhs A reference to the moved handle
*/
- Fade(Fade&& rhs);
+ FadeTransition(FadeTransition&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Fade& operator=(Fade&& rhs);
+ FadeTransition& operator=(FadeTransition&& rhs);
public: // Not intended for use by Application developers
/// @cond internal
/**
- * @brief This constructor is used by Fade::New() methods.
- * @param[in] fade A pointer to a newly allocated Dali resource
+ * @brief This constructor is used by FadeTransition::New() methods.
+ * @param[in] fadeTransition A pointer to a newly allocated Dali resource
*/
- explicit DALI_INTERNAL Fade(Internal::Fade* fade);
+ explicit DALI_INTERNAL FadeTransition(Internal::FadeTransition* fadeTransition);
/// @endcond
};
} // namespace Dali
-#endif // DALI_TOOLKIT_FADE_H
+#endif // DALI_TOOLKIT_FADE_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/fade.h>
-
-// INTERNAL INCLUDES
-#include <dali-toolkit/internal/transition/fade-impl.h>
-
-namespace Dali
-{
-namespace Toolkit
-{
-Fade::Fade() = default;
-
-Fade::Fade(Internal::Fade* fade)
-: TransitionBase(fade)
-{
-}
-
-Fade Fade::New(Dali::Toolkit::Control control, float opacity, TimePeriod timePeriod)
-{
- Internal::FadePtr internal = Dali::Toolkit::Internal::Fade::New(control, opacity, timePeriod);
-
- return Fade(internal.Get());
-}
-
-Fade Fade::DownCast(BaseHandle handle)
-{
- return Fade(dynamic_cast<Dali::Toolkit::Internal::Fade*>(handle.GetObjectPtr()));
-}
-
-Fade::~Fade() = default;
-
-Fade::Fade(const Fade& handle) = default;
-
-Fade& Fade::operator=(const Fade& rhs) = default;
-
-Fade::Fade(Fade&& rhs) = default;
-
-Fade& Fade::operator=(Fade&& rhs) = default;
-
-} // namespace Toolkit
-
-} // namespace Dali
/**
* @brief
- *
* TransitionSet is used to control lifetime of multiple Transitions.
* Transition could be played with multiple other transitions for a scene change.
* For the case, it is more useful to manage a group of transitions with same lifetime and a finished signal.
* TransitionSet provides a single Play call and Finished callback for the multiple traisitions those added on it.
+ *
+ * @note
+ * Do not add transitions for a View by dividing them into multiple TransitionSets.
*/
class DALI_TOOLKIT_API TransitionSet : public BaseHandle
{
Name: dali2-toolkit
Summary: Dali 3D engine Toolkit
-Version: 2.0.40
+Version: 2.0.41
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-toolkit.git / commitdiff