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