#include <dali/public-api/animation/constraint.h>
#include <dali/public-api/animation/constraints.h>
#include <dali/public-api/object/type-registry.h>
+#include <dali/public-api/size-negotiation/relayout-container.h>
#include <dali/devel-api/object/type-registry-helper.h>
+#include <dali/devel-api/rendering/renderer.h>
#include <dali/devel-api/scripting/scripting.h>
-#include <dali/public-api/size-negotiation/relayout-container.h>
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/control-depth-index-ranges.h>
#include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
#include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
#include <dali-toolkit/public-api/controls/control.h>
* @param[in] attributes The attributes with which to perfrom this action.
* @return true if action has been accepted by this control
*/
-const char* ACTION_CONTROL_ACTIVATED = "control-activated";
+const char* ACTION_ACCESSIBILITY_ACTIVATED = "accessibility-activated";
static bool DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes )
{
bool ret = false;
- if( object && ( 0 == strcmp( actionName.c_str(), ACTION_CONTROL_ACTIVATED ) ) )
+ if( object && ( 0 == strcmp( actionName.c_str(), ACTION_ACCESSIBILITY_ACTIVATED ) ) )
{
Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
if( control )
SignalConnectorType registerSignal6( typeRegistration, SIGNAL_PINCHED, &DoConnectSignal );
SignalConnectorType registerSignal7( typeRegistration, SIGNAL_LONG_PRESSED, &DoConnectSignal );
-TypeAction registerAction( typeRegistration, ACTION_CONTROL_ACTIVATED, &DoAction );
+TypeAction registerAction( typeRegistration, ACTION_ACCESSIBILITY_ACTIVATED, &DoAction );
DALI_TYPE_REGISTRATION_END()
*/
struct Background
{
- Actor actor; ///< Either a MeshActor or an ImageActor
+ Actor actor; ///< Background actor
Vector4 color; ///< The color of the actor.
/**
}
};
-/**
- * Creates a white coloured Mesh.
- */
-Vector3 CreateMesh()
-{
- Vector3 white( Color::WHITE );
- /*
- MeshData meshData;
-
- // Create vertices with a white color (actual color is set by actor color)
- MeshData::VertexContainer vertices(4);
- vertices[ 0 ] = MeshData::Vertex( Vector3( -0.5f, -0.5f, 0.0f ), Vector2::ZERO, white );
- vertices[ 1 ] = MeshData::Vertex( Vector3( 0.5f, -0.5f, 0.0f ), Vector2::ZERO, white );
- vertices[ 2 ] = MeshData::Vertex( Vector3( -0.5f, 0.5f, 0.0f ), Vector2::ZERO, white );
- vertices[ 3 ] = MeshData::Vertex( Vector3( 0.5f, 0.5f, 0.0f ), Vector2::ZERO, white );
-
- // Specify all the faces
- MeshData::FaceIndices faces;
- faces.reserve( 6 ); // 2 triangles in Quad
- faces.push_back( 0 ); faces.push_back( 3 ); faces.push_back( 1 );
- faces.push_back( 0 ); faces.push_back( 2 ); faces.push_back( 3 );
-
- // Create the mesh data from the vertices and faces
- meshData.SetMaterial( Material::New( "ControlMaterial" ) );
- meshData.SetVertices( vertices );
- meshData.SetFaceIndices( faces );
- meshData.SetHasColor( true );
- */
- return white;
- //return Mesh::New( meshData );
-}
+unsigned int gQuadIndex[6] = { 0, 2, 1, 1, 2, 3 };
+
+Vector2 gQuad[] = {
+ Vector2( -0.5f, -0.5f ),
+ Vector2( 0.5f, -0.5f ),
+ Vector2( -0.5f, 0.5f ),
+ Vector2( 0.5f, 0.5f )
+};
+
+
+const char* VERTEX_SHADER_COLOR = DALI_COMPOSE_SHADER(
+ attribute mediump vec2 aPosition;\n
+ uniform mediump mat4 uMvpMatrix;\n
+ void main()\n
+ {\n
+ gl_Position = uMvpMatrix * vec4( aPosition, 0.0, 1.0 );\n
+ }\n
+);
+
+const char* FRAGMENT_SHADER_COLOR = DALI_COMPOSE_SHADER(
+ uniform lowp vec4 uBackgroundColor;\n
+ uniform lowp vec4 uColor;\n
+ void main()\n
+ {\n
+ gl_FragColor = uBackgroundColor * uColor;\n
+ }\n
+);
-/**
- * Sets all the required properties for the background actor.
- *
- * @param[in] actor The actor to set the properties on.
- * @param[in] color The required color of the actor.
- */
-void SetupBackgroundActor( Actor actor, const Vector4& color )
-{
- actor.SetColor( color );
- actor.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
- actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_COLOR );
- actor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
-}
/**
- * Sets all the required properties for the background actor.
+ * @brief Create the background actor for the control.
+ *
+ * @param[in] actor The parent actor of the background
+ * @param[in] color The background color
+ * @param[in] image If a valid image is supplied this will be the texture used by the background
+ *
+ * @return An actor which will render the background
*
- * @param[in] actor The actor to set the properties on.
- * @param[in] constrainingIndex The property index to constrain the parent's size on.
- * @param[in] color The required color of the actor.
*/
-void SetupBackgroundActorConstrained( Actor actor, Property::Index constrainingIndex, const Vector4& color )
+Actor CreateBackground( Actor parent, const Vector4& color, Image image = Image() )
{
- actor.SetColor( color );
- actor.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
- actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_COLOR );
+ if( !image )
+ {
+ PropertyBuffer vertexBuffer;
+ Shader shader;
+ Material material;
+
+ Property::Map vertexFormat;
+ vertexFormat["aPosition"] = Property::VECTOR2;
+
+ //Create a vertex buffer for vertex positions
+ vertexBuffer = PropertyBuffer::New( vertexFormat, 4u );
+ vertexBuffer.SetData( gQuad );
+
+ shader = Shader::New( VERTEX_SHADER_COLOR, FRAGMENT_SHADER_COLOR );
+ material = Material::New( shader );
+
+ //Create the index buffer
+ Property::Map indexFormat;
+ indexFormat["indices"] = Property::INTEGER;
+ PropertyBuffer indexBuffer = PropertyBuffer::New( indexFormat, 6u );
+ indexBuffer.SetData(gQuadIndex);
+
+ //Create the geometry
+ Geometry mesh = Geometry::New();
+ mesh.AddVertexBuffer( vertexBuffer );
+ mesh.SetIndexBuffer( indexBuffer );
+
+ //Add uniforms to the shader
+ shader.RegisterProperty( "uBackgroundColor", color );
+
+ //Create the renderer
+ Renderer renderer = Renderer::New( mesh, material );
+ renderer.SetDepthIndex( parent.GetHierarchyDepth() + BACKGROUND_DEPTH_INDEX );
+
+ //Create the actor
+ Actor meshActor = Actor::New();
+ meshActor.SetSize( Vector3::ONE );
+ meshActor.AddRenderer( renderer );
+ meshActor.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
+ meshActor.SetColorMode( USE_PARENT_COLOR );
+
+ //Constraint scale of the mesh actor to the size of the control
+ Constraint constraint = Constraint::New<Vector3>( meshActor,
+ Actor::Property::SCALE,
+ EqualToConstraint() );
+ constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
+ constraint.Apply();
+
+ return meshActor;
+ }
+ else
+ {
+ ImageActor imageActor = ImageActor::New( image );
+ imageActor.SetColor( color );
+ imageActor.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
+ imageActor.SetColorMode( USE_OWN_MULTIPLY_PARENT_COLOR );
+ imageActor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+ imageActor.SetSortModifier( parent.GetHierarchyDepth() + BACKGROUND_DEPTH_INDEX );
+
+ return imageActor;
+ }
- Constraint constraint = Constraint::New<Vector3>( actor,
- constrainingIndex,
- EqualToConstraint() );
- constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
- constraint.Apply();
}
} // unnamed namespace
// Construction & Destruction
Impl(Control& controlImpl)
- : mControlImpl( controlImpl ),
- mStyleName(""),
- mBackground( NULL ),
- mStartingPinchScale( NULL ),
- mKeyEventSignal(),
- mPinchGestureDetector(),
- mPanGestureDetector(),
- mTapGestureDetector(),
- mLongPressGestureDetector(),
- mFlags( Control::ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
- mIsKeyboardNavigationSupported( false ),
- mIsKeyboardFocusGroup( false ),
- mAddRemoveBackgroundChild( false )
- {
- }
+: mControlImpl( controlImpl ),
+ mStyleName(""),
+ mBackground( NULL ),
+ mStartingPinchScale( NULL ),
+ mKeyEventSignal(),
+ mPinchGestureDetector(),
+ mPanGestureDetector(),
+ mTapGestureDetector(),
+ mLongPressGestureDetector(),
+ mFlags( Control::ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
+ mIsKeyboardNavigationSupported( false ),
+ mIsKeyboardFocusGroup( false ),
+ mAddRemoveBackgroundChild( false )
+{
+}
~Impl()
{
case Toolkit::Control::Property::BACKGROUND_IMAGE:
{
- if ( value.HasKey( "image" ) )
+ Image image = Scripting::NewImage( value );
+ if ( image )
{
- Property::Map imageMap = value.GetValue( "image" ).Get< Property::Map >();
- Image image = Scripting::NewImage( imageMap );
-
- if ( image )
- {
- controlImpl.SetBackgroundImage( image );
- }
+ controlImpl.SetBackgroundImage( image );
}
- else if ( value.Get< Property::Map >().Empty() )
+ else
{
// An empty map means the background is no longer required
controlImpl.ClearBackground();
Property::Map map;
Background* back = controlImpl.mImpl->mBackground;
- if( back )
+ if ( back && back->actor )
{
- ImageActor imageActor = ImageActor::DownCast( back->actor );
- if ( imageActor )
+ if( back->actor.GetRendererCount() > 0 && back->actor.GetRendererAt(0).GetMaterial().GetNumberOfSamplers() > 0 )
{
- Image image = imageActor.GetImage();
- Property::Map imageMap;
- Scripting::CreatePropertyMap( image, imageMap );
- map[ "image" ] = imageMap;
+ Image image = back->actor.GetRendererAt(0).GetMaterial().GetSamplerAt(0).GetImage();
+ if ( image )
+ {
+ Scripting::CreatePropertyMap( image, map );
+ }
+ }
+ else
+ {
+ ImageActor imageActor = ImageActor::DownCast( back->actor );
+ if ( imageActor )
+ {
+ Image image = imageActor.GetImage();
+ Scripting::CreatePropertyMap( image, map );
+ }
}
}
{
mImpl->mStyleName = styleName;
- // Apply new style
+ // Apply new style, if stylemanager is available
Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
- GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
+ if( styleManager )
+ {
+ GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
+ }
}
}
if ( background.actor )
{
- // Just set the actor color
- background.actor.SetColor( color );
+ if( background.actor.GetRendererCount() > 0 )
+ {
+ Shader shader = background.actor.GetRendererAt(0).GetMaterial().GetShader();
+ shader.SetProperty( shader.GetPropertyIndex("uBackgroundColor"), color );
+ }
+ else
+ {
+ background.actor.SetColor( color );
+ }
}
- /*
else
{
// Create Mesh Actor
- MeshActor meshActor = MeshActor::New( CreateMesh() );
-
- SetupBackgroundActorConstrained( meshActor, Actor::Property::SCALE, color );
-
- background.actor = meshActor;
- // Set the flag to avoid notifying children
+ Actor actor = CreateBackground(Self(), color );
+ background.actor = actor;
mImpl->mAddRemoveBackgroundChild = true;
- // use insert to guarantee its the first child (so that OVERLAY mode works)
- Self().Insert( 0, meshActor );
+ // use insert to guarantee its the first child (so that OVERLAY_2D mode works)
+ Self().Insert( 0, actor );
mImpl->mAddRemoveBackgroundChild = false;
}
- */
background.color = color;
}
{
Background& background( mImpl->GetBackground() );
- if ( background.actor )
- {
- // Remove Current actor, unset AFTER removal
- mImpl->mAddRemoveBackgroundChild = true;
- Self().Remove( background.actor );
- mImpl->mAddRemoveBackgroundChild = false;
- background.actor.Reset();
- }
+ if ( background.actor )
+ {
+ // Remove Current actor, unset AFTER removal
+ mImpl->mAddRemoveBackgroundChild = true;
+ Self().Remove( background.actor );
+ mImpl->mAddRemoveBackgroundChild = false;
+ background.actor.Reset();
+ }
- /*
- ImageActor imageActor = ImageActor::New( image );
- SetupBackgroundActor( imageActor, background.color );
+ Actor actor = CreateBackground(Self(), background.color, image);
- // Set the background actor before adding so that we do not inform derived classes
- background.actor = imageActor;
- mImpl->mAddRemoveBackgroundChild = true;
- // use insert to guarantee its the first child (so that OVERLAY mode works)
- Self().Insert( 0, imageActor );
- mImpl->mAddRemoveBackgroundChild = false;
- */
+ // Set the background actor before adding so that we do not inform derived classes
+ background.actor = actor;
+ mImpl->mAddRemoveBackgroundChild = true;
+ // use insert to guarantee its the first child (so that OVERLAY_2D mode works)
+ Self().Insert( 0, actor );
+ mImpl->mAddRemoveBackgroundChild = false;
}
void Control::ClearBackground()
OnAccessibilityActivated();
}
+void Control::KeyboardEnter()
+{
+ // Inform deriving classes
+ OnKeyboardEnter();
+}
+
bool Control::OnAccessibilityActivated()
{
return false; // Accessibility activation is not handled by default
}
+bool Control::OnKeyboardEnter()
+{
+ return false; // Keyboard enter is not handled by default
+}
+
bool Control::OnAccessibilityPan(PanGesture gesture)
{
return false; // Accessibility pan gesture is not handled by default
return false; // Accessibility value change action is not handled by default
}
+bool Control::OnAccessibilityZoom()
+{
+ return false; // Accessibility zoom action is not handled by default
+}
+
Actor Control::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
{
return Actor();
void Control::Initialize()
{
+ // Call deriving classes so initialised before styling is applied to them.
+ OnInitialize();
+
if( mImpl->mFlags & REQUIRES_STYLE_CHANGE_SIGNALS )
{
Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
+ // if stylemanager is available
+ if( styleManager )
+ {
+ // Register for style changes
+ styleManager.StyleChangeSignal().Connect( this, &Control::OnStyleChange );
- // Register for style changes
- styleManager.StyleChangeSignal().Connect( this, &Control::OnStyleChange );
-
- // SetTheme
- GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
+ // Apply the current style
+ GetImpl( styleManager ).ApplyThemeStyleAtInit( Toolkit::Control( GetOwner() ) );
+ }
}
if( mImpl->mFlags & REQUIRES_KEYBOARD_NAVIGATION_SUPPORT )
{
SetKeyboardNavigationSupport( true );
}
-
- // Calling deriving classes
- OnInitialize();
}
void Control::OnInitialize()
void Control::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange::Type change )
{
// By default the control is only interested in theme (not font) changes
- if( change == StyleChange::THEME_CHANGE )
+ if( styleManager && change == StyleChange::THEME_CHANGE )
{
GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
}
if ( focusGained )
{
- // signals are allocated dynamically when someone connects
- if ( !mImpl->mKeyInputFocusGainedSignal.Empty() )
- {
+ // signals are allocated dynamically when someone connects
+ if ( !mImpl->mKeyInputFocusGainedSignal.Empty() )
+ {
mImpl->mKeyInputFocusGainedSignal.Emit( handle );
- }
+ }
}
else
{
}
}
-void Control::OnStageConnection()
+void Control::OnStageConnection( int depth )
{
+ unsigned int controlRendererCount = Self().GetRendererCount();
+ for( unsigned int i(0); i<controlRendererCount; ++i )
+ {
+ Renderer controlRenderer = Self().GetRendererAt(i);
+ if( controlRenderer )
+ {
+ controlRenderer.SetDepthIndex( CONTENT_DEPTH_INDEX+depth );
+ }
+ }
+
+ if( mImpl->mBackground )
+ {
+ if(mImpl->mBackground->actor.GetRendererCount() > 0 )
+ {
+ Renderer backgroundRenderer = mImpl->mBackground->actor.GetRendererAt( 0 );
+ if(backgroundRenderer)
+ {
+ backgroundRenderer.SetDepthIndex( BACKGROUND_DEPTH_INDEX+depth );
+ }
+ }
+ else
+ {
+
+ ImageActor imageActor = ImageActor::DownCast( mImpl->mBackground->actor );
+ if ( imageActor )
+ {
+ imageActor.SetSortModifier( BACKGROUND_DEPTH_INDEX+depth );
+ }
+ }
+ }
}
void Control::OnStageDisconnection()
Vector3 Control::GetNaturalSize()
{
+ //Control's natural size is the size of its background image if it has been set, or ZERO otherwise
+ Vector3 naturalSize = Vector3::ZERO;
if( mImpl->mBackground )
{
- Actor actor = mImpl->mBackground->actor;
- if( actor )
+ if( mImpl->mBackground->actor.GetRendererCount() > 0 )
{
- return actor.GetNaturalSize();
+ Material backgroundMaterial = mImpl->mBackground->actor.GetRendererAt(0).GetMaterial();
+ if( backgroundMaterial.GetNumberOfSamplers() > 0 )
+ {
+ Image backgroundImage = backgroundMaterial.GetSamplerAt(0).GetImage();
+ if( backgroundImage )
+ {
+ naturalSize.x = backgroundImage.GetWidth();
+ naturalSize.y = backgroundImage.GetHeight();
+ }
+ }
+ }
+ else
+ {
+ return mImpl->mBackground->actor.GetNaturalSize();
}
}
- return Vector3();
+
+ return naturalSize;
}
float Control::CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )