dali-toolkit/public-api/controls/control-impl.h

   1 #ifndef DALI_TOOLKIT_CONTROL_IMPL_H
   2 #define DALI_TOOLKIT_CONTROL_IMPL_H
   3
   4 /*
   5  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/adaptor-framework/style-change.h>
  23 #include <dali/public-api/animation/alpha-function.h>
  24 #include <dali/public-api/animation/time-period.h>
  25 #include <dali/public-api/events/long-press-gesture.h>
  26 #include <dali/public-api/events/pan-gesture.h>
  27 #include <dali/public-api/events/pinch-gesture.h>
  28 #include <dali/public-api/events/tap-gesture.h>
  29 #include <dali/public-api/object/property-index-ranges.h>
  30 #include <dali/public-api/object/type-info.h>
  31
  32 // INTERNAL INCLUDES
  33 #include <dali-toolkit/public-api/controls/control.h>
  34
  35 namespace Dali
  36 {
  37 namespace Toolkit
  38 {
  39 /**
  40  * @addtogroup dali_toolkit_controls
  41  * @{
  42  */
  43
  44 class StyleManager;
  45
  46 namespace DevelControl
  47 {
  48 class ControlAccessible;
  49
  50 } // namespace DevelControl
  51
  52 namespace Internal
  53 {
  54
  55 /**
  56  * @brief This is the internal base class for all controls.
  57  *
  58  * It will provide some common functionality required by all controls.
  59  * Implements ConnectionTrackerInterface so that signals (typically connected to member functions) will
  60  * be disconnected automatically when the control is destroyed.
  61  * @SINCE_1_0.0
  62  */
  63 class DALI_TOOLKIT_API Control : public CustomActorImpl, public ConnectionTrackerInterface
  64 {
  65 public:
  66   class Extension; ///< Forward declare future extension interface
  67
  68   // Creation & Destruction
  69   /**
  70    * @brief Creates a new ControlImpl instance that does not require touch by default.
  71    *
  72    * If touch is required, then the user can connect to this class' touch signal.
  73    * @SINCE_1_0.0
  74    * @return A handle to the ControlImpl instance
  75    */
  76   static Toolkit::Control New();
  77
  78 protected:
  79   /**
  80    * @brief Virtual destructor.
  81    * @SINCE_1_0.0
  82    */
  83   virtual ~Control();
  84
  85 public:
  86   // Styling
  87
  88   /**
  89    * @copydoc Dali::Toolkit::Control::SetStyleName
  90    */
  91   void SetStyleName(const std::string& styleName);
  92
  93   /**
  94    * @copydoc Dali::Toolkit::Control::GetStyleName
  95    */
  96   const std::string& GetStyleName() const;
  97
  98   // Background
  99
 100   /**
 101    * @copydoc Dali::Toolkit::Control::SetBackgroundColor
 102    */
 103   void SetBackgroundColor(const Vector4& color);
 104
 105   /**
 106    * @brief Sets the background with a property map.
 107    *
 108    * @SINCE_1_0.0
 109    * @param[in] map The background property map
 110    */
 111   void SetBackground(const Property::Map& map);
 112
 113   /**
 114    * @copydoc Dali::Toolkit::Control::ClearBackground
 115    */
 116   void ClearBackground();
 117
 118   // Accessibility
 119
 120   /**
 121    * @brief Gets the Accessible object that represents this control.
 122    *
 123    * This method calls CreateAccessibleObject() if necessary, so a non-null return is expected.
 124    *
 125    * @return The Accessible object
 126    *
 127    * @see CreateAccessibleObject()
 128    */
 129   Toolkit::DevelControl::ControlAccessible* GetAccessibleObject();
 130
 131   // Gesture Detection
 132
 133   /**
 134    * @brief Allows deriving classes to enable any of the gesture detectors that are available.
 135    *
 136    * Gesture detection can be enabled one at a time or in bitwise format as shown:
 137    * @code
 138    * EnableGestureDetection(GestureType::Value(GestureType::PINCH | GestureType::TAP | GestureType::PAN));
 139    * @endcode
 140    * @SINCE_1_0.0
 141    * @param[in] type The gesture type(s) to enable
 142    */
 143   void EnableGestureDetection(GestureType::Value type);
 144
 145   /**
 146    * @brief Allows deriving classes to disable any of the gesture detectors.
 147    *
 148    * Like EnableGestureDetection, this can also be called using bitwise or.
 149    * @SINCE_1_0.0
 150    * @param[in] type The gesture type(s) to disable
 151    * @see EnableGetureDetection
 152    */
 153   void DisableGestureDetection(GestureType::Value type);
 154
 155   /**
 156    * @brief If deriving classes wish to fine tune pinch gesture
 157    * detection, then they can access the gesture detector through this
 158    * API and modify the detection.
 159    *
 160    * @SINCE_1_0.0
 161    * @return The pinch gesture detector
 162    * @pre Pinch detection should have been enabled via EnableGestureDetection().
 163    * @see EnableGestureDetection
 164    */
 165   PinchGestureDetector GetPinchGestureDetector() const;
 166
 167   /**
 168    * @brief If deriving classes wish to fine tune pan gesture
 169    * detection, then they can access the gesture detector through this
 170    * API and modify the detection.
 171    *
 172    * @SINCE_1_0.0
 173    * @return The pan gesture detector
 174    * @pre Pan detection should have been enabled via EnableGestureDetection().
 175    * @see EnableGestureDetection
 176    */
 177   PanGestureDetector GetPanGestureDetector() const;
 178
 179   /**
 180    * @brief If deriving classes wish to fine tune tap gesture
 181    * detection, then they can access the gesture detector through this
 182    * API and modify the detection.
 183    *
 184    * @SINCE_1_0.0
 185    * @return The tap gesture detector
 186    * @pre Tap detection should have been enabled via EnableGestureDetection().
 187    * @see EnableGestureDetection
 188    */
 189   TapGestureDetector GetTapGestureDetector() const;
 190
 191   /**
 192    * @brief If deriving classes wish to fine tune long press gesture
 193    * detection, then they can access the gesture detector through this
 194    * API and modify the detection.
 195    *
 196    * @SINCE_1_0.0
 197    * @return The long press gesture detector
 198    * @pre Long press detection should have been enabled via EnableGestureDetection().
 199    * @see EnableGestureDetection
 200    */
 201   LongPressGestureDetector GetLongPressGestureDetector() const;
 202
 203   // Keyboard Navigation
 204
 205   /**
 206    * @brief Sets whether this control supports two dimensional
 207    * keyboard navigation (i.e. whether it knows how to handle the
 208    * keyboard focus movement between its child actors).
 209    *
 210    * The control doesn't support it by default.
 211    * @SINCE_1_0.0
 212    * @param[in] isSupported Whether this control supports two dimensional keyboard navigation
 213    */
 214   void SetKeyboardNavigationSupport(bool isSupported);
 215
 216   /**
 217    * @brief Gets whether this control supports two dimensional keyboard navigation.
 218    *
 219    * @SINCE_1_0.0
 220    * @return true if this control supports two dimensional keyboard navigation
 221    */
 222   bool IsKeyboardNavigationSupported();
 223
 224   // Key Input
 225
 226   /**
 227    * @copydoc Toolkit::Control::SetKeyInputFocus()
 228    */
 229   void SetKeyInputFocus();
 230
 231   /**
 232    * @copydoc Toolkit::Control::HasKeyInputFocus()
 233    */
 234   bool HasKeyInputFocus();
 235
 236   /**
 237    * @copydoc Toolkit::Control::ClearKeyInputFocus()
 238    */
 239   void ClearKeyInputFocus();
 240
 241   // Keyboard Focus
 242
 243   /**
 244    * @brief Sets whether this control is a focus group for keyboard navigation.
 245    *
 246    * (i.e. the scope of keyboard focus movement
 247    * can be limited to its child actors). The control is not a focus group by default.
 248    * @SINCE_1_0.0
 249    * @param[in] isFocusGroup Whether this control is set as a focus group for keyboard navigation
 250    */
 251   void SetAsKeyboardFocusGroup(bool isFocusGroup);
 252
 253   /**
 254    * @brief Gets whether this control is a focus group for keyboard navigation.
 255    *
 256    * @SINCE_1_0.0
 257    * @return true if this control is set as a focus group for keyboard navigation
 258    */
 259   bool IsKeyboardFocusGroup();
 260
 261   /// @cond internal
 262   /**
 263    * @brief Called by the AccessibilityManager to activate the Control.
 264    * @SINCE_1_0.0
 265    */
 266   DALI_INTERNAL void AccessibilityActivate();
 267
 268   /**
 269    * @brief Called by the KeyboardFocusManager.
 270    * @SINCE_1_0.0
 271    */
 272   DALI_INTERNAL void KeyboardEnter();
 273   /// @endcond
 274
 275
 276   // Signals
 277
 278   /**
 279    * @copydoc Dali::Toolkit::Control::KeyEventSignal()
 280    */
 281   Toolkit::Control::KeyEventSignalType& KeyEventSignal();
 282
 283   /**
 284    * @copydoc Dali::Toolkit::Control::KeyInputFocusGainedSignal()
 285    */
 286   Toolkit::Control::KeyInputFocusSignalType& KeyInputFocusGainedSignal();
 287
 288   /**
 289    * @copydoc Dali::Toolkit::Control::KeyInputFocusLostSignal()
 290    */
 291   Toolkit::Control::KeyInputFocusSignalType& KeyInputFocusLostSignal();
 292
 293   /// @cond internal
 294   /**
 295    * @brief Called by the KeyInputFocusManager to emit key event signals.
 296    *
 297    * @SINCE_1_0.0
 298    * @param[in] event The key event
 299    * @return True if the event was consumed
 300    */
 301   DALI_INTERNAL bool EmitKeyEventSignal(const KeyEvent& event);
 302   /// @endcond
 303
 304 protected: // For derived classes to call
 305   /**
 306    * @brief Emits KeyInputFocusGained signal if true else emits KeyInputFocusLost signal.
 307    *
 308    * Should be called last by the control after it acts on the Input Focus change.
 309    *
 310    * @SINCE_1_0.0
 311    * @param[in] focusGained True if gained, False if lost
 312    */
 313   void EmitKeyInputFocusSignal(bool focusGained);
 314
 315 protected: // From CustomActorImpl
 316   /**
 317    * @copydoc CustomActorImpl::OnSceneConnection()
 318    * @note If overridden, then an up-call to Control::OnSceneConnection MUST be made at the end.
 319    */
 320   void OnSceneConnection(int depth) override;
 321
 322   /**
 323    * @copydoc CustomActorImpl::OnSceneDisconnection()
 324    * @note If overridden, then an up-call to Control::OnSceneDisconnection MUST be made at the end.
 325    */
 326   void OnSceneDisconnection() override;
 327
 328   /**
 329    * @copydoc CustomActorImpl::OnChildAdd()
 330    * @note If overridden, then an up-call to Control::OnChildAdd MUST be made at the end.
 331    */
 332   void OnChildAdd(Actor& child) override;
 333
 334   /**
 335    * @copydoc CustomActorImpl::OnChildRemove()
 336    * @note If overridden, then an up-call to Control::OnChildRemove MUST be made at the end.
 337    */
 338   void OnChildRemove(Actor& child) override;
 339
 340   /**
 341    * @copydoc CustomActorImpl::OnPropertySet()
 342    * @note If overridden, then an up-call to Control::OnChildRemove MUST be made at the end.
 343    */
 344   void OnPropertySet(Property::Index index, const Property::Value& propertyValue) override;
 345
 346   /**
 347    * @copydoc CustomActorImpl::OnSizeSet()
 348    * @note If overridden, then an up-call to Control::OnSizeSet MUST be made at the end.
 349    */
 350   void OnSizeSet(const Vector3& targetSize) override;
 351
 352   /**
 353    * @copydoc CustomActorImpl::OnSizeAnimation()
 354    * @note If overridden, then an up-call to Control::OnSizeAnimation MUST be made at the end.
 355    */
 356   void OnSizeAnimation(Animation& animation, const Vector3& targetSize) override;
 357
 358   /**
 359    * @copydoc CustomActorImpl::OnRelayout()
 360    */
 361   void OnRelayout(const Vector2& size, RelayoutContainer& container) override;
 362
 363   /**
 364    * @copydoc CustomActorImpl::OnSetResizePolicy()
 365    */
 366   void OnSetResizePolicy(ResizePolicy::Type policy, Dimension::Type dimension) override;
 367
 368   /**
 369    * @copydoc CustomActorImpl::GetNaturalSize()
 370    */
 371   Vector3 GetNaturalSize() override;
 372
 373   /**
 374    * @copydoc CustomActorImpl::CalculateChildSize()
 375    */
 376   float CalculateChildSize(const Dali::Actor& child, Dimension::Type dimension) override;
 377
 378   /**
 379    * @copydoc CustomActorImpl::GetHeightForWidth()
 380    */
 381   float GetHeightForWidth(float width) override;
 382
 383   /**
 384    * @copydoc CustomActorImpl::GetWidthForHeight()
 385    */
 386   float GetWidthForHeight(float height) override;
 387
 388   /**
 389    * @copydoc CustomActorImpl::RelayoutDependentOnChildren()
 390    */
 391   bool RelayoutDependentOnChildren(Dimension::Type dimension = Dimension::ALL_DIMENSIONS) override;
 392
 393   /**
 394    * @copydoc CustomActorImpl::OnCalculateRelayoutSize()
 395    */
 396   void OnCalculateRelayoutSize(Dimension::Type dimension) override;
 397
 398   /**
 399    * @copydoc CustomActorImpl::OnLayoutNegotiated()
 400    */
 401   void OnLayoutNegotiated(float size, Dimension::Type dimension) override;
 402
 403 public: // Helpers for deriving classes
 404
 405   /**
 406    * @brief Flags for the constructor.
 407    * @SINCE_1_0.0
 408    */
 409   enum ControlBehaviour
 410   {
 411     CONTROL_BEHAVIOUR_DEFAULT            = 0, ///< Default behaviour: Size negotiation is enabled & listens to Style Change signal, but doesn't receive event callbacks. @SINCE_1_2_10
 412     NOT_IN_USE_1                         = 1 << (CustomActorImpl::ACTOR_FLAG_COUNT + 0),
 413     REQUIRES_KEYBOARD_NAVIGATION_SUPPORT = 1 << (CustomActorImpl::ACTOR_FLAG_COUNT + 1), ///< True if needs to support keyboard navigation @SINCE_1_0.0
 414     DISABLE_STYLE_CHANGE_SIGNALS         = 1 << (CustomActorImpl::ACTOR_FLAG_COUNT + 2), ///< True if control should not monitor style change signals @SINCE_1_2_10
 415
 416     LAST_CONTROL_BEHAVIOUR_FLAG
 417   };
 418
 419   static const int CONTROL_BEHAVIOUR_FLAG_COUNT = Log<LAST_CONTROL_BEHAVIOUR_FLAG - 1>::value + 1; ///< Total count of flags
 420
 421   /**
 422    * @brief Creates a new ControlImpl instance that does not require touch by default.
 423    *
 424    * If touch is required, then the user can connect to this class' touch signal.
 425    * @SINCE_2_1.8
 426    * @param[in] additionalBehaviour Additional control behaviour.
 427    * @return A handle to the ControlImpl instance
 428    */
 429   static Toolkit::Control New(ControlBehaviour additionalBehaviour);
 430
 431 protected:
 432   // Construction
 433
 434   /**
 435    * @brief Control constructor.
 436    *
 437    * @SINCE_1_0.0
 438    * @param[in] behaviourFlags Behavioural flags from ControlBehaviour enum
 439    */
 440   Control(ControlBehaviour behaviourFlags);
 441
 442   /**
 443    * @brief Second phase initialization.
 444    * @SINCE_1_0.0
 445    */
 446   void Initialize();
 447
 448 public: // API for derived classes to override
 449   // Lifecycle
 450
 451   /**
 452    * @brief This method is called after the Control has been initialized.
 453    *
 454    * Derived classes should do any second phase initialization by overriding this method.
 455    * @SINCE_1_0.0
 456    */
 457   virtual void OnInitialize();
 458
 459   // Styling
 460
 461   /**
 462    * @brief This method should be overridden by deriving classes requiring notifications when the style changes.
 463    *
 464    * @SINCE_1_0.0
 465    * @param[in] styleManager The StyleManager object
 466    * @param[in] change Information denoting what has changed
 467    */
 468   virtual void OnStyleChange(Toolkit::StyleManager styleManager, StyleChange::Type change);
 469
 470   // Accessibility
 471
 472   /**
 473    * @brief This method is called when the control is accessibility activated.
 474    *
 475    * Derived classes should override this to perform custom accessibility activation.
 476    * @SINCE_1_0.0
 477    * @return true if this control can perform accessibility activation
 478    */
 479   virtual bool OnAccessibilityActivated();
 480
 481   /**
 482    * @brief This method should be overridden by deriving classes when they wish to respond the accessibility
 483    * pan gesture.
 484    *
 485    * @SINCE_1_0.0
 486    * @param[in] gesture The pan gesture
 487    * @return true if the pan gesture has been consumed by this control
 488    */
 489   virtual bool OnAccessibilityPan(PanGesture gesture);
 490
 491   /**
 492    * @brief This method should be overridden by deriving classes when they wish to respond
 493    * the accessibility up and down action (i.e. value change of slider control).
 494    *
 495    * @SINCE_1_0.0
 496    * @param[in] isIncrease Whether the value should be increased or decreased
 497    * @return true if the value changed action has been consumed by this control
 498    */
 499   virtual bool OnAccessibilityValueChange(bool isIncrease);
 500
 501   /**
 502    * @brief This method should be overridden by deriving classes when they wish to respond
 503    * the accessibility zoom action.
 504    *
 505    * @SINCE_1_0.0
 506    * @return true if the zoom action has been consumed by this control
 507    */
 508   virtual bool OnAccessibilityZoom();
 509
 510   /**
 511    * @brief This method should be overriden by deriving classes when they wish to be
 512    * represented by a custom Accessible object implementation.
 513    *
 514    * The AT-SPI infrastructure is responsible for destroying the returned object.
 515    *
 516    * Currently, this method is called at most once in a given Control's lifetime, when
 517    * GetAccessibleObject() is called for the first time. A future version of the
 518    * AT-SPI infrastructure, however, may delete the Accessible object and request a new
 519    * one to be created (by calling this method) multiple times, for example during
 520    * scene connection and disconnection.
 521    *
 522    * @return The newly created Accessible object
 523    *
 524    * @see GetAccessibleObject()
 525    */
 526   virtual DevelControl::ControlAccessible* CreateAccessibleObject();
 527
 528   // Keyboard focus
 529
 530   /**
 531    * @brief Called when the control gains key input focus.
 532    *
 533    * Should be overridden by derived classes if they need to customize what happens when focus is gained.
 534    * @SINCE_1_0.0
 535    */
 536   virtual void OnKeyInputFocusGained();
 537
 538   /**
 539    * @brief Called when the control loses key input focus.
 540    *
 541    * Should be overridden by derived classes if they need to customize what happens when focus is lost.
 542    * @SINCE_1_0.0
 543    */
 544   virtual void OnKeyInputFocusLost();
 545
 546   /**
 547    * @brief Gets the next keyboard focusable actor in this control towards the given direction.
 548    *
 549    * A control needs to override this function in order to support two dimensional keyboard navigation.
 550    * @SINCE_1_0.0
 551    * @param[in] currentFocusedActor The current focused actor
 552    * @param[in] direction The direction to move the focus towards
 553    * @param[in] loopEnabled Whether the focus movement should be looped within the control
 554    * @return The next keyboard focusable actor in this control or an empty handle if no actor can be focused
 555    */
 556   virtual Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled);
 557
 558   /**
 559    * @brief Informs this control that its chosen focusable actor will be focused.
 560    *
 561    * This allows the application to perform any actions if wishes
 562    * before the focus is actually moved to the chosen actor.
 563    *
 564    * @SINCE_1_0.0
 565    * @param[in] commitedFocusableActor The commited focusable actor
 566    */
 567   virtual void OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor);
 568
 569   /**
 570    * @brief This method is called when the control has enter pressed on it.
 571    *
 572    * Derived classes should override this to perform custom actions.
 573    * @SINCE_1_0.0
 574    * @return true if this control supported this action
 575    */
 576   virtual bool OnKeyboardEnter();
 577
 578   /**
 579    * @brief Called after a key-event is received by the actor that has had its focus set.
 580    *
 581    * @SINCE_1_0.0
 582    * @param[in] event The Key Event
 583    * @return True if the event should be consumed
 584    */
 585   virtual bool OnKeyEvent(const KeyEvent& event);
 586
 587   // Gestures
 588
 589   /**
 590    * @brief Called whenever a pinch gesture is detected on this control.
 591    *
 592    * This can be overridden by deriving classes when pinch detection
 593    * is enabled.  The default behaviour is to scale the control by the
 594    * pinch scale.
 595    *
 596    * @SINCE_1_0.0
 597    * @param[in] pinch The pinch gesture
 598    * @note If overridden, then the default behavior will not occur.
 599    * @note Pinch detection should be enabled via EnableGestureDetection().
 600    * @see EnableGestureDetection
 601    */
 602   virtual void OnPinch(const PinchGesture& pinch);
 603
 604   /**
 605    * @brief Called whenever a pan gesture is detected on this control.
 606    *
 607    * This should be overridden by deriving classes when pan detection
 608    * is enabled.
 609    *
 610    * @SINCE_1_0.0
 611    * @param[in] pan The pan gesture
 612    * @note There is no default behavior with panning.
 613    * @note Pan detection should be enabled via EnableGestureDetection().
 614    * @see EnableGestureDetection
 615    */
 616   virtual void OnPan(const PanGesture& pan);
 617
 618   /**
 619    * @brief Called whenever a tap gesture is detected on this control.
 620    *
 621    * This should be overridden by deriving classes when tap detection
 622    * is enabled.
 623    *
 624    * @SINCE_1_0.0
 625    * @param[in] tap The tap gesture
 626    * @note There is no default behavior with a tap.
 627    * @note Tap detection should be enabled via EnableGestureDetection().
 628    * @see EnableGestureDetection
 629    */
 630   virtual void OnTap(const TapGesture& tap);
 631
 632   /**
 633    * @brief Called whenever a long press gesture is detected on this control.
 634    *
 635    * This should be overridden by deriving classes when long press
 636    * detection is enabled.
 637    *
 638    * @SINCE_1_0.0
 639    * @param[in] longPress The long press gesture
 640    * @note There is no default behaviour associated with a long press.
 641    * @note Long press detection should be enabled via EnableGestureDetection().
 642    * @see EnableGestureDetection
 643    */
 644   virtual void OnLongPress(const LongPressGesture& longPress);
 645
 646   // From ConnectionTrackerInterface
 647
 648   /**
 649    * @copydoc ConnectionTrackerInterface::SignalConnected
 650    */
 651   void SignalConnected(SlotObserver* slotObserver, CallbackBase* callback) override;
 652
 653   /**
 654    * @copydoc ConnectionTrackerInterface::SignalDisconnected
 655    */
 656   void SignalDisconnected(SlotObserver* slotObserver, CallbackBase* callback) override;
 657
 658   /**
 659    * @brief Retrieves the extension for this control.
 660    *
 661    * @SINCE_1_0.0
 662    * @return The extension if available, NULL otherwise
 663    */
 664   virtual Extension* GetControlExtension()
 665   {
 666     return NULL;
 667   }
 668
 669   // Transition APIs
 670
 671   /**
 672    * @brief Make visual transition from source control to destination control about specific Visual.
 673    * If both of source and destination control have same visual index, than generates information for the transition of this Control.
 674    *
 675    * @param[out] sourcePropertyMap Source property map to be applied on this Control.
 676    * @param[out] destinationPropertyMap Destination property map to be applied on this Control.
 677    * @param[in] source Source control of the animation.
 678    * @param[in] destination Destination control of the animation.
 679    * @param[in] visualIndex Property::Index to make animation.
 680    */
 681   void MakeVisualTransition(Dali::Property::Map& sourcePropertyMap, Dali::Property::Map& destinationPropertyMap,
 682                             Dali::Toolkit::Control source, Dali::Toolkit::Control destination, Dali::Property::Index visualIndex);
 683
 684   /**
 685    * @brief Retrieves source and destination visual properties for the Transition of this Control.
 686    * The properties of this Control will be transitioned from the propeties of source Control to that of destination control.
 687    * If a property value is different between source and destination Control,
 688    * the property information of each Control will be included in sourceProperties and destinationProperties.
 689    *
 690    * @param[out] sourceProperties Source property list to be applied on this Control.
 691    * @param[out] destinationProperties Destination property list to be applied on this Control.
 692    * @param[in] source Source control of the animation.
 693    * @param[in] destination Destination control of the animation.
 694    *
 695    * @note This method do not handle Actor properties.
 696    * And the size and order of the sourceProperties and destinationProperties must be synchronized.
 697    */
 698   virtual void OnCreateTransitions(std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& sourceProperties,
 699                                    std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& destinationProperties,
 700                                    Dali::Toolkit::Control                                              source,
 701                                    Dali::Toolkit::Control                                              destination)
 702   {
 703   }
 704
 705   /**
 706    * @brief Update visual properties.
 707    * @param[in] properties Property list to be used to update visual properties of this Control.
 708    */
 709   virtual void OnUpdateVisualProperties(const std::vector<std::pair<Dali::Property::Index, Dali::Property::Map>>& properties)
 710   {
 711   }
 712
 713 private:
 714   /// @cond internal
 715
 716   // Not copyable or movable
 717   DALI_INTERNAL Control(const Control&) = delete;            ///< Deleted copy constructor.
 718   DALI_INTERNAL Control(Control&&)      = delete;            ///< Deleted move constructor.
 719   DALI_INTERNAL Control& operator=(const Control&) = delete; ///< Deleted copy assignment operator.
 720   DALI_INTERNAL Control& operator=(Control&&) = delete;      ///< Deleted move assignment operator.
 721
 722 public:
 723   class DALI_INTERNAL Impl; // Class declaration is public so we can internally add devel API's to the Controls Impl
 724
 725 private:
 726   Impl* mImpl;
 727   /// @endcond
 728 };
 729
 730 /**
 731  * @brief Gets implementation from the handle.
 732  *
 733  * @SINCE_1_0.0
 734  * @param handle
 735  * @return Implementation
 736  * @pre handle is initialized and points to a control
 737  */
 738 DALI_TOOLKIT_API Internal::Control& GetImplementation(Dali::Toolkit::Control& handle);
 739
 740 /**
 741  * @brief Gets implementation from the handle.
 742  *
 743  * @SINCE_1_0.0
 744  * @param handle
 745  * @return Implementation
 746  * @pre Handle is initialized and points to a control.
 747  */
 748 DALI_TOOLKIT_API const Internal::Control& GetImplementation(const Dali::Toolkit::Control& handle);
 749
 750 } // namespace Internal
 751
 752 /**
 753  * @}
 754  */
 755 } // namespace Toolkit
 756
 757 } // namespace Dali
 758
 759 #endif // DALI_TOOLKIT_CONTROL_IMPL_H