dali/internal/event/animation/active-constraint-base.cpp

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 // CLASS HEADER
  18 #include <dali/internal/event/animation/active-constraint-base.h>
  19
  20 // INTERNAL INCLUDES
  21 #include <dali/public-api/animation/active-constraint.h>
  22 #include <dali/public-api/object/handle.h>
  23 #include <dali/public-api/object/type-registry.h>
  24 #include <dali/internal/common/event-to-update.h>
  25 #include <dali/internal/event/animation/animation-impl.h>
  26 #include <dali/internal/update/common/animatable-property.h>
  27 #include <dali/internal/update/animation/scene-graph-constraint-base.h>
  28 #include <dali/internal/update/common/property-owner-messages.h>
  29
  30 using Dali::Internal::SceneGraph::AnimatableProperty;
  31
  32 namespace Dali
  33 {
  34
  35 const Property::Index ActiveConstraint::WEIGHT = 0;
  36
  37 namespace Internal
  38 {
  39
  40 namespace // unnamed namespace
  41 {
  42
  43 BaseHandle Create()
  44 {
  45   // not directly creatable
  46   return BaseHandle();
  47 }
  48
  49 TypeRegistration mType( typeid(Dali::ActiveConstraint), typeid(Dali::Handle), Create );
  50
  51 SignalConnectorType signalConnector1( mType, Dali::ActiveConstraint::SIGNAL_APPLIED, &ActiveConstraintBase::DoConnectSignal );
  52
  53 }
  54
  55
  56 namespace // unnamed namespace
  57 {
  58
  59 /**
  60  * We want to discourage the use of property strings (minimize string comparisons),
  61  * particularly for the default properties.
  62  */
  63 const std::string DEFAULT_PROPERTY_NAMES[] =
  64 {
  65   "weight"
  66 };
  67 const int DEFAULT_PROPERTY_COUNT = sizeof( DEFAULT_PROPERTY_NAMES ) / sizeof( std::string );
  68
  69 const Property::Type DEFAULT_PROPERTY_TYPES[DEFAULT_PROPERTY_COUNT] =
  70 {
  71   Property::FLOAT // WEIGHT
  72 };
  73
  74 } // unnamed namespace
  75
  76 ActiveConstraintBase::ActiveConstraintBase( EventToUpdate& eventToUpdate, Property::Index targetPropertyIndex )
  77 : mEventToUpdate( eventToUpdate ),
  78   mTargetPropertyIndex( targetPropertyIndex ),
  79   mTargetProxy( NULL ),
  80   mSceneGraphConstraint( NULL ),
  81   mOffstageWeight( Dali::ActiveConstraint::DEFAULT_WEIGHT ),
  82   mRemoveTime( 0.0f ),
  83   mAlphaFunction( Dali::Constraint::DEFAULT_ALPHA_FUNCTION ),
  84   mRemoveAction( Dali::Constraint::DEFAULT_REMOVE_ACTION ),
  85   mApplyAnimation(),
  86   mRemoveAnimation()
  87 {
  88 }
  89
  90 ActiveConstraintBase::~ActiveConstraintBase()
  91 {
  92   // Disconnect from internal animation signals
  93
  94   if ( mApplyAnimation )
  95   {
  96     GetImplementation(mApplyAnimation).SetFinishedCallback( NULL, NULL );
  97   }
  98
  99   if( mRemoveAnimation )
 100   {
 101     GetImplementation(mRemoveAnimation).SetFinishedCallback( NULL, NULL );
 102   }
 103 }
 104
 105 void ActiveConstraintBase::FirstApply( ProxyObject& parent, TimePeriod applyTime, ActiveConstraintCallbackType* callback )
 106 {
 107   // Notify derived classes
 108   OnFirstApply( parent );
 109
 110   if ( applyTime.durationSeconds > 0.0f )
 111   {
 112     DALI_ASSERT_DEBUG( !mApplyAnimation );
 113
 114     // Set start weight
 115     SetWeight( 0.0f );
 116
 117     // Automatically animate (increase) the weight, until the constraint is fully applied
 118     mApplyAnimation = Dali::Animation::New( applyTime.delaySeconds + applyTime.durationSeconds );
 119     Dali::ActiveConstraint self( this );
 120     mApplyAnimation.AnimateTo( Property( self, Dali::ActiveConstraint::WEIGHT ), Dali::ActiveConstraint::FINAL_WEIGHT, mAlphaFunction, applyTime );
 121     mApplyAnimation.Play();
 122
 123     // Chain "Finish" to "Applied" signal
 124     GetImplementation(mApplyAnimation).SetFinishedCallback( &ActiveConstraintBase::FirstApplyFinished, this );
 125   }
 126 }
 127
 128 void ActiveConstraintBase::BeginRemove()
 129 {
 130   // Notify derived classes
 131   OnBeginRemove();
 132
 133   // Remove gradually by animating weight down to zero
 134   if ( mRemoveTime.durationSeconds > 0.0f )
 135   {
 136     // Stop baking behaviour from interfering with remove animation
 137     if ( mSceneGraphConstraint )
 138     {
 139       // Immediately remove from scene-graph
 140       SetRemoveActionMessage( mEventToUpdate, *mSceneGraphConstraint, Dali::Constraint::Discard );
 141     }
 142
 143     // Interrupt ongoing apply-animations
 144     if ( mApplyAnimation )
 145     {
 146       mApplyAnimation.Stop();
 147     }
 148
 149     // Reduce the weight to zero
 150     mRemoveAnimation = Dali::Animation::New( mRemoveTime.delaySeconds + mRemoveTime.durationSeconds );
 151     Dali::ActiveConstraint self( this );
 152     mRemoveAnimation.AnimateTo( Property( self, Dali::ActiveConstraint::WEIGHT ), 0.0f, mAlphaFunction, mRemoveTime );
 153     mRemoveAnimation.Play();
 154
 155     // Finish removal when animation ends
 156     GetImplementation(mRemoveAnimation).SetFinishedCallback( &ActiveConstraintBase::OnRemoveFinished, this );
 157   }
 158   else
 159   {
 160     OnRemoveFinished( this );
 161   }
 162 }
 163
 164 bool ActiveConstraintBase::IsRemoving()
 165 {
 166   return mRemoveAnimation;
 167 }
 168
 169 ProxyObject* ActiveConstraintBase::GetParent()
 170 {
 171   return mTargetProxy;
 172 }
 173
 174 bool ActiveConstraintBase::Supports( Capability capability ) const
 175 {
 176   return false; // switch-off support for dynamic properties
 177 }
 178
 179 Dali::Handle ActiveConstraintBase::GetTargetObject()
 180 {
 181   return Dali::Handle( mTargetProxy );
 182 }
 183
 184 Property::Index ActiveConstraintBase::GetTargetProperty()
 185 {
 186   return mTargetPropertyIndex;
 187 }
 188
 189 void ActiveConstraintBase::SetWeight( float weight )
 190 {
 191   if ( mSceneGraphConstraint )
 192   {
 193     BakeWeightMessage( mEventToUpdate, *mSceneGraphConstraint, weight );
 194   }
 195   else
 196   {
 197     mOffstageWeight = weight;
 198   }
 199 }
 200
 201 float ActiveConstraintBase::GetCurrentWeight() const
 202 {
 203   float currentWeight( mOffstageWeight );
 204
 205   if ( mSceneGraphConstraint )
 206   {
 207     currentWeight = mSceneGraphConstraint->GetWeight( mEventToUpdate.GetEventBufferIndex() );
 208   }
 209
 210   return currentWeight;
 211 }
 212
 213 ActiveConstraintSignalV2& ActiveConstraintBase::AppliedSignal()
 214 {
 215   return mAppliedSignal;
 216 }
 217
 218 bool ActiveConstraintBase::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 219 {
 220   bool connected( true );
 221   ActiveConstraintBase* constraint = dynamic_cast<ActiveConstraintBase*>(object);
 222
 223   if ( Dali::ActiveConstraint::SIGNAL_APPLIED == signalName )
 224   {
 225     constraint->AppliedSignal().Connect( tracker, functor );
 226   }
 227   else
 228   {
 229     // signalName does not match any signal
 230     connected = false;
 231   }
 232
 233   return connected;
 234 }
 235
 236 void ActiveConstraintBase::SetRemoveTime( TimePeriod removeTime )
 237 {
 238   mRemoveTime = removeTime;
 239 }
 240
 241 TimePeriod ActiveConstraintBase::GetRemoveTime() const
 242 {
 243   return mRemoveTime;
 244 }
 245
 246 void ActiveConstraintBase::SetAlphaFunction( AlphaFunction alphaFunc )
 247 {
 248   mAlphaFunction = alphaFunc;
 249 }
 250
 251 AlphaFunction ActiveConstraintBase::GetAlphaFunction() const
 252 {
 253   return mAlphaFunction;
 254 }
 255
 256 void ActiveConstraintBase::SetRemoveAction( ActiveConstraintBase::RemoveAction action )
 257 {
 258   mRemoveAction = action;
 259 }
 260
 261 ActiveConstraintBase::RemoveAction ActiveConstraintBase::GetRemoveAction() const
 262 {
 263   return mRemoveAction;
 264 }
 265
 266 bool ActiveConstraintBase::IsSceneObjectRemovable() const
 267 {
 268   return true; // The constraint removed when target SceneGraph::PropertyOwner is destroyed
 269 }
 270
 271 unsigned int ActiveConstraintBase::GetDefaultPropertyCount() const
 272 {
 273   return DEFAULT_PROPERTY_COUNT;
 274 }
 275
 276 const std::string& ActiveConstraintBase::GetDefaultPropertyName( Property::Index index ) const
 277 {
 278   // ProxyObject guarantees that index is within range
 279   return DEFAULT_PROPERTY_NAMES[index];
 280 }
 281
 282 Property::Index ActiveConstraintBase::GetDefaultPropertyIndex( const std::string& name ) const
 283 {
 284   Property::Index index = Property::INVALID_INDEX;
 285
 286   // Only one name to compare with...
 287   if ( name == DEFAULT_PROPERTY_NAMES[0] )
 288   {
 289     index = 0;
 290   }
 291
 292   return index;
 293 }
 294
 295 bool ActiveConstraintBase::IsDefaultPropertyWritable( Property::Index index ) const
 296 {
 297   return true; // All default properties are currently writable
 298 }
 299
 300 bool ActiveConstraintBase::IsDefaultPropertyAnimatable( Property::Index index ) const
 301 {
 302   return true; // All default properties are currently animatable
 303 }
 304
 305 Property::Type ActiveConstraintBase::GetDefaultPropertyType( Property::Index index ) const
 306 {
 307   // ProxyObject guarantees that index is within range
 308   return DEFAULT_PROPERTY_TYPES[index];
 309 }
 310
 311 void ActiveConstraintBase::SetDefaultProperty( Property::Index index, const Property::Value& propertyValue )
 312 {
 313   // ProxyObject guarantees the property is writable and index is in range
 314   switch ( index )
 315   {
 316     case Dali::ActiveConstraint::WEIGHT:
 317     {
 318       SetWeight( propertyValue.Get<float>() );
 319       break;
 320     }
 321
 322     default:
 323     {
 324       DALI_ASSERT_ALWAYS( false && "ActiveConstraint property out of bounds" ); // should not come here
 325       break;
 326     }
 327   }
 328 }
 329
 330 void ActiveConstraintBase::SetCustomProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value )
 331 {
 332   DALI_ASSERT_ALWAYS( false && "ActiveConstraintBase does not have custom properties"); // should not come here
 333 }
 334
 335 Property::Value ActiveConstraintBase::GetDefaultProperty( Property::Index index ) const
 336 {
 337   Property::Value value;
 338
 339   // ProxyObject guarantees that index is within range
 340   switch ( index )
 341   {
 342     case Dali::ActiveConstraint::WEIGHT:
 343     {
 344       value = GetCurrentWeight();
 345       break;
 346     }
 347
 348     default:
 349     {
 350       DALI_ASSERT_ALWAYS( false && "ActiveConstraint property out of bounds" ); // should not come here
 351       break;
 352     }
 353   }
 354
 355   return value;
 356 }
 357
 358 void ActiveConstraintBase::InstallSceneObjectProperty( SceneGraph::PropertyBase& newProperty, const std::string& name, unsigned int index )
 359 {
 360   DALI_ASSERT_ALWAYS( false && "ActiveConstraintBase does not have custom properties" ); // should not come here
 361 }
 362
 363 const SceneGraph::PropertyOwner* ActiveConstraintBase::GetSceneObject() const
 364 {
 365   return mSceneGraphConstraint;
 366 }
 367
 368 const SceneGraph::PropertyBase* ActiveConstraintBase::GetSceneObjectAnimatableProperty( Property::Index index ) const
 369 {
 370   DALI_ASSERT_DEBUG( 0 == index ); // only 1 property supported
 371
 372   // This method should only return a property which is part of the scene-graph
 373   if ( !mSceneGraphConstraint )
 374   {
 375     return NULL;
 376   }
 377
 378   return &mSceneGraphConstraint->mWeight;
 379 }
 380
 381 const PropertyInputImpl* ActiveConstraintBase::GetSceneObjectInputProperty( Property::Index index ) const
 382 {
 383   DALI_ASSERT_DEBUG( 0 == index ); // only 1 property supported
 384
 385   // This method should only return a property which is part of the scene-graph
 386   if ( !mSceneGraphConstraint )
 387   {
 388     return NULL;
 389   }
 390
 391   return &mSceneGraphConstraint->mWeight;
 392 }
 393
 394 void ActiveConstraintBase::FirstApplyFinished( Object* object )
 395 {
 396   ActiveConstraintBase& self = dynamic_cast<ActiveConstraintBase&>( *object );
 397
 398   // This is necessary when the constraint was not added to scene-graph during the animation
 399   self.SetWeight( Dali::ActiveConstraint::FINAL_WEIGHT );
 400
 401   // The animation is no longer needed
 402   GetImplementation(self.mApplyAnimation).SetFinishedCallback( NULL, NULL );
 403   self.mApplyAnimation.Reset();
 404
 405   // Chain "Finish" to "Applied" signal
 406
 407   if ( !self.mAppliedSignal.Empty() )
 408   {
 409     Dali::ActiveConstraint handle( &self );
 410
 411     self.mAppliedSignal.Emit( handle );
 412   }
 413
 414   // WARNING - this constraint may now have been deleted; don't do anything else here
 415 }
 416
 417 void ActiveConstraintBase::OnRemoveFinished( Object* object )
 418 {
 419   ActiveConstraintBase& self = dynamic_cast<ActiveConstraintBase&>( *object );
 420
 421   const SceneGraph::PropertyOwner* propertyOwner = self.mTargetProxy ? self.mTargetProxy->GetSceneObject() : NULL;
 422
 423   if ( propertyOwner &&
 424        self.mSceneGraphConstraint )
 425   {
 426     // Notify base class that the scene-graph constraint is being removed
 427     self.OnSceneObjectRemove();
 428
 429     // Remove from scene-graph
 430     RemoveConstraintMessage( self.mEventToUpdate, *propertyOwner, *(self.mSceneGraphConstraint) );
 431
 432     // mSceneGraphConstraint will be deleted in update-thread, remove dangling pointer
 433     self.mSceneGraphConstraint = NULL;
 434   }
 435
 436   // The animation is no longer needed
 437   self.mRemoveAnimation.Reset();
 438 }
 439
 440 } // namespace Internal
 441
 442 } // namespace Dali