1 #ifndef DALI_SIGNAL_DELEGATE_H
2 #define DALI_SIGNAL_DELEGATE_H
5 * Copyright (c) 2020 Samsung Electronics Co., Ltd.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 #include <dali/public-api/actors/actor.h>
23 #include <dali/public-api/signals/connection-tracker-interface.h>
28 * @brief The SignalDelegate object allows direct connection to a signal that has been pre-configured internally.
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.
33 class DALI_CORE_API SignalDelegate
37 * @brief Create and set up a signal delegate.
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.
42 SignalDelegate(Dali::Actor connectActor, const std::string& signalName);
47 ~SignalDelegate() = default;
51 * @brief Connect to a FunctorDelegate as received from a type-registry signal connection call.
53 * This is required to allow connection to an actor's signal. Typically this is done in a generic
54 * way (IE. via a string of the signal name) using the ConnectSignal function.
55 * This function requires a functor.
57 * @param[in] connectionTracker Passed in to the ConnectSignal function of the actor.
58 * @param[in] functorDelegate A functor delegate object that must be executed when the signal is emitted.
59 * @return True of the connection was made, false otherwise.
61 bool Connect(ConnectionTrackerInterface* connectionTracker, FunctorDelegate* functorDelegate)
65 // Note: We have to new the CallbackBaseFunctor rather than have it as a concrete object, as it
66 // is converted to a FunctorDelegate again within ConnectSignal. FunctorDelegates gain ownership
67 // of any functor they are created from and therefore always attempt to delete them.
68 CallbackBaseFunctor* callbackFunctor = new CallbackBaseFunctor(new CallbackFunctorDelegate0(functorDelegate));
69 mConnectActor.ConnectSignal(connectionTracker, mSignalName, *callbackFunctor);
79 * @brief Connect to a non-static member function.
81 * The object that owns the member function must also inherit from ConnectionTracker.
83 * @param[in] object Object instance that houses the supplied member-function.
84 * @param[in] memberFunction The member-function to call when the signal is emitted.
85 * @return True of the connection was made, false otherwise.
88 bool Connect(T* object, void (T::*memberFunction)(void))
92 CallbackBaseFunctor* callbackFunctor = new CallbackBaseFunctor(MakeCallback(object, memberFunction));
93 mConnectActor.ConnectSignal(object, mSignalName, *callbackFunctor);
103 * @brief Checks if this delegate has been connected yet, so it can be determined if it
104 * can be used or a new delegate must be created to set up a new connection (to the same signal).
106 * @return True if this SignalDelegate has been connected to it's signal.
112 * This functor is used by SignalDelegate in order to callback to a non-static member function
113 * (after it has been converted to a CallbackBase).
114 * The functor can be passed in to a ConnectSignal function of a BaseHandle and call into an
115 * object's member function on despatch.
117 struct CallbackBaseFunctor
120 * @brief Create and initialise the functor with the callback to be called.
122 * @param[in] callback A CallbackBase which can be created from a member function, or a FunctorDelegate.
124 CallbackBaseFunctor(CallbackBase* callback);
127 * @brief Executes the functor.
133 * Note that as this is passed in to a ConnectSignal method, it is converted to a FunctorDelegate.
134 * This means that this functor will automatically have it's destructor called, but we still own
135 * the CallbackBase, which must be destroyed manually here.
137 ~CallbackBaseFunctor();
140 CallbackBase* mCallback; ///< Stores (and owns) the callback to be called on execution.
145 * @brief Not defined.
147 SignalDelegate(const SignalDelegate& rhs);
150 * @brief Not defined.
152 const SignalDelegate& operator=(const SignalDelegate& rhs);
155 bool mIsConnected; ///< Boolean to know if it is connected already.
156 Dali::Actor mConnectActor; ///< The actor owning the signal to connect to.
157 std::string mSignalName; ///< The name of the signal to connect to.
162 #endif // DALI_SIGNAL_DELEGATE_H