dali/internal/event/actors/actor-impl.h

   1 #ifndef __DALI_INTERNAL_ACTOR_H__
   2 #define __DALI_INTERNAL_ACTOR_H__
   3
   4 /*
   5  * Copyright (c) 2014 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 <string>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/public-api/common/map-wrapper.h>
  26 #include <dali/public-api/common/vector-wrapper.h>
  27 #include <dali/public-api/object/ref-object.h>
  28 #include <dali/public-api/actors/actor.h>
  29 #include <dali/public-api/common/dali-common.h>
  30 #include <dali/public-api/events/gesture.h>
  31 #include <dali/public-api/math/viewport.h>
  32 #include <dali/internal/event/common/proxy-object.h>
  33 #include <dali/internal/event/common/stage-def.h>
  34 #include <dali/internal/event/actors/actor-declarations.h>
  35 #include <dali/internal/event/actor-attachments/actor-attachment-declarations.h>
  36 #include <dali/internal/update/nodes/node-declarations.h>
  37
  38 #ifdef DYNAMICS_SUPPORT
  39 #include <dali/internal/event/dynamics/dynamics-declarations.h>
  40 #endif
  41
  42 namespace Dali
  43 {
  44
  45 struct KeyEvent;
  46 struct TouchEvent;
  47 struct MouseWheelEvent;
  48
  49 namespace Internal
  50 {
  51
  52 class Actor;
  53 class ActorGestureData;
  54 class RenderTask;
  55 struct DynamicsData;
  56
  57 typedef IntrusivePtr<Actor>                   ActorPtr;
  58 typedef Dali::ActorContainer                  ActorContainer; // Store handles to return via public-api
  59 typedef ActorContainer::iterator              ActorIter;
  60 typedef ActorContainer::const_iterator        ActorConstIter;
  61
  62 /**
  63  * Actor is the primary object which Dali applications interact with.
  64  * UI controls can be built by combining multiple actors.
  65  * Multi-Touch events are received through signals emitted by the actor tree.
  66  *
  67  * An Actor is a proxy for a Node in the scene graph.
  68  * When an Actor is added to the Stage, it creates a node and attaches it to the scene graph.
  69  * The scene-graph can be updated in a separate thread, so the attachment is done using an asynchronous message.
  70  * When a tree of Actors is detached from the Stage, a message is sent to destroy the associated nodes.
  71  */
  72 class Actor : public ProxyObject
  73 {
  74 public:
  75
  76   /**
  77    * Create a new actor.
  78    * @return A smart-pointer to the newly allocated Actor.
  79    */
  80   static ActorPtr New();
  81
  82   /**
  83    * Retrieve the name of the actor.
  84    * @return The name.
  85    */
  86   const std::string& GetName() const;
  87
  88   /**
  89    * Set the name of the actor.
  90    * @param[in] name The new name.
  91    */
  92   void SetName(const std::string& name);
  93
  94   /**
  95    * @copydoc Dali::Actor::GetId
  96    */
  97   unsigned int GetId() const;
  98
  99   // Attachments
 100
 101   /**
 102    * Attach an object to an actor.
 103    * @pre The actor does not already have an attachment.
 104    * @param[in] attachment The object to attach.
 105    */
 106   void Attach(ActorAttachment& attachment);
 107
 108   /**
 109    * Retreive the object attached to an actor.
 110    * @return The attachment.
 111    */
 112   ActorAttachmentPtr GetAttachment();
 113
 114   // Containment
 115
 116   /**
 117    * Query whether an actor is the root actor, which is owned by the Stage.
 118    * @return True if the actor is a root actor.
 119    */
 120   bool IsRoot() const
 121   {
 122     return mIsRoot;
 123   }
 124
 125   /**
 126    * Query whether the actor is connected to the Stage.
 127    */
 128   bool OnStage() const;
 129
 130   /**
 131    * Query whether the actor is a RenderableActor derived type.
 132    * @return True if the actor is renderable.
 133    */
 134   bool IsRenderable() const
 135   {
 136     // inlined as this is called a lot in hit testing
 137     return mIsRenderable;
 138   }
 139
 140   /**
 141    * Query whether the actor is of class Dali::Layer
 142    * @return True if the actor is a layer.
 143    */
 144   bool IsLayer() const
 145   {
 146     // inlined as this is called a lot in hit testing
 147     return mIsLayer;
 148   }
 149
 150   /**
 151    * Gets the layer in which the actor is present
 152    * @return The layer, which will be uninitialized if the actor is off-stage.
 153    */
 154   Dali::Layer GetLayer();
 155
 156   /**
 157    * Adds a child Actor to this Actor.
 158    * @pre The child actor is not the same as the parent actor.
 159    * @pre The child actor does not already have a parent.
 160    * @param [in] child The child.
 161    * @post The child will be referenced by its parent.
 162    */
 163   void Add(Actor& child);
 164
 165   /**
 166    * Inserts a child Actor to this Actor's child list
 167    * @pre The child actor is not the same as the parent actor.
 168    * @pre The child actor does not already have a parent.
 169    * @param [in] index in childlist to insert child at
 170    * @param [in] child The child.
 171    * @post The child will be referenced by its parent.
 172    */
 173   void Insert(unsigned int index, Actor& child);
 174
 175   /**
 176    * Removes a child Actor from this Actor.
 177    * @param [in] child The child.
 178    * @post The child will be unreferenced.
 179    */
 180   void Remove(Actor& child);
 181
 182   /**
 183    * @copydoc Dali::Actor::Unparent
 184    */
 185   void Unparent();
 186
 187   /**
 188    * Retrieve the number of children held by the actor.
 189    * @return The number of children
 190    */
 191   unsigned int GetChildCount() const;
 192
 193   /**
 194    * @copydoc Dali::Actor::GetChildAt
 195    */
 196   Dali::Actor GetChildAt(unsigned int index) const;
 197
 198   /**
 199    * Retrieve the Actor's children.
 200    * @return A copy of the container of children.
 201    */
 202   ActorContainer GetChildren();
 203
 204   /**
 205    * Retrieve the Actor's children.
 206    * @return A const reference to the container of children.
 207    */
 208   const ActorContainer& GetChildren() const;
 209
 210   /**
 211    * Retrieve a reference to Actor's children.
 212    * @note Not for public use.
 213    * @return A reference to the container of children.
 214    */
 215   ActorContainer& GetChildrenInternal()
 216   {
 217     return *mChildren;
 218   }
 219
 220   /**
 221    * @copydoc Dali::Actor::FindChildByName
 222    */
 223   ActorPtr FindChildByName(const std::string& actorName);
 224
 225   /**
 226    * @copydoc Dali::Actor::FindChildByAlias
 227    */
 228   Dali::Actor FindChildByAlias(const std::string& actorAlias);
 229
 230   /**
 231    * @copydoc Dali::Actor::FindChildById
 232    */
 233   ActorPtr FindChildById(const unsigned int id);
 234
 235   /**
 236    * Retrieve the parent of an Actor.
 237    * @return The parent actor, or NULL if the Actor does not have a parent.
 238    */
 239   Actor* GetParent() const
 240   {
 241     return mParent;
 242   }
 243
 244   /**
 245    * Sets the size of an actor.
 246    * ActorAttachments attached to the actor, can be scaled to fit within this area.
 247    * This does not interfere with the actors scale factor.
 248    * @param [in] width  The new width.
 249    * @param [in] height The new height.
 250    */
 251   void SetSize(float width, float height);
 252
 253   /**
 254    * Sets the size of an actor.
 255    * ActorAttachments attached to the actor, can be scaled to fit within this area.
 256    * This does not interfere with the actors scale factor.
 257    * @param [in] width The size of the actor along the x-axis.
 258    * @param [in] height The size of the actor along the y-axis.
 259    * @param [in] depth The size of the actor along the z-axis.
 260    */
 261   void SetSize(float width, float height, float depth);
 262
 263   /**
 264    * Sets the size of an actor.
 265    * ActorAttachments attached to the actor, can be scaled to fit within this area.
 266    * This does not interfere with the actors scale factor.
 267    * @param [in] size The new size.
 268    */
 269   void SetSize(const Vector2& size);
 270
 271   /**
 272    * Sets the size of an actor.
 273    * ActorAttachments attached to the actor, can be scaled to fit within this area.
 274    * This does not interfere with the actors scale factor.
 275    * @param [in] size The new size.
 276    */
 277   void SetSize(const Vector3& size);
 278
 279   /**
 280    * Set the width component of the Actor's size.
 281    * @param [in] width The new width component.
 282    */
 283   void SetWidth( float width );
 284
 285   /**
 286    * Set the height component of the Actor's size.
 287    * @param [in] height The new height component.
 288    */
 289   void SetHeight( float height );
 290
 291   /**
 292    * Set the depth component of the Actor's size.
 293    * @param [in] depth The new depth component.
 294    */
 295   void SetDepth( float depth );
 296
 297   /**
 298    * Retrieve the Actor's size from event side.
 299    * This size will be the size set or if animating then the target size.
 300    * @return The Actor's size.
 301    */
 302   const Vector3& GetSize() const;
 303
 304   /**
 305    * Retrieve the Actor's size from update side.
 306    * This size will be the size set or animating but will be a frame behind.
 307    * @return The Actor's size.
 308    */
 309   const Vector3& GetCurrentSize() const;
 310
 311   /**
 312    * Return the natural size of the actor
 313    *
 314    * @return The actor's natural size
 315    */
 316   virtual Vector3 GetNaturalSize() const;
 317
 318   /**
 319    * Set the origin of an actor, within its parent's area.
 320    * This is expressed in 2D unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the parent,
 321    * and (1.0, 1.0, 0.5) is the bottom-right corner.
 322    * The default parent-origin is top-left (0.0, 0.0, 0.5).
 323    * An actor position is the distance between this origin, and the actors anchor-point.
 324    * @param [in] origin The new parent-origin.
 325    */
 326   void SetParentOrigin(const Vector3& origin);
 327
 328   /**
 329    * Set the x component of the parent-origin
 330    * @param [in] x The new x value.
 331    */
 332   void SetParentOriginX( float x );
 333
 334   /**
 335    * Set the y component of the parent-origin
 336    * @param [in] y The new y value.
 337    */
 338   void SetParentOriginY( float y );
 339
 340   /**
 341    * Set the z component of the parent-origin
 342    * @param [in] z The new z value.
 343    */
 344   void SetParentOriginZ( float z );
 345
 346   /**
 347    * Retrieve the parent-origin of an actor.
 348    * @return The parent-origin.
 349    */
 350   const Vector3& GetCurrentParentOrigin() const;
 351
 352   /**
 353    * Set the anchor-point of an actor. This is expressed in 2D unit coordinates, such that
 354    * (0.0, 0.0, 0.5) is the top-left corner of the actor, and (1.0, 1.0, 0.5) is the bottom-right corner.
 355    * The default anchor point is top-left (0.0, 0.0, 0.5).
 356    * An actor position is the distance between its parent-origin, and this anchor-point.
 357    * An actor's rotation is centered around its anchor-point.
 358    * @param [in] anchorPoint The new anchor-point.
 359    */
 360   void SetAnchorPoint(const Vector3& anchorPoint);
 361
 362   /**
 363    * Set the x component of the anchor-point.
 364    * @param [in] x The new x value.
 365    */
 366   void SetAnchorPointX( float x );
 367
 368   /**
 369    * Set the y component of the anchor-point.
 370    * @param [in] y The new y value.
 371    */
 372   void SetAnchorPointY( float y );
 373
 374   /**
 375    * Set the z component of the anchor-point.
 376    * @param [in] z The new z value.
 377    */
 378   void SetAnchorPointZ( float z );
 379
 380   /**
 381    * Retrieve the anchor-point of an actor.
 382    * @return The anchor-point.
 383    */
 384   const Vector3& GetCurrentAnchorPoint() const;
 385
 386   /**
 387    * Sets the position of the Actor.
 388    * The coordinates are relative to the Actor's parent.
 389    * The Actor's z position will be set to 0.0f.
 390    * @param [in] x The new x position
 391    * @param [in] y The new y position
 392    */
 393   void SetPosition(float x, float y);
 394
 395   /**
 396    * Sets the position of the Actor.
 397    * The coordinates are relative to the Actor's parent.
 398    * @param [in] x The new x position
 399    * @param [in] y The new y position
 400    * @param [in] z The new z position
 401    */
 402   void SetPosition(float x, float y, float z);
 403
 404   /**
 405    * Sets the position of the Actor.
 406    * The coordinates are relative to the Actor's parent.
 407    * @param [in] position The new position.
 408    */
 409   void SetPosition(const Vector3& position);
 410
 411   /**
 412    * Set the position of an actor along the X-axis.
 413    * @param [in] x The new x position
 414    */
 415   void SetX(float x);
 416
 417   /**
 418    * Set the position of an actor along the Y-axis.
 419    * @param [in] y The new y position.
 420    */
 421   void SetY(float y);
 422
 423   /**
 424    * Set the position of an actor along the Z-axis.
 425    * @param [in] z The new z position
 426    */
 427   void SetZ(float z);
 428
 429   /**
 430    * Move an actor relative to its existing position.
 431    * @param[in] distance The actor will move by this distance.
 432    */
 433   void MoveBy(const Vector3& distance);
 434
 435   /**
 436    * Retrieve the position of the Actor.
 437    * The coordinates are relative to the Actor's parent.
 438    * @return the Actor's position.
 439    */
 440   const Vector3& GetCurrentPosition() const;
 441
 442   /**
 443    * @copydoc Dali::Actor::GetCurrentWorldPosition()
 444    */
 445   const Vector3& GetCurrentWorldPosition() const;
 446
 447   /**
 448    * @copydoc Dali::Actor::SetPositionInheritanceMode()
 449    */
 450   void SetPositionInheritanceMode( PositionInheritanceMode mode );
 451
 452   /**
 453    * @copydoc Dali::Actor::GetPositionInheritanceMode()
 454    */
 455   PositionInheritanceMode GetPositionInheritanceMode() const;
 456
 457   /**
 458    * Sets the rotation of the Actor.
 459    * @param [in] angleRadians The new rotation angle in radians.
 460    * @param [in] axis The new axis of rotation.
 461    */
 462   void SetRotation(const Radian& angleRadians, const Vector3& axis);
 463
 464   /**
 465    * Sets the rotation of the Actor.
 466    * @param [in] rotation The new rotation.
 467    */
 468   void SetRotation(const Quaternion& rotation);
 469
 470   /**
 471    * Rotate an actor around its existing rotation axis.
 472    * @param[in] angleRadians The angle to the rotation to combine with the existing rotation.
 473    * @param[in] axis The axis of the rotation to combine with the existing rotation.
 474    */
 475   void RotateBy(const Radian& angleRadians, const Vector3& axis);
 476
 477   /**
 478    * Apply a relative rotation to an actor.
 479    * @param[in] relativeRotation The rotation to combine with the actors existing rotation.
 480    */
 481   void RotateBy(const Quaternion& relativeRotation);
 482
 483   /**
 484    * Retreive the Actor's rotation.
 485    * @return the rotation.
 486    */
 487   const Quaternion& GetCurrentRotation() const;
 488
 489   /**
 490    * Set whether a child actor inherits it's parent's orientation. Default is to inherit.
 491    * Switching this off means that using SetRotation() sets the actor's world orientation.
 492    * @param[in] inherit - true if the actor should inherit orientation, false otherwise.
 493    */
 494   void SetInheritRotation(bool inherit);
 495
 496   /**
 497    * Returns whether the actor inherit's it's parent's orientation.
 498    * @return true if the actor inherit's it's parent orientation, false if it uses world orientation.
 499    */
 500   bool IsRotationInherited() const;
 501
 502   /**
 503    * @copydoc Dali::Actor::GetCurrentWorldRotation()
 504    */
 505   const Quaternion& GetCurrentWorldRotation() const;
 506
 507   /**
 508    * Sets a scale factor applied to an actor.
 509    * @param [in] scale The scale factor applied on all axes.
 510    */
 511   void SetScale(float scale);
 512
 513   /**
 514    * Sets a scale factor applied to an actor.
 515    * @param [in] scaleX The scale factor applied along the x-axis.
 516    * @param [in] scaleY The scale factor applied along the y-axis.
 517    * @param [in] scaleZ The scale factor applied along the z-axis.
 518    */
 519   void SetScale(float scaleX, float scaleY, float scaleZ);
 520
 521   /**
 522    * Sets a scale factor applied to an actor.
 523    * @param [in] scale A vector representing the scale factor for each axis.
 524    */
 525   void SetScale(const Vector3& scale);
 526
 527   /**
 528    * Set the x component of the scale factor.
 529    * @param [in] x The new x value.
 530    */
 531   void SetScaleX( float x );
 532
 533   /**
 534    * Set the y component of the scale factor.
 535    * @param [in] y The new y value.
 536    */
 537   void SetScaleY( float y );
 538
 539   /**
 540    * Set the z component of the scale factor.
 541    * @param [in] z The new z value.
 542    */
 543   void SetScaleZ( float z );
 544
 545   /**
 546    * Apply a relative scale to an actor.
 547    * @param[in] relativeScale The scale to combine with the actors existing scale.
 548    */
 549   void ScaleBy(const Vector3& relativeScale);
 550
 551   /**
 552    * Retrieve the scale factor applied to an actor.
 553    * @return A vector representing the scale factor for each axis.
 554    */
 555   const Vector3& GetCurrentScale() const;
 556
 557   /**
 558    * @copydoc Dali::Actor::GetCurrentWorldScale()
 559    */
 560   const Vector3& GetCurrentWorldScale() const;
 561
 562   /**
 563    * @copydoc Dali::Actor::SetInheritScale()
 564    */
 565   void SetInheritScale( bool inherit );
 566
 567   /**
 568    * @copydoc Dali::Actor::IsScaleInherited()
 569    */
 570   bool IsScaleInherited() const;
 571
 572   /**
 573    * @copydoc Dali::Actor::GetCurrentWorldMatrix()
 574    */
 575   Matrix GetCurrentWorldMatrix() const;
 576
 577   // Visibility
 578
 579   /**
 580    * Sets the visibility flag of an actor.
 581    * @param [in] visible The new visibility flag.
 582    */
 583   void SetVisible(bool visible);
 584
 585   /**
 586    * Retrieve the visibility flag of an actor.
 587    * @return The visibility flag.
 588    */
 589   bool IsVisible() const;
 590
 591   /**
 592    * Sets the opacity of an actor.
 593    * @param [in] opacity The new opacity.
 594    */
 595   void SetOpacity(float opacity);
 596
 597   /**
 598    * Apply a relative opacity change to an actor.
 599    * @param[in] relativeOpacity The opacity to combine with the actors existing opacity.
 600    */
 601   void OpacityBy(float relativeOpacity);
 602
 603   /**
 604    * Retrieve the actor's opacity.
 605    * @return The actor's opacity.
 606    */
 607   float GetCurrentOpacity() const;
 608
 609   /**
 610    * Sets whether an actor should emit touch signals; see SignalTouch().
 611    * An actor is sensitive by default, which means that as soon as an application connects to the SignalTouch(),
 612    * the touch event signal will be emitted.
 613    *
 614    * If the application wishes to temporarily disable the touch event signal emission, then they can do so by calling:
 615    * @code
 616    * actor.SetSensitive(false);
 617    * @endcode
 618    *
 619    * Then, to re-enable the touch event signal emission, the application should call:
 620    * @code
 621    * actor.SetSensitive(true);
 622    * @endcode
 623    *
 624    * @see SignalTouch().
 625    * @note If an actor's sensitivity is set to false, then it's children will not emit a touch event signal either.
 626    * @param[in]  sensitive  true to enable emission of the touch event signals, false otherwise.
 627    */
 628   void SetSensitive(bool sensitive)
 629   {
 630     mSensitive = sensitive;
 631   }
 632
 633   /**
 634    * Query whether an actor emits touch event signals.
 635    * @see SetSensitive(bool)
 636    * @return true, if emission of touch event signals is enabled, false otherwise.
 637    */
 638   bool IsSensitive() const
 639   {
 640     return mSensitive;
 641   }
 642
 643   /**
 644    * @copydoc Dali::Actor::SetDrawMode
 645    */
 646   void SetDrawMode( DrawMode::Type drawMode );
 647
 648   /**
 649    * @copydoc Dali::Actor::GetDrawMode
 650    */
 651   DrawMode::Type GetDrawMode() const;
 652
 653   /**
 654    * @copydoc Dali::Actor::SetOverlay
 655    */
 656   void SetOverlay(bool enable);
 657
 658   /**
 659    * @copydoc Dali::Actor::IsOverlay
 660    */
 661   bool IsOverlay() const;
 662
 663   /**
 664    * Sets whether an actor transmits geometry scaling to it's children.
 665    * The default value is for it not to transmit scaling.
 666    * @param[in] transmitGeometryScaling True to transmit scaling.
 667    */
 668   void SetTransmitGeometryScaling(bool transmitGeometryScaling);
 669
 670   /**
 671    * Get the TransmitGeometryScaling property for this actor.
 672    * @return True if geometry scaling is applied to the inherited scale.
 673    */
 674   bool GetTransmitGeometryScaling() const;
 675
 676   /**
 677    * Sets the initial volume of the actor. Used for scaling the
 678    * actor appropriately as the actor is sized when transmitGeometryScaling
 679    * is set to true.
 680    *
 681    * @param[in] volume the volume of the model and it's children
 682    */
 683   void SetInitialVolume(const Vector3& volume);
 684
 685   /**
 686    * Sets the actor's color.  The final color of actor depends on its color mode.
 687    * This final color is applied to the drawable elements of an actor.
 688    * @param [in] color The new color.
 689    */
 690   void SetColor(const Vector4& color);
 691
 692   /**
 693    * Set the red component of the color.
 694    * @param [in] red The new red component.
 695    */
 696   void SetColorRed( float red );
 697
 698   /**
 699    * Set the green component of the color.
 700    * @param [in] green The new green component.
 701    */
 702   void SetColorGreen( float green );
 703
 704   /**
 705    * Set the blue component of the scale factor.
 706    * @param [in] blue The new blue value.
 707    */
 708   void SetColorBlue( float blue );
 709
 710   /**
 711    * Apply a relative color change to an actor.
 712    * @param[in] relativeColor The color to combine with the actors existing color.
 713    */
 714   void ColorBy(const Vector4& relativeColor);
 715
 716   /**
 717    * Retrieve the actor's color.
 718    * @return The color.
 719    */
 720   const Vector4& GetCurrentColor() const;
 721
 722   /**
 723    * Sets the actor's color mode.
 724    * Color mode specifies whether Actor uses its own color or inherits its parent color
 725    * @param [in] colorMode to use.
 726    */
 727   void SetColorMode(ColorMode colorMode);
 728
 729   /**
 730    * Returns the actor's color mode.
 731    * @return currently used colorMode.
 732    */
 733   ColorMode GetColorMode() const;
 734
 735   /**
 736    * @copydoc Dali::Actor::GetCurrentWorldColor()
 737    */
 738   const Vector4& GetCurrentWorldColor() const;
 739
 740 #ifdef DYNAMICS_SUPPORT
 741
 742   // Dynamics
 743
 744   /// @copydoc Dali::Actor::DisableDynamics
 745   void DisableDynamics();
 746
 747   /// @copydoc Dali::Actor::EnableDynamics(Dali::DynamicsBodyConfig)
 748   DynamicsBodyPtr  EnableDynamics(DynamicsBodyConfigPtr bodyConfig);
 749
 750   /// @copydoc Dali::Actor::GetDynamicsBody
 751   DynamicsBodyPtr GetDynamicsBody() const;
 752
 753   /// @copydoc Dali::Actor::AddDynamicsJoint(Dali::Actor,const Vector3&)
 754   DynamicsJointPtr AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offset );
 755
 756   /// @copydoc Dali::Actor::AddDynamicsJoint(Dali::Actor,const Vector3&,const Vector3&)
 757   DynamicsJointPtr AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offsetA, const Vector3& offsetB );
 758
 759   /// @copydoc Dali::Actor::GetNumberOfJoints
 760   const int GetNumberOfJoints() const;
 761
 762   /// @copydoc Dali::Actor::GetDynamicsJointByIndex
 763   DynamicsJointPtr GetDynamicsJointByIndex( const int index ) const;
 764
 765   /// @copydoc Dali::Actor::GetDynamicsJoint
 766   DynamicsJointPtr GetDynamicsJoint( ActorPtr attachedActor ) const;
 767
 768   /// @copydoc Dali::Actor::RemoveDynamicsJoint
 769   void RemoveDynamicsJoint( DynamicsJointPtr joint );
 770
 771   /**
 772    * Hold a reference to a DynamicsJoint
 773    * @param[in] joint The joint
 774    */
 775   void ReferenceJoint( DynamicsJointPtr joint );
 776
 777   /**
 778    * Release a reference to a DynamicsJoint
 779    * @param[in] joint The joint
 780    */
 781   void ReleaseJoint( DynamicsJointPtr joint );
 782
 783   /**
 784    * Set this actor to be the root actor in the dynamics simulation
 785    * All children of the actor are added/removed from the simulation.
 786    * @param[in] flag  When true sets this actor to be the simulation world root actor and
 787    *                  if OnStage() all dynamics enabled child actors are added to the simulation,
 788    *                  when false stops this actor being the simulation root and if OnStage() all
 789    *                  dynamics enabled child actors are removed from the simulation.
 790    */
 791   void SetDynamicsRoot(bool flag);
 792
 793 private:
 794   /**
 795    * Check if this actor is the root actor in the dynamics simulation
 796    * @return true if this is the dynamics root actor.
 797    */
 798   bool IsDynamicsRoot() const;
 799
 800   /**
 801    * Add actor to the dynamics simulation
 802    * Invoked when the actor is staged, or it's parent becomes the simulation root
 803    */
 804   void ConnectDynamics();
 805
 806   /**
 807    * Remove actor from the dynamics simulation
 808    * Invoked when the actor is unstaged, or it's parent stops being the the simulation root
 809    */
 810   void DisconnectDynamics();
 811
 812   /**
 813    * An actor in a DynamicsJoint relationship has been staged
 814    * @param[in] actor The actor passed into AddDynamicsJoint()
 815    */
 816   void AttachedActorOnStage( Dali::Actor actor );
 817
 818   /**
 819    * An actor in a DynamicsJoint relationship has been unstaged
 820    * @param[in] actor The actor passed into AddDynamicsJoint()
 821    */
 822   void AttachedActorOffStage( Dali::Actor actor );
 823
 824 #endif // DYNAMICS_SUPPORT
 825
 826 public:
 827   /**
 828    * Converts screen coordinates into the actor's coordinate system.
 829    * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
 830    * @param[out] localX On return, the X-coordinate relative to the actor.
 831    * @param[out] localY On return, the Y-coordinate relative to the actor.
 832    * @param[in] screenX The screen X-coordinate.
 833    * @param[in] screenY The screen Y-coordinate.
 834    * @return True if the conversion succeeded.
 835    */
 836   bool ScreenToLocal(float& localX, float& localY, float screenX, float screenY) const;
 837
 838   /**
 839    * Converts screen coordinates into the actor's coordinate system.
 840    * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
 841    * @param[in] renderTask The render-task used to display the actor.
 842    * @param[out] localX On return, the X-coordinate relative to the actor.
 843    * @param[out] localY On return, the Y-coordinate relative to the actor.
 844    * @param[in] screenX The screen X-coordinate.
 845    * @param[in] screenY The screen Y-coordinate.
 846    * @return True if the conversion succeeded.
 847    */
 848   bool ScreenToLocal(RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY) const;
 849
 850   /**
 851    * Converts from the actor's coordinate system to screen coordinates.
 852    * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
 853    * @param[in] viewMatrix The view-matrix
 854    * @param[in] projectionMatrix The projection-matrix
 855    * @param[in] viewport The view-port
 856    * @param[out] localX On return, the X-coordinate relative to the actor.
 857    * @param[out] localY On return, the Y-coordinate relative to the actor.
 858    * @param[in] screenX The screen X-coordinate.
 859    * @param[in] screenY The screen Y-coordinate.
 860    * @return True if the conversion succeeded.
 861    */
 862   bool ScreenToLocal( const Matrix& viewMatrix,
 863                       const Matrix& projectionMatrix,
 864                       const Viewport& viewport,
 865                       float& localX,
 866                       float& localY,
 867                       float screenX,
 868                       float screenY ) const;
 869
 870   /**
 871    * Performs a ray-sphere test with the given pick-ray and the actor's bounding sphere.
 872    * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
 873    * @param[in] rayOrigin The ray origin in the world's reference system.
 874    * @param[in] rayDir The ray director vector in the world's reference system.
 875    * @return True if the ray intersects the actor's bounding sphere.
 876    */
 877   bool RaySphereTest( const Vector4& rayOrigin, const Vector4& rayDir ) const;
 878
 879   /**
 880    * Performs a ray-actor test with the given pick-ray and the actor's geometry.
 881    * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
 882    * @param[in] rayOrigin The ray origin in the world's reference system.
 883    * @param[in] rayDir The ray director vector in the world's reference system.
 884    * @param[out] hitPointLocal The hit point in the Actor's local reference system.
 885    * @param[out] distance The distance from the hit point to the camera.
 886    * @return True if the ray intersects the actor's geometry.
 887    */
 888   bool RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vector4& hitPointLocal, float& distance ) const;
 889
 890   /**
 891    * Sets whether the actor should receive a notification when touch motion events leave
 892    * the boundary of the actor.
 893    *
 894    * @note By default, this is set to false as most actors do not require this.
 895    * @note Need to connect to the SignalTouch to actually receive this event.
 896    *
 897    * @param[in]  required  Should be set to true if a Leave event is required
 898    */
 899   void SetLeaveRequired(bool required);
 900
 901   /**
 902    * This returns whether the actor requires touch events whenever touch motion events leave
 903    * the boundary of the actor.
 904    * @return true if a Leave event is required, false otherwise.
 905    */
 906   bool GetLeaveRequired() const;
 907
 908   /**
 909    * @copydoc Dali::Actor::SetKeyboardFocusable()
 910    */
 911   void SetKeyboardFocusable( bool focusable );
 912
 913   /**
 914    * @copydoc Dali::Actor::IsKeyboardFocusable()
 915    */
 916   bool IsKeyboardFocusable() const;
 917
 918   /**
 919    * Query whether the application or derived actor type requires touch events.
 920    * @return True if touch events are required.
 921    */
 922   bool GetTouchRequired() const;
 923
 924   /**
 925    * Query whether the application or derived actor type requires mouse wheel events.
 926    * @return True if mouse wheel events are required.
 927    */
 928   bool GetMouseWheelEventRequired() const;
 929
 930   /**
 931    * Query whether the actor is actually hittable.  This method checks whether the actor is
 932    * sensitive, has the visibility flag set to true and is not fully transparent.
 933    * @return true, if it can be hit, false otherwise.
 934    */
 935   bool IsHittable() const;
 936
 937   // Gestures
 938
 939   /**
 940    * Retrieve the gesture data associated with this actor. The first call to this method will
 941    * allocate space for the ActorGestureData so this should only be called if an actor really does
 942    * require gestures.
 943    * @return Reference to the ActorGestureData for this actor.
 944    * @note Once the gesture-data is created for an actor it is likely that gestures are required
 945    * throughout the actor's lifetime so it will only be deleted when the actor is destroyed.
 946    */
 947   ActorGestureData& GetGestureData();
 948
 949   /**
 950    * Queries whether the actor requires the gesture type.
 951    * @param[in] type The gesture type.
 952    */
 953   bool IsGestureRequred( Gesture::Type type ) const;
 954
 955   // Signals
 956
 957   /**
 958    * Used by the EventProcessor to emit touch event signals.
 959    * @param[in] event The touch event.
 960    * @return True if the event was consumed.
 961    */
 962   bool EmitTouchEventSignal(const TouchEvent& event);
 963
 964   /**
 965    * Used by the EventProcessor to emit mouse wheel event signals.
 966    * @param[in] event The mouse wheel event.
 967    * @return True if the event was consumed.
 968    */
 969   bool EmitMouseWheelEventSignal(const MouseWheelEvent& event);
 970
 971   /**
 972    * @copydoc Dali::Actor::TouchedSignal()
 973    */
 974   Dali::Actor::TouchSignalV2& TouchedSignal();
 975
 976   /**
 977    * @copydoc Dali::Actor::MouseWheelEventSignal()
 978    */
 979   Dali::Actor::MouseWheelEventSignalV2& MouseWheelEventSignal();
 980
 981   /**
 982    * @copydoc Dali::Actor::SetSizeSignal()
 983    */
 984   Dali::Actor::SetSizeSignalV2& SetSizeSignal();
 985
 986   /**
 987    * @copydoc Dali::Actor::OnStageSignal()
 988    */
 989   Dali::Actor::OnStageSignalV2& OnStageSignal();
 990
 991   /**
 992    * @copydoc Dali::Actor::OffStageSignal()
 993    */
 994   Dali::Actor::OffStageSignalV2& OffStageSignal();
 995
 996   /**
 997    * Connects a callback function with the object's signals.
 998    * @param[in] object The object providing the signal.
 999    * @param[in] tracker Used to disconnect the signal.
1000    * @param[in] signalName The signal to connect to.
1001    * @param[in] functor A newly allocated FunctorDelegate.
1002    * @return True if the signal was connected.
1003    * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
1004    */
1005   static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
1006
1007   /**
1008    * Performs actions as requested using the action name.
1009    * @param[in] object The object on which to perform the action.
1010    * @param[in] actionName The action to perform.
1011    * @param[in] attributes The attributes with which to perfrom this action.
1012    * @return true if the action was done.
1013    */
1014   static bool DoAction(BaseObject* object, const std::string& actionName, const std::vector<Property::Value>& attributes);
1015
1016 public:  // For Animation
1017
1018   /**
1019    * This should only be called by Animation, when the actor is resized using Animation::Resize().
1020    *
1021    * @param[in] animation The animation that resized the actor
1022    * @param[in] targetSize The new target size of the actor
1023    */
1024   void NotifySizeAnimation(Animation& animation, const Vector3& targetSize);
1025
1026   /**
1027    * For use in derived classes.
1028    * This should only be called by Animation, when the actor is resized using Animation::Resize().
1029    */
1030   virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize) {}
1031
1032 protected:
1033
1034   enum DerivedType
1035   {
1036     BASIC,
1037     RENDERABLE,
1038     LAYER,
1039     ROOT_LAYER
1040   };
1041
1042   /**
1043    * Protected Constructor.  See Actor::New().
1044    * The second-phase construction Initialize() member should be called immediately after this.
1045    * @param[in] derivedType The derived type of actor (if any).
1046    */
1047   Actor( DerivedType derivedType );
1048
1049   /**
1050    * Second-phase constructor. Must be called immediately after creating a new Actor;
1051    */
1052   void Initialize(void);
1053
1054   /**
1055    * A reference counted object may only be deleted by calling Unreference()
1056    */
1057   virtual ~Actor();
1058
1059   /**
1060    * Called on a child during Add() when the parent actor is connected to the Stage.
1061    * @param[in] stage The stage.
1062    * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
1063    */
1064   void ConnectToStage(Stage& stage, int index = -1);
1065
1066   /**
1067    * Helper for ConnectToStage, to recursively connect a tree of actors.
1068    * This is atomic i.e. not interrupted by user callbacks.
1069    * @param[in] stage The stage.
1070    * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
1071    * @param[out] connectionList On return, the list of connected actors which require notification.
1072    */
1073   void RecursiveConnectToStage( Stage& stage, ActorContainer& connectionList, int index = -1 );
1074
1075   /**
1076    * Connect the Node associated with this Actor to the scene-graph.
1077    * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
1078    */
1079   void ConnectToSceneGraph(int index = -1);
1080
1081   /**
1082    * Helper for ConnectToStage, to notify a connected actor through the public API.
1083    */
1084   void NotifyStageConnection();
1085
1086   /**
1087    * Called on a child during Remove() when the actor was previously on the Stage.
1088    */
1089   void DisconnectFromStage();
1090
1091   /**
1092    * Helper for DisconnectFromStage, to recursively disconnect a tree of actors.
1093    * This is atomic i.e. not interrupted by user callbacks.
1094    * @param[out] disconnectionList On return, the list of disconnected actors which require notification.
1095    */
1096   void RecursiveDisconnectFromStage( ActorContainer& disconnectionList );
1097
1098   /**
1099    * Disconnect the Node associated with this Actor from the scene-graph.
1100    */
1101   void DisconnectFromSceneGraph();
1102
1103   /**
1104    * Helper for DisconnectFromStage, to notify a disconnected actor through the public API.
1105    */
1106   void NotifyStageDisconnection();
1107
1108   /**
1109    * When the Actor is OnStage, checks whether the corresponding Node is connected to the scene graph.
1110    * @return True if the Actor is OnStage & has a Node connected to the scene graph.
1111    */
1112   bool IsNodeConnected() const;
1113
1114   /**
1115    * Calculate the size of the z dimension for a 2D size
1116    *
1117    * @param[in] size The 2D size (X, Y) to calculate Z from
1118    *
1119    * @return Return the Z dimension for this size
1120    */
1121   float CalculateSizeZ( const Vector2& size ) const;
1122
1123 public: // Default property extensions from ProxyObject
1124
1125   /**
1126    * @copydoc Dali::Internal::ProxyObject::IsSceneObjectRemovable()
1127    */
1128   virtual bool IsSceneObjectRemovable() const;
1129
1130   /**
1131    * @copydoc Dali::Internal::ProxyObject::GetDefaultPropertyCount()
1132    */
1133   virtual unsigned int GetDefaultPropertyCount() const;
1134
1135   /**
1136    * @copydoc Dali::Internal::ProxyObject::GetDefaultPropertyIndices()
1137    */
1138   virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
1139
1140   /**
1141    * @copydoc Dali::Internal::ProxyObject::GetDefaultPropertyName()
1142    */
1143   virtual const std::string& GetDefaultPropertyName(Property::Index index) const;
1144
1145   /**
1146    * @copydoc Dali::Internal::ProxyObject::GetDefaultPropertyIndex()
1147    */
1148   virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const;
1149
1150   /**
1151    * @copydoc Dali::Internal::ProxyObject::IsDefaultPropertyWritable()
1152    */
1153   virtual bool IsDefaultPropertyWritable(Property::Index index) const;
1154
1155   /**
1156    * @copydoc Dali::Internal::ProxyObject::IsDefaultPropertyAnimatable()
1157    */
1158   virtual bool IsDefaultPropertyAnimatable(Property::Index index) const;
1159
1160   /**
1161    * @copydoc Dali::Internal::ProxyObject::IsDefaultPropertyAConstraintInput()
1162    */
1163   virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
1164
1165   /**
1166    * @copydoc Dali::Internal::ProxyObject::GetDefaultPropertyType()
1167    */
1168   virtual Property::Type GetDefaultPropertyType(Property::Index index) const;
1169
1170   /**
1171    * @copydoc Dali::Internal::ProxyObject::SetDefaultProperty()
1172    */
1173   virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
1174
1175   /**
1176    * @copydoc Dali::Internal::ProxyObject::SetCustomProperty()
1177    */
1178   virtual void SetCustomProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value );
1179
1180   /**
1181    * @copydoc Dali::Internal::ProxyObject::GetDefaultProperty()
1182    */
1183   virtual Property::Value GetDefaultProperty( Property::Index index ) const;
1184
1185   /**
1186    * @copydoc Dali::Internal::ProxyObject::InstallSceneObjectProperty()
1187    */
1188   virtual void InstallSceneObjectProperty( SceneGraph::PropertyBase& newProperty, const std::string& name, unsigned int index );
1189
1190   /**
1191    * @copydoc Dali::Internal::ProxyObject::GetSceneObject()
1192    */
1193   virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
1194
1195   /**
1196    * @copydoc Dali::Internal::ProxyObject::GetSceneObjectAnimatableProperty()
1197    */
1198   virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
1199
1200   /**
1201    * @copydoc Dali::Internal::ProxyObject::GetSceneObjectInputProperty()
1202    */
1203   virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
1204
1205   /**
1206    * @copydoc Dali::Internal::ProxyObject::GetPropertyComponentIndex()
1207    */
1208   virtual int GetPropertyComponentIndex( Property::Index index ) const;
1209
1210 private:
1211
1212   // Undefined
1213   Actor();
1214
1215   // Undefined
1216   Actor(const Actor&);
1217
1218   // Undefined
1219   Actor& operator=(const Actor& rhs);
1220
1221   /**
1222    * Set the actors parent.
1223    * @param[in] parent The new parent.
1224    * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
1225    */
1226   void SetParent(Actor* parent, int index = -1);
1227
1228   /**
1229    * Helper to create a Node for this Actor.
1230    * To be overriden in derived classes.
1231    * @return A newly allocated node.
1232    */
1233   virtual SceneGraph::Node* CreateNode() const;
1234
1235   /**
1236    * For use in derived classes, called after Initialize()
1237    */
1238   virtual void OnInitialize() {}
1239
1240   /**
1241    * For use in internal derived classes.
1242    * This is called during ConnectToStage(), after the actor has finished adding its node to the scene-graph.
1243    * The derived class must not modify the actor hierachy (Add/Remove children) during this callback.
1244    */
1245   virtual void OnStageConnectionInternal() {}
1246
1247   /**
1248    * For use in internal derived classes.
1249    * This is called during DisconnectFromStage(), before the actor removes its node from the scene-graph.
1250    * The derived class must not modify the actor hierachy (Add/Remove children) during this callback.
1251    */
1252   virtual void OnStageDisconnectionInternal() {}
1253
1254   /**
1255    * For use in external (CustomActor) derived classes.
1256    * This is called after the atomic ConnectToStage() traversal has been completed.
1257    */
1258   virtual void OnStageConnectionExternal() {}
1259
1260   /**
1261    * For use in external (CustomActor) derived classes.
1262    * This is called after the atomic DisconnectFromStage() traversal has been completed.
1263    */
1264   virtual void OnStageDisconnectionExternal() {}
1265
1266   /**
1267    * For use in derived classes; this is called after Add() has added a child.
1268    * @param[in] child The child that was added.
1269    */
1270   virtual void OnChildAdd( Actor& child ) {}
1271
1272   /**
1273    * For use in derived classes; this is called after Remove() has removed a child.
1274    * @param[in] child The child that was removed.
1275    */
1276   virtual void OnChildRemove( Actor& child ) {}
1277
1278   /**
1279    * For use in derived classes.
1280    * This is called after SizeSet() has been called.
1281    */
1282   virtual void OnSizeSet(const Vector3& targetSize) {}
1283
1284   /**
1285    * For use in derived classes.
1286    * This is called after a non animatable custom property is set.
1287    * @param [in] index The index of the property.
1288    * @param [in] propertyValue The value of the property.
1289    */
1290   virtual void OnPropertySet( Property::Index index, Property::Value propertyValue ) {}
1291
1292   /**
1293    * For use in derived classes.
1294    * This is only called if mTouchRequired is true, and the touch-signal was not consumed.
1295    * @param[in] event The touch event.
1296    * @return True if the event should be consumed.
1297    */
1298   virtual bool OnTouchEvent(const TouchEvent& event) { return false; }
1299
1300   /**
1301    * For use in derived classes.
1302    * This is only called if the mouse wheel signal was not consumed.
1303    * @param[in] event The mouse event.
1304    * @return True if the event should be consumed.
1305    */
1306   virtual bool OnMouseWheelEvent(const MouseWheelEvent& event) { return false; }
1307
1308   /**
1309    * For use in derived class
1310    * If an alias for a child exists, return the child otherwise return an empty handle.
1311    * For example 'previous' could return the last selected child.
1312    * @pre The Actor has been initialized.
1313    * @param[in] actorAlias the name of the actor to find
1314    * @return A handle to the actor if found, or an empty handle if not.
1315    */
1316   virtual Dali::Actor GetChildByAlias(const std::string& actorAlias) { return Dali::Actor(); }
1317
1318   /**
1319    * Support function for FindChildByAlias
1320    * @pre The Actor has been initialized.
1321    * @param[in] actorAlias the name of the aliased actor to find
1322    * @return A handle to the actor if found, or an empty handle if not.
1323    */
1324   Dali::Actor DoGetChildByAlias(const std::string& actorAlias);
1325
1326 protected:
1327
1328   StagePtr                mStage;        ///< Used to send messages to Node; valid until Core destruction
1329   Actor*                  mParent;       ///< Each actor (except the root) can have one parent
1330   ActorContainer*         mChildren;     ///< Container of referenced actors
1331   const SceneGraph::Node* mNode;         ///< Not owned
1332   Vector3*                mParentOrigin; // NULL means ParentOrigin::DEFAULT. ParentOrigin is non-animatable
1333   Vector3*                mAnchorPoint;  // NULL means AnchorPoint::DEFAULT. AnchorPoint is non-animatable
1334
1335 #ifdef DYNAMICS_SUPPORT
1336   DynamicsData*           mDynamicsData; ///< optional physics data
1337 #endif
1338
1339   ActorGestureData*       mGestureData; /// Optional Gesture data. Only created when actor requires gestures
1340
1341   ActorAttachmentPtr      mAttachment;   ///< Optional referenced attachment
1342
1343   // Signals
1344   Dali::Actor::TouchSignalV2             mTouchedSignalV2;
1345   Dali::Actor::MouseWheelEventSignalV2   mMouseWheelEventSignalV2;
1346   Dali::Actor::SetSizeSignalV2           mSetSizeSignalV2;
1347   Dali::Actor::OnStageSignalV2           mOnStageSignalV2;
1348   Dali::Actor::OffStageSignalV2          mOffStageSignalV2;
1349
1350   Vector3         mSize;      ///< Event-side storage for size (not a pointer as most actors will have a size)
1351
1352   std::string     mName;      ///< Name of the actor
1353   unsigned int    mId;        ///< A unique ID to identify the actor starting from 1, and 0 is reserved
1354
1355   const bool mIsRoot                               : 1; ///< Flag to identify the root actor
1356   const bool mIsRenderable                         : 1; ///< Flag to identify that this is a renderable actor
1357   const bool mIsLayer                              : 1; ///< Flag to identify that this is a layer
1358   bool mIsOnStage                                  : 1; ///< Flag to identify whether the actor is on-stage
1359   bool mIsDynamicsRoot                             : 1; ///< Flag to identify if this is the dynamics world root
1360   bool mSensitive                                  : 1; ///< Whether the actor emits touch event signals
1361   bool mLeaveRequired                              : 1; ///< Whether a touch event signal is emitted when the a touch leaves the actor's bounds
1362   bool mKeyboardFocusable                          : 1; ///< Whether the actor should be focusable by keyboard navigation
1363   bool mDerivedRequiresTouch                       : 1; ///< Whether the derived actor type requires touch event signals
1364   bool mDerivedRequiresMouseWheelEvent             : 1; ///< Whether the derived actor type requires mouse wheel event signals
1365   bool mOnStageSignalled                           : 1; ///< Set to true before OnStageConnection signal is emitted, and false before OnStageDisconnection
1366   bool mInheritRotation                            : 1; ///< Cached: Whether the parent's rotation should be inherited.
1367   bool mInheritScale                               : 1; ///< Cached: Whether the parent's scale should be inherited.
1368   DrawMode::Type mDrawMode                         : 2; ///< Cached: How the actor and its children should be drawn
1369   PositionInheritanceMode mPositionInheritanceMode : 2; ///< Cached: Determines how position is inherited
1370   ColorMode mColorMode                             : 2; ///< Cached: Determines whether mWorldColor is inherited
1371
1372   // Default properties
1373   typedef std::map<std::string, Property::Index> DefaultPropertyLookup;
1374
1375 private:
1376
1377   static ActorContainer mNullChildren; ///< Empty container (shared by all actors, returned by GetChildren() const)
1378   static unsigned int   mActorCounter; ///< A counter to track the actor instance creation
1379
1380   // Default properties
1381   static DefaultPropertyLookup* mDefaultPropertyLookup;
1382
1383 };
1384
1385 /**
1386  * @brief Structure for setting up default properties and their details.
1387  */
1388 struct PropertyDetails
1389 {
1390   std::string name;         ///< The name of the property.
1391   Property::Type type;      ///< The property type.
1392   bool writable:1;          ///< Whether the property is writable
1393   bool animatable:1;        ///< Whether the property is animatable.
1394   bool constraintInput:1;   ///< Whether the property can be used as an input to a constraint.
1395 };
1396
1397 } // namespace Internal
1398
1399 // Helpers for public-api forwarding methods
1400
1401 inline Internal::Actor& GetImplementation(Dali::Actor& actor)
1402 {
1403   DALI_ASSERT_ALWAYS(actor && "Actor handle is empty");
1404
1405   BaseObject& handle = actor.GetBaseObject();
1406
1407   return static_cast<Internal::Actor&>(handle);
1408 }
1409
1410 inline const Internal::Actor& GetImplementation(const Dali::Actor& actor)
1411 {
1412   DALI_ASSERT_ALWAYS(actor && "Actor handle is empty");
1413
1414   const BaseObject& handle = actor.GetBaseObject();
1415
1416   return static_cast<const Internal::Actor&>(handle);
1417 }
1418
1419 } // namespace Dali
1420
1421 #endif // __DALI_INTERNAL_ACTOR_H__