base/dali-toolkit/public-api/controls/control-impl.cpp

   1 /*
   2  * Copyright (c) 2014 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 #include <dali-toolkit/public-api/controls/control-impl.h>
  19
  20 #include <stack>
  21
  22 #include <dali/integration-api/debug.h>
  23
  24 #include "dali-toolkit/internal/controls/relayout-controller.h"
  25 #include "dali-toolkit/internal/controls/relayout-helper.h"
  26 #include "dali-toolkit/public-api/focus-manager/keyinput-focus-manager.h"
  27 #include "dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h"
  28 #include <dali-toolkit/public-api/controls/control.h>
  29
  30 #include <dali-toolkit/public-api/styling/style-manager.h>
  31 #include <dali-toolkit/internal/styling/style-manager-impl.h>
  32
  33 namespace Dali
  34 {
  35
  36 namespace Toolkit
  37 {
  38
  39 const Property::Index Control::PROPERTY_BACKGROUND_COLOR      = Internal::Control::CONTROL_PROPERTY_START_INDEX;
  40 const Property::Index Control::PROPERTY_BACKGROUND            = Internal::Control::CONTROL_PROPERTY_START_INDEX + 1;
  41 const Property::Index Control::PROPERTY_WIDTH_POLICY          = Internal::Control::CONTROL_PROPERTY_START_INDEX + 2;
  42 const Property::Index Control::PROPERTY_HEIGHT_POLICY         = Internal::Control::CONTROL_PROPERTY_START_INDEX + 3;
  43 const Property::Index Control::PROPERTY_MINIMUM_SIZE          = Internal::Control::CONTROL_PROPERTY_START_INDEX + 4;
  44 const Property::Index Control::PROPERTY_MAXIMUM_SIZE          = Internal::Control::CONTROL_PROPERTY_START_INDEX + 5;
  45 const Property::Index Control::PROPERTY_KEY_INPUT_FOCUS       = Internal::Control::CONTROL_PROPERTY_START_INDEX + 6;
  46
  47 namespace
  48 {
  49
  50 const Scripting::StringEnum< Control::SizePolicy > SIZE_POLICY_STRING_TABLE[] =
  51 {
  52   { "FIXED",      Control::Fixed      },
  53   { "MINIMUM",    Control::Minimum    },
  54   { "MAXIMUM",    Control::Maximum    },
  55   { "RANGE",      Control::Range      },
  56   { "FLEXIBLE",   Control::Flexible   },
  57 };
  58 const unsigned int SIZE_POLICY_STRING_TABLE_COUNT = sizeof( SIZE_POLICY_STRING_TABLE ) / sizeof( SIZE_POLICY_STRING_TABLE[0] );
  59
  60 #if defined(DEBUG_ENABLED)
  61 Integration::Log::Filter* gLogFilter  = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_CONTROL");
  62 #endif
  63
  64 const float MAX_FLOAT_VALUE( std::numeric_limits<float>::max() );
  65 const Vector3 MAX_SIZE( MAX_FLOAT_VALUE, MAX_FLOAT_VALUE, MAX_FLOAT_VALUE );
  66 const float BACKGROUND_ACTOR_Z_POSITION( -0.1f );
  67
  68 BaseHandle Create()
  69 {
  70   return Internal::Control::New();
  71 }
  72
  73 TypeRegistration CONTROL_TYPE( typeid(Control), typeid(CustomActor), Create );
  74
  75 // Property Registration after Internal::Control::Impl definition below
  76
  77 TypeAction ACTION_TYPE_1( CONTROL_TYPE, Toolkit::Control::ACTION_CONTROL_ACTIVATED, &Internal::Control::DoAction );
  78
  79 /**
  80  * Structure which holds information about the background of a control
  81  */
  82 struct Background
  83 {
  84   Actor actor;   ///< Either a MeshActor or an ImageActor
  85   Vector4 color; ///< The color of the actor.
  86
  87   /**
  88    * Constructor
  89    */
  90   Background()
  91   : actor(),
  92     color( Color::WHITE )
  93   {
  94   }
  95 };
  96
  97 /**
  98  * Helper function to calculate a dimension given the policy of that dimension; the minimum &
  99  * maximum values that dimension can be; and the allocated value for that dimension.
 100  *
 101  * @param[in]  policy     The size policy for that dimension.
 102  * @param[in]  minimum    The minimum value that dimension can be.
 103  * @param[in]  maximum    The maximum value that dimension can be.
 104  * @param[in]  allocated  The value allocated for that dimension.
 105  *
 106  * @return The value that the dimension should be.
 107  *
 108  * @note This does not handle Control::Fixed policy.
 109  */
 110 float Calculate( Control::SizePolicy policy, float minimum, float maximum, float allocated )
 111 {
 112   float size( allocated );
 113
 114   switch( policy )
 115   {
 116     case Control::Fixed:
 117     {
 118       // Use allocated value
 119       break;
 120     }
 121
 122     case Control::Minimum:
 123     {
 124       // Size is always at least the minimum.
 125       size = std::max( allocated, minimum );
 126       break;
 127     }
 128
 129     case Control::Maximum:
 130     {
 131       // Size can grow but up to a maximum value.
 132       size = std::min( allocated, maximum );
 133       break;
 134     }
 135
 136     case Control::Range:
 137     {
 138       // Size is at least the minimum and can grow up to the maximum
 139       size = std::max( size, minimum );
 140       size = std::min( size, maximum );
 141      break;
 142     }
 143
 144     case Control::Flexible:
 145     {
 146       // Size grows or shrinks with no limits.
 147       size = allocated;
 148       break;
 149     }
 150
 151     default:
 152     {
 153       DALI_ASSERT_DEBUG( false && "This function was not intended to be used by any other policy." );
 154       break;
 155     }
 156   }
 157
 158   return size;
 159 }
 160
 161 /**
 162  * Creates a white coloured Mesh.
 163  */
 164 Mesh CreateMesh()
 165 {
 166   Vector3 white( Color::WHITE );
 167
 168   MeshData meshData;
 169
 170   // Create vertices with a white color (actual color is set by actor color)
 171   MeshData::VertexContainer vertices(4);
 172   vertices[ 0 ] = MeshData::Vertex( Vector3( -0.5f, -0.5f, 0.0f ), Vector2::ZERO, white );
 173   vertices[ 1 ] = MeshData::Vertex( Vector3(  0.5f, -0.5f, 0.0f ), Vector2::ZERO, white );
 174   vertices[ 2 ] = MeshData::Vertex( Vector3( -0.5f,  0.5f, 0.0f ), Vector2::ZERO, white );
 175   vertices[ 3 ] = MeshData::Vertex( Vector3(  0.5f,  0.5f, 0.0f ), Vector2::ZERO, white );
 176
 177   // Specify all the faces
 178   MeshData::FaceIndices faces;
 179   faces.reserve( 6 ); // 2 triangles in Quad
 180   faces.push_back( 0 ); faces.push_back( 3 ); faces.push_back( 1 );
 181   faces.push_back( 0 ); faces.push_back( 2 ); faces.push_back( 3 );
 182
 183   // Create the mesh data from the vertices and faces
 184   meshData.SetMaterial( Material::New( "ControlMaterial" ) );
 185   meshData.SetVertices( vertices );
 186   meshData.SetFaceIndices( faces );
 187   meshData.SetHasColor( true );
 188
 189   return Mesh::New( meshData );
 190 }
 191
 192 /**
 193  * Sets all the required properties for the background actor.
 194  *
 195  * @param[in]  actor              The actor to set the properties on.
 196  * @param[in]  constrainingIndex  The property index to constrain the parent's size on.
 197  * @param[in]  color              The required color of the actor.
 198  */
 199 void SetupBackgroundActor( Actor actor, Property::Index constrainingIndex, const Vector4& color )
 200 {
 201   actor.SetColor( color );
 202   actor.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
 203   actor.SetZ( BACKGROUND_ACTOR_Z_POSITION );
 204
 205   Constraint constraint = Constraint::New<Vector3>( constrainingIndex,
 206                                                     ParentSource( Actor::SIZE ),
 207                                                     EqualToConstraint() );
 208   actor.ApplyConstraint( constraint );
 209 }
 210
 211 } // unnamed namespace
 212
 213 namespace Internal
 214 {
 215
 216 class Control::Impl : public ConnectionTracker
 217 {
 218 public:
 219
 220   /**
 221    * Size indices for mMinMaxSize array
 222    */
 223   enum
 224   {
 225     MIN_SIZE_INDEX = 0,
 226     MAX_SIZE_INDEX = 1
 227   };
 228
 229 public:
 230   // Construction & Destruction
 231   Impl(Control& controlImpl)
 232   : mControlImpl( controlImpl ),
 233     mBackground( NULL ),
 234     mStartingPinchScale( NULL ),
 235     mKeyEventSignalV2(),
 236     mPinchGestureDetector(),
 237     mPanGestureDetector(),
 238     mTapGestureDetector(),
 239     mLongPressGestureDetector(),
 240     mCurrentSize(),
 241     mNaturalSize(),
 242     mWidthPolicy( Toolkit::Control::Fixed ),
 243     mHeightPolicy( Toolkit::Control::Fixed ),
 244     mFlags( Control::CONTROL_BEHAVIOUR_NONE ),
 245     mInsideRelayout( false ),
 246     mIsKeyboardNavigationSupported( false ),
 247     mIsKeyboardFocusGroup( false ),
 248     mInitialized( false )
 249   {
 250   }
 251
 252   ~Impl()
 253   {
 254     // All gesture detectors will be destroyed so no need to disconnect.
 255     delete mBackground;
 256     delete mStartingPinchScale;
 257   }
 258
 259   // Gesture Detection Methods
 260
 261   void PinchDetected(Actor actor, PinchGesture pinch)
 262   {
 263     mControlImpl.OnPinch(pinch);
 264   }
 265
 266   void PanDetected(Actor actor, PanGesture pan)
 267   {
 268     mControlImpl.OnPan(pan);
 269   }
 270
 271   void TapDetected(Actor actor, TapGesture tap)
 272   {
 273     mControlImpl.OnTap(tap);
 274   }
 275
 276   void LongPressDetected(Actor actor, LongPressGesture longPress)
 277   {
 278     mControlImpl.OnLongPress(longPress);
 279   }
 280
 281   // Background Methods
 282
 283   /**
 284    * Only creates an instance of the background if we actually use it.
 285    * @return A reference to the Background structure.
 286    */
 287   Background& GetBackground()
 288   {
 289     if ( !mBackground )
 290     {
 291       mBackground = new Background;
 292     }
 293     return *mBackground;
 294   }
 295
 296   // Properties
 297
 298   /**
 299    * Called when a property of an object of this type is set.
 300    * @param[in] object The object whose property is set.
 301    * @param[in] index The property index.
 302    * @param[in] value The new property value.
 303    */
 304   static void SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 305   {
 306     Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
 307
 308     if ( control )
 309     {
 310       Control& controlImpl( control.GetImplementation() );
 311
 312       switch ( index )
 313       {
 314         case Toolkit::Control::PROPERTY_BACKGROUND_COLOR:
 315         {
 316           controlImpl.SetBackgroundColor( value.Get< Vector4 >() );
 317           break;
 318         }
 319
 320         case Toolkit::Control::PROPERTY_BACKGROUND:
 321         {
 322           if ( value.HasKey( "image" ) )
 323           {
 324             Property::Map imageMap = value.GetValue( "image" ).Get< Property::Map >();
 325             Image image = Scripting::NewImage( imageMap );
 326
 327             if ( image )
 328             {
 329               controlImpl.SetBackground( image );
 330             }
 331           }
 332           else if ( value.Get< Property::Map >().empty() )
 333           {
 334             // An empty map means the background is no longer required
 335             controlImpl.ClearBackground();
 336           }
 337           break;
 338         }
 339
 340         case Toolkit::Control::PROPERTY_WIDTH_POLICY:
 341         {
 342           controlImpl.mImpl->mWidthPolicy = Scripting::GetEnumeration< Toolkit::Control::SizePolicy >( value.Get< std::string >(), SIZE_POLICY_STRING_TABLE, SIZE_POLICY_STRING_TABLE_COUNT );
 343           break;
 344         }
 345
 346         case Toolkit::Control::PROPERTY_HEIGHT_POLICY:
 347         {
 348           controlImpl.mImpl->mHeightPolicy = Scripting::GetEnumeration< Toolkit::Control::SizePolicy >( value.Get< std::string >(), SIZE_POLICY_STRING_TABLE, SIZE_POLICY_STRING_TABLE_COUNT );
 349           break;
 350         }
 351
 352         case Toolkit::Control::PROPERTY_MINIMUM_SIZE:
 353         {
 354           controlImpl.SetMinimumSize( value.Get< Vector3 >() );
 355           break;
 356         }
 357
 358         case Toolkit::Control::PROPERTY_MAXIMUM_SIZE:
 359         {
 360           controlImpl.SetMaximumSize( value.Get< Vector3 >() );
 361           break;
 362         }
 363
 364         case Toolkit::Control::PROPERTY_KEY_INPUT_FOCUS:
 365         {
 366           if ( value.Get< bool >() )
 367           {
 368             controlImpl.SetKeyInputFocus();
 369           }
 370           else
 371           {
 372             controlImpl.ClearKeyInputFocus();
 373           }
 374           break;
 375         }
 376       }
 377     }
 378   }
 379
 380   /**
 381    * Called to retrieve a property of an object of this type.
 382    * @param[in] object The object whose property is to be retrieved.
 383    * @param[in] index The property index.
 384    * @return The current value of the property.
 385    */
 386   static Property::Value GetProperty( BaseObject* object, Property::Index index )
 387   {
 388     Property::Value value;
 389
 390     Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
 391
 392     if ( control )
 393     {
 394       Control& controlImpl( control.GetImplementation() );
 395
 396       switch ( index )
 397       {
 398         case Toolkit::Control::PROPERTY_BACKGROUND_COLOR:
 399         {
 400           value = controlImpl.GetBackgroundColor();
 401           break;
 402         }
 403
 404         case Toolkit::Control::PROPERTY_BACKGROUND:
 405         {
 406           Property::Map map;
 407
 408           Actor actor = controlImpl.GetBackgroundActor();
 409           if ( actor )
 410           {
 411             ImageActor imageActor = ImageActor::DownCast( actor );
 412             if ( imageActor )
 413             {
 414               Image image = imageActor.GetImage();
 415               Property::Map imageMap;
 416               Scripting::CreatePropertyMap( image, imageMap );
 417               map.push_back( Property::StringValuePair( "image", imageMap ) );
 418             }
 419           }
 420
 421           value = map;
 422           break;
 423         }
 424
 425         case Toolkit::Control::PROPERTY_WIDTH_POLICY:
 426         {
 427           value = std::string( Scripting::GetEnumerationName< Toolkit::Control::SizePolicy >( controlImpl.mImpl->mWidthPolicy, SIZE_POLICY_STRING_TABLE, SIZE_POLICY_STRING_TABLE_COUNT ) );
 428           break;
 429         }
 430
 431         case Toolkit::Control::PROPERTY_HEIGHT_POLICY:
 432         {
 433           value = std::string( Scripting::GetEnumerationName< Toolkit::Control::SizePolicy >( controlImpl.mImpl->mHeightPolicy, SIZE_POLICY_STRING_TABLE, SIZE_POLICY_STRING_TABLE_COUNT ) );
 434           break;
 435         }
 436
 437         case Toolkit::Control::PROPERTY_MINIMUM_SIZE:
 438         {
 439           value = controlImpl.mImpl->GetMinimumSize();
 440           break;
 441         }
 442
 443         case Toolkit::Control::PROPERTY_MAXIMUM_SIZE:
 444         {
 445           value = controlImpl.mImpl->GetMaximumSize();
 446           break;
 447         }
 448
 449         case Toolkit::Control::PROPERTY_KEY_INPUT_FOCUS:
 450         {
 451           value = controlImpl.HasKeyInputFocus();
 452           break;
 453         }
 454       }
 455     }
 456
 457     return value;
 458   }
 459
 460   /**
 461    * Helper to get minimum size
 462    * @return minimum size
 463    */
 464   inline const Vector3& GetMinimumSize()
 465   {
 466     if( mMinMaxSize.Count() > MIN_SIZE_INDEX )
 467     {
 468       return mMinMaxSize[ MIN_SIZE_INDEX ];
 469     }
 470     else
 471     {
 472       // its not been allocated so its ZERO
 473       return Vector3::ZERO;
 474     }
 475   }
 476   /**
 477    * Helper to Set minimum size
 478    * @param size to set
 479    */
 480   inline void SetMinimumSize( const Vector3& size )
 481   {
 482     if( mMinMaxSize.Count() > MIN_SIZE_INDEX )
 483     {
 484       mMinMaxSize[ MIN_SIZE_INDEX ] = size;
 485     }
 486     else
 487     {
 488       // its not been allocated so push the new value there
 489       mMinMaxSize.PushBack( size );
 490     }
 491   }
 492
 493   /**
 494    * Helper to get maximum size
 495    * @return maximum size
 496    */
 497   inline const Vector3& GetMaximumSize()
 498   {
 499     if( mMinMaxSize.Count() > MAX_SIZE_INDEX )
 500     {
 501       return mMinMaxSize[ MAX_SIZE_INDEX ];
 502     }
 503     else
 504     {
 505       // its not been allocated so its MAX_SIZE
 506       return MAX_SIZE;
 507     }
 508   }
 509
 510   /**
 511    * Helper to Set minimum size
 512    * @param size to set
 513    */
 514   inline void SetMaximumSize( const Vector3& size )
 515   {
 516     if( mMinMaxSize.Count() > MAX_SIZE_INDEX )
 517     {
 518       mMinMaxSize[ MAX_SIZE_INDEX ] = size;
 519     }
 520     else if( mMinMaxSize.Count() > MIN_SIZE_INDEX )
 521     {
 522       // max has not been allocated, but min has
 523       mMinMaxSize.PushBack( size );
 524     }
 525     else
 526     {
 527       // min and max both unallocated so allocate both
 528       mMinMaxSize.Resize( 2u ); // this will reserve and default construct two Vector3s
 529       mMinMaxSize[ MAX_SIZE_INDEX ] = size;
 530     }
 531   }
 532
 533   // Data
 534
 535   Control& mControlImpl;
 536   Background* mBackground;           ///< Only create the background if we use it
 537   Vector3* mStartingPinchScale;      ///< The scale when a pinch gesture starts, TODO: consider removing this
 538   Toolkit::Control::KeyEventSignalV2 mKeyEventSignalV2;
 539
 540   // Gesture Detection
 541   PinchGestureDetector mPinchGestureDetector;
 542   PanGestureDetector mPanGestureDetector;
 543   TapGestureDetector mTapGestureDetector;
 544   LongPressGestureDetector mLongPressGestureDetector;
 545   // @todo change all these to Vector2 when we have a chance to sanitize the public API as well
 546   Vector3 mCurrentSize; ///< Stores the current control's size, this is the negotiated size
 547   Vector3 mNaturalSize; ///< Stores the size set through the Actor's API. This is size the actor wants to be. Useful when reset to the initial size is needed.
 548   Dali::Vector< Vector3 > mMinMaxSize; ///< Stores the minimum and maximum size if they are set
 549
 550   Toolkit::Control::SizePolicy mWidthPolicy :3;  ///< Stores the width policy. 3 bits covers 8 values
 551   Toolkit::Control::SizePolicy mHeightPolicy :3; ///< Stores the height policy. 3 bits covers 8 values
 552   ControlBehaviour mFlags :4;             ///< Flags passed in from constructor. Need to increase this size when new enums are added
 553   bool mInsideRelayout:1;                 ///< Detect when were in Relayout
 554   bool mIsKeyboardNavigationSupported:1;  ///< Stores whether keyboard navigation is supported by the control.
 555   bool mIsKeyboardFocusGroup:1;           ///< Stores whether the control is a focus group.
 556   bool mInitialized:1;
 557
 558   // Properties - these need to be members of Internal::Control::Impl as they need to functions within this class.
 559   static PropertyRegistration PROPERTY_1;
 560   static PropertyRegistration PROPERTY_2;
 561   static PropertyRegistration PROPERTY_3;
 562   static PropertyRegistration PROPERTY_4;
 563   static PropertyRegistration PROPERTY_5;
 564   static PropertyRegistration PROPERTY_6;
 565   static PropertyRegistration PROPERTY_7;
 566 };
 567
 568 PropertyRegistration Control::Impl::PROPERTY_1( CONTROL_TYPE, "background-color", Toolkit::Control::PROPERTY_BACKGROUND_COLOR, Property::VECTOR4, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
 569 PropertyRegistration Control::Impl::PROPERTY_2( CONTROL_TYPE, "background",       Toolkit::Control::PROPERTY_BACKGROUND,       Property::MAP,     &Control::Impl::SetProperty, &Control::Impl::GetProperty );
 570 PropertyRegistration Control::Impl::PROPERTY_3( CONTROL_TYPE, "width-policy",     Toolkit::Control::PROPERTY_WIDTH_POLICY,     Property::STRING,  &Control::Impl::SetProperty, &Control::Impl::GetProperty );
 571 PropertyRegistration Control::Impl::PROPERTY_4( CONTROL_TYPE, "height-policy",    Toolkit::Control::PROPERTY_HEIGHT_POLICY,    Property::STRING,  &Control::Impl::SetProperty, &Control::Impl::GetProperty );
 572 PropertyRegistration Control::Impl::PROPERTY_5( CONTROL_TYPE, "minimum-size",     Toolkit::Control::PROPERTY_MINIMUM_SIZE,     Property::VECTOR3, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
 573 PropertyRegistration Control::Impl::PROPERTY_6( CONTROL_TYPE, "maximum-size",     Toolkit::Control::PROPERTY_MAXIMUM_SIZE,     Property::VECTOR3, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
 574 PropertyRegistration Control::Impl::PROPERTY_7( CONTROL_TYPE, "key-input-focus",  Toolkit::Control::PROPERTY_KEY_INPUT_FOCUS,  Property::BOOLEAN, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
 575
 576 Toolkit::Control Control::New()
 577 {
 578   // Create the implementation, temporarily owned on stack
 579   IntrusivePtr<Control> controlImpl = new Control( CONTROL_BEHAVIOUR_NONE );
 580
 581   // Pass ownership to handle
 582   Toolkit::Control handle( *controlImpl );
 583
 584   // Second-phase init of the implementation
 585   // This can only be done after the CustomActor connection has been made...
 586   controlImpl->Initialize();
 587
 588   return handle;
 589 }
 590
 591 Control::~Control()
 592 {
 593   delete mImpl;
 594 }
 595
 596 void Control::Initialize()
 597 {
 598
 599   // Calling deriving classes
 600   OnInitialize();
 601
 602   if( mImpl->mFlags & REQUIRES_STYLE_CHANGE_SIGNALS )
 603   {
 604     Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
 605
 606     // Register for style changes
 607     styleManager.StyleChangeSignal().Connect( this, &ControlImpl::DoStyleChange );
 608
 609     // SetTheme
 610     GetImpl( styleManager ).ApplyThemeStyle( GetOwner() );
 611   }
 612
 613   mImpl->mInitialized = true;
 614 }
 615
 616 void Control::EnableGestureDetection(Gesture::Type type)
 617 {
 618   if ( (type & Gesture::Pinch) && !mImpl->mPinchGestureDetector )
 619   {
 620     mImpl->mPinchGestureDetector = PinchGestureDetector::New();
 621     mImpl->mPinchGestureDetector.DetectedSignal().Connect(mImpl, &Impl::PinchDetected);
 622     mImpl->mPinchGestureDetector.Attach(Self());
 623   }
 624
 625   if ( (type & Gesture::Pan) && !mImpl->mPanGestureDetector )
 626   {
 627     mImpl->mPanGestureDetector = PanGestureDetector::New();
 628     mImpl->mPanGestureDetector.DetectedSignal().Connect(mImpl, &Impl::PanDetected);
 629     mImpl->mPanGestureDetector.Attach(Self());
 630   }
 631
 632   if ( (type & Gesture::Tap) && !mImpl->mTapGestureDetector )
 633   {
 634     mImpl->mTapGestureDetector = TapGestureDetector::New();
 635     mImpl->mTapGestureDetector.DetectedSignal().Connect(mImpl, &Impl::TapDetected);
 636     mImpl->mTapGestureDetector.Attach(Self());
 637   }
 638
 639   if ( (type & Gesture::LongPress) && !mImpl->mLongPressGestureDetector )
 640   {
 641     mImpl->mLongPressGestureDetector = LongPressGestureDetector::New();
 642     mImpl->mLongPressGestureDetector.DetectedSignal().Connect(mImpl, &Impl::LongPressDetected);
 643     mImpl->mLongPressGestureDetector.Attach(Self());
 644   }
 645 }
 646
 647 void Control::DisableGestureDetection(Gesture::Type type)
 648 {
 649   if ( (type & Gesture::Pinch) && mImpl->mPinchGestureDetector )
 650   {
 651     mImpl->mPinchGestureDetector.Detach(Self());
 652     mImpl->mPinchGestureDetector.Reset();
 653   }
 654
 655   if ( (type & Gesture::Pan) && mImpl->mPanGestureDetector )
 656   {
 657     mImpl->mPanGestureDetector.Detach(Self());
 658     mImpl->mPanGestureDetector.Reset();
 659   }
 660
 661   if ( (type & Gesture::Tap) && mImpl->mTapGestureDetector )
 662   {
 663     mImpl->mTapGestureDetector.Detach(Self());
 664     mImpl->mTapGestureDetector.Reset();
 665   }
 666
 667   if ( (type & Gesture::LongPress) && mImpl->mLongPressGestureDetector)
 668   {
 669     mImpl->mLongPressGestureDetector.Detach(Self());
 670     mImpl->mLongPressGestureDetector.Reset();
 671   }
 672 }
 673
 674 PinchGestureDetector Control::GetPinchGestureDetector() const
 675 {
 676   return mImpl->mPinchGestureDetector;
 677 }
 678
 679 PanGestureDetector Control::GetPanGestureDetector() const
 680 {
 681   return mImpl->mPanGestureDetector;
 682 }
 683
 684 TapGestureDetector Control::GetTapGestureDetector() const
 685 {
 686   return mImpl->mTapGestureDetector;
 687 }
 688
 689 LongPressGestureDetector Control::GetLongPressGestureDetector() const
 690 {
 691   return mImpl->mLongPressGestureDetector;
 692 }
 693
 694 void Control::SetBackgroundColor( const Vector4& color )
 695 {
 696   Background& background( mImpl->GetBackground() );
 697
 698   if ( background.actor )
 699   {
 700     // Just set the actor color
 701     background.actor.SetColor( color );
 702   }
 703   else
 704   {
 705     // Create Mesh Actor
 706     MeshActor meshActor = MeshActor::New( CreateMesh() );
 707
 708     meshActor.SetAffectedByLighting( false );
 709     SetupBackgroundActor( meshActor, Actor::SCALE, color );
 710
 711     // Set the background actor before adding so that we do not inform deriving classes
 712     background.actor = meshActor;
 713     Self().Add( meshActor );
 714   }
 715
 716   background.color = color;
 717 }
 718
 719 Vector4 Control::GetBackgroundColor() const
 720 {
 721   if ( mImpl->mBackground )
 722   {
 723     return mImpl->mBackground->color;
 724   }
 725   return Color::TRANSPARENT;
 726 }
 727
 728 void Control::SetBackground( Image image )
 729 {
 730   Background& background( mImpl->GetBackground() );
 731
 732   if ( background.actor )
 733   {
 734     // Remove Current actor, unset AFTER removal so that we do not inform deriving classes
 735     Self().Remove( background.actor );
 736     background.actor = NULL;
 737   }
 738
 739   ImageActor imageActor = ImageActor::New( image );
 740   SetupBackgroundActor( imageActor, Actor::SIZE, background.color );
 741
 742   // Set the background actor before adding so that we do not inform derived classes
 743   background.actor = imageActor;
 744   Self().Add( imageActor );
 745 }
 746
 747 void Control::ClearBackground()
 748 {
 749   if ( mImpl->mBackground )
 750   {
 751     Background& background( mImpl->GetBackground() );
 752     Self().Remove( background.actor );
 753
 754     delete mImpl->mBackground;
 755     mImpl->mBackground = NULL;
 756   }
 757 }
 758
 759 Actor Control::GetBackgroundActor() const
 760 {
 761   if ( mImpl->mBackground )
 762   {
 763     return mImpl->mBackground->actor;
 764   }
 765
 766   return Actor();
 767 }
 768
 769 void Control::OnThemeChange( Toolkit::StyleManager styleManager )
 770 {
 771   GetImpl( styleManager ).ApplyThemeStyle( GetOwner() );
 772 }
 773
 774 void Control::OnPinch(PinchGesture pinch)
 775 {
 776   if( !( mImpl->mStartingPinchScale ) )
 777   {
 778     // lazy allocate
 779     mImpl->mStartingPinchScale = new Vector3;
 780   }
 781
 782   if( pinch.state == Gesture::Started )
 783   {
 784     *( mImpl->mStartingPinchScale ) = Self().GetCurrentScale();
 785   }
 786
 787   Self().SetScale( *( mImpl->mStartingPinchScale ) * pinch.scale );
 788 }
 789
 790 void Control::OnStageConnection()
 791 {
 792   RelayoutRequest();
 793
 794   // Notify derived classes.
 795   OnControlStageConnection();
 796 }
 797
 798 void Control::OnStageDisconnection()
 799 {
 800   // Notify derived classes
 801   OnControlStageDisconnection();
 802 }
 803
 804 void Control::OnChildAdd(Actor& child)
 805 {
 806   // If this is the background actor, then we do not want to relayout or inform deriving classes
 807   if ( mImpl->mBackground && ( child == mImpl->mBackground->actor ) )
 808   {
 809     return;
 810   }
 811
 812   // Request for relayout as we may need to position the new child and old ones
 813   RelayoutRequest();
 814
 815   // Notify derived classes.
 816   OnControlChildAdd( child );
 817 }
 818
 819 void Control::OnChildRemove(Actor& child)
 820 {
 821   // If this is the background actor, then we do not want to relayout or inform deriving classes
 822   if ( mImpl->mBackground && ( child == mImpl->mBackground->actor ) )
 823   {
 824     return;
 825   }
 826
 827   // Request for relayout as we may need to re-position the old child
 828   RelayoutRequest();
 829
 830   // Notify derived classes.
 831   OnControlChildRemove( child );
 832 }
 833
 834 void Control::OnSizeSet(const Vector3& targetSize)
 835 {
 836   if( ( !mImpl->mInsideRelayout ) && ( targetSize != mImpl->mNaturalSize ) )
 837   {
 838     // Only updates size if set through Actor's API
 839     mImpl->mNaturalSize = targetSize;
 840   }
 841
 842   if( targetSize != mImpl->mCurrentSize )
 843   {
 844     // Update control size.
 845     mImpl->mCurrentSize = targetSize;
 846
 847     // Notify derived classes.
 848     OnControlSizeSet( targetSize );
 849   }
 850 }
 851
 852 void Control::OnSizeAnimation(Animation& animation, const Vector3& targetSize)
 853 {
 854   // @todo consider animating negotiated child sizes to target size
 855 }
 856
 857 bool Control::OnTouchEvent(const TouchEvent& event)
 858 {
 859   return false; // Do not consume
 860 }
 861
 862 bool Control::OnKeyEvent(const KeyEvent& event)
 863 {
 864   return false; // Do not consume
 865 }
 866
 867 bool Control::OnMouseWheelEvent(const MouseWheelEvent& event)
 868 {
 869   return false; // Do not consume
 870 }
 871
 872 void Control::OnKeyInputFocusGained()
 873 {
 874   // Do Nothing
 875 }
 876
 877 void Control::OnKeyInputFocusLost()
 878 {
 879   // Do Nothing
 880 }
 881
 882 Actor Control::GetChildByAlias(const std::string& actorAlias)
 883 {
 884   return Actor();
 885 }
 886
 887 bool Control::OnAccessibilityPan(PanGesture gesture)
 888 {
 889   return false; // Accessibility pan gesture is not handled by default
 890 }
 891
 892 bool Control::OnAccessibilityTouch(const TouchEvent& touchEvent)
 893 {
 894   return false; // Accessibility touch event is not handled by default
 895 }
 896
 897 bool Control::OnAccessibilityValueChange(bool isIncrease)
 898 {
 899   return false; // Accessibility value change action is not handled by default
 900 }
 901
 902
 903 void Control::SetKeyboardNavigationSupport(bool isSupported)
 904 {
 905   mImpl->mIsKeyboardNavigationSupported = isSupported;
 906 }
 907
 908 bool Control::IsKeyboardNavigationSupported()
 909 {
 910   return mImpl->mIsKeyboardNavigationSupported;
 911 }
 912
 913 void Control::SetAsKeyboardFocusGroup(bool isFocusGroup)
 914 {
 915   mImpl->mIsKeyboardFocusGroup = isFocusGroup;
 916
 917   // The following line will be removed when the deprecated API in KeyboardFocusManager is deleted
 918   Toolkit::KeyboardFocusManager::Get().SetAsFocusGroup(Self(), isFocusGroup);
 919 }
 920
 921 bool Control::IsKeyboardFocusGroup()
 922 {
 923   return Toolkit::KeyboardFocusManager::Get().IsFocusGroup(Self());
 924 }
 925
 926 Actor Control::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
 927 {
 928   return Actor();
 929 }
 930
 931 bool Control::DoAction(BaseObject* object, const std::string& actionName, const std::vector<Property::Value>& attributes)
 932 {
 933   bool ret = false;
 934
 935   if( object && (actionName == Toolkit::Control::ACTION_CONTROL_ACTIVATED) )
 936   {
 937     Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
 938     if( control )
 939     {
 940       // if cast succeeds there is an implementation so no need to check
 941       control.GetImplementation().OnActivated();
 942     }
 943   }
 944
 945   return ret;
 946 }
 947
 948 void Control::DoStyleChange( Toolkit::StyleManager styleManager, StyleChange change )
 949 {
 950   if( change.themeChange )
 951   {
 952     OnThemeChange( styleManager );
 953   }
 954   else if( change.defaultFontChange || change.defaultFontSizeChange )
 955   {
 956     // This OnStyleChange(StyleChange change ) is deprecated, use OnFontChange instead
 957     OnStyleChange( change );
 958
 959     OnFontChange( change.defaultFontChange, change.defaultFontSizeChange );
 960   }
 961 }
 962
 963 Toolkit::Control::KeyEventSignalV2& Control::KeyEventSignal()
 964 {
 965   return mImpl->mKeyEventSignalV2;
 966 }
 967
 968 void Control::SetSizePolicy( Toolkit::Control::SizePolicy widthPolicy, Toolkit::Control::SizePolicy heightPolicy )
 969 {
 970   bool relayoutRequest( false );
 971
 972   if ( ( mImpl->mWidthPolicy != widthPolicy ) || ( mImpl->mHeightPolicy != heightPolicy ) )
 973   {
 974     relayoutRequest = true;
 975   }
 976
 977   mImpl->mWidthPolicy = widthPolicy;
 978   mImpl->mHeightPolicy = heightPolicy;
 979
 980   // Ensure RelayoutRequest is called AFTER new policies have been set.
 981   if ( relayoutRequest )
 982   {
 983     RelayoutRequest();
 984   }
 985 }
 986
 987 void Control::GetSizePolicy( Toolkit::Control::SizePolicy& widthPolicy, Toolkit::Control::SizePolicy& heightPolicy ) const
 988 {
 989   widthPolicy = mImpl->mWidthPolicy;
 990   heightPolicy = mImpl->mHeightPolicy;
 991 }
 992
 993 void Control::SetMinimumSize( const Vector3& size )
 994 {
 995   const Vector3& minSize = mImpl->GetMinimumSize();
 996   if ( fabsf( minSize.width - size.width ) > Math::MACHINE_EPSILON_1000 ||
 997        fabsf( minSize.height - size.height ) > Math::MACHINE_EPSILON_1000 )
 998   {
 999     mImpl->SetMinimumSize( size );
1000
1001     // Only relayout if our control is using the minimum or range policy.
1002     if ( ( mImpl->mHeightPolicy == Toolkit::Control::Minimum ) || ( mImpl->mWidthPolicy  == Toolkit::Control::Minimum ) ||
1003          ( mImpl->mHeightPolicy == Toolkit::Control::Range   ) || ( mImpl->mWidthPolicy  == Toolkit::Control::Range   ) )
1004     {
1005       RelayoutRequest();
1006     }
1007   }
1008 }
1009
1010 const Vector3& Control::GetMinimumSize() const
1011 {
1012   return mImpl->GetMinimumSize();
1013 }
1014
1015 void Control::SetMaximumSize( const Vector3& size )
1016 {
1017   const Vector3& maxSize = mImpl->GetMaximumSize();
1018   if ( fabsf( maxSize.width - size.width ) > Math::MACHINE_EPSILON_1000 ||
1019        fabsf( maxSize.height - size.height ) > Math::MACHINE_EPSILON_1000 )
1020   {
1021     mImpl->SetMaximumSize( size );
1022
1023     // Only relayout if our control is using the maximum or range policy.
1024     if ( ( mImpl->mHeightPolicy == Toolkit::Control::Maximum ) || ( mImpl->mWidthPolicy  == Toolkit::Control::Maximum ) ||
1025          ( mImpl->mHeightPolicy == Toolkit::Control::Range   ) || ( mImpl->mWidthPolicy  == Toolkit::Control::Range   ) )
1026     {
1027       RelayoutRequest();
1028     }
1029   }
1030 }
1031
1032 const Vector3& Control::GetMaximumSize() const
1033 {
1034   return mImpl->GetMaximumSize();
1035 }
1036
1037 Vector3 Control::GetNaturalSize()
1038 {
1039   // could be overridden in derived classes.
1040   return mImpl->mNaturalSize;
1041 }
1042
1043 float Control::GetHeightForWidth( float width )
1044 {
1045   // could be overridden in derived classes.
1046   float height( 0.0f );
1047   if ( mImpl->mNaturalSize.width > 0.0f )
1048   {
1049     height = mImpl->mNaturalSize.height * width / mImpl->mNaturalSize.width;
1050   }
1051   return height;
1052 }
1053
1054 float Control::GetWidthForHeight( float height )
1055 {
1056   // could be overridden in derived classes.
1057   float width( 0.0f );
1058   if ( mImpl->mNaturalSize.height > 0.0f )
1059   {
1060     width = mImpl->mNaturalSize.width * height / mImpl->mNaturalSize.height;
1061   }
1062   return width;
1063 }
1064
1065 const Vector3& Control::GetControlSize() const
1066 {
1067   return mImpl->mCurrentSize;
1068 }
1069
1070 const Vector3& Control::GetSizeSet() const
1071 {
1072   return mImpl->mNaturalSize;
1073 }
1074
1075 void Control::SetKeyInputFocus()
1076 {
1077   if( Self().OnStage() )
1078   {
1079     Toolkit::KeyInputFocusManager::Get().SetFocus(Toolkit::Control::DownCast(Self()));
1080   }
1081 }
1082
1083 bool Control::HasKeyInputFocus()
1084 {
1085   bool result = false;
1086   if( Self().OnStage() )
1087   {
1088     result = Toolkit::KeyInputFocusManager::Get().IsKeyboardListener(Toolkit::Control::DownCast(Self()));
1089   }
1090   return result;
1091 }
1092
1093 void Control::ClearKeyInputFocus()
1094 {
1095   if( Self().OnStage() )
1096   {
1097     Toolkit::KeyInputFocusManager::Get().RemoveFocus(Toolkit::Control::DownCast(Self()));
1098   }
1099 }
1100
1101 void Control::RelayoutRequest()
1102 {
1103   // unfortunate double negative but thats to guarantee new controls get size negotiation
1104   // by default and have to "opt-out" if they dont want it
1105   if( !(mImpl->mFlags & NO_SIZE_NEGOTIATION) )
1106   {
1107     Internal::RelayoutController::Request();
1108   }
1109 }
1110
1111 void Control::Relayout(Vector2 size, ActorSizeContainer& container)
1112 {
1113   // Avoids relayout again when OnSizeSet callback arrives.
1114   mImpl->mInsideRelayout = true;
1115   Self().SetSize( size );
1116   // @todo this really needs to be at the end of method but not sure why the scope used to be only the SetSize, needs to be cleaned up in size negotiation rework
1117   mImpl->mInsideRelayout = false;
1118
1119   // Only relayout controls which requested to be relaid out.
1120   OnRelaidOut( size, container );
1121 }
1122
1123 void Control::Relayout( Actor actor, Vector2 size, ActorSizeContainer& container )
1124 {
1125   if ( actor )
1126   {
1127     Toolkit::Control control( Toolkit::Control::DownCast( actor ) );
1128     if( control )
1129     {
1130       control.GetImplementation().NegotiateSize( size, container );
1131     }
1132     else
1133     {
1134       container.push_back( ActorSizePair( actor, size ) );
1135     }
1136   }
1137 }
1138
1139 void Control::OnRelaidOut( Vector2 size, ActorSizeContainer& container )
1140 {
1141   unsigned int numChildren = Self().GetChildCount();
1142
1143   for( unsigned int i=0; i<numChildren; ++i )
1144   {
1145     container.push_back( ActorSizePair( Self().GetChildAt(i), size ) );
1146   }
1147 }
1148
1149 void Control::NegotiateSize( Vector2 allocatedSize, ActorSizeContainer& container )
1150 {
1151   Vector2 size;
1152
1153   if ( mImpl->mWidthPolicy == Toolkit::Control::Fixed )
1154   {
1155     if ( mImpl->mHeightPolicy == Toolkit::Control::Fixed )
1156     {
1157       // If a control says it has a fixed size, then use the size set by the application / control.
1158       Vector2 setSize( mImpl->mNaturalSize );
1159       if ( setSize != Vector2::ZERO )
1160       {
1161         size = setSize;
1162
1163         // Policy is set to Fixed, so if the application / control has not set one of the dimensions,
1164         // then we should use the natural size of the control rather than the full allocation.
1165         if ( EqualsZero( size.width ) )
1166         {
1167           size.width = GetWidthForHeight( size.height );
1168         }
1169         else if ( EqualsZero( size.height ) )
1170         {
1171           size.height = GetHeightForWidth( size.width );
1172         }
1173       }
1174       else
1175       {
1176         // If that is not set then set the size to the control's natural size
1177         size = Vector2( GetNaturalSize() );
1178       }
1179     }
1180     else
1181     {
1182       // Width is fixed so if the application / control has set it, then use that.
1183       if ( !EqualsZero( mImpl->mNaturalSize.width ) )
1184       {
1185         size.width = mImpl->mNaturalSize.width;
1186       }
1187       else
1188       {
1189         // Otherwise, set the width to what has been allocated.
1190         size.width = allocatedSize.width;
1191       }
1192
1193       // Height is flexible so ask control what the height should be for our width.
1194       size.height = GetHeightForWidth( size.width );
1195
1196       // Ensure height is within our policy rules
1197       size.height = Calculate( mImpl->mHeightPolicy, GetMinimumSize().height, GetMaximumSize().height, size.height );
1198     }
1199   }
1200   else
1201   {
1202     if ( mImpl->mHeightPolicy == Toolkit::Control::Fixed )
1203     {
1204       // Height is fixed so if the application / control has set it, then use that.
1205       if ( !EqualsZero( mImpl->mNaturalSize.height ) )
1206       {
1207         size.height = mImpl->mNaturalSize.height;
1208       }
1209       else
1210       {
1211         // Otherwise, set the height to what has been allocated.
1212         size.height = allocatedSize.height;
1213       }
1214
1215       // Width is flexible so ask control what the width should be for our height.
1216       size.width = GetWidthForHeight( size.height );
1217
1218       // Ensure width is within our policy rules
1219       size.width = Calculate( mImpl->mWidthPolicy, mImpl->GetMinimumSize().width, mImpl->GetMaximumSize().width, size.width );
1220     }
1221     else
1222     {
1223       // Width and height are BOTH flexible.
1224       // Calculate the width and height using the policy rules.
1225       size.width = Calculate( mImpl->mWidthPolicy, mImpl->GetMinimumSize().width, mImpl->GetMaximumSize().width, allocatedSize.width );
1226       size.height = Calculate( mImpl->mHeightPolicy, mImpl->GetMinimumSize().height, mImpl->GetMaximumSize().height, allocatedSize.height );
1227     }
1228   }
1229
1230   // If the width has not been set, then set to the allocated width.
1231   // Also if the width set is greater than the allocated, then set to allocated (no exceed support).
1232   if ( EqualsZero( size.width ) || ( size.width > allocatedSize.width ) )
1233   {
1234     size.width = allocatedSize.width;
1235   }
1236
1237   // If the height has not been set, then set to the allocated height.
1238   // Also if the height set is greater than the allocated, then set to allocated (no exceed support).
1239   if ( EqualsZero( size.height ) || ( size.height > allocatedSize.height ) )
1240   {
1241     size.height = allocatedSize.height;
1242   }
1243
1244   DALI_LOG_INFO( gLogFilter, Debug::Verbose,
1245                  "%p: Natural: [%.2f, %.2f] Allocated: [%.2f, %.2f] Set: [%.2f, %.2f]\n",
1246                  Self().GetObjectPtr(),
1247                  GetNaturalSize().x, GetNaturalSize().y,
1248                  allocatedSize.x, allocatedSize.y,
1249                  size.x, size.y );
1250
1251   Relayout( size, container );
1252 }
1253
1254 bool Control::EmitKeyEventSignal( const KeyEvent& event )
1255 {
1256   // Guard against destruction during signal emission
1257   Dali::Toolkit::Control handle( GetOwner() );
1258
1259   bool consumed = false;
1260
1261   // signals are allocated dynamically when someone connects
1262   if ( !mImpl->mKeyEventSignalV2.Empty() )
1263   {
1264     consumed = mImpl->mKeyEventSignalV2.Emit( handle, event );
1265   }
1266
1267   if (!consumed)
1268   {
1269     // Notification for derived classes
1270     consumed = OnKeyEvent(event);
1271   }
1272
1273   return consumed;
1274 }
1275
1276 void Control::SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
1277 {
1278   mImpl->SignalConnected( slotObserver, callback );
1279 }
1280
1281 void Control::SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback )
1282 {
1283   mImpl->SignalDisconnected( slotObserver, callback );
1284 }
1285
1286 std::size_t Control::GetConnectionCount() const
1287 {
1288   return mImpl->GetConnectionCount();
1289 }
1290
1291 Control::Control( bool requiresTouchEvents )
1292 : CustomActorImpl( requiresTouchEvents ),
1293   mImpl(new Impl(*this))
1294 {
1295 }
1296
1297 Control::Control( ControlBehaviour behaviourFlags )
1298 : CustomActorImpl( behaviourFlags & REQUIRES_TOUCH_EVENTS ),
1299   mImpl(new Impl(*this))
1300 {
1301   mImpl->mFlags = behaviourFlags;
1302 }
1303
1304 } // namespace Internal
1305
1306 } // namespace Toolkit
1307
1308 } // namespace Dali