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;
}
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 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 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;
}
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 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 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;
}
int UtcDaliControlRendererGetPropertyMap2(void)
{
ToolkitTestApplication application;
tet_infoline( "UtcDaliControlRendererGetPropertyMap2: BorderRenderer" );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
propertyMap.Insert("renderer-type", "border-renderer");
propertyMap.Insert("border-color", Color::BLUE);
propertyMap.Insert("border-size", 5.f);
ControlRenderer borderRenderer = factory.GetControlRenderer( propertyMap );
Property::Map resultMap;
borderRenderer.CreatePropertyMap( resultMap );
// check the property values from the returned map from control renderer
Property::Value* typeValue = resultMap.Find( "renderer-type", Property::STRING );
DALI_TEST_CHECK( typeValue );
DALI_TEST_CHECK( typeValue->Get<std::string>() == "border-renderer" );
Property::Value* colorValue = resultMap.Find( "border-color", Property::VECTOR4 );
DALI_TEST_CHECK( colorValue );
DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
Property::Value* sizeValue = resultMap.Find( "border-size", Property::FLOAT );
DALI_TEST_CHECK( sizeValue );
DALI_TEST_CHECK( sizeValue->Get<float>() == 5.f );
borderRenderer = factory.GetControlRenderer( 10.f, Color::CYAN );
borderRenderer.CreatePropertyMap( resultMap );
typeValue = resultMap.Find( "renderer-type", Property::STRING );
DALI_TEST_CHECK( typeValue );
DALI_TEST_CHECK( typeValue->Get<std::string>() == "border-renderer" );
colorValue = resultMap.Find( "border-color", Property::VECTOR4 );
DALI_TEST_CHECK( colorValue );
DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
colorValue = resultMap.Find( "border-size", Property::FLOAT );
DALI_TEST_CHECK( colorValue );
DALI_TEST_CHECK( colorValue->Get<float>() == 10.f );
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 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;
}
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 UtcDaliControlRendererGetPropertyMap5(void)
{
ToolkitTestApplication application;
tet_infoline( "UtcDaliControlRendererGetPropertyMap5: ImageRenderer" );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
propertyMap.Insert( "renderer-type", "image-renderer" );
propertyMap.Insert( "image-url", TEST_IMAGE_FILE_NAME );
propertyMap.Insert( "image-desired-width", 20 );
propertyMap.Insert( "image-desired-height", 30 );
propertyMap.Insert( "image-fitting-mode", "fit-height" );
propertyMap.Insert( "image-sampling-mode", "box-then-nearest" );
ControlRenderer imageRenderer = factory.GetControlRenderer(propertyMap);
DALI_TEST_CHECK( imageRenderer );
Property::Map resultMap;
imageRenderer.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>() == "image-renderer" );
value = resultMap.Find( "image-url", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
value = resultMap.Find( "image-fitting-mode", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "fit-height" );
value = resultMap.Find( "image-sampling-mode", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "box-then-nearest" );
value = resultMap.Find( "image-desired-width", Property::INTEGER );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<int>() == 20 );
value = resultMap.Find( "image-desired-height", Property::INTEGER );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<int>() == 30 );
// Get an image renderer with an image handle, and test the default property values
Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
imageRenderer = factory.GetControlRenderer(image);
imageRenderer.CreatePropertyMap( resultMap );
value = resultMap.Find( "renderer-type", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "image-renderer" );
value = resultMap.Find( "image-url", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
value = resultMap.Find( "image-fitting-mode", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "shrink-to-fit" );
value = resultMap.Find( "image-sampling-mode", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "box" );
value = resultMap.Find( "image-desired-width", Property::INTEGER );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<int>() == 100 );
value = resultMap.Find( "image-desired-height", Property::INTEGER );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<int>() == 200 );
END_TEST;
}
int UtcDaliControlRendererGetPropertyMap4(void)
{
ToolkitTestApplication application;
tet_infoline( "UtcDaliControlRendererGetPropertyMap4: radial GradientRenderer" );
RendererFactory factory = RendererFactory::Get();
DALI_TEST_CHECK( factory );
Property::Map propertyMap;
propertyMap.Insert("renderer-type", "gradient-renderer");
Vector2 center(100.f, 100.f);
float radius = 100.f;
propertyMap.Insert("gradient-units", "user-space");
propertyMap.Insert("gradient-center", center);
propertyMap.Insert("gradient-radius", radius);
propertyMap.Insert("gradient-stop-offset", Vector3(0.1f, 0.3f, 1.1f));
Property::Array stopColors;
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::BLACK );
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("gradient-stop-color", stopColors);
ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap);
DALI_TEST_CHECK( gradientRenderer );
Property::Map resultMap;
gradientRenderer.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>() == "gradient-renderer" );
value = resultMap.Find( "gradient-units", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "user-space" );
value = resultMap.Find( "gradient-spread-method", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "pad" );
value = resultMap.Find( "gradient-center", Property::VECTOR2 );
DALI_TEST_CHECK( value );
DALI_TEST_EQUALS( value->Get<Vector2>(), center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
value = resultMap.Find( "gradient-radius", Property::FLOAT );
DALI_TEST_CHECK( value );
DALI_TEST_EQUALS( value->Get<float>(), radius , Math::MACHINE_EPSILON_100, TEST_LOCATION );
value = resultMap.Find( "gradient-stop-offset", Property::ARRAY );
DALI_TEST_CHECK( value );
Property::Array* offsetArray = value->GetArray();
DALI_TEST_CHECK( offsetArray->Count() == 3 );
DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.1f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.3f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
// any stop value will be clamped to [0.0, 1.0];
DALI_TEST_EQUALS( offsetArray->GetElementAt(2).Get<float>(), 1.0f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
value = resultMap.Find( "gradient-stop-color", Property::ARRAY );
DALI_TEST_CHECK( value );
Property::Array* colorArray = value->GetArray();
DALI_TEST_CHECK( colorArray->Count() == 3 );
DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK , Math::MACHINE_EPSILON_100, TEST_LOCATION );
DALI_TEST_EQUALS( colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
END_TEST;
}
int UtcDaliControlRendererGetPropertyMap3(void)
{
ToolkitTestApplication application;
tet_infoline( "UtcDaliControlRendererGetPropertyMap3: linear GradientRenderer" );
RendererFactory factory = RendererFactory::Get();
DALI_TEST_CHECK( factory );
Property::Map propertyMap;
propertyMap.Insert("renderer-type", "gradient-renderer");
Vector2 start(-1.f, -1.f);
Vector2 end(1.f, 1.f);
propertyMap.Insert("gradient-start-position", start);
propertyMap.Insert("gradient-end-position", end);
propertyMap.Insert("gradient-spread-method", "repeat");
propertyMap.Insert("gradient-stop-offset", Vector2(0.2f, 0.8f));
Property::Array stopColors;
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("gradient-stop-color", stopColors);
ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap);
Property::Map resultMap;
gradientRenderer.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>() == "gradient-renderer" );
value = resultMap.Find( "gradient-units", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "object-bounding-box" );
value = resultMap.Find( "gradient-spread-method", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "repeat" );
value = resultMap.Find( "gradient-start-position", Property::VECTOR2 );
DALI_TEST_CHECK( value );
DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
value = resultMap.Find( "gradient-end-position", Property::VECTOR2 );
DALI_TEST_CHECK( value );
DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
value = resultMap.Find( "gradient-stop-offset", Property::ARRAY );
DALI_TEST_CHECK( value );
Property::Array* offsetArray = value->GetArray();
DALI_TEST_CHECK( offsetArray->Count() == 2 );
DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.2f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.8f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
value = resultMap.Find( "gradient-stop-color", Property::ARRAY );
DALI_TEST_CHECK( value );
Property::Array* colorArray = value->GetArray();
DALI_TEST_CHECK( colorArray->Count() == 2 );
DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
END_TEST;
}
bool SetPropertyFromNode( const TreeNode& node, Property::Type type, Property::Value& value,
const Replacement& replacer )
{
bool done = false;
switch(type)
{
case Property::BOOLEAN:
{
if( OptionalBoolean v = replacer.IsBoolean(node) )
{
value = *v;
done = true;
}
break;
}
case Property::FLOAT:
{
if( OptionalFloat v = replacer.IsFloat(node) )
{
value = *v;
done = true;
}
break;
}
case Property::INTEGER:
{
if( OptionalInteger v = replacer.IsInteger(node) )
{
value = *v;
done = true;
}
break;
}
case Property::VECTOR2:
{
if( OptionalVector2 v = replacer.IsVector2(node) )
{
value = *v;
done = true;
}
break;
}
case Property::VECTOR3:
{
if( OptionalVector3 v = replacer.IsVector3(node) )
{
value = *v;
done = true;
}
break;
}
case Property::VECTOR4:
{
if( OptionalVector4 v = replacer.IsVector4(node) )
{
value = *v;
done = true;
}
else if( OptionalString s = replacer.IsString(node) )
{
if( (*s)[0] == '#' && 7 == (*s).size() )
{
value = HexStringToVector4( &(*s)[1] );
done = true;
}
else if( Dali::ColorController::Get() )
{
Vector4 color;
done = Dali::ColorController::Get().RetrieveColor( *s, color );
value = color;
}
}
else if( TreeNode::OBJECT == node.GetType() )
{
// check for "r", "g" and "b" child color component nodes
OptionalInteger r = replacer.IsInteger( IsChild(node, "r") );
OptionalInteger g = replacer.IsInteger( IsChild(node, "g") );
OptionalInteger b = replacer.IsInteger( IsChild(node, "b") );
if( r && g && b )
{
float red( (*r) * (1.0f/255.0f) );
float green( (*g) * (1.0f/255.0f) );
float blue( (*b) * (1.0f/255.0f) );
// check for optional "a" (alpha) node, default to fully opaque if it is not found.
float alpha( 1.0f );
OptionalInteger a = replacer.IsInteger( IsChild(node, "a") );
if( a )
{
alpha = (*a) * (1.0f/255.0f);
}
value = Vector4( red, green, blue, alpha );
done = true;
}
}
break;
}
case Property::MATRIX3:
{
if( OptionalMatrix3 v = replacer.IsMatrix3(node) )
{
value = *v;
done = true;
}
break;
}
case Property::MATRIX:
{
if( OptionalMatrix v = replacer.IsMatrix(node) )
{
value = *v;
done = true;
}
break;
}
case Property::RECTANGLE:
{
if( OptionalRect v = replacer.IsRect(node) )
{
value = *v;
done = true;
}
break;
}
case Property::ROTATION:
{
if(4 == node.Size())
{
if( OptionalVector4 ov = replacer.IsVector4(node) )
{
const Vector4& v = *ov;
// angle, axis as per spec
value = Quaternion(Radian(Degree(v[3])),
Vector3(v[0],v[1],v[2]));
done = true;
}
}
else
{
// degrees Euler as per spec
if( OptionalVector3 v = replacer.IsVector3(node) )
{
value = Quaternion(Radian(Degree((*v).x)),
Radian(Degree((*v).y)),
Radian(Degree((*v).z)));
done = true;
}
}
break;
}
case Property::STRING:
{
if( OptionalString v = replacer.IsString(node) )
{
value = *v;
done = true;
}
break;
}
case Property::ARRAY:
{
if( replacer.IsArray( node, value ) )
{
done = true;
}
else if(node.Size())
{
value = Property::Value(Property::ARRAY);
Property::Array* array = value.GetArray();
unsigned int i = 0;
TreeNode::ConstIterator iter(node.CBegin());
if( array )
{
for( ; i < node.Size(); ++i, ++iter)
{
Property::Value childValue;
if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
{
array->PushBack( childValue );
}
}
if( array->Count() == node.Size() )
{
done = true;
}
else
{
done = false;
}
}
}
break;
}
case Property::MAP:
{
if( replacer.IsMap( node, value ) )
{
done = true;
}
else if(node.Size())
{
value = Property::Value(Property::MAP);
Property::Map* map = value.GetMap();
unsigned int i = 0;
TreeNode::ConstIterator iter(node.CBegin());
if( map )
{
for( ; i < node.Size(); ++i, ++iter)
{
Property::Value childValue;
if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
{
map->Insert( (*iter).first, childValue );
}
}
if( map->Count() == node.Size() )
{
done = true;
}
else
{
done = false;
}
}
}
break;
}
case Property::NONE:
{
break;
}
} // switch type
return done;
}
int UtcDaliControlRendererSize(void)
{
ToolkitTestApplication application;
tet_infoline( "UtcDaliControlRendererGetNaturalSize" );
RendererFactory factory = RendererFactory::Get();
Vector2 rendererSize( 20.f, 30.f );
Vector2 naturalSize;
// color renderer
ControlRenderer colorRenderer = factory.GetControlRenderer( Color::MAGENTA );
colorRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( colorRenderer.GetSize(), rendererSize, TEST_LOCATION );
colorRenderer.GetNaturalSize(naturalSize);
DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
// image renderer
Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
ControlRenderer imageRenderer = factory.GetControlRenderer( image );
imageRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( imageRenderer.GetSize(), rendererSize, TEST_LOCATION );
imageRenderer.GetNaturalSize(naturalSize);
DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 200.f), TEST_LOCATION );
// n patch renderer
TestPlatformAbstraction& platform = application.GetPlatform();
Vector2 testSize(80.f, 160.f);
platform.SetClosestImageSize(testSize);
image = ResourceImage::New(TEST_NPATCH_FILE_NAME);
ControlRenderer nPatchRenderer = factory.GetControlRenderer( image );
nPatchRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( nPatchRenderer.GetSize(), rendererSize, TEST_LOCATION );
nPatchRenderer.GetNaturalSize(naturalSize);
DALI_TEST_EQUALS( naturalSize, testSize, TEST_LOCATION );
// border renderer
float borderSize = 5.f;
ControlRenderer borderRenderer = factory.GetControlRenderer( borderSize, Color::RED );
borderRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( borderRenderer.GetSize(), rendererSize, TEST_LOCATION );
borderRenderer.GetNaturalSize(naturalSize);
DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
// gradient renderer
Property::Map propertyMap;
propertyMap.Insert("renderer-type", "gradient-renderer");
Vector2 start(-1.f, -1.f);
Vector2 end(1.f, 1.f);
propertyMap.Insert("gradient-start-position", start);
propertyMap.Insert("gradient-end-position", end);
propertyMap.Insert("gradient-stop-offset", Vector2(0.f, 1.f));
Property::Array stopColors;
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("gradient-stop-color", stopColors);
ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap);
gradientRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( gradientRenderer.GetSize(), rendererSize, TEST_LOCATION );
gradientRenderer.GetNaturalSize(naturalSize);
DALI_TEST_EQUALS( naturalSize, Vector2::ZERO,TEST_LOCATION );
END_TEST;
}
bool SetPropertyFromNode( const TreeNode& node, Property::Value& value,
const Replacement& replacer )
{
bool done = false;
// some values are ambiguous as we have no Property::Type but can be disambiguated in the json
// Currently Rotations and Rectangle must always be disambiguated when a type isnt available
if( Disambiguated( node, value, replacer ) )
{
done = true;
}
else
{
if( node.Size() )
{
// our current heuristic for deciding an array is actually a vector and not say a map
// is to check if the values are all floats
bool allNumbers = true;
for(TreeConstIter iter = node.CBegin(); iter != node.CEnd(); ++iter)
{
OptionalFloat f = IsFloat((*iter).second);
if(!f)
{
allNumbers = false;
break;
}
}
if( allNumbers )
{
// prefer finding vectors over presuming composite Property::Array...
if( OptionalMatrix v = IsMatrix(node) )
{
value = *v;
done = true;
}
else if( OptionalMatrix3 v = IsMatrix3(node) )
{
value = *v;
done = true;
}
else if( OptionalVector4 v = IsVector4(node) )
{
value = *v;
done = true;
}
else if( OptionalVector3 v = IsVector3(node) )
{
value = *v;
done = true;
}
else if( OptionalVector2 v = IsVector2(node) )
{
value = *v;
done = true;
}
else if( 4 == node.Size() )
{
if( OptionalVector4 v = IsVector4(node) )
{
value = *v;
done = true;
}
}
else
{
value = Property::Value(Property::ARRAY);
Property::Array* array = value.GetArray();
if( array )
{
for(TreeConstIter iter = node.CBegin(); iter != node.CEnd(); ++iter)
{
Property::Value childValue;
if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
{
array->PushBack( childValue );
done = true;
}
}
}
}
}
if(!done)
{
// presume an array or map
// container of size 1
TreeNode::ConstIterator iter = node.CBegin();
// its seems legal with current json parser for a map to have an empty key
// but here we take that to mean the structure is a list
if( ((*iter).first) == 0 )
{
value = Property::Value(Property::ARRAY);
Property::Array* array = value.GetArray();
if( array )
{
for(unsigned int i = 0; i < node.Size(); ++i, ++iter)
{
Property::Value childValue;
if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
{
array->PushBack( childValue );
done = true;
}
}
}
}
else
{
value = Property::Value(Property::MAP);
Property::Map* map = value.GetMap();
if( map )
{
for(unsigned int i = 0; i < node.Size(); ++i, ++iter)
{
Property::Value childValue;
if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
{
map->Insert( (*iter).first, childValue );
done = true;
}
}
}
}
} // if!done
} // if node.size()
else // if( 0 == node.size() )
{
// no children so either one of bool, float, integer, string
OptionalBoolean aBool = replacer.IsBoolean(node);
OptionalInteger anInt = replacer.IsInteger(node);
OptionalFloat aFloat = replacer.IsFloat(node);
OptionalString aString = replacer.IsString(node);
if(aBool)
{
// a bool is also an int but here we presume int
if(anInt)
{
value = *anInt;
done = true;
}
else
{
value = *aBool;
done = true;
}
}
else
{
// Note: These are both floats and strings
// {"value":"123"}
// {"value":123}
// This means we can't have a string with purely numeric content without disambiguation.
if(aFloat)
{
value = *aFloat;
done = true;
}
else if(anInt)
{
value = *anInt;
done = true;
}
else
{
// string always succeeds with the current json parser so its last
value = *aString;
done = true;
}
} // if aBool
} // if( node.size() )
} // if Disambiguated()
return done;
} // bool SetPropertyFromNode( const TreeNode& node, Property::Value& value )