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

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