projects / platform / core / uifw / dali-toolkit.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Make to use Size of source for transition.
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / transition / transition-impl.cpp
diff --git a/dali-toolkit/internal/transition/transition-impl.cpp b/dali-toolkit/internal/transition/transition-impl.cpp
index a465433..78ba8db 100644 (file)
--- a/dali-toolkit/internal/transition/transition-impl.cpp
+++ b/dali-toolkit/internal/transition/transition-impl.cpp
@@ -27,6 +27,7 @@
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/internal/controls/control/control-data-impl.h>
 
 namespace Dali
 {
@@ -37,10 +38,9 @@ namespace Internal
 namespace
 {
 const Dali::AlphaFunction DEFAULT_ALPHA_FUNCTION(Dali::AlphaFunction::DEFAULT);
-
 } // anonymous namespace
 
-TransitionPtr Transition::New(Dali::Toolkit::Control source, Dali::Toolkit::Control destination, TimePeriod timePeriod)
+TransitionPtr Transition::New(Dali::Toolkit::Control source, Dali::Toolkit::Control destination, bool useDestinationTarget, TimePeriod timePeriod)
 {
   float delaySeconds = timePeriod.delaySeconds;
   if(delaySeconds < 0.0f)
@@ -56,7 +56,7 @@ TransitionPtr Transition::New(Dali::Toolkit::Control source, Dali::Toolkit::Cont
     durationSeconds = 0.0f;
   }
 
-  TransitionPtr transition = new Transition(source, destination, TimePeriod(delaySeconds, durationSeconds));
+  TransitionPtr transition = new Transition(source, destination, useDestinationTarget, TimePeriod(delaySeconds, durationSeconds));
 
   // Second-phase construction
   transition->Initialize();
@@ -64,13 +64,16 @@ TransitionPtr Transition::New(Dali::Toolkit::Control source, Dali::Toolkit::Cont
   return transition;
 }
 
-Transition::Transition(Dali::Toolkit::Control source, Dali::Toolkit::Control destination, TimePeriod timePeriod)
+Transition::Transition(Dali::Toolkit::Control source, Dali::Toolkit::Control destination, bool useDestinationTarget, TimePeriod timePeriod)
 : TransitionBase(),
+  mUseDestinationTarget(useDestinationTarget),
+  mOriginalSize(),
   mSourceControl(source),
   mDestinationControl(destination)
 {
-  SetTarget(destination);
+  SetTarget(mUseDestinationTarget ? destination : source);
   SetTimePeriod(timePeriod);
+  SetPairTransition(true);
 }
 
 Transition::~Transition()
@@ -89,7 +92,7 @@ void Transition::OnPlay()
   }
 
   //Make startPropertyMap and finishPropertyMap to use for property animation.
-  Matrix     sourceWorldTransform = sourceControl[Dali::Actor::Property::WORLD_MATRIX];
+  Matrix     sourceWorldTransform = GetWorldTransform(sourceControl);
   Vector3    sourcePosition, sourceScale;
   Quaternion sourceOrientation;
   sourceWorldTransform.GetTransformComponents(sourcePosition, sourceOrientation, sourceScale);
@@ -99,20 +102,9 @@ void Transition::OnPlay()
   Quaternion destinationOrientation;
   destinationWorldTransform.GetTransformComponents(destinationPosition, destinationOrientation, destinationScale);
 
-  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);
@@ -123,29 +115,36 @@ void Transition::OnPlay()
   startPropertyMap.Insert(Dali::Actor::Property::SCALE, sourceScale);
   finishPropertyMap.Insert(Dali::Actor::Property::SCALE, destinationScale);
 
-  Vector4 sourceColor = sourceControl.GetCurrentProperty<Vector4>(Dali::Actor::Property::WORLD_COLOR);
+  Vector4 sourceColor      = GetWorldColor(sourceControl);
+  Vector4 destinationColor = GetWorldColor(destinationControl);
   startPropertyMap.Insert(Dali::Actor::Property::COLOR, sourceColor);
-  finishPropertyMap.Insert(Dali::Actor::Property::COLOR, targetColor);
+  finishPropertyMap.Insert(Dali::Actor::Property::COLOR, destinationColor);
 
   // Set animation for other properties if source and destination is different.
-  Vector3 sourceSize = sourceControl.GetCurrentProperty<Vector3>(Dali::Actor::Property::SIZE);
-  if(sourceSize != targetSize)
+  Vector3 sourceSize      = sourceControl[Dali::Actor::Property::SIZE];
+  Vector3 destinationSize = destinationControl[Dali::Actor::Property::SIZE];
+  if(sourceSize != destinationSize)
   {
     startPropertyMap.Insert(Dali::Actor::Property::SIZE, sourceSize);
-    finishPropertyMap.Insert(Dali::Actor::Property::SIZE, targetSize);
+    finishPropertyMap.Insert(Dali::Actor::Property::SIZE, destinationSize);
+    if(!mUseDestinationTarget)
+    {
+      mOriginalSize = GetTargetControl().GetProperty<Vector3>(Dali::Actor::Property::SIZE);
+    }
   }
 
   SetStartPropertyMap(startPropertyMap);
   SetFinishPropertyMap(finishPropertyMap);
 
   // source View becomes transparent during transition.
+  Dali::Toolkit::Control waitingControl = GetWaitingControl();
   if(IsTransitionWithChild())
   {
-    sourceControl[Dali::Actor::Property::VISIBLE] = false;
+    waitingControl[Dali::Actor::Property::VISIBLE] = false;
   }
   else
   {
-    GetImplementation(sourceControl).SetTransparent(true);
+    GetImplementation(waitingControl).SetTransparent(true);
   }
 
   Dali::Animation animation = GetAnimation();
@@ -154,27 +153,82 @@ void Transition::OnPlay()
     DALI_LOG_ERROR("animation is still not initialized\n");
     return;
   }
-  Dali::Toolkit::DevelControl::CreateTransitions(destinationControl, animation, sourceControl, GetAlphaFunction(), GetTimePeriod());
+
+  mOriginalVisualProperties.clear();
+  std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>> destinationVisualProperties;
+  Dali::Toolkit::Control                                             targetControl   = GetTargetControl();
+  Internal::Control&                                                 internalControl = Toolkit::Internal::GetImplementation(targetControl);
+  Internal::Control::Impl&                                           controlDataImpl = Toolkit::Internal::Control::Impl::Get(internalControl);
+  controlDataImpl.CreateTransitions(mOriginalVisualProperties, destinationVisualProperties, sourceControl, destinationControl);
+
+  for(uint32_t index = 0; index < mOriginalVisualProperties.size(); ++index)
+  {
+    Dali::Property::Map source      = mOriginalVisualProperties[index].second;
+    Dali::Property::Map destination = destinationVisualProperties[index].second;
+    for(size_t i = 0; i < source.Count(); ++i)
+    {
+      Dali::Property property = DevelControl::GetVisualProperty(targetControl, mOriginalVisualProperties[index].first, source.GetKeyAt(i));
+      if(GetTimePeriod().delaySeconds > 0.0f)
+      {
+        Dali::KeyFrames initialKeyframes = Dali::KeyFrames::New();
+        initialKeyframes.Add(0.0f, source.GetValue(i));
+        animation.AnimateBetween(property, initialKeyframes, TimePeriod(GetTimePeriod().delaySeconds));
+      }
+      Dali::KeyFrames keyframes = Dali::KeyFrames::New();
+      keyframes.Add(0.0f, source.GetValue(i));
+      keyframes.Add(1.0f, destination.GetValue(i));
+      animation.AnimateBetween(property, keyframes, GetAlphaFunction(), GetTimePeriod());
+    }
+  }
 }
 
 void Transition::OnFinished()
 {
-  Dali::Toolkit::Control sourceControl = mSourceControl.GetHandle();
-  if(!sourceControl)
+  Dali::Toolkit::Control waitingControl = GetWaitingControl();
+  if(!waitingControl)
   {
     return;
   }
 
+  if(!mUseDestinationTarget)
+  {
+    Dali::Toolkit::Control target         = GetTargetControl();
+    Dali::Animation        resetAnimation = Dali::Animation::New(0.0f);
+    if(mOriginalSize != target.GetProperty<Vector3>(Dali::Actor::Property::SIZE))
+    {
+      // Use Animation not to notify size change and not to change width and height resize policy.
+      resetAnimation.AnimateTo(Dali::Property(target, Dali::Actor::Property::SIZE), mOriginalSize);
+    }
+    resetAnimation.Play();
+
+    Dali::Toolkit::Control   targetControl   = GetTargetControl();
+    Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(targetControl);
+    Internal::Control::Impl& controlDataImpl = Toolkit::Internal::Control::Impl::Get(internalControl);
+    controlDataImpl.UpdateVisualProperties(mOriginalVisualProperties);
+  }
+
   if(IsTransitionWithChild())
   {
-    sourceControl[Dali::Actor::Property::VISIBLE] = true;
+    waitingControl[Dali::Actor::Property::VISIBLE] = true;
   }
   else
   {
-    GetImplementation(sourceControl).SetTransparent(false);
+    GetImplementation(waitingControl).SetTransparent(false);
   }
 }
 
+Dali::Toolkit::Control Transition::GetTargetControl()
+{
+  Dali::Toolkit::Control target = mUseDestinationTarget ? mDestinationControl.GetHandle() : mSourceControl.GetHandle();
+  return target;
+}
+
+Dali::Toolkit::Control Transition::GetWaitingControl()
+{
+  Dali::Toolkit::Control waitingControl = mUseDestinationTarget ? mSourceControl.GetHandle() : mDestinationControl.GetHandle();
+  return waitingControl;
+}
+
 } // namespace Internal
 
 } // namespace Toolkit
Domain: Graphics System / DALi;