int UtcDaliVideoViewProperty4(void)
{
ToolkitTestApplication application;
tet_infoline(" UtcDaliVideoViewProperty4");
Toolkit::VideoView view = Toolkit::VideoView::New();
DALI_TEST_CHECK( view );
float left, right;
left = right = 0.f;
Property::Map map;
map.Insert( VOLUME_LEFT, 1.0f );
map.Insert( VOLUME_RIGHT, 0.5f );
Property::Map map2;
view.SetProperty( VideoView::Property::VOLUME, map );
Property::Value val4 = view.GetProperty( VideoView::Property::VOLUME );
DALI_TEST_CHECK( val4.Get( map2 ) );
Property::Value* volumeLeft = map.Find( VOLUME_LEFT );
Property::Value* volumeRight = map.Find( VOLUME_RIGHT );
DALI_TEST_CHECK( volumeLeft && volumeLeft->Get( left ) );
DALI_TEST_CHECK( volumeRight && volumeRight->Get( right ) );
DALI_TEST_CHECK( left == 1.0f );
DALI_TEST_CHECK( right == 0.5f );
END_TEST;
}
int UtcDaliControlRendererSetGetDepthIndex(void)
{
ToolkitTestApplication application;
tet_infoline( "UtcDaliControlRendererSetDepthIndex" );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
propertyMap.Insert("renderer-type", "color-renderer");
propertyMap.Insert("blend-color", Color::BLUE);
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
controlRenderer.SetDepthIndex( 1.f );
Actor actor = Actor::New();
actor.SetSize(200.f, 200.f);
Stage::GetCurrent().Add( actor );
controlRenderer.SetOnStage( actor );
DALI_TEST_EQUALS( actor.GetRendererAt(0u).GetDepthIndex(), 1.f, TEST_LOCATION );
DALI_TEST_EQUALS( controlRenderer.GetDepthIndex(), 1.f, TEST_LOCATION );
controlRenderer.SetDepthIndex( -1.f );
DALI_TEST_EQUALS( actor.GetRendererAt(0u).GetDepthIndex(), -1.f, TEST_LOCATION );
DALI_TEST_EQUALS( controlRenderer.GetDepthIndex(), -1.f, TEST_LOCATION );
END_TEST;
}
int UtcDaliControlRendererSetOnOffStage(void)
{
ToolkitTestApplication application;
tet_infoline( "UtcDaliControlRendererSetDepthIndex" );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
propertyMap.Insert("renderer-type", "color-renderer");
propertyMap.Insert("blend-color", Color::BLUE);
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
Actor actor = Actor::New();
actor.SetSize(200.f, 200.f);
Stage::GetCurrent().Add( actor );
application.SendNotification();
application.Render(0);
DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
controlRenderer.SetOnStage( actor );
application.SendNotification();
application.Render(0);
DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
controlRenderer.SetOffStage( actor );
application.SendNotification();
application.Render(0);
DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
END_TEST;
}
Actor NewActor( const Property::Map& map )
{
BaseHandle handle;
// First find type and create Actor
Property::Value* typeValue = map.Find( "type" );
if ( typeValue )
{
TypeInfo type = TypeRegistry::Get().GetTypeInfo( typeValue->Get< std::string >() );
if ( type )
{
handle = type.CreateInstance();
}
}
if ( !handle )
{
DALI_LOG_ERROR( "Actor type not provided\n" );
return Actor();
}
Actor actor( Actor::DownCast( handle ) );
if ( actor )
{
// Now set the properties, or create children
for ( unsigned int i = 0, mapCount = map.Count(); i < mapCount; ++i )
{
const StringValuePair& pair( map.GetPair( i ) );
const std::string& key( pair.first );
if ( key == "type" )
{
continue;
}
const Property::Value& value( pair.second );
if ( key == "actors" )
{
// Create children
Property::Array actorArray = value.Get< Property::Array >();
for ( Property::Array::SizeType i = 0; i < actorArray.Size(); ++i)
{
actor.Add( NewActor( actorArray[i].Get< Property::Map >() ) );
}
}
else
{
Property::Index index( actor.GetPropertyIndex( key ) );
if ( index != Property::INVALID_INDEX )
{
actor.SetProperty( index, value );
}
}
}
}
return actor;
}
int UtcDaliControlRendererCopyAndAssignment(void)
{
ToolkitTestApplication application;
tet_infoline( "UtcDaliControlRendererCopyAndAssignment" );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
propertyMap.Insert("renderer-type", "color-renderer");
propertyMap.Insert("blend-color", Color::BLUE);
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
ControlRenderer controlRendererCopy( controlRenderer );
DALI_TEST_CHECK(controlRenderer == controlRendererCopy);
ControlRenderer emptyControlRenderer;
ControlRenderer emptyControlRendererCopy( emptyControlRenderer );
DALI_TEST_CHECK(emptyControlRenderer == emptyControlRendererCopy);
ControlRenderer controlRendererEquals;
controlRendererEquals = controlRenderer;
DALI_TEST_CHECK(controlRenderer == controlRendererEquals);
ControlRenderer emptyControlRendererEquals;
emptyControlRendererEquals = emptyControlRenderer;
DALI_TEST_CHECK( emptyControlRenderer == emptyControlRendererEquals );
//self assignment
controlRenderer = controlRenderer;
DALI_TEST_CHECK( controlRenderer = controlRendererCopy );
END_TEST;
}
Property::Value& Property::Value::GetValue(const std::string& key) const
{
DALI_ASSERT_DEBUG(Property::MAP == GetType() && "Property type invalid");
Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
DALI_ASSERT_DEBUG(container);
if(container)
{
for(Property::Map::iterator iter = container->begin(); iter != container->end(); ++iter)
{
if(iter->first == key)
{
return iter->second;
}
}
}
DALI_LOG_WARNING("Cannot find property map key %s", key.c_str());
DALI_ASSERT_ALWAYS(!"Cannot find property map key");
// should never return this
static Property::Value null;
return null;
}
void Property::Value::SetItem(const int index, const Property::Value &value)
{
switch( GetType() )
{
case Property::MAP:
{
Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
if( container && index < static_cast<int>(container->size()) )
{
int i = 0;
for(Property::Map::iterator iter = container->begin(); iter != container->end(); ++iter)
{
if(i++ == index)
{
iter->second = value;
break;
}
}
}
}
break;
case Property::ARRAY:
{
Property::Array *container = AnyCast<Property::Array>(&(mImpl->mValue));
if( container && index < static_cast<int>(container->size()) )
{
(*container)[index] = value;
}
}
break;
case Property::NONE:
case Property::BOOLEAN:
case Property::FLOAT:
case Property::INTEGER:
case Property::UNSIGNED_INTEGER:
case Property::VECTOR2:
case Property::VECTOR3:
case Property::VECTOR4:
case Property::MATRIX3:
case Property::MATRIX:
case Property::RECTANGLE:
case Property::ROTATION:
case Property::STRING:
case Property::TYPE_COUNT:
{
DALI_ASSERT_ALWAYS(!"Cannot SetItem on property Type; not a container");
break;
}
}
}
int UtcDaliControlRendererGetPropertyMap6(void)
{
ToolkitTestApplication application;
tet_infoline( "UtcDaliControlRendererGetPropertyMap6: NPatchRenderer" );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
propertyMap.Insert( "renderer-type", "n-patch-renderer" );
propertyMap.Insert( "image-url", TEST_NPATCH_FILE_NAME );
propertyMap.Insert( "border-only", true );
ControlRenderer nPatchRenderer = factory.GetControlRenderer( propertyMap );
Property::Map resultMap;
nPatchRenderer.CreatePropertyMap( resultMap );
// check the property values from the returned map from control renderer
Property::Value* value = resultMap.Find( "renderer-type", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "n-patch-renderer" );
value = resultMap.Find( "image-url", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
value = resultMap.Find( "border-only", Property::BOOLEAN );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<bool>() );
END_TEST;
}
int UtcDaliCheckBoxSetLabelP(void)
{
TestApplication application;
CheckBoxButton checkBox = CheckBoxButton::New();
Property::Map propertyMap;
propertyMap.Insert("text", "activate");
checkBox.SetProperty( checkBox.GetPropertyIndex("label"), propertyMap );
DALI_TEST_EQUALS( checkBox.GetLabelText(), "activate", TEST_LOCATION ); // Change to use GerProperty once that code is implemented
END_TEST;
}
const std::string& Property::Value::GetKey(const int index) const
{
switch( GetType() )
{
case Property::MAP:
{
int i = 0;
Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
DALI_ASSERT_DEBUG(container && "Property::Map has no container?");
if(container)
{
if(0 <= index && index < static_cast<int>(container->size()))
{
for(Property::Map::iterator iter = container->begin(); iter != container->end(); ++iter)
{
if(i++ == index)
{
return iter->first;
}
}
}
}
}
break;
case Property::NONE:
case Property::ARRAY:
case Property::BOOLEAN:
case Property::FLOAT:
case Property::UNSIGNED_INTEGER:
case Property::INTEGER:
case Property::VECTOR2:
case Property::VECTOR3:
case Property::VECTOR4:
case Property::MATRIX:
case Property::MATRIX3:
case Property::RECTANGLE:
case Property::ROTATION:
case Property::STRING:
case Property::TYPE_COUNT:
{
break;
}
}
// should never return this
static std::string null;
return null;
}
int Property::Value::GetSize() const
{
int ret = 0;
switch(GetType())
{
case Property::MAP:
{
Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
if(container)
{
ret = container->size();
}
}
break;
case Property::ARRAY:
{
Property::Array *container = AnyCast<Property::Array>(&(mImpl->mValue));
if(container)
{
ret = container->size();
}
}
break;
case Property::NONE:
case Property::BOOLEAN:
case Property::FLOAT:
case Property::INTEGER:
case Property::UNSIGNED_INTEGER:
case Property::VECTOR2:
case Property::VECTOR3:
case Property::VECTOR4:
case Property::MATRIX3:
case Property::MATRIX:
case Property::RECTANGLE:
case Property::ROTATION:
case Property::STRING:
case Property::TYPE_COUNT:
{
break;
}
}
return ret;
}
void CreatePropertyMap( Actor actor, Property::Map& map )
{
map.Clear();
if ( actor )
{
map[ "type" ] = actor.GetTypeName();
// Default properties
Property::IndexContainer indices;
actor.GetPropertyIndices( indices );
const Property::IndexContainer::ConstIterator endIter = indices.End();
for ( Property::IndexContainer::Iterator iter = indices.Begin(); iter != endIter; ++iter )
{
map[ actor.GetPropertyName( *iter ) ] = actor.GetProperty( *iter );
}
// Children
unsigned int childCount( actor.GetChildCount() );
if ( childCount )
{
Property::Array childArray;
for ( unsigned int child = 0; child < childCount; ++child )
{
Property::Map childMap;
CreatePropertyMap( actor.GetChildAt( child ), childMap );
childArray.PushBack( childMap );
}
map[ "actors" ] = childArray;
}
}
}
bool SetPropertyMapRetrieved( TextField& field, const Property::Index property, const std::string mapKey, const std::string mapValue )
{
bool result = false;
Property::Map imageMap;
imageMap[mapKey] =mapValue;
field.SetProperty( property , imageMap );
Property::Value propValue = field.GetProperty( property );
Property::Map* resultMap = propValue.GetMap();
if ( resultMap->Find( mapKey )->Get< std::string>() == mapValue )
{
result = true;
}
return result;
}
int UtcDaliControlRendererGetPropertyMap1(void)
{
ToolkitTestApplication application;
tet_infoline( "UtcDaliControlRendererGetPropertyMap1: ColorRenderer" );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
propertyMap.Insert("renderer-type", "color-renderer");
propertyMap.Insert("blend-color", Color::BLUE);
ControlRenderer colorRenderer = factory.GetControlRenderer( propertyMap );
Property::Map resultMap;
colorRenderer.CreatePropertyMap( resultMap );
Property::Value* typeValue = resultMap.Find( "renderer-type", Property::STRING );
DALI_TEST_CHECK( typeValue );
DALI_TEST_CHECK( typeValue->Get<std::string>() == "color-renderer" );
Property::Value* colorValue = resultMap.Find( "blend-color", Property::VECTOR4 );
DALI_TEST_CHECK( colorValue );
DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
// change the blend color
Actor actor;
factory.ResetRenderer( colorRenderer, actor, Color::CYAN );
colorRenderer.CreatePropertyMap( resultMap );
colorValue = resultMap.Find( "blend-color", Property::VECTOR4 );
DALI_TEST_CHECK( colorValue );
DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
END_TEST;
}
int UtcDaliPropertyMapFind(void)
{
Property::Map map;
map[ "hello" ] = 1;
map[ "world" ] = 2;
Property::Value* value = NULL;
value = map.Find( "hello" );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<int>() == 1 );
value = map.Find( "world" );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<int>() == 2 );
value = map.Find( "invalid-key" );
DALI_TEST_CHECK( !value );
END_TEST;
}
int UtcDaliScriptingNewActorNegative(void)
{
TestApplication application;
// Empty map
{
Actor handle = NewActor( Property::Map() );
DALI_TEST_CHECK( !handle );
}
// Map with only properties
{
Property::Map map;
map.push_back( Property::StringValuePair( "parent-origin", ParentOrigin::TOP_CENTER ) );
map.push_back( Property::StringValuePair( "anchor-point", AnchorPoint::TOP_CENTER ) );
Actor handle = NewActor( map );
DALI_TEST_CHECK( !handle );
}
// Add some signals to the map, we should have no signal connections as its not yet supported
{
Property::Map map;
map.push_back( Property::StringValuePair( "type", "Actor" ) );
map.push_back( Property::StringValuePair( "signals", Property::MAP ) );
Actor handle = NewActor( map );
DALI_TEST_CHECK( handle );
DALI_TEST_CHECK( !handle.MouseWheelEventSignal().GetConnectionCount() );
DALI_TEST_CHECK( !handle.OffStageSignal().GetConnectionCount() );
DALI_TEST_CHECK( !handle.OnStageSignal().GetConnectionCount() );
DALI_TEST_CHECK( !handle.SetSizeSignal().GetConnectionCount() );
DALI_TEST_CHECK( !handle.TouchedSignal().GetConnectionCount() );
}
END_TEST;
}
void DissolveEffectApp::OnInit( Application& application )
{
Stage::GetCurrent().KeyEventSignal().Connect(this, &DissolveEffectApp::OnKeyEvent);
// Creates a default view with a default tool bar, the view is added to the stage.
mContent = DemoHelper::CreateView( application, mView,mToolBar, "", TOOLBAR_IMAGE, "" );
// Add an effect-changing button on the right of the tool bar.
mEffectChangeButton = Toolkit::PushButton::New();
mEffectChangeButton.SetProperty( Toolkit::Button::Property::UNSELECTED_STATE_IMAGE, EFFECT_HIGHP_IMAGE );
mEffectChangeButton.SetProperty( Toolkit::Button::Property::SELECTED_STATE_IMAGE, EFFECT_HIGHP_IMAGE_SELECTED );
mEffectChangeButton.ClickedSignal().Connect( this, &DissolveEffectApp::OnEffectButtonClicked );
mToolBar.AddControl( mEffectChangeButton, DemoHelper::DEFAULT_VIEW_STYLE.mToolBarButtonPercentage, Toolkit::Alignment::HorizontalRight, DemoHelper::DEFAULT_MODE_SWITCH_PADDING );
// Add title to the tool bar.
mTitleActor = DemoHelper::CreateToolBarLabel( APPLICATION_TITLE_HIGHP );
mToolBar.AddControl( mTitleActor, DemoHelper::DEFAULT_VIEW_STYLE.mToolBarTitlePercentage, Toolkit::Alignment::HorizontalCenter );
// Add an slide-show button on the right of the title
mPlayStopButton = Toolkit::PushButton::New();
mPlayStopButton.SetProperty( Toolkit::Button::Property::UNSELECTED_STATE_IMAGE, PLAY_ICON );
mPlayStopButton.SetProperty( Toolkit::Button::Property::SELECTED_STATE_IMAGE, PLAY_ICON_SELECTED );
mPlayStopButton.ClickedSignal().Connect( this, &DissolveEffectApp::OnSildeshowButtonClicked );
mToolBar.AddControl( mPlayStopButton, DemoHelper::DEFAULT_VIEW_STYLE.mToolBarButtonPercentage, Toolkit::Alignment::HorizontalCenter, DemoHelper::DEFAULT_PLAY_PADDING );
// use pan gesture to detect the cursor or finger movement
mPanGestureDetector = PanGestureDetector::New();
mPanGestureDetector.DetectedSignal().Connect( this, &DissolveEffectApp::OnPanGesture );
mViewTimer = Timer::New( VIEWINGTIME );
mViewTimer.TickSignal().Connect( this, &DissolveEffectApp::OnTimerTick );
mTimerReady = true;
// Set size to stage size to avoid seeing a black border on transition
mParent = Actor::New();
mParent.SetSize( Stage::GetCurrent().GetSize() );
mParent.SetParentOrigin( ParentOrigin::CENTER );
mContent.Add( mParent );
// show the first image
mCurrentImage = CreateStageFillingImageView( IMAGES[mIndex] );
mCurrentImage.SetParentOrigin( ParentOrigin::CENTER );
mCurrentImage.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
mCurrentImage.SetSizeScalePolicy( SizeScalePolicy::FIT_WITH_ASPECT_RATIO );
mParent.Add( mCurrentImage );
mPanGestureDetector.Attach( mCurrentImage );
mDissolveEffect = Dali::Toolkit::CreateDissolveEffect( mUseHighPrecision );
Property::Map emptyShaderMap;
mEmptyEffect.Insert( "shader", emptyShaderMap );
}
int UtcDaliScriptingNewShaderEffect(void)
{
TestApplication application;
Property::Map programMap;
programMap.push_back( Property::StringValuePair( "vertex-filename", "bump.vert" ) );
programMap.push_back( Property::StringValuePair( "fragment-filename", "bump.frag" ) );
Property::Map imageMap;
imageMap.push_back( Property::StringValuePair( "filename", "image.png" ) );
Property::Map map;
map.push_back( Property::StringValuePair( "image", imageMap ) );
map.push_back( Property::StringValuePair( "program", programMap ) );
map.push_back( Property::StringValuePair( "uLightPosition", Vector3( 0.0, 0.0, -1.5) ) );
map.push_back( Property::StringValuePair( "uAmbientLight", (int)10 ) );
ShaderEffect shader = NewShaderEffect( map );
DALI_TEST_CHECK( shader );
END_TEST;
}
void Property::Value::SetValue(const std::string& key, const Property::Value &value)
{
DALI_ASSERT_DEBUG(Property::MAP == GetType() && "Property type invalid");
Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
if(container)
{
for(Property::Map::iterator iter = container->begin(); iter != container->end(); ++iter)
{
if(iter->first == key)
{
iter->second = value;
return;
}
}
// if we get here its a new key
container->push_back(Property::StringValuePair(key, value));
}
}
int UtcDaliPropertyMapGetKey(void)
{
Property::Map map;
map[ "hello" ] = 1;
map[ "world" ] = 2;
DALI_TEST_CHECK( map.GetKey( 0 ) == "hello" );
DALI_TEST_CHECK( map.GetKey( 1 ) == "world" );
// Out of bounds
try
{
map.GetKey( 2 );
tet_result( TET_FAIL );
}
catch ( DaliException& e )
{
DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
}
END_TEST;
}
int UtcDaliPropertyMapGetValue(void)
{
Property::Map map;
map[ "hello" ] = 1;
map[ "world" ] = 2;
Property::Value& value = map.GetValue( 0 );
DALI_TEST_CHECK( value.Get<int>() == 1 );
value = 10; // Allows the actual changing of the value as we have a ref
DALI_TEST_CHECK( map[ "hello" ].Get<int>() == 10 );
// Out of bounds
try
{
map.GetValue( 2 );
tet_result( TET_FAIL );
}
catch ( DaliException& e )
{
DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
}
END_TEST;
}
int UtcDaliPropertyMapConstOperator(void)
{
Property::Map map;
map[ "hello" ] = 1;
map[ "world" ] = 2;
DALI_TEST_CHECK( map.Count() == 2 );
const Property::Map& constMap( map );
DALI_TEST_CHECK( constMap[ "world" ].Get<int>() == 2 );
DALI_TEST_CHECK( constMap.Count() == 2 ); // Ensure count hasn't gone up
// Invalid Key
try
{
constMap[ "invalid-key" ];
tet_result( TET_FAIL );
}
catch ( DaliException& e )
{
DALI_TEST_ASSERT( e, "! \"Invalid Key\"", TEST_LOCATION );
}
END_TEST;
}
bool Property::Value::HasKey(const std::string& key) const
{
bool has = false;
if( Property::MAP == GetType() )
{
Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
DALI_ASSERT_DEBUG(container && "Property::Map has no container?");
if(container)
{
for(Property::Map::iterator iter = container->begin(); iter != container->end(); ++iter)
{
if(iter->first == key)
{
has = true;
}
}
}
}
return has;
}
int UtcDaliCheckBoxSetLabelDisabledP(void)
{
TestApplication application;
CheckBoxButton checkBox = CheckBoxButton::New();
Stage::GetCurrent().Add( checkBox );
checkBox.SetSize( Vector2( 20.0f, 20.0f ) );
checkBox.SetDisabledBackgroundImage( "Image.jpg" );
application.SendNotification();
application.Render();
Property::Map propertyMap;
propertyMap.Insert("text", "activate");
checkBox.SetProperty(checkBox.GetPropertyIndex("disabled"), true);
checkBox.SetProperty( checkBox.GetPropertyIndex("label"), propertyMap );
DALI_TEST_CHECK( checkBox.GetProperty<bool>(checkBox.GetPropertyIndex("disabled")) );
DALI_TEST_EQUALS( checkBox.GetLabelText(), "activate", TEST_LOCATION ); // Change to use GerProperty once that code is implemented
END_TEST;
}
int UtcDaliPropertyMapInsertP(void)
{
Property::Map map;
DALI_TEST_EQUALS( 0, map.Count(), TEST_LOCATION );
map.Insert( "foo", "bar");
DALI_TEST_EQUALS( 1, map.Count(), TEST_LOCATION );
Property::Value* value = map.Find( "foo" );
DALI_TEST_CHECK( value );
DALI_TEST_EQUALS( "bar", value->Get<std::string>(), TEST_LOCATION );
map.Insert( std::string("foo2"), "testing" );
DALI_TEST_EQUALS( 2, map.Count(), TEST_LOCATION );
value = map.Find( "foo2" );
DALI_TEST_CHECK( value );
DALI_TEST_EQUALS( "testing", value->Get<std::string>(), TEST_LOCATION );
END_TEST;
}
void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap )
{
if( renderer )
{
Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
std::string typeValue ;
if( type && type->Get( typeValue ))
{
//If there's been a renderer type change then we have to return a new shader
if( typeValue == COLOR_RENDERER && typeid( renderer ) != typeid( ColorRenderer ) )
{
renderer = GetControlRenderer( propertyMap );
return;
}
else if( typeValue == GRADIENT_RENDERER && typeid( renderer ) != typeid( GradientRenderer ) )
{
renderer = GetControlRenderer( propertyMap );
return;
}
else if( typeValue == IMAGE_RENDERER && typeid( renderer ) != typeid( ImageRenderer ) )
{
renderer = GetControlRenderer( propertyMap );
return;
}
else if( typeValue == N_PATCH_RENDERER && typeid( renderer ) != typeid( NPatchRenderer ) )
{
renderer = GetControlRenderer( propertyMap );
return;
}
else if( typeValue == BORDER_RENDERER && typeid( renderer ) != typeid( BorderRenderer ) )
{
renderer = GetControlRenderer( propertyMap );
return;
}
}
GetImplementation( renderer ).Initialize( actor, propertyMap );
}
else
{
renderer = GetControlRenderer( propertyMap );
}
}
void ControlRenderer::Initialize( Actor& actor, const Property::Map& propertyMap )
{
if( mImpl->mCustomShader )
{
mImpl->mCustomShader->SetPropertyMap( propertyMap );
}
else
{
Property::Value* customShaderValue = propertyMap.Find( CUSTOM_SHADER );
if( customShaderValue )
{
Property::Map customShader;
if( customShaderValue->Get( customShader ) )
{
mImpl->mCustomShader = new Impl::CustomShader( propertyMap );
}
}
}
DoInitialize( actor, propertyMap );
}
void CreatePropertyMap( Image image, Property::Map& map )
{
map.Clear();
if ( image )
{
std::string imageType( "ResourceImage" );
// Get Type - cannot use TypeRegistry as Image is not an Object and thus, not registered
BufferImage bufferImage = BufferImage::DownCast( image );
if ( bufferImage )
{
imageType = "BufferImage";
map[ "pixelFormat" ] = GetEnumerationName< Pixel::Format >( bufferImage.GetPixelFormat(), PIXEL_FORMAT_TABLE, PIXEL_FORMAT_TABLE_COUNT );
}
else if ( FrameBufferImage::DownCast( image ) )
{
imageType = "FrameBufferImage";
}
map[ "type" ] = imageType;
map[ "releasePolicy" ] = GetEnumerationName< Image::ReleasePolicy >( image.GetReleasePolicy(), IMAGE_RELEASE_POLICY_TABLE, IMAGE_RELEASE_POLICY_TABLE_COUNT );
ResourceImage resourceImage = ResourceImage::DownCast( image );
if( resourceImage )
{
map[ "filename" ] = resourceImage.GetUrl();
map[ "loadPolicy" ] = GetEnumerationName< ResourceImage::LoadPolicy >( resourceImage.GetLoadPolicy(), IMAGE_LOAD_POLICY_TABLE, IMAGE_LOAD_POLICY_TABLE_COUNT );
}
int width( image.GetWidth() );
int height( image.GetHeight() );
if ( width && height )
{
map[ "width" ] = width;
map[ "height" ] = height;
}
}
}
int UtcDaliPropertyMapPopulate(void)
{
Property::Map map;
DALI_TEST_CHECK( map.Empty() );
map[ "hello" ] = 1;
map[ "world" ] = "world";
map[ "world" ] = 3; // same item as line above
DALI_TEST_CHECK( !map.Empty() ); // Should no longer be empty
DALI_TEST_CHECK( map.Count() == 2 ); // Should only have two items, not three!!
DALI_TEST_CHECK( map["hello"].Get<int>() == 1 );
DALI_TEST_CHECK( map["world"].Get<int>() == 3 );
map.Clear();
DALI_TEST_CHECK( map.Empty() );
END_TEST;
}
int UtcDaliPropertyMapCopyAndAssignment(void)
{
Property::Map map;
map[ "hello" ] = 1;
map[ "world" ] = 2;
Property::Map assignedMap;
assignedMap[ "foo" ] = 3;
DALI_TEST_CHECK( assignedMap.Count() == 1 );
assignedMap = map;
DALI_TEST_CHECK( assignedMap.Count() == 2 );
Property::Map copiedMap( map );
DALI_TEST_CHECK( copiedMap.Count() == 2 );
// Self assignment
DALI_TEST_CHECK( map.Count() == 2 );
map = map;
DALI_TEST_CHECK( map.Count() == 2 );
END_TEST;
}
