18dd3fde2aa4006842c9f4130cc7f9e73e369451
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / public-api / controls / control-impl.cpp
1 /*
2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 // CLASS HEADER
19 #include <dali-toolkit/public-api/controls/control-impl.h>
20
21 // EXTERNAL INCLUDES
22 #include <cstring> // for strcmp
23 #include <limits>
24 #include <stack>
25 #include <typeinfo>
26 #include <dali/public-api/animation/constraint.h>
27 #include <dali/public-api/animation/constraints.h>
28 #include <dali/public-api/object/type-registry.h>
29 #include <dali/public-api/object/type-registry-helper.h>
30 #include <dali/public-api/rendering/renderer.h>
31 #include <dali/public-api/size-negotiation/relayout-container.h>
32 #include <dali/devel-api/common/owner-container.h>
33 #include <dali/devel-api/object/handle-devel.h>
34 #include <dali/devel-api/scripting/enum-helper.h>
35 #include <dali/devel-api/scripting/scripting.h>
36 #include <dali/integration-api/debug.h>
37
38 // INTERNAL INCLUDES
39 #include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
40 #include <dali-toolkit/public-api/controls/control.h>
41 #include <dali-toolkit/public-api/styling/style-manager.h>
42 #include <dali-toolkit/public-api/visuals/color-visual-properties.h>
43 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
44 #include <dali-toolkit/devel-api/controls/control-devel.h>
45 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
46 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
47 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
48 #include <dali-toolkit/internal/styling/style-manager-impl.h>
49 #include <dali-toolkit/internal/visuals/color/color-visual.h>
50 #include <dali-toolkit/internal/visuals/transition-data-impl.h>
51 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
52 #include <dali-toolkit/devel-api/align-enums.h>
53 #include <dali-toolkit/internal/controls/tooltip/tooltip.h>
54
55 namespace Dali
56 {
57
58 namespace Toolkit
59 {
60
61 namespace
62 {
63
64 #if defined(DEBUG_ENABLED)
65 Debug::Filter* gLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_CONTROL_VISUALS");
66 #endif
67
68 DALI_ENUM_TO_STRING_TABLE_BEGIN( CLIPPING_MODE )
69 DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, DISABLED )
70 DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, CLIP_CHILDREN )
71 DALI_ENUM_TO_STRING_TABLE_END( CLIPPING_MODE )
72
73 /**
74  * Struct used to store Visual within the control, index is a unique key for each visual.
75  */
76 struct RegisteredVisual
77 {
78   Property::Index index;
79   Toolkit::Visual::Base visual;
80   bool enabled;
81
82   RegisteredVisual( Property::Index aIndex, Toolkit::Visual::Base &aVisual, bool aEnabled)
83   : index(aIndex), visual(aVisual), enabled(aEnabled)
84   {
85   }
86 };
87
88 typedef Dali::OwnerContainer< RegisteredVisual* > RegisteredVisualContainer;
89
90 /**
91  *  Finds visual in given array, returning true if found along with the iterator for that visual as a out parameter
92  */
93 bool FindVisual( Property::Index targetIndex, RegisteredVisualContainer& visuals, RegisteredVisualContainer::Iterator& iter )
94 {
95   for ( iter = visuals.Begin(); iter != visuals.End(); iter++ )
96   {
97     if ( (*iter)->index ==  targetIndex )
98     {
99       return true;
100     }
101   }
102   return false;
103 }
104
105 Toolkit::Visual::Base GetVisualByName(
106   RegisteredVisualContainer& visuals,
107   const std::string& visualName )
108 {
109   Toolkit::Visual::Base visualHandle;
110
111   RegisteredVisualContainer::Iterator iter;
112   for ( iter = visuals.Begin(); iter != visuals.End(); iter++ )
113   {
114     Toolkit::Visual::Base visual = (*iter)->visual;
115     if( visual && visual.GetName() == visualName )
116     {
117       visualHandle = visual;
118       break;
119     }
120   }
121   return visualHandle;
122 }
123
124 void SetDefaultTransform( Property::Map& propertyMap )
125 {
126   propertyMap.Clear();
127   propertyMap
128     .Add( Toolkit::DevelVisual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f) )
129     .Add( Toolkit::DevelVisual::Transform::Property::SIZE, Vector2(1.0f, 1.0f) )
130     .Add( Toolkit::DevelVisual::Transform::Property::ORIGIN, Toolkit::Align::CENTER )
131     .Add( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT, Toolkit::Align::CENTER )
132     .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_SIZE_MODE, Vector4::ZERO );
133 }
134
135 /**
136  * Creates control through type registry
137  */
138 BaseHandle Create()
139 {
140   return Internal::Control::New();
141 }
142
143 /**
144  * Performs actions as requested using the action name.
145  * @param[in] object The object on which to perform the action.
146  * @param[in] actionName The action to perform.
147  * @param[in] attributes The attributes with which to perfrom this action.
148  * @return true if action has been accepted by this control
149  */
150 const char* ACTION_ACCESSIBILITY_ACTIVATED = "accessibilityActivated";
151 static bool DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes )
152 {
153   bool ret = false;
154
155   if( object && ( 0 == strcmp( actionName.c_str(), ACTION_ACCESSIBILITY_ACTIVATED ) ) )
156   {
157     Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
158     if( control )
159     {
160       // if cast succeeds there is an implementation so no need to check
161       ret = Internal::GetImplementation( control ).OnAccessibilityActivated();
162     }
163   }
164
165   return ret;
166 }
167
168 /**
169  * Connects a callback function with the object's signals.
170  * @param[in] object The object providing the signal.
171  * @param[in] tracker Used to disconnect the signal.
172  * @param[in] signalName The signal to connect to.
173  * @param[in] functor A newly allocated FunctorDelegate.
174  * @return True if the signal was connected.
175  * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
176  */
177 const char* SIGNAL_KEY_EVENT = "keyEvent";
178 const char* SIGNAL_KEY_INPUT_FOCUS_GAINED = "keyInputFocusGained";
179 const char* SIGNAL_KEY_INPUT_FOCUS_LOST = "keyInputFocusLost";
180 const char* SIGNAL_TAPPED = "tapped";
181 const char* SIGNAL_PANNED = "panned";
182 const char* SIGNAL_PINCHED = "pinched";
183 const char* SIGNAL_LONG_PRESSED = "longPressed";
184 static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
185 {
186   Dali::BaseHandle handle( object );
187
188   bool connected( false );
189   Toolkit::Control control = Toolkit::Control::DownCast( handle );
190   if ( control )
191   {
192     Internal::Control& controlImpl( Internal::GetImplementation( control ) );
193     connected = true;
194
195     if ( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT ) )
196     {
197       controlImpl.KeyEventSignal().Connect( tracker, functor );
198     }
199     else if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_INPUT_FOCUS_GAINED ) )
200     {
201       controlImpl.KeyInputFocusGainedSignal().Connect( tracker, functor );
202     }
203     else if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_INPUT_FOCUS_LOST ) )
204     {
205       controlImpl.KeyInputFocusLostSignal().Connect( tracker, functor );
206     }
207     else if( 0 == strcmp( signalName.c_str(), SIGNAL_TAPPED ) )
208     {
209       controlImpl.EnableGestureDetection( Gesture::Tap );
210       controlImpl.GetTapGestureDetector().DetectedSignal().Connect( tracker, functor );
211     }
212     else if( 0 == strcmp( signalName.c_str(), SIGNAL_PANNED ) )
213     {
214       controlImpl.EnableGestureDetection( Gesture::Pan );
215       controlImpl.GetPanGestureDetector().DetectedSignal().Connect( tracker, functor );
216     }
217     else if( 0 == strcmp( signalName.c_str(), SIGNAL_PINCHED ) )
218     {
219       controlImpl.EnableGestureDetection( Gesture::Pinch );
220       controlImpl.GetPinchGestureDetector().DetectedSignal().Connect( tracker, functor );
221     }
222     else if( 0 == strcmp( signalName.c_str(), SIGNAL_LONG_PRESSED ) )
223     {
224       controlImpl.EnableGestureDetection( Gesture::LongPress );
225       controlImpl.GetLongPressGestureDetector().DetectedSignal().Connect( tracker, functor );
226     }
227   }
228   return connected;
229 }
230
231 // Setup signals and actions using the type-registry.
232 DALI_TYPE_REGISTRATION_BEGIN( Control, CustomActor, Create );
233
234 // Note: Properties are registered separately below.
235
236 SignalConnectorType registerSignal1( typeRegistration, SIGNAL_KEY_EVENT, &DoConnectSignal );
237 SignalConnectorType registerSignal2( typeRegistration, SIGNAL_KEY_INPUT_FOCUS_GAINED, &DoConnectSignal );
238 SignalConnectorType registerSignal3( typeRegistration, SIGNAL_KEY_INPUT_FOCUS_LOST, &DoConnectSignal );
239 SignalConnectorType registerSignal4( typeRegistration, SIGNAL_TAPPED, &DoConnectSignal );
240 SignalConnectorType registerSignal5( typeRegistration, SIGNAL_PANNED, &DoConnectSignal );
241 SignalConnectorType registerSignal6( typeRegistration, SIGNAL_PINCHED, &DoConnectSignal );
242 SignalConnectorType registerSignal7( typeRegistration, SIGNAL_LONG_PRESSED, &DoConnectSignal );
243
244 TypeAction registerAction( typeRegistration, ACTION_ACCESSIBILITY_ACTIVATED, &DoAction );
245
246 DALI_TYPE_REGISTRATION_END()
247
248 } // unnamed namespace
249
250 namespace Internal
251 {
252
253 class Control::Impl : public ConnectionTracker
254 {
255 public:
256
257   // Construction & Destruction
258   Impl(Control& controlImpl)
259   : mControlImpl( controlImpl ),
260     mStyleName(""),
261     mBackgroundColor(Color::TRANSPARENT),
262     mStartingPinchScale( NULL ),
263     mKeyEventSignal(),
264     mPinchGestureDetector(),
265     mPanGestureDetector(),
266     mTapGestureDetector(),
267     mLongPressGestureDetector(),
268     mFlags( Control::ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
269     mIsKeyboardNavigationSupported( false ),
270     mIsKeyboardFocusGroup( false )
271   {
272   }
273
274   ~Impl()
275   {
276     // All gesture detectors will be destroyed so no need to disconnect.
277     delete mStartingPinchScale;
278   }
279
280   // Gesture Detection Methods
281
282   void PinchDetected(Actor actor, const PinchGesture& pinch)
283   {
284     mControlImpl.OnPinch(pinch);
285   }
286
287   void PanDetected(Actor actor, const PanGesture& pan)
288   {
289     mControlImpl.OnPan(pan);
290   }
291
292   void TapDetected(Actor actor, const TapGesture& tap)
293   {
294     mControlImpl.OnTap(tap);
295   }
296
297   void LongPressDetected(Actor actor, const LongPressGesture& longPress)
298   {
299     mControlImpl.OnLongPress(longPress);
300   }
301
302   // Properties
303
304   /**
305    * Called when a property of an object of this type is set.
306    * @param[in] object The object whose property is set.
307    * @param[in] index The property index.
308    * @param[in] value The new property value.
309    */
310   static void SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
311   {
312     Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
313
314     if ( control )
315     {
316       Control& controlImpl( GetImplementation( control ) );
317
318       switch ( index )
319       {
320         case Toolkit::Control::Property::STYLE_NAME:
321         {
322           controlImpl.SetStyleName( value.Get< std::string >() );
323           break;
324         }
325
326         case Toolkit::Control::Property::BACKGROUND_COLOR:
327         {
328           DALI_LOG_WARNING( "BACKGROUND_COLOR property is deprecated. Use BACKGROUND property instead\n" );
329           controlImpl.SetBackgroundColor( value.Get< Vector4 >() );
330           break;
331         }
332
333         case Toolkit::Control::Property::BACKGROUND_IMAGE:
334         {
335           DALI_LOG_WARNING( "BACKGROUND_IMAGE property is deprecated. Use BACKGROUND property instead\n" );
336           Image image = Scripting::NewImage( value );
337           if ( image )
338           {
339             controlImpl.SetBackgroundImage( image );
340           }
341           else
342           {
343             // An empty image means the background is no longer required
344             controlImpl.ClearBackground();
345           }
346           break;
347         }
348
349         case Toolkit::Control::Property::KEY_INPUT_FOCUS:
350         {
351           if ( value.Get< bool >() )
352           {
353             controlImpl.SetKeyInputFocus();
354           }
355           else
356           {
357             controlImpl.ClearKeyInputFocus();
358           }
359           break;
360         }
361
362         case Toolkit::Control::Property::BACKGROUND:
363         {
364           std::string url;
365           const Property::Map* map = value.GetMap();
366           if( map && !map->Empty() )
367           {
368             controlImpl.SetBackground( *map );
369           }
370           else if( value.Get( url ) )
371           {
372             // don't know the size to load
373             Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual( url, ImageDimensions() );
374             if( visual )
375             {
376               controlImpl.RegisterVisual( Toolkit::Control::Property::BACKGROUND, visual );
377               visual.SetDepthIndex( DepthIndex::BACKGROUND );
378             }
379           }
380           else
381           {
382             // The background is an empty property map, so we should clear the background
383             controlImpl.ClearBackground();
384           }
385           break;
386         }
387
388         case Toolkit::DevelControl::Property::TOOLTIP:
389         {
390           TooltipPtr& tooltipPtr = controlImpl.mImpl->mTooltip;
391           if( ! tooltipPtr )
392           {
393             tooltipPtr = Tooltip::New( control );
394           }
395           tooltipPtr->SetProperties( value );
396         }
397       }
398     }
399   }
400
401   /**
402    * Called to retrieve a property of an object of this type.
403    * @param[in] object The object whose property is to be retrieved.
404    * @param[in] index The property index.
405    * @return The current value of the property.
406    */
407   static Property::Value GetProperty( BaseObject* object, Property::Index index )
408   {
409     Property::Value value;
410
411     Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
412
413     if ( control )
414     {
415       Control& controlImpl( GetImplementation( control ) );
416
417       switch ( index )
418       {
419         case Toolkit::Control::Property::STYLE_NAME:
420         {
421           value = controlImpl.GetStyleName();
422           break;
423         }
424
425         case Toolkit::Control::Property::BACKGROUND_COLOR:
426         {
427           DALI_LOG_WARNING( "BACKGROUND_COLOR property is deprecated. Use BACKGROUND property instead\n" );
428           value = controlImpl.GetBackgroundColor();
429           break;
430         }
431
432         case Toolkit::Control::Property::BACKGROUND_IMAGE:
433         {
434           DALI_LOG_WARNING( "BACKGROUND_IMAGE property is deprecated. Use BACKGROUND property instead\n" );
435           Property::Map map;
436           Toolkit::Visual::Base visual = controlImpl.GetVisual( Toolkit::Control::Property::BACKGROUND );
437           if( visual )
438           {
439             visual.CreatePropertyMap( map );
440           }
441           value = map;
442           break;
443         }
444
445         case Toolkit::Control::Property::KEY_INPUT_FOCUS:
446         {
447           value = controlImpl.HasKeyInputFocus();
448           break;
449         }
450
451         case Toolkit::Control::Property::BACKGROUND:
452         {
453           Property::Map map;
454           Toolkit::Visual::Base visual = controlImpl.GetVisual( Toolkit::Control::Property::BACKGROUND );
455           if( visual )
456           {
457             visual.CreatePropertyMap( map );
458           }
459
460           value = map;
461           break;
462         }
463
464         case Toolkit::DevelControl::Property::TOOLTIP:
465         {
466           Property::Map map;
467           if( controlImpl.mImpl->mTooltip )
468           {
469             controlImpl.mImpl->mTooltip->CreatePropertyMap( map );
470           }
471           value = map;
472           break;
473         }
474
475       }
476     }
477
478     return value;
479   }
480
481   // Data
482
483   Control& mControlImpl;
484   RegisteredVisualContainer mVisuals; // Stores visuals needed by the control, non trivial type so std::vector used.
485   std::string mStyleName;
486   Vector4 mBackgroundColor;                       ///< The color of the background visual
487   Vector3* mStartingPinchScale;      ///< The scale when a pinch gesture starts, TODO: consider removing this
488   Toolkit::Control::KeyEventSignalType mKeyEventSignal;
489   Toolkit::Control::KeyInputFocusSignalType mKeyInputFocusGainedSignal;
490   Toolkit::Control::KeyInputFocusSignalType mKeyInputFocusLostSignal;
491
492   // Gesture Detection
493   PinchGestureDetector mPinchGestureDetector;
494   PanGestureDetector mPanGestureDetector;
495   TapGestureDetector mTapGestureDetector;
496   LongPressGestureDetector mLongPressGestureDetector;
497
498   // Tooltip
499   TooltipPtr mTooltip;
500
501   ControlBehaviour mFlags : CONTROL_BEHAVIOUR_FLAG_COUNT;    ///< Flags passed in from constructor.
502   bool mIsKeyboardNavigationSupported :1;  ///< Stores whether keyboard navigation is supported by the control.
503   bool mIsKeyboardFocusGroup :1;           ///< Stores whether the control is a focus group.
504
505   // Properties - these need to be members of Internal::Control::Impl as they access private methods/data of Internal::Control and Internal::Control::Impl.
506   static const PropertyRegistration PROPERTY_1;
507   static const PropertyRegistration PROPERTY_2;
508   static const PropertyRegistration PROPERTY_3;
509   static const PropertyRegistration PROPERTY_4;
510   static const PropertyRegistration PROPERTY_5;
511   static const PropertyRegistration PROPERTY_6;
512 };
513
514 // Properties registered without macro to use specific member variables.
515 const PropertyRegistration Control::Impl::PROPERTY_1( typeRegistration, "styleName",       Toolkit::Control::Property::STYLE_NAME,       Property::STRING,  &Control::Impl::SetProperty, &Control::Impl::GetProperty );
516 const PropertyRegistration Control::Impl::PROPERTY_2( typeRegistration, "backgroundColor", Toolkit::Control::Property::BACKGROUND_COLOR, Property::VECTOR4, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
517 const PropertyRegistration Control::Impl::PROPERTY_3( typeRegistration, "backgroundImage", Toolkit::Control::Property::BACKGROUND_IMAGE, Property::MAP,     &Control::Impl::SetProperty, &Control::Impl::GetProperty );
518 const PropertyRegistration Control::Impl::PROPERTY_4( typeRegistration, "keyInputFocus",   Toolkit::Control::Property::KEY_INPUT_FOCUS,  Property::BOOLEAN, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
519 const PropertyRegistration Control::Impl::PROPERTY_5( typeRegistration, "background",      Toolkit::Control::Property::BACKGROUND,       Property::MAP,     &Control::Impl::SetProperty, &Control::Impl::GetProperty );
520 const PropertyRegistration Control::Impl::PROPERTY_6( typeRegistration, "tooltip",         Toolkit::DevelControl::Property::TOOLTIP,     Property::MAP,     &Control::Impl::SetProperty, &Control::Impl::GetProperty );
521
522 Toolkit::Control Control::New()
523 {
524   // Create the implementation, temporarily owned on stack
525   IntrusivePtr<Control> controlImpl = new Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) );
526
527   // Pass ownership to handle
528   Toolkit::Control handle( *controlImpl );
529
530   // Second-phase init of the implementation
531   // This can only be done after the CustomActor connection has been made...
532   controlImpl->Initialize();
533
534   return handle;
535 }
536
537 void Control::SetStyleName( const std::string& styleName )
538 {
539   if( styleName != mImpl->mStyleName )
540   {
541     mImpl->mStyleName = styleName;
542
543     // Apply new style, if stylemanager is available
544     Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
545     if( styleManager )
546     {
547       GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
548     }
549   }
550 }
551
552 const std::string& Control::GetStyleName() const
553 {
554   return mImpl->mStyleName;
555 }
556
557 void Control::SetBackgroundColor( const Vector4& color )
558 {
559   mImpl->mBackgroundColor = color;
560   Property::Map map;
561   map[ Toolkit::DevelVisual::Property::TYPE ] = Toolkit::Visual::COLOR;
562   map[ Toolkit::ColorVisual::Property::MIX_COLOR ] = color;
563
564   SetBackground( map );
565 }
566
567 Vector4 Control::GetBackgroundColor() const
568 {
569   return mImpl->mBackgroundColor;
570 }
571
572 void Control::SetBackground( const Property::Map& map )
573 {
574   Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual( map );
575   if( visual )
576   {
577     RegisterVisual( Toolkit::Control::Property::BACKGROUND, visual );
578     visual.SetDepthIndex( DepthIndex::BACKGROUND );
579
580     // Trigger a size negotiation request that may be needed by the new visual to relayout its contents.
581     RelayoutRequest();
582   }
583 }
584
585 void Control::SetBackgroundImage( Image image )
586 {
587   Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual( image );
588   if( visual )
589   {
590     RegisterVisual( Toolkit::Control::Property::BACKGROUND, visual );
591     visual.SetDepthIndex( DepthIndex::BACKGROUND );
592   }
593 }
594
595 void Control::ClearBackground()
596 {
597    UnregisterVisual( Toolkit::Control::Property::BACKGROUND );
598    mImpl->mBackgroundColor = Color::TRANSPARENT;
599
600    // Trigger a size negotiation request that may be needed when unregistering a visual.
601    RelayoutRequest();
602 }
603
604 void Control::EnableGestureDetection(Gesture::Type type)
605 {
606   if ( (type & Gesture::Pinch) && !mImpl->mPinchGestureDetector )
607   {
608     mImpl->mPinchGestureDetector = PinchGestureDetector::New();
609     mImpl->mPinchGestureDetector.DetectedSignal().Connect(mImpl, &Impl::PinchDetected);
610     mImpl->mPinchGestureDetector.Attach(Self());
611   }
612
613   if ( (type & Gesture::Pan) && !mImpl->mPanGestureDetector )
614   {
615     mImpl->mPanGestureDetector = PanGestureDetector::New();
616     mImpl->mPanGestureDetector.DetectedSignal().Connect(mImpl, &Impl::PanDetected);
617     mImpl->mPanGestureDetector.Attach(Self());
618   }
619
620   if ( (type & Gesture::Tap) && !mImpl->mTapGestureDetector )
621   {
622     mImpl->mTapGestureDetector = TapGestureDetector::New();
623     mImpl->mTapGestureDetector.DetectedSignal().Connect(mImpl, &Impl::TapDetected);
624     mImpl->mTapGestureDetector.Attach(Self());
625   }
626
627   if ( (type & Gesture::LongPress) && !mImpl->mLongPressGestureDetector )
628   {
629     mImpl->mLongPressGestureDetector = LongPressGestureDetector::New();
630     mImpl->mLongPressGestureDetector.DetectedSignal().Connect(mImpl, &Impl::LongPressDetected);
631     mImpl->mLongPressGestureDetector.Attach(Self());
632   }
633 }
634
635 void Control::DisableGestureDetection(Gesture::Type type)
636 {
637   if ( (type & Gesture::Pinch) && mImpl->mPinchGestureDetector )
638   {
639     mImpl->mPinchGestureDetector.Detach(Self());
640     mImpl->mPinchGestureDetector.Reset();
641   }
642
643   if ( (type & Gesture::Pan) && mImpl->mPanGestureDetector )
644   {
645     mImpl->mPanGestureDetector.Detach(Self());
646     mImpl->mPanGestureDetector.Reset();
647   }
648
649   if ( (type & Gesture::Tap) && mImpl->mTapGestureDetector )
650   {
651     mImpl->mTapGestureDetector.Detach(Self());
652     mImpl->mTapGestureDetector.Reset();
653   }
654
655   if ( (type & Gesture::LongPress) && mImpl->mLongPressGestureDetector)
656   {
657     mImpl->mLongPressGestureDetector.Detach(Self());
658     mImpl->mLongPressGestureDetector.Reset();
659   }
660 }
661
662 PinchGestureDetector Control::GetPinchGestureDetector() const
663 {
664   return mImpl->mPinchGestureDetector;
665 }
666
667 PanGestureDetector Control::GetPanGestureDetector() const
668 {
669   return mImpl->mPanGestureDetector;
670 }
671
672 TapGestureDetector Control::GetTapGestureDetector() const
673 {
674   return mImpl->mTapGestureDetector;
675 }
676
677 LongPressGestureDetector Control::GetLongPressGestureDetector() const
678 {
679   return mImpl->mLongPressGestureDetector;
680 }
681
682 void Control::SetKeyboardNavigationSupport(bool isSupported)
683 {
684   mImpl->mIsKeyboardNavigationSupported = isSupported;
685 }
686
687 bool Control::IsKeyboardNavigationSupported()
688 {
689   return mImpl->mIsKeyboardNavigationSupported;
690 }
691
692 void Control::SetKeyInputFocus()
693 {
694   if( Self().OnStage() )
695   {
696     Toolkit::KeyInputFocusManager::Get().SetFocus(Toolkit::Control::DownCast(Self()));
697   }
698 }
699
700 bool Control::HasKeyInputFocus()
701 {
702   bool result = false;
703   if( Self().OnStage() )
704   {
705     result = Toolkit::KeyInputFocusManager::Get().IsKeyboardListener(Toolkit::Control::DownCast(Self()));
706   }
707   return result;
708 }
709
710 void Control::ClearKeyInputFocus()
711 {
712   if( Self().OnStage() )
713   {
714     Toolkit::KeyInputFocusManager::Get().RemoveFocus(Toolkit::Control::DownCast(Self()));
715   }
716 }
717
718 void Control::SetAsKeyboardFocusGroup(bool isFocusGroup)
719 {
720   mImpl->mIsKeyboardFocusGroup = isFocusGroup;
721
722   // The following line will be removed when the deprecated API in KeyboardFocusManager is deleted
723   Toolkit::KeyboardFocusManager::Get().SetAsFocusGroup(Self(), isFocusGroup);
724 }
725
726 bool Control::IsKeyboardFocusGroup()
727 {
728   return Toolkit::KeyboardFocusManager::Get().IsFocusGroup(Self());
729 }
730
731 void Control::AccessibilityActivate()
732 {
733   // Inform deriving classes
734   OnAccessibilityActivated();
735 }
736
737 void Control::KeyboardEnter()
738 {
739   // Inform deriving classes
740   OnKeyboardEnter();
741 }
742
743 void Control::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual )
744 {
745   RegisterVisual( index, visual, true );
746 }
747
748 void Control::RegisterVisual( Property::Index index, Toolkit::Visual::Base& visual, bool enabled )
749 {
750   bool visualReplaced ( false );
751   Actor self = Self();
752
753   if( !mImpl->mVisuals.Empty() )
754   {
755     RegisteredVisualContainer::Iterator iter;
756     // Check if visual (index) is already registered.  Replace if so.
757     if ( FindVisual( index, mImpl->mVisuals, iter ) )
758     {
759       if( (*iter)->visual && self.OnStage() )
760       {
761         Toolkit::GetImplementation((*iter)->visual).SetOffStage( self );
762       }
763       (*iter)->visual = visual;
764       visualReplaced = true;
765     }
766   }
767
768   // If not set, set the name of the visual to the same name as the control's property.
769   // ( If the control has been type registered )
770   if( visual.GetName().empty() )
771   {
772     // Check if the control has been type registered:
773     TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(*this) );
774     if( typeInfo )
775     {
776       // Check if the property index has been registered:
777       Property::IndexContainer indices;
778       typeInfo.GetPropertyIndices( indices );
779       Property::IndexContainer::Iterator iter = std::find( indices.Begin(), indices.End(), index );
780       if( iter != indices.End() )
781       {
782         // If it has, then get it's name and use that for the visual
783         std::string visualName = typeInfo.GetPropertyName( index );
784         visual.SetName( visualName );
785       }
786     }
787   }
788
789   if( !visualReplaced ) // New registration entry
790   {
791     mImpl->mVisuals.PushBack( new RegisteredVisual( index, visual, enabled ) );
792   }
793
794   if( visual && self.OnStage() && enabled )
795   {
796     Toolkit::GetImplementation(visual).SetOnStage( self );
797   }
798
799   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::RegisterVisual() Registered %s(%d), enabled:%s\n",  visual.GetName().c_str(), index, enabled?"T":"F" );
800 }
801
802 void Control::UnregisterVisual( Property::Index index )
803 {
804    RegisteredVisualContainer::Iterator iter;
805    if ( FindVisual( index, mImpl->mVisuals, iter ) )
806    {
807      Actor self( Self() );
808      Toolkit::GetImplementation((*iter)->visual).SetOffStage( self );
809      (*iter)->visual.Reset();
810      mImpl->mVisuals.Erase( iter );
811    }
812 }
813
814 Toolkit::Visual::Base Control::GetVisual( Property::Index index ) const
815 {
816   RegisteredVisualContainer::Iterator iter;
817   if ( FindVisual( index, mImpl->mVisuals, iter ) )
818   {
819     return (*iter)->visual;
820   }
821
822   return Toolkit::Visual::Base();
823 }
824
825 void Control::EnableVisual( Property::Index index, bool enable )
826 {
827   RegisteredVisualContainer::Iterator iter;
828   if ( FindVisual( index, mImpl->mVisuals, iter ) )
829   {
830     if (  (*iter)->enabled == enable )
831     {
832       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::EnableVisual Visual %s(%d) already %s\n", (*iter)->visual.GetName().c_str(), index, enable?"enabled":"disabled");
833       return;
834     }
835
836     (*iter)->enabled = enable;
837     Actor parentActor = Self();
838     if ( Self().OnStage() ) // If control not on Stage then Visual will be added when StageConnection is called.
839     {
840       if ( enable )
841       {
842         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::EnableVisual Setting %s(%d) on stage \n", (*iter)->visual.GetName().c_str(), index );
843         Toolkit::GetImplementation((*iter)->visual).SetOnStage( parentActor );
844       }
845       else
846       {
847         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::EnableVisual Setting %s(%d) off stage \n", (*iter)->visual.GetName().c_str(), index );
848         Toolkit::GetImplementation((*iter)->visual).SetOffStage( parentActor );  // No need to call if control not staged.
849       }
850     }
851   }
852 }
853
854 bool Control::IsVisualEnabled( Property::Index index ) const
855 {
856   RegisteredVisualContainer::Iterator iter;
857   if ( FindVisual( index, mImpl->mVisuals, iter ) )
858   {
859     return (*iter)->enabled;
860   }
861   return false;
862 }
863
864 Dali::Animation Control::CreateTransition( const Toolkit::TransitionData& handle )
865 {
866   Dali::Animation transition;
867   const Internal::TransitionData& transitionData = Toolkit::GetImplementation( handle );
868
869   if( transitionData.Count() > 0 )
870   {
871     // Setup a Transition from TransitionData.
872     TransitionData::Iterator end = transitionData.End();
873     for( TransitionData::Iterator iter = transitionData.Begin() ;
874          iter != end; ++iter )
875     {
876       TransitionData::Animator* animator = (*iter);
877
878       Toolkit::Visual::Base visual = GetVisualByName( mImpl->mVisuals, animator->objectName );
879
880       if( visual )
881       {
882         Internal::Visual::Base& visualImpl = Toolkit::GetImplementation( visual );
883         visualImpl.AnimateProperty( transition, *animator );
884       }
885       else
886       {
887         // Otherwise, try any actor children of control (Including the control)
888         Actor child = Self().FindChildByName( animator->objectName );
889         if( child )
890         {
891           Property::Index propertyIndex = DevelHandle::GetPropertyIndex( child, animator->propertyKey );
892           if( propertyIndex != Property::INVALID_INDEX )
893           {
894             if( animator->animate == false )
895             {
896               if( animator->targetValue.GetType() != Property::NONE )
897               {
898                 child.SetProperty( propertyIndex, animator->targetValue );
899               }
900             }
901             else // animate the property
902             {
903               if( animator->initialValue.GetType() != Property::NONE )
904               {
905                 child.SetProperty( propertyIndex, animator->initialValue );
906               }
907
908               if( ! transition )
909               {
910                 transition = Dali::Animation::New( 0.1f );
911               }
912
913               transition.AnimateTo( Property( child, propertyIndex ),
914                                     animator->targetValue,
915                                     animator->alphaFunction,
916                                     TimePeriod( animator->timePeriodDelay,
917                                                 animator->timePeriodDuration ) );
918             }
919           }
920         }
921       }
922     }
923   }
924
925   return transition;
926 }
927
928 bool Control::OnAccessibilityActivated()
929 {
930   return false; // Accessibility activation is not handled by default
931 }
932
933 bool Control::OnKeyboardEnter()
934 {
935   return false; // Keyboard enter is not handled by default
936 }
937
938 bool Control::OnAccessibilityPan(PanGesture gesture)
939 {
940   return false; // Accessibility pan gesture is not handled by default
941 }
942
943 bool Control::OnAccessibilityTouch(const TouchEvent& touchEvent)
944 {
945   return false; // Accessibility touch event is not handled by default
946 }
947
948 bool Control::OnAccessibilityValueChange(bool isIncrease)
949 {
950   return false; // Accessibility value change action is not handled by default
951 }
952
953 bool Control::OnAccessibilityZoom()
954 {
955   return false; // Accessibility zoom action is not handled by default
956 }
957
958 Actor Control::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
959 {
960   return Actor();
961 }
962
963 void Control::OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor)
964 {
965 }
966
967 Toolkit::Control::KeyEventSignalType& Control::KeyEventSignal()
968 {
969   return mImpl->mKeyEventSignal;
970 }
971
972 Toolkit::Control::KeyInputFocusSignalType& Control::KeyInputFocusGainedSignal()
973 {
974   return mImpl->mKeyInputFocusGainedSignal;
975 }
976
977 Toolkit::Control::KeyInputFocusSignalType& Control::KeyInputFocusLostSignal()
978 {
979   return mImpl->mKeyInputFocusLostSignal;
980 }
981
982 bool Control::EmitKeyEventSignal( const KeyEvent& event )
983 {
984   // Guard against destruction during signal emission
985   Dali::Toolkit::Control handle( GetOwner() );
986
987   bool consumed = false;
988
989   // signals are allocated dynamically when someone connects
990   if ( !mImpl->mKeyEventSignal.Empty() )
991   {
992     consumed = mImpl->mKeyEventSignal.Emit( handle, event );
993   }
994
995   if (!consumed)
996   {
997     // Notification for derived classes
998     consumed = OnKeyEvent(event);
999   }
1000
1001   return consumed;
1002 }
1003
1004 Control::Control( ControlBehaviour behaviourFlags )
1005 : CustomActorImpl( static_cast< ActorFlags >( behaviourFlags ) ),
1006   mImpl(new Impl(*this))
1007 {
1008   mImpl->mFlags = behaviourFlags;
1009 }
1010
1011 Control::~Control()
1012 {
1013   delete mImpl;
1014 }
1015
1016 void Control::Initialize()
1017 {
1018   // Call deriving classes so initialised before styling is applied to them.
1019   OnInitialize();
1020
1021   if( (mImpl->mFlags & REQUIRES_STYLE_CHANGE_SIGNALS) ||
1022       !(mImpl->mFlags & DISABLE_STYLE_CHANGE_SIGNALS) )
1023   {
1024     Toolkit::StyleManager styleManager = StyleManager::Get();
1025
1026     // if stylemanager is available
1027     if( styleManager )
1028     {
1029       StyleManager& styleManagerImpl = GetImpl( styleManager );
1030
1031       // Register for style changes
1032       styleManagerImpl.ControlStyleChangeSignal().Connect( this, &Control::OnStyleChange );
1033
1034       // Apply the current style
1035       styleManagerImpl.ApplyThemeStyleAtInit( Toolkit::Control( GetOwner() ) );
1036     }
1037   }
1038
1039   if( mImpl->mFlags & REQUIRES_KEYBOARD_NAVIGATION_SUPPORT )
1040   {
1041     SetKeyboardNavigationSupport( true );
1042   }
1043 }
1044
1045 void Control::OnInitialize()
1046 {
1047 }
1048
1049 void Control::OnControlChildAdd( Actor& child )
1050 {
1051 }
1052
1053 void Control::OnControlChildRemove( Actor& child )
1054 {
1055 }
1056
1057 void Control::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange::Type change )
1058 {
1059   // By default the control is only interested in theme (not font) changes
1060   if( styleManager && change == StyleChange::THEME_CHANGE )
1061   {
1062     GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
1063   }
1064   RelayoutRequest();
1065 }
1066
1067 void Control::OnPinch(const PinchGesture& pinch)
1068 {
1069   if( !( mImpl->mStartingPinchScale ) )
1070   {
1071     // lazy allocate
1072     mImpl->mStartingPinchScale = new Vector3;
1073   }
1074
1075   if( pinch.state == Gesture::Started )
1076   {
1077     *( mImpl->mStartingPinchScale ) = Self().GetCurrentScale();
1078   }
1079
1080   Self().SetScale( *( mImpl->mStartingPinchScale ) * pinch.scale );
1081 }
1082
1083 void Control::OnPan( const PanGesture& pan )
1084 {
1085 }
1086
1087 void Control::OnTap(const TapGesture& tap)
1088 {
1089 }
1090
1091 void Control::OnLongPress( const LongPressGesture& longPress )
1092 {
1093 }
1094
1095 void Control::EmitKeyInputFocusSignal( bool focusGained )
1096 {
1097   Dali::Toolkit::Control handle( GetOwner() );
1098
1099   if ( focusGained )
1100   {
1101     // signals are allocated dynamically when someone connects
1102     if ( !mImpl->mKeyInputFocusGainedSignal.Empty() )
1103     {
1104       mImpl->mKeyInputFocusGainedSignal.Emit( handle );
1105     }
1106   }
1107   else
1108   {
1109     // signals are allocated dynamically when someone connects
1110     if ( !mImpl->mKeyInputFocusLostSignal.Empty() )
1111     {
1112       mImpl->mKeyInputFocusLostSignal.Emit( handle );
1113     }
1114   }
1115 }
1116
1117 void Control::OnStageConnection( int depth )
1118 {
1119   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::OnStageConnection number of registered visuals(%d)\n",  mImpl->mVisuals.Size() );
1120
1121   Actor self( Self() );
1122
1123   for(RegisteredVisualContainer::Iterator iter = mImpl->mVisuals.Begin(); iter!= mImpl->mVisuals.End(); iter++)
1124   {
1125     // Check whether the visual is empty and enabled
1126     if( (*iter)->visual && (*iter)->enabled )
1127     {
1128       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::OnStageConnection Setting visual(%d) on stage\n", (*iter)->index );
1129       Toolkit::GetImplementation((*iter)->visual).SetOnStage( self );
1130     }
1131   }
1132
1133   if( mImpl->mVisuals.Empty() && ! self.GetRendererCount() )
1134   {
1135     Property::Value clippingValue = self.GetProperty( Actor::Property::CLIPPING_MODE );
1136     int clippingMode = ClippingMode::DISABLED;
1137     if( clippingValue.Get( clippingMode ) )
1138     {
1139       // Add a transparent background if we do not have any renderers or visuals so we clip our children
1140
1141       if( clippingMode == ClippingMode::CLIP_CHILDREN )
1142       {
1143         // Create a transparent background visual which will also get staged.
1144         SetBackgroundColor( Color::TRANSPARENT );
1145       }
1146     }
1147   }
1148 }
1149
1150 void Control::OnStageDisconnection()
1151 {
1152   for(RegisteredVisualContainer::Iterator iter = mImpl->mVisuals.Begin(); iter!= mImpl->mVisuals.End(); iter++)
1153   {
1154     // Check whether the visual is empty
1155     if( (*iter)->visual )
1156     {
1157       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::OnStageDisconnection Setting visual(%d) off stage\n", (*iter)->index );
1158       Actor self( Self() );
1159       Toolkit::GetImplementation((*iter)->visual).SetOffStage( self );
1160     }
1161   }
1162 }
1163
1164 void Control::OnKeyInputFocusGained()
1165 {
1166   EmitKeyInputFocusSignal( true );
1167 }
1168
1169 void Control::OnKeyInputFocusLost()
1170 {
1171   EmitKeyInputFocusSignal( false );
1172 }
1173
1174 void Control::OnChildAdd(Actor& child)
1175 {
1176   // Notify derived classes.
1177   OnControlChildAdd( child );
1178 }
1179
1180 void Control::OnChildRemove(Actor& child)
1181 {
1182   // Notify derived classes.
1183   OnControlChildRemove( child );
1184 }
1185
1186 void Control::OnPropertySet( Property::Index index, Property::Value propertyValue )
1187 {
1188   Actor self( Self() );
1189   if( index == Actor::Property::CLIPPING_MODE )
1190   {
1191     // Only set the background if we're already on the stage and have no renderers or visuals
1192
1193     if( mImpl->mVisuals.Empty() && ! self.GetRendererCount() && self.OnStage() )
1194     {
1195       ClippingMode::Type clippingMode = ClippingMode::DISABLED;
1196       if( Scripting::GetEnumerationProperty< ClippingMode::Type >( propertyValue, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, clippingMode ) )
1197       {
1198         // Add a transparent background if we do not have one so we clip children
1199
1200         if( clippingMode == ClippingMode::CLIP_CHILDREN )
1201         {
1202           SetBackgroundColor( Color::TRANSPARENT );
1203         }
1204       }
1205     }
1206   }
1207 }
1208
1209 void Control::OnSizeSet(const Vector3& targetSize)
1210 {
1211   Toolkit::Visual::Base visual = GetVisual( Toolkit::Control::Property::BACKGROUND );
1212   if( visual )
1213   {
1214     Vector2 size( targetSize );
1215     Property::Map transformMap;
1216     SetDefaultTransform( transformMap );
1217     visual.SetTransformAndSize( transformMap, size );
1218   }
1219 }
1220
1221 void Control::OnSizeAnimation(Animation& animation, const Vector3& targetSize)
1222 {
1223   // @todo size negotiate background to new size, animate as well?
1224 }
1225
1226 bool Control::OnTouchEvent(const TouchEvent& event)
1227 {
1228   return false; // Do not consume
1229 }
1230
1231 bool Control::OnHoverEvent(const HoverEvent& event)
1232 {
1233   return false; // Do not consume
1234 }
1235
1236 bool Control::OnKeyEvent(const KeyEvent& event)
1237 {
1238   return false; // Do not consume
1239 }
1240
1241 bool Control::OnWheelEvent(const WheelEvent& event)
1242 {
1243   return false; // Do not consume
1244 }
1245
1246 void Control::OnRelayout( const Vector2& size, RelayoutContainer& container )
1247 {
1248   for( unsigned int i = 0, numChildren = Self().GetChildCount(); i < numChildren; ++i )
1249   {
1250     container.Add( Self().GetChildAt( i ), size );
1251   }
1252
1253   Toolkit::Visual::Base visual = GetVisual( Toolkit::Control::Property::BACKGROUND );
1254   if( visual )
1255   {
1256     Vector2 controlSize( size );
1257     Property::Map transformMap;
1258     SetDefaultTransform( transformMap );
1259     visual.SetTransformAndSize( transformMap, controlSize );
1260   }
1261 }
1262
1263 void Control::OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
1264 {
1265 }
1266
1267 Vector3 Control::GetNaturalSize()
1268 {
1269   Toolkit::Visual::Base visual = GetVisual( Toolkit::Control::Property::BACKGROUND );
1270   if( visual )
1271   {
1272     Vector2 naturalSize;
1273     visual.GetNaturalSize( naturalSize );
1274     return Vector3( naturalSize );
1275   }
1276   return Vector3::ZERO;
1277 }
1278
1279 float Control::CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
1280 {
1281   return CalculateChildSizeBase( child, dimension );
1282 }
1283
1284 float Control::GetHeightForWidth( float width )
1285 {
1286   return GetHeightForWidthBase( width );
1287 }
1288
1289 float Control::GetWidthForHeight( float height )
1290 {
1291   return GetWidthForHeightBase( height );
1292 }
1293
1294 bool Control::RelayoutDependentOnChildren( Dimension::Type dimension )
1295 {
1296   return RelayoutDependentOnChildrenBase( dimension );
1297 }
1298
1299 void Control::OnCalculateRelayoutSize( Dimension::Type dimension )
1300 {
1301 }
1302
1303 void Control::OnLayoutNegotiated( float size, Dimension::Type dimension )
1304 {
1305 }
1306
1307 void Control::SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
1308 {
1309   mImpl->SignalConnected( slotObserver, callback );
1310 }
1311
1312 void Control::SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback )
1313 {
1314   mImpl->SignalDisconnected( slotObserver, callback );
1315 }
1316
1317 Control& GetImplementation( Dali::Toolkit::Control& handle )
1318 {
1319   CustomActorImpl& customInterface = handle.GetImplementation();
1320   // downcast to control
1321   Control& impl = dynamic_cast< Internal::Control& >( customInterface );
1322   return impl;
1323 }
1324
1325 const Control& GetImplementation( const Dali::Toolkit::Control& handle )
1326 {
1327   const CustomActorImpl& customInterface = handle.GetImplementation();
1328   // downcast to control
1329   const Control& impl = dynamic_cast< const Internal::Control& >( customInterface );
1330   return impl;
1331 }
1332
1333 } // namespace Internal
1334
1335 } // namespace Toolkit
1336
1337 } // namespace Dali