dali/internal/event/events/actor-observer.h

   1 #ifndef DALI_INTERNAL_ACTOR_OBSERVER_H
   2 #define DALI_INTERNAL_ACTOR_OBSERVER_H
   3
   4 /*
   5  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/signals/callback.h>
  23 #include <dali/internal/event/common/object-impl.h>
  24
  25 namespace Dali
  26 {
  27
  28 namespace Internal
  29 {
  30
  31 class Actor;
  32
  33 /**
  34  * Stores an actor pointer and connects/disconnects to any required signals appropriately when set/unset.
  35  */
  36 struct ActorObserver : public Object::Observer
  37 {
  38 public:
  39
  40   // Construction & Destruction
  41
  42   /**
  43    * Constructor.
  44    */
  45   ActorObserver();
  46
  47   /**
  48    * Constructor with a callback which is called when the observed actor is removed from the scene.
  49    *
  50    * The callback should have the following signature:
  51    * @code
  52    * void MyCallback( Actor* actor );
  53    * @endcode
  54    * Where actor is a pointer to the object that has been removed from the scene.
  55    *
  56    * @param[in]  callback  The callback to connect to.
  57    *
  58    * @note Ownership of callback is passed onto this class.
  59    */
  60   ActorObserver( CallbackBase* callback );
  61
  62   /**
  63    * Non virtual destructor
  64    */
  65   ~ActorObserver();
  66
  67   // Methods
  68
  69   /**
  70    * Return the stored Actor pointer.
  71    * @return The Actor pointer.
  72    */
  73   Actor* GetActor();
  74
  75   /**
  76    * Assignment operator.
  77    * This disconnects the required signals from the currently set actor and connects to the required
  78    * signals for the the actor specified (if set).
  79    */
  80   void SetActor( Actor* actor );
  81
  82   /**
  83    * Resets the set actor and disconnects any connected signals.
  84    */
  85   void ResetActor();
  86
  87 private:
  88
  89   // Undefined
  90   ActorObserver( const ActorObserver& );
  91   ActorObserver& operator=( const ActorObserver& );
  92
  93 private:
  94
  95   /**
  96    * This will never get called as we do not observe objects that have not been added to the scene.
  97    * @param[in] object The object object.
  98    * @see Object::Observer::SceneObjectAdded()
  99    */
 100   virtual void SceneObjectAdded(Object& object) { }
 101
 102   /**
 103    * This will be called when the actor is removed from the stage, we should clear and stop
 104    * observing it.
 105    * @param[in] object The object object.
 106    * @see Object::Observer::SceneObjectRemoved()
 107    */
 108   virtual void SceneObjectRemoved(Object& object);
 109
 110   /**
 111    * This will be called when the actor is destroyed. We should clear the actor.
 112    * No need to stop observing as the object is being destroyed anyway.
 113    * @see Object::Observer::ObjectDestroyed()
 114    */
 115   virtual void ObjectDestroyed(Object& object);
 116
 117 private:
 118   Actor* mActor;                 ///< Raw pointer to an Actor.
 119   bool  mActorDisconnected;      ///< Indicates whether the actor has been disconnected from the scene
 120   CallbackBase* mRemoveCallback; ///< Callback to call when the observed actor is removed from the scene
 121 };
 122
 123 } // namespace Internal
 124
 125 } // namespace Dali
 126
 127 #endif // DALI_INTERNAL_ACTOR_OBSERVER_H
 128