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   // Movable
  68
  69   /**
  70    * Move constructor.
  71    *
  72    * @param[in] other The object to move the data from
  73    *
  74    * @note The other's actor is appropriately disconnected.
  75    * @note Ownership of callback is passed onto this class.
  76    */
  77   ActorObserver( ActorObserver&& other );
  78
  79   /**
  80    * Move assignment operator.
  81    *
  82    * @param[in] other The object to move the data from
  83    *
  84    * @note The other's actor is appropriately disconnected.
  85    * @note Ownership of callback is passed onto this class.
  86    */
  87   ActorObserver& operator=( ActorObserver&& other );
  88
  89   // Not copyable
  90
  91   ActorObserver( const ActorObserver& ) = delete;   ///< Deleted copy constructor.
  92   ActorObserver& operator=( const ActorObserver& ) = delete;   ///< Deleted copy assignment operator.
  93
  94   // Methods
  95
  96   /**
  97    * Return the stored Actor pointer.
  98    * @return The Actor pointer.
  99    * @note Returns nullptr while the observed actor is not on the scene.
 100    */
 101   Actor* GetActor() const;
 102
 103   /**
 104    * Assignment operator.
 105    * This disconnects the required signals from the currently set actor and connects to the required
 106    * signals for the the actor specified (if set).
 107    */
 108   void SetActor( Actor* actor );
 109
 110   /**
 111    * Resets the set actor and disconnects any connected signals.
 112    */
 113   void ResetActor();
 114
 115 private:
 116
 117   /**
 118    * This will be called if an actor is added to the scene.
 119    * @param[in] object The object object.
 120    * @see Object::Observer::SceneObjectAdded()
 121    */
 122   virtual void SceneObjectAdded( Object& object );
 123
 124   /**
 125    * This will be called when the actor is removed from the scene.
 126    * @param[in] object The object object.
 127    * @see Object::Observer::SceneObjectRemoved()
 128    */
 129   virtual void SceneObjectRemoved( Object& object );
 130
 131   /**
 132    * This will be called when the actor is destroyed. We should clear the actor.
 133    * No need to stop observing as the object is being destroyed anyway.
 134    * @see Object::Observer::ObjectDestroyed()
 135    */
 136   virtual void ObjectDestroyed( Object& object );
 137
 138 private:
 139   Actor* mActor;                 ///< Raw pointer to an Actor.
 140   bool  mActorDisconnected;      ///< Indicates whether the actor has been disconnected from the scene
 141   CallbackBase* mRemoveCallback; ///< Callback to call when the observed actor is removed from the scene
 142 };
 143
 144 } // namespace Internal
 145
 146 } // namespace Dali
 147
 148 #endif // DALI_INTERNAL_ACTOR_OBSERVER_H
 149