dali/devel-api/actors/actor-devel.h

   1 #ifndef DALI_ACTOR_DEVEL_H
   2 #define DALI_ACTOR_DEVEL_H
   3
   4 /*
   5  * Copyright (c) 2023 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 // INTERNAL INCLUDES
  22 #include <dali/public-api/actors/actor.h>
  23 #include <dali/public-api/math/rect.h>
  24
  25 namespace Dali
  26 {
  27 namespace DevelActor
  28 {
  29 namespace Property
  30 {
  31 enum Type
  32 {
  33   PARENT_ORIGIN              = Dali::Actor::Property::PARENT_ORIGIN,
  34   PARENT_ORIGIN_X            = Dali::Actor::Property::PARENT_ORIGIN_X,
  35   PARENT_ORIGIN_Y            = Dali::Actor::Property::PARENT_ORIGIN_Y,
  36   PARENT_ORIGIN_Z            = Dali::Actor::Property::PARENT_ORIGIN_Z,
  37   ANCHOR_POINT               = Dali::Actor::Property::ANCHOR_POINT,
  38   ANCHOR_POINT_X             = Dali::Actor::Property::ANCHOR_POINT_X,
  39   ANCHOR_POINT_Y             = Dali::Actor::Property::ANCHOR_POINT_Y,
  40   ANCHOR_POINT_Z             = Dali::Actor::Property::ANCHOR_POINT_Z,
  41   SIZE                       = Dali::Actor::Property::SIZE,
  42   SIZE_WIDTH                 = Dali::Actor::Property::SIZE_WIDTH,
  43   SIZE_HEIGHT                = Dali::Actor::Property::SIZE_HEIGHT,
  44   SIZE_DEPTH                 = Dali::Actor::Property::SIZE_DEPTH,
  45   POSITION                   = Dali::Actor::Property::POSITION,
  46   POSITION_X                 = Dali::Actor::Property::POSITION_X,
  47   POSITION_Y                 = Dali::Actor::Property::POSITION_Y,
  48   POSITION_Z                 = Dali::Actor::Property::POSITION_Z,
  49   WORLD_POSITION             = Dali::Actor::Property::WORLD_POSITION,
  50   WORLD_POSITION_X           = Dali::Actor::Property::WORLD_POSITION_X,
  51   WORLD_POSITION_Y           = Dali::Actor::Property::WORLD_POSITION_Y,
  52   WORLD_POSITION_Z           = Dali::Actor::Property::WORLD_POSITION_Z,
  53   ORIENTATION                = Dali::Actor::Property::ORIENTATION,
  54   WORLD_ORIENTATION          = Dali::Actor::Property::WORLD_ORIENTATION,
  55   SCALE                      = Dali::Actor::Property::SCALE,
  56   SCALE_X                    = Dali::Actor::Property::SCALE_X,
  57   SCALE_Y                    = Dali::Actor::Property::SCALE_Y,
  58   SCALE_Z                    = Dali::Actor::Property::SCALE_Z,
  59   WORLD_SCALE                = Dali::Actor::Property::WORLD_SCALE,
  60   VISIBLE                    = Dali::Actor::Property::VISIBLE,
  61   COLOR                      = Dali::Actor::Property::COLOR,
  62   COLOR_RED                  = Dali::Actor::Property::COLOR_RED,
  63   COLOR_GREEN                = Dali::Actor::Property::COLOR_GREEN,
  64   COLOR_BLUE                 = Dali::Actor::Property::COLOR_BLUE,
  65   COLOR_ALPHA                = Dali::Actor::Property::COLOR_ALPHA,
  66   WORLD_COLOR                = Dali::Actor::Property::WORLD_COLOR,
  67   WORLD_MATRIX               = Dali::Actor::Property::WORLD_MATRIX,
  68   NAME                       = Dali::Actor::Property::NAME,
  69   SENSITIVE                  = Dali::Actor::Property::SENSITIVE,
  70   LEAVE_REQUIRED             = Dali::Actor::Property::LEAVE_REQUIRED,
  71   INHERIT_ORIENTATION        = Dali::Actor::Property::INHERIT_ORIENTATION,
  72   INHERIT_SCALE              = Dali::Actor::Property::INHERIT_SCALE,
  73   COLOR_MODE                 = Dali::Actor::Property::COLOR_MODE,
  74   DRAW_MODE                  = Dali::Actor::Property::DRAW_MODE,
  75   SIZE_MODE_FACTOR           = Dali::Actor::Property::SIZE_MODE_FACTOR,
  76   WIDTH_RESIZE_POLICY        = Dali::Actor::Property::WIDTH_RESIZE_POLICY,
  77   HEIGHT_RESIZE_POLICY       = Dali::Actor::Property::HEIGHT_RESIZE_POLICY,
  78   SIZE_SCALE_POLICY          = Dali::Actor::Property::SIZE_SCALE_POLICY,
  79   WIDTH_FOR_HEIGHT           = Dali::Actor::Property::WIDTH_FOR_HEIGHT,
  80   HEIGHT_FOR_WIDTH           = Dali::Actor::Property::HEIGHT_FOR_WIDTH,
  81   PADDING                    = Dali::Actor::Property::PADDING,
  82   MINIMUM_SIZE               = Dali::Actor::Property::MINIMUM_SIZE,
  83   MAXIMUM_SIZE               = Dali::Actor::Property::MAXIMUM_SIZE,
  84   INHERIT_POSITION           = Dali::Actor::Property::INHERIT_POSITION,
  85   CLIPPING_MODE              = Dali::Actor::Property::CLIPPING_MODE,
  86   LAYOUT_DIRECTION           = Dali::Actor::Property::LAYOUT_DIRECTION,
  87   INHERIT_LAYOUT_DIRECTION   = Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION,
  88   OPACITY                    = Dali::Actor::Property::OPACITY,
  89   SCREEN_POSITION            = Dali::Actor::Property::SCREEN_POSITION,
  90   POSITION_USES_ANCHOR_POINT = Dali::Actor::Property::POSITION_USES_ANCHOR_POINT,
  91   CULLED                     = Dali::Actor::Property::CULLED,
  92   ID                         = Dali::Actor::Property::ID,
  93   HIERARCHY_DEPTH            = Dali::Actor::Property::HIERARCHY_DEPTH,
  94   IS_ROOT                    = Dali::Actor::Property::IS_ROOT,
  95   IS_LAYER                   = Dali::Actor::Property::IS_LAYER,
  96   CONNECTED_TO_SCENE         = Dali::Actor::Property::CONNECTED_TO_SCENE,
  97   KEYBOARD_FOCUSABLE         = Dali::Actor::Property::KEYBOARD_FOCUSABLE,
  98   UPDATE_AREA_HINT           = Dali::Actor::Property::UPDATE_AREA_HINT,
  99
 100   /**
 101    * @brief Sets the sibling order of the actor so depth position can be defined within the same parent.
 102    * @details Name "siblingOrder", type Property::INTEGER.
 103    * @note The initial value is 0.
 104    * @note Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove and LowerBelow will override the
 105    * sibling order. The values set by this Property will likely change.
 106    */
 107   SIBLING_ORDER,
 108
 109   /**
 110     * @brief If this actor receives a touch-start event, then all following touch events are sent to this actor until a touch-end.
 111     * @details Name "captureAllTouchAfterStart", type Property::BOOLEAN
 112     * @note Default is false, i.e. actor under touch event will receive the touch even if touch started on this actor
 113     */
 114   CAPTURE_ALL_TOUCH_AFTER_START,
 115
 116   /**
 117     * @brief If you set the TOUCH_AREA_OFFSET on an actor, when you touch the actor, the touch area is expand from the size of actor.
 118     * @details Name "touchAreaOffset", type Property::Rect<int> (left, right, bottom, top).
 119     * For example
 120     * @code{.cpp}
 121     *  Actor actor = Actor::New();
 122     *  actor.SetProperty(Actor::Property::SIZE, Vector2(20.0f, 20.0f));
 123     *  actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Rect<int>(-10, 20, 30, -40));
 124     *  actor.TouchedSignal().Connect(OnTouchCallback);
 125     *
 126     * +---------------------+
 127     * |         ^           |
 128     * |         |           |
 129     * |         | -40       |
 130     * |         |           |
 131     * |         |           |
 132     * |    +----+----+      |
 133     * |    |         |      |
 134     * | -10|         | 20   |
 135     * |<---+         +----->|
 136     * |    |         |      |
 137     * |    |         |      |
 138     * |    +----+----+      |
 139     * |         |           |
 140     * |         | 30        |
 141     * |         |           |
 142     * |         v           |
 143     * +---------------------+
 144     * @endcode
 145     * The actual touched size is actor.width + touchAreaOffset.right - touchAreaOffset.left and actor.height + touchAreaOffset.bottom - touchAreaOffset.top
 146     */
 147   TOUCH_AREA_OFFSET,
 148
 149   /**
 150    * @brief Determines which blend equation will be used to render renderers of this actor.
 151    * @pre To use Advanced Blend Equation(DevelBlendEquation::MULTIPLY ~ DevelBlendEquation::LUMINOSITY), the color to be rendered should be pre-multipled alpha.
 152    * @details Name "blendEquation", type Property::INTEGER.
 153    * @note Color of each renderer will be blended with rendering framebuffer.
 154    * @note To check the blend equation is supported in the system, use Dali::Capabilities::IsBlendEquationSupported
 155    */
 156   BLEND_EQUATION,
 157
 158   /**
 159    * @brief Sets whether this actor can focus by touch. If user sets this to true, the actor will be focused when user touch it.
 160    * @code
 161    * Actor actor = Actor::New();
 162    * actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true); // whether the actor can have focus or not with keyboard navigation.
 163    * actor.SetProperty(DevelActor::Property::TOUCH_FOCUSABLE, true); // Whether the user can focus by touch, user can set focus by touching the actor.
 164    * @endcode
 165    * @details Name "touchFocusable", type Property::BOOLEAN.
 166    */
 167   TOUCH_FOCUSABLE,
 168
 169   /**
 170    * @brief Whether the children of this actor can be focusable by keyboard navigation. If user sets this to false, the children of this actor will not be focused.
 171    * @details Name "keyboardFocusableChildren", type Property::BOOLEAN.
 172    * @note Default value is true.
 173    */
 174   KEYBOARD_FOCUSABLE_CHILDREN,
 175
 176   /**
 177    * @brief The flag whether the actor should be enabled all user interaction including touch, focus and activation. this value have higher priority over the sensitve and focusable in negative action.
 178    * @details Name "userInteractionEnabled", type Property::BOOLEAN.
 179    * @note Default value is true.
 180    */
 181   USER_INTERACTION_ENABLED,
 182
 183   /**
 184    * @brief It only receive for touch events that started from itself.
 185    * @details Name "allowOnlyOwnTouch", type Property::BOOLEAN
 186    * @note Default is false.
 187    */
 188   ALLOW_ONLY_OWN_TOUCH,
 189
 190   /**
 191    * @brief Whether the actor uses the update area of the texture instead of its own.
 192    * @details Name "useTextureUpdateArea", type Property::BOOLEAN
 193    * @note Default is false. If this set true, the value of Actor::Property::UPDATE_AREA_HINT is ignored and we assume the sizes of the actor and the texture are same.
 194    */
 195   USE_TEXTURE_UPDATE_AREA,
 196
 197   /**
 198    * @brief Whether to send touch motion events or not.
 199    * @details Name "dispatchTouchMotion", type Property::BOOLEAN
 200    * @note Default is true.
 201    */
 202   DISPATCH_TOUCH_MOTION,
 203
 204   /**
 205    * @brief Whether to send hover motion events or not.
 206    * @details Name "dispatchHoverMotion", type Property::BOOLEAN
 207    * @note Default is true.
 208    */
 209   DISPATCH_HOVER_MOTION
 210 };
 211
 212 } // namespace Property
 213
 214 namespace VisibilityChange
 215 {
 216 enum Type
 217 {
 218   SELF,  ///< The visibility of the actor itself has changed.
 219   PARENT ///< The visibility of a parent has changed.
 220 };
 221
 222 } // namespace VisibilityChange
 223
 224 using VisibilityChangedSignalType = Signal<void(Actor, bool, VisibilityChange::Type)>; ///< Signal type of VisibilityChangedSignalType
 225
 226 /**
 227  * @brief This signal is emitted when the visible property of this or a parent actor is changed.
 228  *
 229  * A callback of the following type may be connected:
 230  * @code
 231  *   void YourCallbackName( Actor actor, bool visible, VisibilityChange::Type& type );
 232  * @endcode
 233  * actor: The actor, or child of actor, whose visibility has changed.
 234  * visible: If type is SELF, then this is true if this actor's VISIBILITY property is true. If Type is PARENT, this is true if a parent's VISIBILITY property has changed to true.
 235  * type: Whether the actor's visible property has changed or a parent's.
 236  * @return The signal to connect to
 237  * @pre The Actor has been initialized.
 238  * @note This signal is NOT emitted if the actor becomes transparent (or the reverse), it's ONLY linked with Actor::Property::VISIBLE.
 239  * @note For reference, an actor is only shown if it and it's parents (up to the root actor) are also visible, are not transparent, and this actor has a non-zero size.
 240  */
 241 DALI_CORE_API VisibilityChangedSignalType& VisibilityChangedSignal(Actor actor);
 242
 243 /**
 244  * Calculates screen position.
 245  *
 246  * @return position of anchor point from top-left corner on screen respectively.
 247  */
 248 DALI_CORE_API Vector2 CalculateScreenPosition(Actor actor);
 249
 250 /**
 251  * Calculates screen position and size.
 252  *
 253  * @return pair of two values, position of top-left corner on screen and size respectively.
 254  */
 255 DALI_CORE_API Rect<> CalculateScreenExtents(Actor actor);
 256
 257 /**
 258  * Calculates screen position and size from the scene-graph values.
 259  *
 260  * It will use already calculated informations on scene-graph so calculation will be fast.
 261  * But the result doesn't applied what this event-loop updated. For example, it will return wrong value in Relayout API.
 262  *
 263  * @return pair of two values, position of top-left corner on screen and size respectively.
 264  */
 265 DALI_CORE_API Rect<> CalculateCurrentScreenExtents(Actor actor);
 266
 267 using ChildChangedSignalType = Signal<void(Actor)>; ///< Called when the actor has a child added or removed
 268
 269 /**
 270  * @brief This signal is emitted when a child is added to this actor.
 271  *
 272  * A callback of the following type may be connected:
 273  * @code
 274  *   void MyCallbackName( Actor child );
 275  * @endcode
 276  * child: The child that has been added.
 277  *
 278  * @note Use this signal with caution. Changing the parent of the actor
 279  * within this callback is possible, but DALi will prevent further signals
 280  * being sent.
 281  *
 282  * @return The signal to connect to
 283  * @pre The Actor has been initialized
 284  */
 285 DALI_CORE_API ChildChangedSignalType& ChildAddedSignal(Actor actor);
 286
 287 /**
 288  * @brief This signal is emitted when a child is removed from this actor.
 289  *
 290  * A callback of the following type may be connected:
 291  * @code
 292  *   void MyCallbackName( Actor child );
 293  * @endcode
 294  * child: The child that has been removed.
 295  *
 296  * @note Use this signal with caution. Changing the parent of the actor
 297  * within this callback is possible, but DALi will prevent further signals
 298  * being sent.
 299  *
 300  * @note If the child actor is moved from one actor to another, then
 301  * this signal will be emitted followed immediately by an
 302  * ChildAddedSignal() on the new parent.
 303  *
 304  * @return The signal to connect to
 305  * @pre The Actor has been initialized
 306  */
 307 DALI_CORE_API ChildChangedSignalType& ChildRemovedSignal(Actor actor);
 308
 309 using ChildOrderChangedSignalType = Signal<void(Actor)>; ///< Used when the actor's children have changed order
 310
 311 /**
 312  * @brief This signal is emitted when an actor's children change their sibling order
 313  *
 314  * A callback of the following type may be connected:
 315  * @code
 316  *   void MyCallbackName( Actor parent );
 317  * @endcode
 318  * parent The parent actor of the moved children
 319  *
 320  * @return The signal to connect to
 321  * @pre The Actor has been initialized
 322  */
 323 DALI_CORE_API ChildOrderChangedSignalType& ChildOrderChangedSignal(Actor actor);
 324
 325 /**
 326  * @brief This signal is emitted when intercepting the actor's touch event.
 327  *
 328  * A callback of the following type may be connected:
 329  * @code
 330  *   void MyCallbackName( Actor actor );
 331  * @endcode
 332  * actor The actor to intercept
 333  *
 334  * @note TouchEvent callbacks are called from the last child in the order of the parent's actor.
 335  * The InterceptTouchEvent callback is to intercept the touch event in the parent.
 336  * So, if the parent interepts the touch event, the child cannot receive the touch event.
 337  *
 338  * @note example
 339  *   Actor parent = Actor::New();
 340  *   Actor child = Actor::New();
 341  *   parent.Add(child);
 342  *   child.TouchedSignal().Connect(&application, childFunctor);
 343  *   parent.TouchedSignal().Connect(&application, parentFunctor);
 344  * The touch event callbacks are called in the order childFunctor -> parentFunctor.
 345  *
 346  * If you connect interceptTouchSignal to parentActor.
 347  *   Dali::DevelActor::InterceptTouchedSignal(parent).Connect(&application, interceptFunctor);
 348  *
 349  * When interceptFunctor returns false, the touch event callbacks are called in the same order childFunctor -> parentFunctor.
 350  * If interceptFunctor returns true, it means that the TouchEvent was intercepted.
 351  * So the child actor will not be able to receive touch events.
 352  * Only the parentFunctor is called.
 353  *
 354  * @return The signal to connect to
 355  * @pre The Actor has been initialized
 356  */
 357 DALI_CORE_API Actor::TouchEventSignalType& InterceptTouchedSignal(Actor actor);
 358
 359 /**
 360  * @brief This signal is emitted when intercepting the actor's wheel event.
 361  *
 362  * A callback of the following type may be connected:
 363  * @code
 364  *   void MyCallbackName( Actor actor );
 365  * @endcode
 366  * actor The actor to intercept
 367  *
 368  * @note WheelEvent callbacks are called from the last child in the order of the parent's actor.
 369  * The InterceptWheelEvent callback is to intercept the wheel event in the parent.
 370  * So, if the parent interepts the wheel event, the child cannot receive the Wheel event.
 371  *
 372  * @note example
 373  *   Actor parent = Actor::New();
 374  *   Actor child = Actor::New();
 375  *   parent.Add(child);
 376  *   child.WheelEventSignal().Connect(&application, childFunctor);
 377  *   parent.WheelEventSignal().Connect(&application, parentFunctor);
 378  * The wheel event callbacks are called in the order childFunctor -> parentFunctor.
 379  *
 380  * If you connect InterceptWheelSignal to parentActor.
 381  *   Dali::DevelActor::InterceptWheelSignal(parent).Connect(&application, interceptFunctor);
 382  *
 383  * When interceptFunctor returns false, the wheel event callbacks are called in the same order childFunctor -> parentFunctor.
 384  * If interceptFunctor returns true, it means that the WheelEvent was intercepted.
 385  * So the child actor will not be able to receive wheel events.
 386  * Only the parentFunctor is called.
 387  *
 388  * @return The signal to connect to
 389  * @pre The Actor has been initialized
 390  */
 391 DALI_CORE_API Actor::WheelEventSignalType& InterceptWheelSignal(Actor actor);
 392
 393 /**
 394  * @brief This is used when the parent actor wants to listen to gesture events.
 395  *
 396  * @note example The child is overlapped on the parent.
 397  * Currently, if you tap a child, the parent cannot listen to the tap event.
 398  * Now, If set to SetNeedGesturePropagation(true), the parent can receive gesture events.
 399  * Please call this setting inside a gesture callback, it will be reset after the gesture callback is called.
 400  * @code
 401  * {
 402  *    Actor parent = Actor::New();
 403  *    Actor child = Actor::New();
 404  *    parent.Add(child);
 405  *    parentTapDetector = TapGestureDetector::New();
 406  *    childTapDetector = TapGestureDetector::New();
 407  *    parentTapDetector.Attach(parent);
 408  *    childTapDetector.Attach(child);
 409  *    parentTapDetector.DetectedSignal().Connect(this, &OnParentTap);
 410  *    childTapDetector.DetectedSignal().Connect(this, &OnChildTap);
 411  * }
 412  * void OnChildTap(Dali::Actor actor, const Dali::TapGesture& tap)
 413  * {
 414  *    // If you set SetNeedGesturePropagation to true here, the parent actor can also listen to events
 415  *    Dali::DevelActor::SetNeedGesturePropagation(Self(), true);
 416  * }
 417  * @endcode
 418  *
 419  */
 420 DALI_CORE_API void SetNeedGesturePropagation(Actor actor, bool propagation);
 421
 422 /**
 423  * Switch parent in the same tree.
 424  * This method changes the actor's parent with keeping on scene state.
 425  * Both of current parent Actor and new parent Actor must already be added on Scene.
 426  * This method don't emit notification about add/remove and on/off scene.
 427  * @param [in] actor This actor
 428  * @param [in] newParent An actor to be a new parent of this actor.
 429  */
 430 DALI_CORE_API void SwitchParent(Actor actor, Actor newParent);
 431
 432 /**
 433  * @brief This signal is emitted when an actor is hit through hit-test.
 434  *
 435  * A callback of the following type may be connected:
 436  * @code
 437  *   void MyCallbackName( Actor actor );
 438  * @endcode
 439  * actor The actor to intercept
 440  *
 441  * @note This callback is called when the actor is hit.
 442  * If true is returned, TouchEvent is called from the this actor.
 443  * If false is returned, the hit test starts again from the next lower actor.
 444  *
 445  * @note example
 446  *   Actor topActor = Actor::New();
 447  *   Actor bottomActor = Actor::New();
 448  *   topActor.TouchedSignal().Connect(&application, topActorFunctor);
 449  *   bottomActor.TouchedSignal().Connect(&application, bottomActorFunctor);
 450  * The two actors have no relationship.
 451  * So when the topActor is touched, the event cannot be propagated to the bottomActor.
 452  *
 453  * If you connect HitTestResultSignal to topActor.
 454  *   Dali::DevelActor::HitTestResultSignal(topActor).Connect(&application, hitTestResultFunctor);
 455  *
 456  * If the hitTestResult Functor returns false, it passes the hit-test and starts the hit-test again from the next lower actor.
 457  * So the bottomActor can be hit and receive touch events.
 458  * If hitTestResult returns true, it means that it has been hit. So it receives a TouchEvent from itself.
 459  *
 460  * @return The signal to connect to
 461  * @pre The Actor has been initialized
 462  */
 463 DALI_CORE_API Actor::TouchEventSignalType& HitTestResultSignal(Actor actor);
 464
 465 /**
 466  * Get the world transform of the actor.
 467  *
 468  * This calculates the world transform from scratch using only event
 469  * side properties - it does not rely on the update thread to have
 470  * already calculated the transform.
 471  *
 472  * @param[in] actor The actor for which to calculate the world transform
 473  * @return The world transform matrix
 474  */
 475 DALI_CORE_API Matrix GetWorldTransform(Actor actor);
 476
 477 /**
 478  * Get the world color of the actor.
 479  *
 480  * This calcualtes the world color of the actor from scratch using
 481  * only event side properties. It does not rely on the update thread
 482  * to have already calculated the color.
 483  *
 484  * @param[in] actor The actor to calculate the world color for
 485  * @return the world color
 486  */
 487 DALI_CORE_API Vector4 GetWorldColor(Actor actor);
 488
 489 /**
 490  * Rotate the actor look at specific position.
 491  * It will change the actor's orientation property.
 492  *
 493  * This calculates the world transform from scratch using only event
 494  * side properties - it does not rely on the update thread to have
 495  * already calculated the transform.
 496  *
 497  * @note Target position should be setup by world coordinates.
 498  * @note The result of invalid input is not determined.
 499  *       (ex : forward vector or actor-to-target vector has same direction with up, One of them is ZERO)
 500  *
 501  * @param[in] actor The actor for which to calculate the look at orientation.
 502  * @param[in] target The target world position to look at.
 503  * @param[in] up The up vector after target look at. Default is +Y axis.
 504  * @param[in] localForward The forward vector of actor when it's orientation is not applied. Default is +Z axis.
 505  * @param[in] localUp The up vector of actor when it's orientation is not applied. Default is +Y axis.
 506  */
 507 DALI_CORE_API void LookAt(Actor actor, Vector3 target, Vector3 up = Vector3::YAXIS, Vector3 localForward = Vector3::ZAXIS, Vector3 localUp = Vector3::YAXIS);
 508
 509 /**
 510  * Query whether the actor is actually hittable.  This method checks whether the actor is
 511  * sensitive, has the visibility flag set to true and is not fully transparent.
 512  *
 513  * @param[in] actor The actor for whether is hittable or not
 514  * @return true, if it can be hit, false otherwise.
 515  */
 516 DALI_CORE_API bool IsHittable(Actor actor);
 517
 518 /**
 519  * Query whether the application or derived actor type requires touch events.
 520  *
 521  * @param[in] actor The actor for whether is required for touch event or not.
 522  * @return True if touch events are required.
 523  */
 524 DALI_CORE_API bool GetTouchRequired(Actor actor);
 525
 526 } // namespace DevelActor
 527
 528 } // namespace Dali
 529
 530 #endif // DALI_ACTOR_DEVEL_H