Merge remote-tracking branch 'origin/tizen' into new_text
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / public-api / controls / control-impl.h
1 #ifndef __DALI_TOOLKIT_CONTROL_IMPL_H__
2 #define __DALI_TOOLKIT_CONTROL_IMPL_H__
3
4 /*
5  * Copyright (c) 2014 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 // EXTERNAL INCLUDES
22 #include <dali/public-api/adaptor-framework/style-change.h>
23 #include <dali/public-api/common/vector-wrapper.h>
24 #include <dali/public-api/events/long-press-gesture.h>
25 #include <dali/public-api/events/pan-gesture.h>
26 #include <dali/public-api/events/pinch-gesture.h>
27 #include <dali/public-api/events/tap-gesture.h>
28 #include <dali/public-api/object/property-index-ranges.h>
29 #include <dali/public-api/object/type-info.h>
30
31 // INTERNAL INCLUDES
32 #include <dali-toolkit/public-api/controls/control.h>
33
34 namespace Dali
35 {
36
37 namespace Toolkit
38 {
39
40 class StyleManager;
41
42 namespace Internal DALI_INTERNAL
43 {
44 class RelayoutControllerImpl;
45 class KeyInputFocusManager;
46 }
47
48 typedef std::pair< Actor, Vector2 > ActorSizePair;       ///< Pair of actor and size
49 typedef std::vector< ActorSizePair > ActorSizeContainer; ///< Container of actors and their sizes
50
51 namespace Internal
52 {
53
54 /**
55  * @brief This is the internal base class for all controls.
56  *
57  * It will provide some common functionality required by all controls.
58  * Implements ConnectionTrackerInterface so that signals (typically connected to member functions) will
59  * be disconnected automatically when the control is destroyed.
60  */
61 class DALI_IMPORT_API Control : public CustomActorImpl, public ConnectionTrackerInterface
62 {
63 public:
64
65   // Creation & Destruction
66
67   /**
68    * @brief Create a new ControlImpl instance that does not require touch by default.
69    *
70    * If touch is required then the user can connect to this class' touch signal.
71    * @return A handle to the ControlImpl instance.
72    */
73   static Toolkit::Control New();
74
75   /**
76    * @brief Virtual destructor.
77    */
78   virtual ~Control();
79
80   // Size negotiation
81
82   /**
83    * @copydoc Toolkit::Control::SetSizePolicy()
84    */
85   void SetSizePolicy( Toolkit::Control::SizePolicy widthPolicy, Toolkit::Control::SizePolicy heightPolicy );
86
87   /**
88    * @copydoc Toolkit::Control::GetSizePolicy()
89    */
90   void GetSizePolicy( Toolkit::Control::SizePolicy& widthPolicy, Toolkit::Control::SizePolicy& heightPolicy ) const;
91
92   /**
93    * @copydoc Toolkit::Control::SetMinimumSize()
94    */
95   void SetMinimumSize( const Vector3& size );
96
97   /**
98    * @copydoc Toolkit::Control::GetMinimumSize()
99    */
100   const Vector3& GetMinimumSize() const;
101
102   /**
103    * @copydoc Toolkit::Control::SetMaximumSize()
104    */
105   void SetMaximumSize( const Vector3& size );
106
107   /**
108    * @copydoc Toolkit::Control::GetMaximumSize()
109    */
110   const Vector3& GetMaximumSize() const;
111
112   /**
113    * @copydoc Toolkit::Control::GetNaturalSize()
114    */
115   virtual Vector3 GetNaturalSize();
116
117   /**
118    * @brief This method is called during size negotiation when a height is required for a given width.
119    *
120    * Derived classes should override this if they wish to customize the height returned.
121    *
122    * @param width to use.
123    * @return the height based on the width.
124    */
125   virtual float GetHeightForWidth( float width );
126
127   /**
128    * @brief This method is called during size negotiation when a width is required for a given height.
129    *
130    * Derived classes should override this if they wish to customize the width returned.
131    *
132    * @param height to use.
133    * @return the width based on the width.
134    */
135   virtual float GetWidthForHeight( float height );
136
137   /**
138    * @brief Retrieves the current Control's size.
139    *
140    * @return The control's size.
141    */
142   const Vector3& GetControlSize() const;
143
144   /**
145    * @brief Retrieves the Control's size set by the Application / Control.
146    *
147    * @return The control's size.
148    */
149   const Vector3& GetSizeSet() const;
150
151   // Key Input
152
153   /**
154    * @copydoc Toolkit::Control::SetKeyInputFocus()
155    */
156   void SetKeyInputFocus();
157
158   /**
159    * @copydoc Toolkit::Control::HasKeyInputFocus()
160    */
161   bool HasKeyInputFocus();
162
163   /**
164    * @copydoc Toolkit::Control::ClearKeyInputFocus()
165    */
166   void ClearKeyInputFocus();
167
168   // Gesture Detection
169
170   /**
171    * @brief If deriving classes wish to fine tune pinch gesture
172    * detection then they can access the gesture detector through this
173    * API and modify the detection.
174    *
175    * @return The pinch gesture detector.
176    * @pre Pinch detection should have been enabled via EnableGestureDetection().
177    * @see EnableGestureDetection
178    */
179   PinchGestureDetector GetPinchGestureDetector() const;
180
181   /**
182    * @brief If deriving classes wish to fine tune pan gesture
183    * detection then they can access the gesture detector through this
184    * API and modify the detection.
185    *
186    * @return The pan gesture detector.
187    * @pre Pan detection should have been enabled via EnableGestureDetection().
188    * @see EnableGestureDetection
189    */
190   PanGestureDetector GetPanGestureDetector() const;
191
192   /**
193    * @brief If deriving classes wish to fine tune tap gesture
194    * detection then they can access the gesture detector through this
195    * API and modify the detection.
196    *
197    * @return The tap gesture detector.
198    * @pre Tap detection should have been enabled via EnableGestureDetection().
199    * @see EnableGestureDetection
200    */
201   TapGestureDetector GetTapGestureDetector() const;
202
203   /**
204    * @brief If deriving classes wish to fine tune long press gesture
205    * detection then they can access the gesture detector through this
206    * API and modify the detection.
207    *
208    * @return The long press gesture detector.
209    * @pre Long press detection should have been enabled via EnableGestureDetection().
210    * @see EnableGestureDetection
211    */
212   LongPressGestureDetector GetLongPressGestureDetector() const;
213
214   // Background
215
216   /**
217    * @copydoc Dali::Toolkit::Control::SetBackgroundColor
218    */
219   void SetBackgroundColor( const Vector4& color );
220
221   /**
222    * @copydoc Dali::Toolkit::Control::GetBackgroundColor
223    */
224   Vector4 GetBackgroundColor() const;
225
226   /**
227    * @copydoc Dali::Toolkit::Control::SetBackground
228    */
229   void SetBackground( Image image );
230
231   /**
232    * @copydoc Dali::Toolkit::Control::ClearBackground
233    */
234   void ClearBackground();
235
236   /**
237    * @copydoc Dali::Toolkit::Control::GetBackgroundActor
238    */
239   Actor GetBackgroundActor() const;
240
241   // Keyboard Navigation
242
243   /**
244    * @brief Sets whether this control supports two dimensional
245    * keyboard navigation (i.e. whether it knows how to handle the
246    * keyboardn focus movement between its child actors).
247    *
248    * The control doesn't support it by default.
249    * @param[in] isSupported Whether this control supports two dimensional keyboard navigation.
250    */
251   void SetKeyboardNavigationSupport(bool isSupported);
252
253   /**
254    * @brief Gets whether this control supports two dimensional keyboard navigation.
255    *
256    * @return true if this control supports two dimensional keyboard navigation.
257    */
258   bool IsKeyboardNavigationSupported();
259
260   // Called by Focus Managers
261
262   /**
263    * @brief Called by the focus manager and keyboard focus manager to Activate the Control
264    */
265   DALI_INTERNAL void Activate();
266
267   /**
268    * @brief This method should be overridden by deriving classes when they wish to respond the accessibility
269    * pan gesture.
270    *
271    * @param[in] gesture The pan gesture.
272    * @return true if the pan gesture has been consumed by this control
273    */
274   virtual bool OnAccessibilityPan(PanGesture gesture);
275
276   /**
277    * @brief This method should be overridden by deriving classes when they wish to respond the accessibility
278    * touch event.
279    *
280    * @param[in] touchEvent The touch event.
281    * @return true if the touch event has been consumed by this control
282    */
283   virtual bool OnAccessibilityTouch(const TouchEvent& touchEvent);
284
285   /**
286    * @brief This method should be overridden by deriving classes when they wish to respond
287    * the accessibility up and down action (i.e. value change of slider control).
288    *
289    * @param[in] isIncrease Whether the value should be increased or decreased
290    * @return true if the value changed action has been consumed by this control
291    */
292   virtual bool OnAccessibilityValueChange(bool isIncrease);
293
294   // Called by the RelayoutController
295
296   /**
297    * @brief Called by the RelayoutController to negotiate the size of a control.
298    *
299    * The size allocated by the the algorithm is passed in which the
300    * control must adhere to.  A container is passed in as well which
301    * the control should populate with actors it has not / or does not
302    * need to handle in its size negotiation.
303    *
304    * @param[in]      size       The allocated size.
305    * @param[in,out]  container  The container that holds actors that are fed back into the
306    *                            RelayoutController algorithm.
307    */
308   DALI_INTERNAL void NegotiateSize( const Vector2& size, ActorSizeContainer& container );
309
310   // Keyboard Focus
311
312   /**
313    * @brief Sets whether this control is a focus group for keyboard navigation.
314    *
315    * (i.e. the scope of keyboard focus movement
316    * can be limitied to its child actors). The control is not a focus group by default.
317    * @param[in] isFocusGroup Whether this control is set as a focus group for keyboard navigation.
318    */
319   void SetAsKeyboardFocusGroup(bool isFocusGroup);
320
321   /**
322    * @brief Gets whether this control is a focus group for keyboard navigation.
323    *
324    * @return true if this control is set as a focus group for keyboard navigation.
325    */
326   bool IsKeyboardFocusGroup();
327
328   /**
329    * @brief Gets the next keyboard focusable actor in this control towards the given direction.
330    *
331    * A control needs to override this function in order to support two dimensional keyboard navigation.
332    * @param[in] currentFocusedActor The current focused actor.
333    * @param[in] direction The direction to move the focus towards.
334    * @param[in] loopEnabled Whether the focus movement should be looped within the control.
335    * @return the next keyboard focusable actor in this control or an empty handle if no actor can be focused.
336    */
337   virtual Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled);
338
339   /**
340    * @brief Informs this control that its chosen focusable actor will be focused.
341    *
342    * This allows the application to preform any actions if wishes
343    * before the focus is actually moved to the chosen actor.
344    *
345    * @param[in] commitedFocusableActor The commited focusable actor.
346    */
347   virtual void OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor);
348
349   // Actions & Signals
350
351   /**
352    * @brief Performs actions as requested using the action name.
353    *
354    * @param[in] object The object on which to perform the action.
355    * @param[in] actionName The action to perform.
356    * @param[in] attributes The attributes with which to perfrom this action.
357    * @return true if action has been accepted by this control
358    */
359   static bool DoAction(BaseObject* object, const std::string& actionName, const PropertyValueContainer& attributes);
360
361   /**
362    * Connects a callback function with the object's signals.
363    * @param[in] object The object providing the signal.
364    * @param[in] tracker Used to disconnect the signal.
365    * @param[in] signalName The signal to connect to.
366    * @param[in] functor A newly allocated FunctorDelegate.
367    * @return True if the signal was connected.
368    * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
369    */
370   static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
371
372   /**
373    * @copydoc Dali::Toolkit::Control::KeyEventSignal()
374    */
375   Toolkit::Control::KeyEventSignalType& KeyEventSignal();
376
377   /**
378    * @brief Called by the KeyInputFocusManager to emit key event signals.
379    *
380    * @param[in] event The key event.
381    * @return True if the event was consumed.
382    */
383   DALI_INTERNAL bool EmitKeyEventSignal(const KeyEvent& event);
384
385 protected:
386
387   // Construction
388
389   // Flags for the constructor
390   enum ControlBehaviour
391   {
392     CONTROL_BEHAVIOUR_NONE        = 0,
393     REQUIRES_TOUCH_EVENTS         = 1<<1,     ///< True if the OnTouchEvent() callback is required.
394     REQUIRES_STYLE_CHANGE_SIGNALS = 1<<2,     ///< True if needs to monitor style change signals such as theme/font change
395     NO_SIZE_NEGOTIATION           = 1<<3,     ///< True if control does not need size negotiation, i.e. it can be skipped in the algorithm
396     REQUIRES_HOVER_EVENTS         = 1<<4,     ///< True if the OnHoverEvent() callback is required.
397     REQUIRES_MOUSE_WHEEL_EVENTS   = 1<<5      ///< True if the OnMouseWheelEvent() callback is required.
398   };
399
400   /**
401    * @brief Create a Control.
402    *
403    * @param[in] behaviourFlags Behavioural flags from ControlBehaviour enum
404    */
405   Control(ControlBehaviour behaviourFlags);
406
407   /**
408    * @brief Second phase initialization.
409    */
410   void Initialize();
411
412   // Gesture Detection
413
414   /**
415    * @brief Allows deriving classes to enable any of the gesture detectors that are available.
416    *
417    * Gesture detection can be enabled one at a time or in bitwise format as shown:
418    * @code
419    * EnableGestureDetection(Gesture::Type(Gesture::Pinch | Gesture::Tap | Gesture::Pan));
420    * @endcode
421    * @param[in]  type  The gesture type(s) to enable.
422    */
423   void EnableGestureDetection(Gesture::Type type);
424
425   /**
426    * @brief Allows deriving classes to disable any of the gesture detectors.
427    *
428    * Like EnableGestureDetection, this can also be called using bitwise or.
429    * @param[in]  type  The gesture type(s) to disable.
430    * @see EnableGetureDetection
431    */
432   void DisableGestureDetection(Gesture::Type type);
433
434   // Size Negotiation
435
436   /**
437    * @brief Request a relayout, which means performing a size negotiation on this control, its parent and children (and potentially whole scene)
438    *
439    * This method is automatically called from OnStageConnection(), OnChildAdd(),
440    * OnChildRemove(), SetSizePolicy(), SetMinimumSize() and SetMaximumSize().
441    *
442    * This method can also be called from a derived class every time it needs a different size.
443    * At the end of event processing, the relayout process starts and
444    * all controls which requested Relayout will have their sizes (re)negotiated.
445    *
446    * @note RelayoutRequest() can be called multiple times; the size negotiation is still
447    * only performed once, i.e. there is no need to keep track of this in the calling side.
448    */
449   void RelayoutRequest();
450
451   /**
452    * @brief Helper method for controls to Relayout their children if
453    * they do not know whether that child is a control or not.
454    *
455    * @param[in]      actor      The actor to relayout.
456    * @param[in]      size       The size to allocate to the actor.
457    * @param[in,out]  container  The container that holds actors that have not been allocated a size yet.
458    */
459   static void Relayout( Actor actor, const Vector2& size, ActorSizeContainer& container );
460
461 private:
462
463   // For derived classes to override
464
465   /**
466    * @brief This method is called after the Control has been initialized.
467    *
468    * Derived classes should do any second phase initialization by overriding this method.
469    */
470   virtual void OnInitialize();
471
472   /**
473    * @brief This method is called when the control is activated.
474    *
475    * Derived classes should override this if they wish to be notified when they are activated.
476    */
477   virtual void OnActivated();
478
479   /**
480    * @brief This method should be overridden by deriving classes requiring notifications when the style changes.
481    *
482    * @param[in] styleManager  The StyleManager object.
483    * @param[in] change  Information denoting what has changed.
484    */
485   virtual void OnStyleChange( Toolkit::StyleManager styleManager, StyleChange change );
486
487   /**
488    * @brief Called whenever a pinch gesture is detected on this control.
489    *
490    * This can be overridden by deriving classes when pinch detection
491    * is enabled.  The default behaviour is to scale the control by the
492    * pinch scale.
493    *
494    * @note If overridden, then the default behaviour will not occur.
495    * @note Pinch detection should be enabled via EnableGestureDetection().
496    * @param[in]  pinch  The pinch gesture.
497    * @see EnableGestureDetection
498    */
499   virtual void OnPinch(const PinchGesture& pinch);
500
501   /**
502    * @brief Called whenever a pan gesture is detected on this control.
503    *
504    * This should be overridden by deriving classes when pan detection
505    * is enabled.
506    *
507    * @note There is no default behaviour with panning.
508    * @note Pan detection should be enabled via EnableGestureDetection().
509    * @param[in]  pan  The pan gesture.
510    * @see EnableGestureDetection
511    */
512   virtual void OnPan( const PanGesture& pan );
513
514   /**
515    * @brief Called whenever a tap gesture is detected on this control.
516    *
517    * This should be overridden by deriving classes when tap detection
518    * is enabled.
519    *
520    * @note There is no default behaviour with a tap.
521    * @note Tap detection should be enabled via EnableGestureDetection().
522    * @param[in]  tap  The tap gesture.
523    * @see EnableGestureDetection
524    */
525   virtual void OnTap( const TapGesture& tap );
526
527   /**
528    * @brief Called whenever a long press gesture is detected on this control.
529    *
530    * This should be overridden by deriving classes when long press
531    * detection is enabled.
532    *
533    * @note There is no default behaviour associated with a long press.
534    * @note Long press detection should be enabled via EnableGestureDetection().
535    * @param[in]  longPress  The long press gesture.
536    * @see EnableGestureDetection
537    */
538   virtual void OnLongPress( const LongPressGesture& longPress );
539
540   /**
541    * @brief Called whenever the control is added to the stage.
542    *
543    * Could be overridden by derived classes.
544    */
545   virtual void OnControlStageConnection();
546
547   /**
548    * @brief Called whenever the control is removed from the stage.
549    *
550    * Could be overridden by derived classes.
551    */
552   virtual void OnControlStageDisconnection();
553
554   /**
555    * @brief Called whenever an Actor is added to the control.
556    *
557    * Could be overridden by derived classes.
558    *
559    * @param[in] child The added actor.
560    */
561   virtual void OnControlChildAdd( Actor& child );
562
563   /**
564    * @brief Called whenever an Actor is removed from the control.
565    *
566    * Could be overridden by derived classes.
567    *
568    * @param[in] child The removed actor.
569    */
570   virtual void OnControlChildRemove( Actor& child );
571
572   /**
573    * @brief Called whenever the Control's size is set.
574    *
575    * Could be overridden by derived classes.
576    *
577    * @param[in] size The new size.
578    */
579   virtual void OnControlSizeSet( const Vector3& size );
580
581   /**
582    * @brief Called after the size negotiation has been finished for this control.
583    *
584    * The control is expected to assign this given size to itself/its children.
585    *
586    * Should be overridden by derived classes if they need to layout
587    * actors differently after certain operations like add or remove
588    * actors, resize or after changing specific properties.
589    *
590    * Note! As this function is called from inside the size negotiation algorithm, you cannot
591    * call RequestRelayout (the call would just be ignored)
592    *
593    * @param[in]      size       The allocated size.
594    * @param[in,out]  container  The control should add actors to this container that it is not able
595    *                            to allocate a size for.
596    */
597   virtual void OnRelayout( const Vector2& size, ActorSizeContainer& container );
598
599   /**
600    * @brief Called when the control gains key input focus.
601    *
602    * Should be overridden by derived classes if they need to customize what happens when focus is gained.
603    */
604   virtual void OnKeyInputFocusGained();
605
606   /**
607    * @brief Called when the control loses key input focus.
608    *
609    * Should be overridden by derived classes if they need to customize what happens when focus is lost.
610    */
611   virtual void OnKeyInputFocusLost();
612
613   // From CustomActorImpl, derived classes can override these.
614
615   /**
616    * @copydoc Dali::CustomActorImpl::OnSizeAnimation(Animation&, const Vector3&)
617    */
618   virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize);
619
620   /**
621    * @copydoc Dali::CustomActorImpl::OnTouchEvent(const TouchEvent&)
622    */
623   virtual bool OnTouchEvent(const TouchEvent& event);
624
625   /**
626    * @copydoc Dali::CustomActorImpl::OnHoverEvent(const HoverEvent&)
627    */
628   virtual bool OnHoverEvent(const HoverEvent& event);
629
630   /**
631    * @copydoc Dali::CustomActorImpl::OnKeyEvent(const KeyEvent&)
632    */
633   virtual bool OnKeyEvent(const KeyEvent& event);
634
635   /**
636    * @copydoc Dali::CustomActorImpl::OnMouseWheelEvent(const MouseWheelEvent&)
637    */
638   virtual bool OnMouseWheelEvent(const MouseWheelEvent& event);
639
640   // From CustomActorImpl, derived classes should NOT override these.
641
642   /**
643    * @brief Sends a request to relayout this control.
644    *
645    * The control will be relaid out after the
646    * Dali::Stage::SignalMessageQueueFlushed() signal is emitted.
647    *
648    * It calls OnControlStageConnection() to notify derived classes.
649    *
650    * @see Dali::CustomActorImpl::OnStageConnection()
651    */
652   virtual void OnStageConnection();
653
654   /**
655    * @brief Calls OnControlStageDisconnection() to notify derived classed.
656    *
657    * @see Dali::CustomActorImpl::OnStageDisconnection()
658    */
659   virtual void OnStageDisconnection();
660
661   /**
662    * @brief Sends a request to relayout this control.
663    *
664    * The control will be relaid out after the
665    * Dali::Stage::SignalMessageQueueFlushed() signal is emitted.  It
666    * calls OnControlChildAdd() to notify derived classes.
667    *
668    * @note This method shouldn't be overridden by derived classes.
669    *
670    * @param[in] child The added actor.
671    *
672    * @see Dali::CustomActorImpl::OnChildAdd(Actor&)
673    */
674   virtual void OnChildAdd(Actor& child);
675
676   /**
677    * @brief Sends a request to relayout this control.
678    *
679    * The control will be relaid out after the
680    * Dali::Stage::SignalMessageQueueFlushed() signal is emitted.  It
681    * calls OnControlChildRemove() to notify derived classes.
682    *
683    * @note This method shouldn't be overridden by derived classes.
684    *
685    * @param[in] child The removed actor.
686    *
687    * @see Dali::CustomActorImpl::OnChildRemove(Actor&)
688    */
689   virtual void OnChildRemove(Actor& child);
690
691   /**
692    * @brief It stores the size set by size negotiation and relayout.
693    *
694    * It also keeps a backup of the size set through the Actor's API used in the size negotiation.
695    * It calls the OnControlSizeSet() to notify derived classes.
696    *
697    * @param[in] targetSize The new size.
698    *
699    * @see Dali::CustomActorImpl::OnSizeSet(const Vector3&)
700    */
701   virtual void OnSizeSet(const Vector3& targetSize);
702
703   // From ConnectionTrackerInterface
704
705   /**
706    * @copydoc ConnectionTrackerInterface::SignalConnected
707    */
708   virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback );
709
710   /**
711    * @copydoc ConnectionTrackerInterface::SignalDisconnected
712    */
713   virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback );
714
715 private:
716
717   // Undefined
718   DALI_INTERNAL Control(const Control&);
719   DALI_INTERNAL Control& operator=(const Control&);
720
721   class Impl;
722   Impl* mImpl;
723
724   friend class Internal::KeyInputFocusManager;     ///< KeyInputFocusManager needs to call several methods which are private. // TODO: Remove
725 };
726
727 } // namespace Internal
728
729 } // namespace Toolkit
730
731 } // namespace Dali
732
733 #endif // __DALI_TOOLKIT_CONTROL_IMPL_H__