namespace
{
-const float BACKGROUND_ACTOR_Z_POSITION( -0.1f );
-
/**
* Creates control through type registry
*/
* @return true if action has been accepted by this control
*/
const char* ACTION_CONTROL_ACTIVATED = "control-activated";
- static bool DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes )
+static bool DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes )
{
bool ret = false;
actor.SetColor( color );
actor.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_COLOR );
- actor.SetZ( BACKGROUND_ACTOR_Z_POSITION );
actor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
}
actor.SetColor( color );
actor.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_COLOR );
- actor.SetZ( BACKGROUND_ACTOR_Z_POSITION );
Constraint constraint = Constraint::New<Vector3>( actor,
constrainingIndex,
mLongPressGestureDetector(),
mFlags( Control::ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
mIsKeyboardNavigationSupported( false ),
- mIsKeyboardFocusGroup( false )
+ mIsKeyboardFocusGroup( false ),
+ mAddRemoveBackgroundChild( false )
{
}
ControlBehaviour mFlags :CONTROL_BEHAVIOUR_FLAG_COUNT; ///< Flags passed in from constructor.
bool mIsKeyboardNavigationSupported :1; ///< Stores whether keyboard navigation is supported by the control.
bool mIsKeyboardFocusGroup :1; ///< Stores whether the control is a focus group.
+ bool mAddRemoveBackgroundChild:1; ///< Flag to know when we are adding or removing our own actor to avoid call to OnControlChildAdd
// Properties - these need to be members of Internal::Control::Impl as they need to function within this class.
static PropertyRegistration PROPERTY_1;
SetupBackgroundActorConstrained( meshActor, Actor::Property::SCALE, color );
- // Set the background actor before adding so that we do not inform deriving classes
background.actor = meshActor;
- Self().Add( meshActor );
+ // Set the flag to avoid notifying children
+ mImpl->mAddRemoveBackgroundChild = true;
+ // use insert to guarantee its the first child (so that OVERLAY mode works)
+ Self().Insert( 0, meshActor );
+ mImpl->mAddRemoveBackgroundChild = false;
}
background.color = color;
if ( background.actor )
{
- // Remove Current actor, unset AFTER removal so that we do not inform deriving classes
+ // Remove Current actor, unset AFTER removal
+ mImpl->mAddRemoveBackgroundChild = true;
Self().Remove( background.actor );
+ mImpl->mAddRemoveBackgroundChild = false;
background.actor.Reset();
}
// Set the background actor before adding so that we do not inform derived classes
background.actor = imageActor;
- Self().Add( imageActor );
+ mImpl->mAddRemoveBackgroundChild = true;
+ // use insert to guarantee its the first child (so that OVERLAY mode works)
+ Self().Insert( 0, imageActor );
+ mImpl->mAddRemoveBackgroundChild = false;
}
void Control::ClearBackground()
if ( mImpl->mBackground )
{
Background& background( mImpl->GetBackground() );
+ mImpl->mAddRemoveBackgroundChild = true;
Self().Remove( background.actor );
+ mImpl->mAddRemoveBackgroundChild = false;
delete mImpl->mBackground;
mImpl->mBackground = NULL;
void Control::OnChildAdd(Actor& child)
{
- // If this is the background actor, then we do not want to relayout or inform deriving classes
- if ( mImpl->mBackground && ( child == mImpl->mBackground->actor ) )
+ // If this is the background actor, then we do not want to inform deriving classes
+ if ( mImpl->mAddRemoveBackgroundChild )
{
return;
}
void Control::OnChildRemove(Actor& child)
{
- // If this is the background actor, then we do not want to relayout or inform deriving classes
- if ( mImpl->mBackground && ( child == mImpl->mBackground->actor ) )
+ // If this is the background actor, then we do not want to inform deriving classes
+ if ( mImpl->mAddRemoveBackgroundChild )
{
return;
}
+ [Shader Animation](@ref animation-shader)
### Resources
- + Resource Image
- + 9 Patch Image
- + Buffer Image
+ + [Resource Image](@ref resource-image)
+ + [9 Patch Image](@ref resource-9-patch)
+ + [Buffer Image](@ref resource-buffer)
### Control Base Class
+ [Background Feature](@ref background)
/*! \page constraints Constraints
*
-<h2 class="pg">Introduction</h2>
+<h1 class="pg">Introduction</h1>
Constraints are used to modify the property of an actor, based on other properties of the same actor; properties of the actor's parent; or properties of another actor altogether, when the modification needs to be at run-time.
Custom functions or functors can be supplied, where the desired value of the property can be calculated.
Not all properties can be used as a constraint input, please see Dali::Handle::IsPropertyAConstraintInput() for more details.
-<h2 class="pg">When to use a Constraint</h2>
+<h1 class="pg">When to use a Constraint</h1>
Constraints are designed as a way of modifying properties that cannot be modified by any existing built in functionality; Like Animations, Size negotiation or Parent anchor, origin settings.
As they provide the ability for the application developer to execute their own code within the update thread, DALi can no-longer guarantee the timeliness of this code, or how optimised it may be.
For most general cases, the position and size requirements of a child or parent actor (from it's child or parent) can be calculated with Size Negotiation.
-<h2 class="pg">Constraint Sources</h2>
+<h1 class="pg">Constraint Sources</h1>
These are properties of this (or another actor) that are used as inputs into the constraint.
The constraint will take these values, optionally perform a calculation on them (if using a custom functor) and write the result to the specified property of the target actor.
The source actor is specified as either the same actor, it's parent or another actor.
-<h3 class="pg">Local Source</h3>
+<h2 class="pg">Local Source</h2>
A local source is based on the local properties (i.e. size, position, scale, orientation, color) of an actor.
For example, the actor's orientation could be used as a constraint input source.
Dali::ConstraintSource source( Dali::LocalSource( Dali::Actor::Property::ORIENTATION ) );
@endcode
-<h3 class="pg">Parent Source</h3>
+<h2 class="pg">Parent Source</h2>
A parent source is based on properties of the actor's parent.
For example, a parent's position can be used as a constraint input source.
Dali::ConstraintSource source( Dali::ParentSource( Dali::Actor::Property::POSITION ) );
@endcode
-<h3 class="pg">Source</h3>
+<h2 class="pg">Source</h2>
Finally, you can base your source on the properties of another handle altogether.
For example, a sibling actor's color could be used as a constraint input source.
Dali::ConstraintSource source( Dali::Source( anotherHandle, Dali::Actor::Property::COLOR ) );
@endcode
-<h2 class="pg">The Constraint Function</h2>
+<h1 class="pg">The Constraint Function</h1>
The signature of the constraint function is:
const Dali::Vector3& parentSize( inputs[3]->GetVector3() );
@endcode
-<h2 class="pg">Creating a Constraint</h2>
+<h1 class="pg">Creating a Constraint</h1>
-<h3 class="pg">Using C Functions</h3>
+<h2 class="pg">Using C Functions</h2>
If you do not have any data that is changed at runtime, then C functions should be used.
For example, the color of an actor could be changed based on its position along the x-axis till a preset distance of 100, beyond which it is transparent.
Please have a look at Dali::Constraint::New() for more details.
-<h3 class="pg">Using Functors</h3>
+<h2 class="pg">Using Functors</h2>
If you need to store some data in a struct/class, then a functor can be used.
Reusing the last example, the color of an actor is changed based on its position along the x-axis, but the distance when it is transparent is different for each applied constraint.
Please have a look at Dali::Constraint::New(Handle, Property::Index, const T&) for more details.
Instead of using the default functor, another method can be declared in the class or struct and used as the constraint function.
-Please have a look at appropriate Dali::Constraint::New() method for more details.
+Please have a look at the appropriate Dali::Constraint::New() method for more details.
-<h2 class="pg">Removing Constraints</h2>
+<h1 class="pg">Removing Constraints</h1>
The actor's constraints can later be removed in several ways:
--- /dev/null
+<!--
+/**-->
+# Resources {#resoources}
+
+## Resource Image {#resource-image}
+
+A resource image is an image that is loaded using a file path or a URL.
+
+To create a resource image:
+~~~{.cpp}
+Dali::ResourceImage image = Dali::ResourceImage::New( "/my-path/my-image.png" );
+~~~
+Which can then be used with actors (e.g. ImageActor).
+
+Resources are loaded in separate threads.
+The application can connect to the Dali::ResourceImage::LoadingFinishedSignal() to get notified when the image has loaded.
+
+By default, resource images start loading immediately and the data is released only when the ResourceImage handle is destroyed.
+To optimise an application's memory footprint, the application can ask resources to be only loaded when actually required and
+their data to be released automatically when they are no longer being used (not being used by Actors).
+~~~{.cpp}
+Dali::ResourceImage image = Dali::ResourceImage::New( "/my-path/my-image.png", Dali::ResourceImage::ON_DEMAND, Dali::Image::UNUSED );
+~~~
+If Dali::Image::UNUSED is used, then when the ResourceImage is used again, the resource data is reloaded automatically.
+
+If the application requires the image dimensions immediately, then they can be retrieved synchronously:
+~~~{.cpp}
+Dali::ImageDimensions dimensions = Dali::ResourceImage::GetImageSize( "/my-path/my-image.png" );
+~~~
+This is a disk read which can be slow and will block the event thread, so should only be used if absolutely necessary.
+
+## 9-Patch Image {#resource-9-patch}
+
+DALi has support for 9-patch images.
+These are stretchable, repeatable images which are reduced to their smallest size.
+Essentially, an image is sliced up into 9 squares and the four corners do not change size at all.
+The other 5 segments are stretched (or repeated) to allow the whole image to scale appropriately.
+
+DALi has inbuilt support for *.9.png, *.9.jpg etc. images as well.
+More information about these images can be found here: http://developer.android.com/tools/help/draw9patch.html
+
+The following is an example of a *.9.png image:
+
+
+Zoomed in, the red section shows the part that will be repeated.
+The four corners areas remain static.
+The one pixel border will also be stripped out.
+
+
+And if the image is given a 200 by 200 size, it will look like the following:
+
+
+## Buffer Image {#resource-buffer}
+
+A BufferImage represents an image resource in the form of a pixel buffer data that can be provided by the application developer.
+The application can then write to this buffer as required and the image is updated on the screen.
+
+~~~{.cpp}
+Dali::BufferImage image = Dali::BufferImage::New( 200, 200 ); // Creates a 200 by 200 pixel buffer with a color-depth of 32-bits (with alpha)
+~~~
+
+*/
projects / platform / core / uifw / dali-toolkit.git / commitdiff
