END_TEST;
}
-int UtcDaliControlImplOnStyleChangeP(void)
+int UtcDaliControlImplOnStyleChangeN(void)
{
ToolkitTestApplication application;
- DummyControl dummy = DummyControl::New( true );
+ Control dummy = Control::New();
Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation( dummy );
- Dali::Toolkit::StyleManager styleManager;
- controlImpl.OnStyleChange( styleManager, StyleChange::THEME_CHANGE );
-
- // unfortunately OnStyleChange does not return anything
- DALI_TEST_CHECK( true );
+ // test that style manager is being used, passing an empty handle throws exception
+ try
+ {
+ Dali::Toolkit::StyleManager styleManager;
+ controlImpl.OnStyleChange( styleManager, StyleChange::THEME_CHANGE );
+ tet_result(TET_FAIL);
+ }
+ catch (DaliException &exception)
+ {
+ tet_result(TET_PASS);
+ }
END_TEST;
}
int UtcDaliControlImplOnAccessibilityPanP(void)
{
ToolkitTestApplication application;
- DummyControl dummy = DummyControl::New( true );
- DummyControlImplOverride& dummyImpl = static_cast<DummyControlImplOverride&>(dummy.GetImplementation());
+ Control dummy = Control::New();
+ Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation( dummy );
+
PanGesture pan;
- DALI_TEST_EQUALS( false, dummyImpl.OnAccessibilityPan( pan ), TEST_LOCATION );
+ DALI_TEST_EQUALS( false, controlImpl.OnAccessibilityPan( pan ), TEST_LOCATION );
END_TEST;
}
int UtcDaliControlImplOnAccessibilityTouchP(void)
{
ToolkitTestApplication application;
- DummyControl dummy = DummyControl::New( true );
- DummyControlImplOverride& dummyImpl = static_cast<DummyControlImplOverride&>(dummy.GetImplementation());
+ Control dummy = Control::New();
+ Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation( dummy );
TouchEvent touch;
- DALI_TEST_EQUALS( false, dummyImpl.OnAccessibilityTouch( touch ), TEST_LOCATION );
+ DALI_TEST_EQUALS( false, controlImpl.OnAccessibilityTouch( touch ), TEST_LOCATION );
END_TEST;
}
int UtcDaliControlImplGetNextKeyboardFocusableActorP(void)
{
ToolkitTestApplication application;
- DummyControl dummy = DummyControl::New( true );
- DummyControlImplOverride& dummyImpl = static_cast<DummyControlImplOverride&>(dummy.GetImplementation());
+ Control dummy = Control::New();
+ Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation( dummy );
Actor currentFocusedActor;
- Actor result = dummyImpl.GetNextKeyboardFocusableActor( currentFocusedActor, Control::Left, false );
+ Actor result = controlImpl.GetNextKeyboardFocusableActor( currentFocusedActor, Control::Left, false );
DALI_TEST_EQUALS( result, currentFocusedActor, TEST_LOCATION );
{
validateFontsPerScript = new ValidateFontsPerScript();
- mValidFontsPerScriptCache.PushBack( validateFontsPerScript );
- validFontsPerScriptCacheBuffer = mValidFontsPerScriptCache.Begin();
+ *( validFontsPerScriptCacheBuffer + script ) = validateFontsPerScript;
}
if( NULL != validateFontsPerScript )
-# DALi introduction
-
-## DALi 3D ( Dynamic Animation Library )
-
-DALi is a quick and easy way of allowing developers to create Rich UI Applications like:
-
- + Image & Video galleries
- + Music players
- + Games
- + Maps
- + Homescreens / launch pads
- + Advanced watch faces for wearable devices
-
-DALi is based on OpenGL ES 2.0 & 3.0, however it hides the complexity of
-the OpenGL API from developers and provides a clean cross-platform C++ & JavaScript framework.
-
-+ Create Images, Text and Meshes
-+ Create shaders using GLSL
-+ Provide multiple cameras and render targets
-+ Provides Layers to aid in 2D UI layout
-+ Easy to use Animation framework
-+ Automatic background loading of resources ( images / text / meshes )
-+ Runs all animations in a seperate thread. This helps maintain 60 FPS even if JavaScript is performing a long operation ( e.g. Garbage Collection ).
-+ Provides keyboard / touch / mouse handling
-
-
-
-## Introduction
-- \link fundamentals Dali Fundamentals \endlink
-- \link dali-application Dali Application and Adaptor \endlink
-- \link hello-world Hello World - explained \endlink
-- \link handle-body-idiom Handle – body idiom \endlink
-
-## Actors
- - \link image-mesh-actor Image and Mesh actors \endlink
- - \link event-system Event Handling \endlink
- - \link custom-actor Custom Actor \endlink
-
- ## ShaderEffects
- - \link shader-intro Shader Effects\endlink
-
- ## Animation
- - \link animation-example Example and Usage\endlink
- - \link animation-rotation Rotation with quaternions \endlink
- - \link animation-shader Shader Animation \endlink
- - \link animation-multi-threading-notes Multi-threading Notes \endlink
-
- ## Constraints
- - \link constraints Introduction to Constraints \endlink
-
-## Size Negotation
- - \link size-negotiation Size Negotiation \endlink
-
- ## UI Controls
- - \link text-label Text Label\endlink
- - \link scroll-view Scroll View \endlink
- - \link size-negotiation-controls Size Negotiation for Controls \endlink
- - \link type-registration Type Registration \endlink
- - \link properties Properties \endlink
- - \link background Background \endlink
-
- ## Dynamics
- - \link dynamics-intro Introduction to Dynamics\endlink
- - \link dynamics-initialization Initializing the Simulation\endlink
- - \link dynamics-bodies Bodies - adding and controlling dynamic objects \endlink
- - \link dynamics-joints Joints - linking objects\endlink
- - \link dynamics-collisions Collision Detection and Filtering\endlink
-
- ## Scripting
- - \link scriptoverview JSON and JavaScript Overview \endlink
- - \link script-json-specification JSON Specification\endlink
- - \link script-hello Hello World in script \endlink
- - \link javascriptwrapping JavaScript Wrapping Guide for DALi developers\endlink
-
- ## Rendering
- - \link viewing-modes Viewing modes \endlink
-
- ## Profiling
- - \link performanceprofiling Performance Profiling \endlink
- - \link resourcetracking Resource Tracking \endlink
-
- ## Performance
- - \link performancetips Performance Tips \endlink
- - \link textureatlases Texture Atlases \endlink
- - \link texturecompression Compressing Textures \endlink
-
-## Testing
- See [Automated Tests](@ref auto_testing) for instructions.
-
-
-## Modifying this documentation
-- \link documentationguide Modifying this documentation \endlink
-
+# DALi Introduction
+
+### Introduction
+ + [What is DALi?](@ref dali-introduction)
+ + [Features](@ref dali-features)
+ + [High Level Design](@ref dali-hld)
+ + [Components](@ref dali-components)
+ + [Main, Update & Render Threads](@ref dali-threads)
+ + [DALi Fundamentals](@ref fundamentals)
+ + [Actors & Stage](@ref actors-and-stage)
+ + [Coordinate System](@ref coordinate-system)
+ + Units & the Default Camera (default unit 1 is 1 pixel with default camera)
+ + [Handle / Body Idiom](@ref handle-body-idiom)
+ + Signals
+ + [Properties](@ref properties)
+ + Actions
+ + Tutorial
+ + [Hello World](@ref hello-world)
+
+### Getting Started
+ + How to build DALi on Ubuntu Desktop
+
+### Programming Guide
+ + [Programming Languages:](@ref programming-languages)
+ + [C++](@ref c-plus-plus)
+ + [JavaScript](@ref java-script-support)
+ + [JSON](@ref json-support)
+ + [Application](@ref dali-application)
+ + Actors
+ + [Positioning](@ref positioning-actors)
+ + [Event Handling](@ref event-system)
+ + [Layouting](@ref size-negotiation)
+ + [Image Actor](@ref image-actor)
+ + Animation
+ + AnimateTo
+ + AnimateBy
+ + Key Frame Animations
+ + Path Animations
+ + [Constraints](@ref constraints)
+ + Equal To Constraint
+ + Relative To Constraint
+ + Linear Constrainer
+ + Path Constrainer
+ + [Multi-threading Notes](@ref animation-multi-threading-notes)
+ + [Shader Animation](@ref animation-shader)
+ + [Example and Usage](@ref animation-example)
+ + [Rotation with quaternions](@ref animation-rotation)
+
+### Resources
+ + Resource Image
+ + 9 Patch Image
+ + Buffer Image
+
+### Control Base Class
+ + [Background Feature](@ref background)
+ + Keyboard Focus
+ + Accessibility
+
+### UI Controls
+ + [Text Label](@ref text-label)
+ + TextEntry
+ + Buttons
+ + TableView
+ + [Scroll View](@ref scroll-view)
+ + ItemView
+
+### RenderTasks
+
+### Shader Effects
+ + [Overview](@ref shader-intro)
+
+### Scripting
+ + [JSON and JavaScript Overview](@ref scriptoverview)
+ + [JSON Syntax](@ref script-json-specification)
+ + [Scripting Hello World](@ref script-hello)
+
+### Tools
+ + Environment Variables
+ + [Resource Tracking](@ref resourcetracking)
+ + Logging
+ + GUI Builder
+ + Stagehand
+
+### Viewing Modes
+ + [Overview](@ref viewing-modes)
+
+### Extending DALi
+ + Control Base Class Services
+ + How to write Custom UI Controls
+ + [Size Negotiation for Controls](@ref size-negotiation-controls)
+ + [Type Registration](@ref type-registration)
+ + How to make Controls Scriptable
+ + [Automated Tests](@ref auto_testing)
+ + [Programming Guide](@ref documentationguide)
+ + [JavaScript Wrapping Guide for DALi developers](@ref javascriptwrapping)
+
+### Application Optimization Guide
+ + [Texture Atlases](@ref textureatlases)
+ + [Texture Compression](@ref texturecompression)
+ + Performance & Debugging
+ + [Performance Tips](@ref performancetips)
+ + [Performance Profiling](@ref performanceprofiling)
+++ /dev/null
-/*! \page custom-actor Custom Actor
- * The Dali::CustomActor is used as a base class for UI controls. It is a proxy object to enable derived classes access
- * to a subset of the methods defined in the internal Actor class.
- *
- * Classes deriving from Custom Actor should follow the same handle - body design principle as the rest of the Dali API.
- *
- * One class of the new UI control should inherit from Dali::CustomActor, while a second should inherit
- * Dali::CustomActorImpl. This implementation class contains a number of pure virtual methods that enable the new UI
- * control to respond to a variety of events such as touch and notification of being added to the stage.
- *
- * For example, if creating a new button widget called myNewButton, the user would create two classes, myNewButton which
- * derives from Dali::CustomActor and an implementation part myNewButtonImpl which would derive from Dali::CustomActorImpl.
- *
- * In the New() method for the myNewButton class, the user should then create a new instance of the myNewButtonImpl class
- * and pass this to the constructor of the myNewButton object. Internally the connection will be made
- * between the new widget actor and Dali, thus allowing messages such as OnPropertySet to be received by the new actor.
- *
- * It is the responsibility of the implementation of the new UI control to implement the method bodies for the inherited
- * pure virtual methods from Dali::CustomActorImpl. Obviously the application won't compile if the methods are not
- * overidden, but the user does not need to fill in the code for methods they don't want or need to use.
- *
- * After the implementation object is created it is passed back to the basic Text View through the constructor,the
- * constructor uses this passed in object to initialise the internal implementation objects.
- *
- * After both the objects are created it calls an init method on the implementation which is used to initialise
- * objects. THis is the preferred way to do things so to avoid errors in the constructors.
- *
- * If desired, the user can then use the myNewButtonImpl implementation class to handle only the callback message
- * handler methods, and do all the rest of their widget processing the the main myNewButton class. Access to the
- * implementation class can be gained using the GetImpl(*this) method. For example:
- *
- */
-/*! \page dali-application Dali Application and Adaptor
+/*! \page dali-application DALi Application
*
<h2 class="pg">Creating an Application</h2>
-The Adaptor framework provides several classes which intialises and sets up Dali appropriately so that the application writer does not have to. These classes also provides many platform related services (e.g. orienation change notifications, timer services etc.).
+The Adaptor framework provides provides a Dali::Application class which initialises and sets up Dali appropriately so that the application writer does not have to.
+This provides many platform related services.
-The simplest way to create an application that uses Dali is to utilise the Dali::Application class. In addition to initialising the environment used by Dali, it also provides several signals which the user can connect to when certain platform related activities occur. It also ensures that, upon system events, Dali is called in a thread-safe manner.
+Several signals can be connected to so that the application writer is informed when certain platform related activities occur.
+It also ensures that, upon system events, DALi is called in a thread-safe manner.
The following example shows how to create a Dali::Application instance and connect to its initialise signal (which is where a Dali::Actor hierarchy should be created).
int main (int argc, char **argv)
{
- Application app = Application::New(&argc, &argv);
+ Dali::Application app = Application::New(&argc, &argv);
app.InitSignal().Connect(&CreateProgram);
app.MainLoop();
}
Please see the Dali::Application class for other signals to which the application can connect.
-<h2 class="pg">Using an Adaptor or EvasPlugin instead of the Application class</h2>
-
-If the application requires finer grained control, an Dali::Adaptor can be created instead. This allows the application writer to create other platform related functionality themselves (e.g managing the main loop, providing a surface to render to etc.).
-
-When using the Adaptor, the application writer can specify the use of normal window creation and drawing by using the New method with an appropriate Window.
-
-If the application writer wants Dali to draw to a specific surface then they need to create a Dali::RenderSurface instance and use the Adaptor constructor which takes the Dali::RenderSurface as the parameter.
-
-The only signal provided by the adaptors is a <i>surface resized signal</i>; the application writer will have to handle system signals like <i>initialise, pause, terminate </i> etc. themselves. It is also important that any calls to Dali are made in a thread-safe manner from your application when using the adaptor directly.
-
-An adaptor can be created as shown below:
-
-@code
-void CreateProgram(void* data)
-{
- // Start Adaptor
- Dali::Adaptor* adaptor = reinterpret_cast<Dali::Adaptor*>(data);
- adaptor->Start();
-
- // Create Dali components...
- // Can instantiate here, if required
-}
-
-int main ()
-{
- // Initialise platform
- MyPlatform.Init();
-
- // Create an 800 by 1280 window positioned at (0,0).
- Dali::PositionSize positionSize(0, 0, 800, 1280);
- Dali::Window window = Dali::Window::New( positionSize, "My Application" );
- Dali::Adaptor& adaptor = Dali::Adaptor::New( window );
-
- // Assuming second parameter takes in data which is passed back to the callback function
- MyPlatform.InitialisationConnection(&CreateProgram, &adaptor);
-
- // Start Main Loop of your platform
- MyPlatform.StartMainLoop();
-
- return 0;
-}
-@endcode
-
-A Dali::EvasPlugin instance can be created by EFL applications that wish to use Dali. Like the Adaptor, it also provides a means for initialising the resources required by the Dali::Core.
-
-The Dali::EvasPlugin emits several signals which the user can connect to. The user should not create any Dali objects in the main function and instead should connect to the Init signal of the EvasPlugin and create the Dali objects in the connected callback.
-
-A Dali::EvasPlugin can be used in an EFL application as shown below:
-
-@code
-void Created(EvasPlugin& evasPlugin)
-{
- // Create Dali components...
- // Can instantiate here, if required
-}
-
-void Resized(EvasPlugin& evasPlugin)
-{
- // Set size properties of Dali components
- // Set screen layout
-}
-
-int main (int argc, char **argv)
-{
- // Initialise Elementary
- elm_init(&argc, &argv);
-
- // Create an Evas Window
- Evas_Object* win = elm_win_add(...);
-
- // Get the actual window
- Evas* e = evas_object_evas_get(win);
-
- // Create the EvasPlugin and pass the actual window
- Dali::EvasPlugin evasPlugin = Dali::EvasPlugin(e);
-
- evasPlugin.SignalInit().Connect(&Created);
- evasPlugin.SignalResize().Connect(&Resized);
-
- // Retrieve the Evas_Object from the plugin and show it.
- Evas_Object* evasObject = evasPlugin.GetEvasObject();
- evas_object_show(evasObject);
-
- // add evasObject to layout such as elm_box
-
- // Start main loop
- elm_run();
-}
-@endcode
-
<h2 class="pg">Window</h2>
-Dali provides a Window class to manage drawing to a default surface. It is also responsible for drawing the Indicator bar if required. The Application class automatically creates a Window which the application author can access after the SignalInit has fired.
+DALi provides a Window class to manage drawing to a default surface. It is also responsible for drawing the Indicator bar if required. The Application class automatically creates a Window which the application author can access after the SignalInit has fired.
@code
void CreateProgram(Application& app)
int main (int argc, char **argv)
{
- Application app = Application::New(argc, argv);
+ Dali::Application app = Application::New(argc, argv);
app.SignalInit().Connect(&CreateProgram);
app.MainLoop();
}
@endcode
-<h2 class="pg">Orientation</h2>
-
-The Adaptor Framework also provides a means of retrieving the current device orientation and connection to a signal when the orientation of the device changes. The Dali::Application class provides access to an already created Dali::Orientation object. If using a Dali::Adaptor, an instance of the Dali::Orientation class has to be created in the application.
-
-The following example shows how to connect to an orientation changed signal through the Dali::Application class:
-
-@code
-void OrientationChanged(const Orientation& orientation)
-{
- int degrees = orientation.GetDegrees();
- ...
-}
-
-int main(int argc, char **argv)
-{
- Application app = Application::New(&argc, &argv);
- app.GetWindow().GetOrientation().SignalChanged().Connect(&OrientationChanged);
-}
-@endcode
-
<h2 class="pg">Timers</h2>
Timers are also provided by the Adaptor Framework so that the application writer can execute a portion of their code periodically or just once, after a delay. The example below shows how a Dali::Timer can be created and used:
...
// Elsewhere
-Timer timer = Timer::New(2000); // 2 second timeout
+Dali::Timer timer = Dali::Timer::New(2000); // 2 second timeout
timer.SignalTick().Connect(&Tick);
...
@endcode
+++ /dev/null
-/**
- * \page dynamics-bodies Dynamics - Bodies
- * A Dali::DynamicsBody can be "Rigid" or "Soft". Rigid bodies require much less processing and should be used
- * in preference to a soft body.\n
- * All bodies are controlled by the simulation, the application developer can influence them by setting their
- * linear or angular velocities, but direct control of their position is not possible until the Dali::DynamicsBody is flagged
- * as a \ref kinematic-body "kinematic object".\n
- *
- * \section create-body Creating a body
- * <p>
- * Each Dali::DynamicsBody is created by an Dali::Actor through its Dali::Actor::EnableDynamics method using a
- * Dali::DynamicsBodyConfig object to specify options for the Dali::DynamicsBody.
- * \code
- * // Initialize and get a handle to the Dali::DynamicsWorld
- * Dali::DynamicsWorldConfig worldConfig( Dali::DynamicsWorldConfig::New() );
- * Dali::DynamicsWorld dynamicsWorld( Dali::Stage::GetCurrent().InitializeDynamics( worldConfig ) );
- * // Create an actor to represent the world
- * Dali::Actor dynamicsRootActor( Dali::Actor::New() );
- * dynamicsWorld.SetRootActor( dynamicsRootActor );
- * Dali::Stage::GetCurrent().Add( dynamicsRootActor );
- *
- * // create an actor to represent a rigid body
- * Dali::Actor actor( Dali::Actor::New() );
- * actor.SetParentOrigin( Dali::ParentOrigin::CENTER );
- * dynamicsRootActor.Add( actor );
- * // Enable dynamics for the actor, creating a rigid body with default configuration
- * actor.EnableDynamics( Dali::DynamicsBodyConfig::New() );
- * \endcode
- *
- * \section create-body-advanced Specifying options
- * <h4>Mass</h4>
- * Use Dali::DynamicsBodyConfig::SetMass to specify the mass of the body [default: 1].
- * <h4>Elasticity</h4>
- * Use Dali::DynamicsBodyConfig::SetElasticity to specify the elasticity of the body [default: 0.85].\n
- * This may also be known as the co-efficient of restitution or 'bounciness'.
- * <h4>Damping</h4>
- * Use Dali::DynamicsBodyConfig::SetLinearDamping to specify the linear damping coefficient [default: 0].\n
- * and Dali::DynamicsBodyConfig::SetAngularDamping to specify the angular damping coefficient [default: 0].\n
- * <h4>Friction</h4>
- * Use Dali::DynamicsBodyConfig::SetFriction to specify the friction of the body [default: 0.5].\n
- * <h4>Collision Filtering</h4>
- * See \link dynamics-collisions Collision Detection and Filtering \endlink\n\n
- * Use Dali::DynamicsBodyConfig::SetCollisionGroup to specify the collision filter group.\n
- * Use Dali::DynamicsBodyConfig::SetCollisionMask to specify the collision filter mask.\n
- * <h3>Soft body specific options</h3>
- * <h4>Stiffness</h4>
- * Use Dali::DynamicsBodyConfig::SetStiffness to specify the stiffness of the links between the mesh vertices used to
- * define the soft body. Values clamped between 0 and 1 [default: 1].\n
- * <h4>Anchor hardness</h4>
- * Use Dali::DynamicsBodyConfig::SetAnchorHardness to specify the hardness or drift correction applied to anchors.
- * Values clamped between 0 and 1 [default: 0.7]. Smaller values mean less drift correction.\n
- * <h4>Conservation</h4>
- * Use Dali::DynamicsBodyConfig::SetShapeConservation to specify the shape conservation coefficient,
- * or the magnitude of the force which will attempt to maintain the soft bodies shape (see \ref Dali::DynamicsBody::ConserveShape).\n
- * Use Dali::DynamicsBodyConfig::SetVolumeConservation to specify the volume conservation coefficient,
- * or the magnitude of the force which will attempt to maintain the soft bodies volume (see \ref Dali::DynamicsBody::ConserveVolume).
- * Smaller values mean less conservation.\n
- * <h4>Create a rigid body with advanced options</h4>
- * \code
- * Dali::DynamicsBodyConfig bodyConfig( Dali::DynamicsBodyConfig::New() );
- * // increase mass from the default
- * bodyConfig.SetMass( 2.5f );
- * // set elasticity so that the velocity of the object will be halved after a collision
- * // (assuming the other body has a mass = 1 and a velocity 0f 0).
- * bodyConfig.SetElasticity( 0.5f );
- * // increase the rate at which a bodies linear velocity will decrease
- * bodyConfig.SetLinearDamping( 0.5f );
- * // reduce the friction to zero
- * bodyConfig.SetFriction( 0.0f );
- * // Ignore all collisions
- * bodyConfig.SetCollisionGroup( 0 );
- * bodyConfig.SetCollisionMask( 0 );
- *
- * // create an actor for the Dali::DynamicsBody
- * Actor actor( Actor::New() );
- * actor.SetParentOrigin( Dali::ParentOrigin::CENTER );
- * // create the Dali::DynamicsBody
- * actor.EnableDynamics( bodyConfig );
- *
- * // add to the simulation
- * dynamicsRootActor.Add( actor );
- * \endcode
- * <h4>Create a soft body with advanced options</h4>
- * \code
- * // Create a unit mesh with 25 vertices
- * Dali::Mesh mesh( Dali::Mesh::NewPlane(1.0f, 1.0f, 5, 5) );
- *
- * Dali::DynamicsBodyConfig bodyConfig( Dali::DynamicsBodyConfig::New() );
- * // select a soft body
- * bodyConfig.SetType( Dali::DynamicsBodyConfig::SOFT );
- * // set the mesh as the soft body shape
- * bodyConfig.SetShape( Dali::DynamicsShape::NewMesh( mesh ) );
- * // decrease the stiffness of the links between the soft body vertices
- * bodyConfig.SetStiffness( 0.25f );
- * // Make anchors very loose/weak
- * bodyConfig.SetAnchorHardness( 0.1f );
- *
- * // create an actor for the Dali::DynamicsBody
- * Actor actor( MeshActor::New(mesh) );
- * actor.SetParentOrigin( Dali::ParentOrigin::CENTER );
- * // create the Dali::DynamicsBody
- * actor.EnableDynamics( bodyConfig );
- *
- * // add to the simulation
- * dynamicsRootActor.Add( actor );
- * \endcode
- * \image html dynamics/dynamics-soft.png "A soft body (with debug rendering enabled)"
- * \section kinematic-body Kinematic bodies
- * A kinematic body is not controlled by the simulation, there is a one-way interaction with other dynamic objects
- * under control of the simulation, where other objects will be pushed away, but the kinematic object will be unaffected.\n
- * Kinematic objects can be animated with DALi's \ref animation-example "animation system", each DALi update the simulation will
- * get the current position of associated DALi actor.\n Use Dali::DynamicsBody::SetKinematic to make a kinematic object.
- * <h3>Animating a kinematic object</h3>
- * Other dynamics enabled actors that collide with the kinematic object during the animation will be pushed
- * away.
- * \code
- * ...
- * // create an actor to represent a rigid body
- * Dali::Actor actor( Dali::Actor::New() );
- * dynamicsRootActor.Add( actor );
- * // Enable dynamics for the actor, creating a rigid body with default configuration
- * actor.EnableDynamics( Dali::DynamicsBodyConfig::New() );
- * // get the DynamicsBody handle
- * DynamicsBody body( actor.GetDynamicsBody() );
- * body.SetKinematic( true );
- * // create a second animation to move the actor 100 units to the right
- * Animation animation( Animation::New( 1 ) );
- * animation.AnimateBy( Property( actor, Actor::Property::POSITION ), Vector3( 100, 0, 0 ), AlphaFunction::LINEAR );
- * animation.Play();
- * \endcode
- * <hr>
- * <p>See also
- * <ul>
- * <li>Dali::DynamicsBodyConfig</li>
- * <li>Dali::Actor::EnableDynamics</li>
- * <li>\link dynamics-initialization DynamicsWorld Initialization and Usage\endlink</li>
- * </ul>
- * </p>
- */
-
+++ /dev/null
-/**
- * \page dynamics-collisions Collisions
- * \section collision-detection Collision Detection
- * <p>
- * Collision detection is automatic and occurs between all Dali::DynamicsBody objects in the simulation.@n
- * To respond to a detected collisions, the application developer can connect to a signal provided by
- * a Dali::DynamicsWorld object.
- * \code
- * ...
- *
- * // DynamicsWorld initialization code
- *
- * ...
- *
- * // Connect a signal handler to the signal
- * Dali::DynamicsWorld theWorld( Stage::GetCurrent().GetDynamicsWorld() );
- * theWorld.SignalCollision().Connect( this, &myClass::OnDynamicsCollision );
- *
- * ...
- *
- * // Implement a signal handler
- * void myClass::OnDynamicsCollision( Dali::DynamicsWorld world, Dali::DynamicsCollision collisionData )
- * {
- * std::cout << "Collision between "
- * << collisionData.GetActorA().GetName() << " and "
- * << collisionData.GetActorB().GetName() << " ";
- *
- * if( collisionData.GetImpactForce() != 0.0f )
- * {
- * std::cout << "detected (impact force: " << collisionData.GetImpactForce() << " )";
- * }
- * else
- * {
- * std::cout << "ended";
- * }
- * std::cout << std::endl;
- * }
- * \endcode
- *
- * <hr>
- * \section collision-filtering Collision Filtering
- *
- * <p>
- * When a large number of Dali::DynamicsBody objects are added to the simulation, collision detection can become a
- * significant performance drain, where every possible pairing of objects needs to be checked for collisions.</p>
- * <p>You can significantly reduce the number of pairs considered for collision detection by using a collision filter.</p>
- * <p>Each Dali::DynamicsBody can belong to a user defined collision filter group and have a user defined collision filter mask.<p>
- * <p>A Dali::DynamicsBody pair are considered for collision detection if one or more bits in the filter group from each Dali::DynamicsBody
- * matches one or more bits in the filter mask of the other Dali::DynamicsBody.
- * </p>
- * <center><table border="1">
- * <caption>Truth table</caption>
- * <tr align="center">
- * <th> P </th>
- * <th> Q </th>
- * <th>tested for collision?</th>
- * </tr>
- * <tr align="center">
- * <td>0</th>
- * <td>0</th>
- * <td>no</th>
- * </tr>
- * <tr align="center">
- * <td>0</th>
- * <td>1</th>
- * <td>no</th>
- * </tr>
- * <tr align="center">
- * <td>1</th>
- * <td>0</th>
- * <td>no</th>
- * </tr>
- * <tr align="center">
- * <td>1</th>
- * <td>1</th>
- * <td>yes</th>
- * </tr>
- * </table></center>
- * <p>
- * where <b>P</b> = bitwise AND of the collision group from the first Dali::DynamicsBody and the collision mask from the second Dali::DynamicsBody\n
- * and <b>Q</b> = bitwise AND of the collision group from the second Dali::DynamicsBody and the collision mask from the first Dali::DynamicsBody.
- * </p><br>
- * <p>
- * <b>Pseudo code for the filter check.</b>
- * \code
- * const bool canCollide( ( firstBody->GetCollisionGroup() & secondBody->GetCollisionMask() &&
- * ( secondBody->GetCollisionGroup() & firstBody->GetCollisionMask() );
- * \endcode
- * </p>
- * <h3 class="pg">Code example - Illustrating how to create multiple filter groups and masks.</h3>
- * \code
- * // Define some collision groups
- * const short int group0( 1 << 1 );
- * const short int group1( 1 << 2 );
- * const short int group2( 1 << 3 );
- *
- * // Create some Dali::DynamicsBodyConfig objects
- * Dali::DynamicsBodyConfig bodyConfig0( Dali::DynamicsBodyConfig::New() );
- * Dali::DynamicsBodyConfig bodyConfig1( Dali::DynamicsBodyConfig::New() );
- * Dali::DynamicsBodyConfig bodyConfig2( Dali::DynamicsBodyConfig::New() );
- *
- * // Assign the collision filters to the configurations
- * bodyConfig0->SetCollisionGroup(group0);
- * bodyConfig0->SetCollisionMask( group1 | group2 );
- * bodyConfig1->SetCollisionGroup(group1);
- * bodyConfig1->SetCollisionMask(group0);
- * bodyConfig2->SetCollisionGroup(group2);
- * bodyConfig2->SetCollisionMask(group0 | group2);
- * \endcode
- * <p>
- * Collision detection is \b enabled between Dali::DynamicsBody pairs of...
- * <ul>
- * <li>group0 and group1 objects.</li>
- * <li>group0 and group2 objects.</li>
- * <li>group2 objects.</li>
- * </ul>
- * Collision detection is \b disabled between Dali::DynamicsBody pairs of...
- * <ul>
- * <li>group0 objects.</li>
- * <li>group1 objects.</li>
- * <li>group1 and group2 objects.</li>
- * </ul>
- * </p>
- *
- * See
- * <ul>
- * <li>Dali::DynamicsWorld::SignalCollision</li>
- * <li>Dali::DynamicsCollision</li>
- * <li>\ref Dali::DynamicsBodyConfig::SetCollisionGroup - to set the collision group</li>
- * <li>\ref Dali::DynamicsBodyConfig::SetCollisionMask - to set the collision mask</li>
- * </ul>
- */
-
+++ /dev/null
-/**
- * \page dynamics-initialization Initializing the Simulation
- * \section dynamics-prerequisites Dynamics prerequisites
- * <p>
- * In order to reduce binary size on devices, by default Dali core is built without Dynamics support. \n
- * This can be enabled by adding the --enable-debug option to configure. The configure command should output this: \n
- * \code
- * Configuration
- * -------------
- * Dynamics support: yes
- * \endcode
- * <p>In addition to rebuilding Dali, a physics plugin (e.g. bullet, havok) should be installed on the target device.
- * Dali adaptor provides the bullet plugin e.g. install dali-adaptor-dali-bullet-plugin-X.armv7l.rpm.
- *
- * \section initializing-world Initializing the World
- * <p>
- * The simulation is encapsulated and controlled by a instance of a Dali::DynamicsWorld object.\n
- * \code
- * // DynamicsWorld initialisation code
- * Dali::DynamicsWorldConfig worldConfig( Dali::DynamicsWorldConfig::New() );
- * Dali::Stage::GetCurrent().InitializeDynamics( worldConfig );
- * \endcode
- * <p>If the DynamicsWorld handle empty, then a prerequisite is missing (see above).
- * Use a Dali::DynamicsWorldConfig object to specify options for the type of simulation required.\n
- * Dali::DynamicsWorldConfig::RIGID supports rigid body dynamics only, while Dali::DynamicsWorldConfig::SOFT supports
- * both rigid and soft body dynamics. Rigid body dynamics uses less CPU than soft body dynamics and is simpler to set up.
- * \code
- * // DynamicsWorld initialisation code
- * Dali::DynamicsWorldConfig worldConfig( Dali::DynamicsWorldConfig::New() );
- * // Choose a rigid body capable simulation
- * worldConfig.SetType( Dali::DynamicsWorldConfig::RIGID );
- * // or a soft and rigid body simulation
- * worldConfig.SetType( Dali::DynamicsWorldConfig::SOFT );
- * // Request Dali::Stage to create an instance of the DynamicsWorld
- * Dali::Stage::GetCurrent().InitializeDynamics( worldConfig );
- * \endcode
- *
- * \section initializing-world-advanced Advanced Initialization
- * <h3>Units</h3>
- * <p>All distance units in the simulation are based on meters, so positioning an actor at (0, -500, -1000)
- * will position it 0.5km in the air and 1km away from the camera.\n So if the actor was to fall under
- * the control of gravity it will seem to fall in slow motion. To counteract this the simulation units can
- * be modified using Dali::DynamicsWorldConfig::SetUnit. The default value is set to 0.01 to change the
- * simulation units to centimeters.
- * </p>
- * \code
- * // change simulation back to meters
- * worldConfig.SetUnit(1.0f);
- * // or change simulation unit to millimeters
- * worldConfig.SetUnit(1.0f/1000.0f);
- * \endcode
- *
- * <h3>Simulation update ticks</h3>
- * <p>The application developer can set the number of simulation time steps / DALi update tick using
- * Dali::DynamicsWorldConfig::SetSimulationSubSteps.\n
- * Use this to advance the simulation in smaller time steps, thus gaining a more accurate
- * simulation for collision detection.\n
- * Using this API may adversely affect performance, as the dynamics simulation is performing many more
- * calculations each DAli tick than normal.</p>
- * \code
- * // Assume DAli is updating at 60Hz (16.667ms / update)
- * //Setting subSteps to 1 will update the simulation once per DALi update.
- * worldConfig.SetSimulationSubSteps(1);
- * //Setting subSteps to 4 will perform 4 simulation updates per DALi update each with a time step of Approx 4.2ms.
- * worldConfig.SetSimulationSubSteps(1);
- * \endcode
- * \section manipulating-world Using the World
- * <h3>The Dynamics Simulation Root Actor</h3>
- * <p>To manipulate the world within the scene-graph it must be connected to a Dali::Actor.\n
- * All Rigid or Soft bodies that will be simulated must each be connected to a Dali::Actor which is a
- * direct child of the dynamics root actor.</p>
- * \code
- * // Create an actor to represent our view of the simulation
- * Dali::Actor dynamicsRootActor( Dali::Actor::New() );
- * // retrieve a handle to the DynamicsWorld object initialized previously
- * Dali::DynamicsWorld dynamicsWorld( Dali::Stage::GetCurrent().GetDynamicsWorld() );
- * // Connect the Dali::DynamicsWorld and the Dali::Actor
- * dynamicsWorld.SetRootActor( dynamicsRootActor );
- * // Add root actor to Dali::Stage
- * Dali::Stage::GetCurrent().Add( dynamicsRootActor );
- * \endcode
- * <h3>Gravity</h3>
- * <p>The gravity applicable to the entire simulation can be set through Dali::DynamicsWorld::SetGravity.\n
- * The gravity will apply a constant force on all Dali::DynamicsBody objects added to the world which have a
- * non zero mass and are not flagged as kinematic.</p>
- * \code
- * // Set gravity to apply a force on the negative Y axis
- * dynamicsWorld.SetGravity( Vector3( 0.0f, -10.0f, 0.0f ) );
- * \endcode
- * <hr>
- * <p>See also
-* <p>See
- * <ul>
- * <li>Dali::DynamicsWorldConfig</li>
- * <li>Dali::DynamicsWorld</li>
- * <li>Dali::Stage::InitializeDynamics</li>
- * </ul>
- * </p>
- *
- */
-
+++ /dev/null
-/*! \page dynamics-intro Dynamics - Introduction
- *
- * Dynamics gives the application developer a means to simulate physical kinetic properties on solid shapes.
- * Simple physical shapes can be associated with a given actor, e.g., an actor representing a ball would have
- * a spherical shape. Other simple shapes include cube, cone, cylinder and capsule (a pill or lozenge shape).
- * \image html dynamics/dynamics-shapes.png "Simple Shapes"
- * The application developer can provide more complex shapes using arbitrary meshes, however, this will use more
- * CPU than the simple shapes.\n\n
- * Dali supports both rigid body and soft body simulations.
- * <ul>
- * <li>Rigid body simulation means that the shapes used in the simulation cannot deform. This is simpler, and requires
- * less processing power.</li>
- * <li>Soft body simulation allows the shapes used in the simulation to deform, e.g. a rubber ball will squash and change
- * shape when it hits a wall; or a cloth flag will flutter, etc.</li>
- * </ul>
- * Both forms of simulation provide automatic collision detection, and can be detected on all bodies in the simulation.
- * The application developer can use signals to listen for detected collisions.
- *
- * \image html dynamics/dynamics-rigid.png "Example application"
- */
-
+++ /dev/null
-/**
- * \page dynamics-joints Joints
- * A Dali::DynamicsJoint represents a connection (or link) between a Dali::DynamicsBody pair.
- * A Joint can optionally allow \ref linear "linear motion" and/or \ref angular "angular rotation" around its origin on one or more axis, and
- * can have a \ref motors "motor" or \ref springs "spring" enabled on those axis.
- * \image html dynamics/dynamics-joint2.png
- * \section create-joint Creating a joint
- * <p>Each Dali::DynamicsJoint is created by a Dali::Actor through its Dali::Actor::AddDynamicsJoint method.\n
- * This method takes two parameters\n
- * 1. The other Dali::Actor in the joint relationship.\n
- * 2. A Dali::Vector3 relative offset from the owning Dali::Actor's current position.\n
- * A joint is active in the simulation when both of the actors are connected to the Stage via the Dali::Actor
- * set with Dali::DynamicsWorld::SetRootActorDynamics.
- * </p>
- * <h3>A code example creating two actors connected by a joint</h3>
- * \code
- * // create an actor to represent a rigid body
- * Dali::Actor actor1( Dali::Actor::New() );
- * // Enable dynamics for the actor, creating a rigid body with default configuration
- * actor1.EnableDynamics( Dali::DynamicsBodyConfig::New() );
- * actor1.SetPosition( Vector3( 0, 0, 0 ) );
- * // create an actor to represent a second rigid body
- * Dali::Actor actor2( Dali::Actor::New() );
- * actor1.SetPosition( Vector3( 100, 0, 0 ) );
- * // Enable dynamics for the actor, creating a rigid body with default configuration
- * actor2.EnableDynamics( Dali::DynamicsBodyConfig::New() );
- * // create the joint
- * Vector3 relativeOffset( 25, 0, 0 );
- * actor1.AddDynamicsJoint( actor2, relativeOffset );
- * \endcode
- * The joint is 25 units to the right of actor1 and 75 units to the left of actor2. If
- * either actor is moved the joint will follow pulling the other actor with it.
- * \section linear Linear Limits
- * \image html dynamics/dynamics-joint.png "A joint allowing linear motion on the Y Axis"
- * Limits control how much translation is allowed relative to the joints origin point, use Dali::DynamicsJoint::SetLinearLimit
- * to set linear limits.
- * \code
- * ...
- * actor1.AddDynamicsJoint( actor2, Vector3(0, 0, 0) );
- * DynamicsJoint joint( actor1.GetDynamicsJoint(actor2) );
- *
- * // Allow translation from the joint's origin along the X axis of +/- 50 units
- * joint.SetLinearLimit( Dali::DynamicsJoint::LINEAR_X, -50, 50);
- * \endcode
- * \section angular Angular Limits
- * Limits control how much rotation is allowed around the joint's origin point, use Dali::DynamicsJoint::SetAngularLimit
- * to set angular limits.
- * \code
- * ...
- * actor1.AddDynamicsJoint( actor2, Vector3(0, 0, 0) );
- * DynamicsJoint joint( actor1.GetDynamicsJoint(actor2) );
- *
- * // Allow rotation around the joint's origin on the Z axis of - 45 degrees and +90 degrees
- * joint.SetAngularLimit( Dali::DynamicsJoint::ANGULAR_Z, -Dali::Degree(45), Dali::Degree(90) );
- * \endcode
- * \section motors Motors
- * Motors apply a force along a given axis towards the lower or upper limit set on that axis.\n
- * Use Dali::DynamicsJoint::EnableMotor to enable/disable a motor.\n
- * The torque of the motor can be set with Dali::DynamicsJoint::SetMotorForce and the velocity
- * with Dali::DynamicsJoint::SetMotorVelocity.
- * \code
- * ...
- * actor1.AddDynamicsJoint( actor2, Vector3(0, 0, 0) );
- * DynamicsJoint joint( actor1.GetDynamicsJoint(actor2) );
- *
- * // allow angular rotation on the Z axis
- * joint.SetAngularLimit(Dali::DynamicsJoint::ANGULAR_Z, -Dali::Degree(90), Dali::Degree(90));
- * // enable the Z axis angular motor
- * joint.EnableMotor(Dali::DynamicsJoint::ANGULAR_Z, true);
- * // set the motor torque
- * joint.SetMotorForce(Dali::DynamicsJoint::ANGULAR_Z, 0.5f);
- * // set the motor velocity (acts towards lower limit)
- * joint.SetMotorVelocity(Dali::DynamicsJoint::ANGULAR_Z, -10.0f);
- * \endcode
- * \section springs Springs
- * Springs apply a force to keep the Dali::DynamicsJoint origin at the spring's center point.
- * A spring can be enabled for a given axis using Dali::DynamicsJoint::EnableSpring.\n
- * The center point is set as a ratio between the lower and upper limits on the given axis using
- * Dali::DynamicsJoint::SetSpringCenterPoint.\n
- * The magnitude of the spring's centering force can be set with Dali::DynamicsJoint::SetSpringStiffness.\n
- * Dali::DynamicsJoint::SetSpringDamping can be used to limit the amount of overshoot and oscillations
- * of the spring as it settles at its center point.
- * \code
- * ...
- * actor1.AddDynamicsJoint( actor2, Vector3(0, 0, 0) );
- * DynamicsJoint joint( actor1.GetDynamicsJoint(actor2) );
- *
- * // allow linear motion on Y axis
- * joint.SetLinearLimit(Dali::DynamicsJoint::LINEAR_Y, -50, 50);
- * // enable the Y axis linear spring
- * joint.EnableSpring(Dali::DynamicsJoint::LINEAR_Y, true);
- * // set the center point of the spring at -40 ( 10% of the limits set )
- * joint.SetSpringCenterPoint(Dali::DynamicsJoint::LINEAR_Y, 0.1f);
- * // set the springs stiffness or centering force
- * joint.SetSpringStiffness(Dali::DynamicsJoint::LINEAR_Y, 40.0f);
- * // allow more oscillations before the spring comes to reset
- * joint.SetSpringDamping(Dali::DynamicsJoint::LINEAR_Y, 0.1f);
- * \endcode
- * <hr>
- * <p>See also
- * <ul>
- * <li>Dali::DynamicsJoint</li>
- * <li>Dali::Actor::AddDynamicsJoint</li>
- * <li>Dali::Actor::GetDynamicsJoint</li>
- * </ul>
- * </p>
- */
-
-/*! \page image-mesh-actor Image and Mesh actors
+/*! \page image-actor Image Actors
*
*
* <h1 class="pg">Overview</h1>
- * The Dali::ImageActor & Dali::MeshActor are inherited from Dali::Actor and provide means to display resources like Images and Geometries (Triangle meshes) on the stage.
+ * The Dali::ImageActor inherits from Dali::Actor and provide means to display resources like Images on the stage.
* All the Dali::Actor methods can be called on them.<br>
*
* - <b>ImageActor:</b> An actor for displaying Images. It allows the developer to display a Dali::Image object on the stage.<br>
- * - <b>MeshActor:</b> An actor for displaying one or more mesh geometries. It may have children, which may be plain actors or other mesh actors.<br>
*
* <h1 class="pg">Image Actor</h1>
*
* myImageActor.SetImage( newImage );
* @endcode
*
- * <h2 class="pg">Fade in</h2>
- * It's possible to fade in the image gradually when first rendered.
- * @code
- * if (!myImageActor.GetFadeIn())
- * {
- * myImageActor.SetFadeIn(true);
- * }
- *
- * // default : 1 Second
- * myImageActor.SetFadeInDuration(seconds);
- * @endcode
- *
- *
- * <h1 class="pg">Mesh Actor</h1>
- *
- * <h2 class="pg">Construction</h2>
- * The mesh actor is created by passing a reference to Dali::Mesh object
- *
- * @code
- * Dali::Mesh mesh = Dali::Mesh::New();
- * Dali::MeshActor myMeshActor = Dali::MeshActor::New(mesh);
- * @endcode
-
- *
- * <h2 class="pg">Modifying material</h2>
- * The developer can change the material of mesh actor using the material entity name.
- *
- * @code
- * Dali::Image image = Dali::Image::New(myTextureFile);
- * myCustomMaterial = Dali::Material::New("CustomMaterial");
- * myCustomMaterial.SetDiffuseTexture(image);
- * Dali::MeshActor::SetMaterial(myMeshActor, materialEntityNameInModel, 0, myCustomMaterial);
- *
- * @endcode
- *
- *
*/
--- /dev/null
+/**
+ *
+# DALi 3D ( Dynamic Animation Library ) {#dali-introduction}
+
+DALi is a quick and easy way of allowing developers to create Rich UI Applications like:
+
+ + Image & Video galleries
+ + Music players
+ + Games
+ + Maps
+ + Homescreens / launch pads
+ + Advanced watch faces for wearable devices
+
+DALi is based on OpenGL ES 2.0 & 3.0, however it hides the complexity of
+the OpenGL API from developers and provides a clean cross-platform C++ & JavaScript framework.
+
+## Features {#dali-features}
+
+ + Create Images & Text
+ + Create shaders using GLSL
+ + Provide multiple cameras and render targets
+ + Provides Layers to aid in 2D UI layout
+ + Easy to use Animation framework
+ + Automatic background loading of resources ( images / text / meshes )
+ + Runs all animations in a seperate thread. This helps maintain 60 FPS even if JavaScript is performing a long operation ( e.g. Garbage Collection ).
+ + Provides keyboard / touch / mouse handling
+
+
+
+*/
*
# Dali Fundamentals {#fundamentals}
-## Actors and the Stage
+## Actors and the Stage {#actors-and-stage}
A Dali application uses a hierachy of Dali::Actor objects to position visible content. An actor inherits a position relative to its parent, and can be moved relative to this point. UI controls can be built by combining multiple actors.
dali.stage.add( actor );
~~~
-## The Coordinate System
+## The Coordinate System {#coordinate-system}
The Stage has a 2D size, which matches the size of the application window. The default coordinate system in Dali has the origin at the top-left corner, with positive X to right, and position Y going
downwards. This is intended to be convenient when laying-out 2D views.
-## Positioning Actors
+## Positioning Actors {#positioning-actors}
An actor inherits its parent's position. The relative position between the actor & parent is determined by 3 properties:
1) ParentOrigin. This Vector3 property defines a point within the parent actor's area.
--- /dev/null
+/**
+ *
+
+# High Level Design {#dali-hld}
+
+## Components {#dali-components}
+
+ + **DALi Core:** Event handling, Scene Graph, Rendering, Resource Management
+ + **DALi Adaptor:** Threading Model, Integration with the main loop.
+ + **DALi Platform Abstraction:** Resource loading & decoding in multiple threads (part of dali-adaptor)
+ + **DALi Toolkit:** Reusable UI Controls, Effects & Scripting Support
+
+
+
+## Main, Update & Render Threads {#dali-threads}
+
+DALi uses a multithreaded architecture in order to provide the best performance and scalability.
+
+ + **Event Thread:** The main thread in which application code and event handling runs.
+ + **Update Thread:** Updates the nodes on the scene as well as running animations & constraints
+ + **Render Thread:** OpenGL drawing, texture and geometry uploading etc.
+ + **Resource Threads:** Loads images and decodes into bitmaps etc.
+
+
+
+*/
--- /dev/null
+/**
+ *
+# Programming Languages {#programming-languages}
+
+DALi applications can be written in several different programming languages.
+
+## C++ {#c-plus-plus}
+
+~~~{.cpp}
+Dali::Actor actor = Dali::Actor::New();
+actor.SetParentOrigin( Dali::ParentOrigin::CENTER );
+actor.SetAnchorPoint( Dali::AnchorPoint::CENTER );
+Dali::Stage::GetCurrent().Add( actor );
+...
+bool OnPressed( Dali::Actor, const TouchEvent& event )
+{
+ Dali::Animation anim = Dali::Animation::New( 1.5f );
+ anim.AnimateTo( Property( actor, Actor::Property::POSITION ), Vector3( 200,-100,0), AlphaFunctions::Bounce );
+ anim.play();
+ return true; // consume the touch event
+}
+...
+actor.TouchedSignal().Connect( &OnPressed );
+~~~
+
+*/
+
+## JavaScript {#java-script-support}
+
+~~~{.js}
+var actor = new dali.Actor();
+actor.parentOrigin = dali.CENTER;
+actor.anchorPoint = dali.CENTER;
+dali.stage.add( actor );
+...
+function onPressed( actor, touchEvent )
+{
+ var animOptions = { alpha: "bounce", delay: 0, duration: 15 };
+ var anim = new dali.Animation();
+ anim.animateTo( actor, "position", [ 200,-100,0], animOptions );
+ anim.play();
+ return true; // consume the touch event
+}
+...
+actor.connect( "touched", onPressed );
+
+~~~
+
+## JSON {#json-support}
+
+~~~{.json}
+{
+ "animations":
+ {
+ "move":
+ {
+ "duration": 1.5,
+ "properties":
+ [
+ {
+ "actor":"image",
+ "property":"position",
+ "value":[200,-100,0],
+ "alpha-function": "BOUNCE"
+ }
+ ]
+ }
+ },
+ "stage":
+ [
+ {
+ "name":"image",
+ "type":"Actor",
+ "anchor-point": "CENTER",
+ "parent-origin": "CENTER",
+ "signals" :
+ [
+ { "name" : "touched", "action": "play", "animation": "move" }
+ ]
+ }
+ ]
+}
+~~~
\ No newline at end of file
projects / platform / core / uifw / dali-toolkit.git / commitdiff
