dali/devel-api/signals/signal-delegate.h

   1 #ifndef DALI_SIGNAL_DELEGATE_H
   2 #define DALI_SIGNAL_DELEGATE_H
   3
   4 /*
   5  * Copyright (c) 2020 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/actors/actor.h>
  23 #include <dali/public-api/signals/connection-tracker-interface.h>
  24
  25 namespace Dali
  26 {
  27 /**
  28  * @brief The SignalDelegate object allows direct connection to a signal that has been pre-configured internally.
  29  *
  30  * EG: The SignalDelegate can be created internally and exposed to the application-developer.
  31  * They can then call the connect function to transparently bind to their callback.
  32  */
  33 class DALI_CORE_API SignalDelegate
  34 {
  35 public:
  36   /**
  37    * @brief Create and set up a signal delegate.
  38    *
  39    * @param[in] connectActor The actor whose signal should be connected to.
  40    * @param[in] signalName The name of the signal within the actor to connect to.
  41    */
  42   SignalDelegate(Dali::Actor connectActor, const std::string& signalName);
  43
  44   /**
  45    * @brief Destructor.
  46    */
  47   ~SignalDelegate()
  48   {
  49   }
  50
  51 public:
  52   /**
  53    * @brief Connect to a FunctorDelegate as received from a type-registry signal connection call.
  54    *
  55    * This is required to allow connection to an actor's signal. Typically this is done in a generic
  56    * way (IE. via a string of the signal name) using the ConnectSignal function.
  57    * This function requires a functor.
  58    *
  59    * @param[in] connectionTracker Passed in to the ConnectSignal function of the actor.
  60    * @param[in] functorDelegate A functor delegate object that must be executed when the signal is emitted.
  61    * @return    True of the connection was made, false otherwise.
  62    */
  63   bool Connect(ConnectionTrackerInterface* connectionTracker, FunctorDelegate* functorDelegate)
  64   {
  65     if(!mIsConnected)
  66     {
  67       // Note: We have to new the CallbackBaseFunctor rather than have it as a concrete object, as it
  68       // is converted to a FunctorDelegate again within ConnectSignal. FunctorDelegates gain ownership
  69       // of any functor they are created from and therefore always attempt to delete them.
  70       CallbackBaseFunctor* callbackFunctor = new CallbackBaseFunctor(new CallbackFunctorDelegate0(functorDelegate));
  71       mConnectActor.ConnectSignal(connectionTracker, mSignalName, *callbackFunctor);
  72       mIsConnected = true;
  73
  74       return true;
  75     }
  76
  77     return false;
  78   }
  79
  80   /**
  81    * @brief Connect to a non-static member function.
  82    *
  83    * The object that owns the member function must also inherit from ConnectionTracker.
  84    *
  85    * @param[in] object Object instance that houses the supplied member-function.
  86    * @param[in] memberFunction The member-function to call when the signal is emitted.
  87    * @return    True of the connection was made, false otherwise.
  88    */
  89   template<class T>
  90   bool Connect(T* object, void (T::*memberFunction)(void))
  91   {
  92     if(!mIsConnected)
  93     {
  94       CallbackBaseFunctor* callbackFunctor = new CallbackBaseFunctor(MakeCallback(object, memberFunction));
  95       mConnectActor.ConnectSignal(object, mSignalName, *callbackFunctor);
  96       mIsConnected = true;
  97
  98       return true;
  99     }
 100
 101     return false;
 102   }
 103
 104   /**
 105    * @brief Checks if this delegate has been connected yet, so it can be determined if it
 106    * can be used or a new delegate must be created to set up a new connection (to the same signal).
 107    *
 108    * @return True if this SignalDelegate has been connected to it's signal.
 109    */
 110   bool IsConnected();
 111
 112 private:
 113   /**
 114    * This functor is used by SignalDelegate in order to callback to a non-static member function
 115    * (after it has been converted to a CallbackBase).
 116    * The functor can be passed in to a ConnectSignal function of a BaseHandle and call into an
 117    * object's member function on despatch.
 118    */
 119   struct CallbackBaseFunctor
 120   {
 121     /**
 122      * @brief Create and initialise the functor with the callback to be called.
 123      *
 124      * @param[in] callback A CallbackBase which can be created from a member function, or a FunctorDelegate.
 125      */
 126     CallbackBaseFunctor(CallbackBase* callback);
 127
 128     /**
 129      * @brief Executes the functor.
 130      */
 131     void operator()();
 132
 133     /**
 134      * Destructor.
 135      * Note that as this is passed in to a ConnectSignal method, it is converted to a FunctorDelegate.
 136      * This means that this functor will automatically have it's destructor called, but we still own
 137      * the CallbackBase, which must be destroyed manually here.
 138      */
 139     ~CallbackBaseFunctor();
 140
 141   private:
 142     CallbackBase* mCallback; ///< Stores (and owns) the callback to be called on execution.
 143   };
 144
 145 private:
 146   /**
 147    * @brief Not defined.
 148    */
 149   SignalDelegate(const SignalDelegate& rhs);
 150
 151   /**
 152    * @brief Not defined.
 153    */
 154   const SignalDelegate& operator=(const SignalDelegate& rhs);
 155
 156 private:
 157   bool        mIsConnected;  ///< Boolean to know if it is connected already.
 158   Dali::Actor mConnectActor; ///< The actor owning the signal to connect to.
 159   std::string mSignalName;   ///< The name of the signal to connect to.
 160 };
 161
 162 } // namespace Dali
 163
 164 #endif // DALI_SIGNAL_DELEGATE_H