// Invalid load-policy value type
Property::Map map;
map[ "filename" ] = "TEST_FILE";
- map[ "load-policy" ] = Vector3::ZERO;
+ map[ "loadPolicy" ] = Vector3::ZERO;
// will give us a valid image handle with default load policy
Image image = NewImage( map );
DALI_TEST_CHECK( image );
// Invalid load-policy value
Property::Map map;
map[ "filename" ] = "TEST_FILE";
- map[ "load-policy" ] = "INVALID";
+ map[ "loadPolicy" ] = "INVALID";
// will give us a valid image with default load policy
Image image = NewImage( map );
DALI_TEST_CHECK( image );
// Invalid release-policy value type
Property::Map map;
map[ "filename" ] = "TEST_FILE";
- map[ "release-policy" ] = Vector3::ZERO;
+ map[ "releasePolicy" ] = Vector3::ZERO;
// will give us a valid image with default release policy
Image image = NewImage( map );
DALI_TEST_CHECK( image );
// Invalid release-policy value
Property::Map map;
map[ "filename" ] = "TEST_FILE";
- map[ "release-policy" ] = "INVALID";
+ map[ "releasePolicy" ] = "INVALID";
// will give us a valid image with default release policy
Image image = NewImage( map );
DALI_TEST_CHECK( image );
// Invalid fitting-mode
Property::Map map;
map[ "filename" ] = "TEST_FILE";
- map[ "fitting-mode" ] = Vector3::ZERO;
+ map[ "fittingMode" ] = Vector3::ZERO;
// will give us a valid image
Image image = NewImage( map );
DALI_TEST_CHECK( image );
// Invalid value
Property::Map map;
map[ "filename" ] = "TEST_FILE";
- map[ "fitting-mode" ] = "INVALID";
+ map[ "fittingMode" ] = "INVALID";
// will give us a valid image
Image image = NewImage( map );
DALI_TEST_CHECK( image );
// Invalid scaling-mode
Property::Map map;
map[ "filename" ] = "TEST_FILE";
- map[ "sampling-mode" ] = Vector3::ZERO;
+ map[ "samplingMode" ] = Vector3::ZERO;
// will give us a valid image
Image image = NewImage( map );
DALI_TEST_CHECK( image );
{
// Invalid pixel-format
Property::Map map;
- map[ "pixel-format" ] = Vector3::ZERO;
+ map[ "pixelFormat" ] = Vector3::ZERO;
Image image = NewImage( map );
DALI_TEST_CHECK( !image );
END_TEST;
{
// Invalid value
Property::Map map;
- map[ "pixel-format" ] = "INVALID";
+ map[ "pixelFormat" ] = "INVALID";
Image image = NewImage( map );
DALI_TEST_CHECK( !image );
END_TEST;
map[ "filename" ] = "TEST_FILE";
// load-policy
- map[ "load-policy" ] = "";
+ map[ "loadPolicy" ] = "";
const StringEnum values[] =
{
{ "IMMEDIATE", ResourceImage::IMMEDIATE },
{ "ON_DEMAND", ResourceImage::ON_DEMAND }
};
- TestEnumStrings< ResourceImage::LoadPolicy, ResourceImage >( map, "load-policy", values, ( sizeof( values ) / sizeof ( values[0] ) ), &ResourceImage::GetLoadPolicy, &NewResourceImage );
+ TestEnumStrings< ResourceImage::LoadPolicy, ResourceImage >( map, "loadPolicy", values, ( sizeof( values ) / sizeof ( values[0] ) ), &ResourceImage::GetLoadPolicy, &NewResourceImage );
END_TEST;
}
map[ "filename" ] = "TEST_FILE";
// release-policy
- map[ "release-policy" ] = "";
+ map[ "releasePolicy" ] = "";
const StringEnum values[] =
{
{ "UNUSED", Image::UNUSED },
{ "NEVER", Image::NEVER }
};
- TestEnumStrings< Image::ReleasePolicy, Image >( map, "release-policy", values, ( sizeof( values ) / sizeof ( values[0] ) ), &Image::GetReleasePolicy, &NewImage );
+ TestEnumStrings< Image::ReleasePolicy, Image >( map, "releasePolicy", values, ( sizeof( values ) / sizeof ( values[0] ) ), &Image::GetReleasePolicy, &NewImage );
END_TEST;
}
map[ "width"] = 66;
map[ "height" ] = 99;
// pixel-format
- map[ "pixel-format" ] = "";
+ map[ "pixelFormat" ] = "";
const StringEnum values[] =
{
{ "A8", Pixel::A8 },
{ "BGRA8888", Pixel::BGRA8888 },
// BufferImage does not support compressed formats
};
- TestEnumStrings< Pixel::Format, BufferImage >( map, "pixel-format", values, ( sizeof( values ) / sizeof ( values[0] ) ), &BufferImage::GetPixelFormat, &NewBufferImage );
+ TestEnumStrings< Pixel::Format, BufferImage >( map, "pixelFormat", values, ( sizeof( values ) / sizeof ( values[0] ) ), &BufferImage::GetPixelFormat, &NewBufferImage );
END_TEST;
}
TestApplication application;
Property::Map programMap;
- programMap[ "vertex-filename" ] = "bump.vert";
- programMap[ "fragment-filename" ] = "bump.frag";
+ programMap[ "vertexFilename" ] = "bump.vert";
+ programMap[ "fragmentFilename" ] = "bump.frag";
Property::Map imageMap;
imageMap[ "filename" ] = "image.png";
// Map with only properties
{
Property::Map map;
- map[ "parent-origin" ] = ParentOrigin::TOP_CENTER;
- map[ "anchor-point" ] = AnchorPoint::TOP_CENTER;
+ map[ "parentOrigin" ] = ParentOrigin::TOP_CENTER;
+ map[ "anchorPoint" ] = AnchorPoint::TOP_CENTER;
Actor handle = NewActor( map );
DALI_TEST_CHECK( !handle );
}
map[ "visible" ] = false;
map[ "color" ] = Color::MAGENTA;
map[ "name" ] = "MyActor";
- map[ "color-mode" ] = "USE_PARENT_COLOR";
- map[ "inherit-shader-effect" ] = false;
+ map[ "colorMode" ] = "USE_PARENT_COLOR";
+ map[ "inheritShaderEffect" ] = false;
map[ "sensitive" ] = false;
- map[ "leave-required" ] = true;
- map[ "position-inheritance" ] = "DONT_INHERIT_POSITION";
- map[ "draw-mode" ] = "STENCIL";
- map[ "inherit-orientation" ] = false;
- map[ "inherit-scale" ] = false;
+ map[ "leaveRequired" ] = true;
+ map[ "positionInheritance" ] = "DONT_INHERIT_POSITION";
+ map[ "drawMode" ] = "STENCIL";
+ map[ "inheritOrientation" ] = false;
+ map[ "inheritScale" ] = false;
// Default properties
{
}
// Check Anchor point and parent origin vector3s
- map[ "parent-origin" ] = ParentOrigin::TOP_CENTER;
- map[ "anchor-point" ] = AnchorPoint::TOP_LEFT;
+ map[ "parentOrigin" ] = ParentOrigin::TOP_CENTER;
+ map[ "anchorPoint" ] = AnchorPoint::TOP_LEFT;
{
Actor handle = NewActor( map );
DALI_TEST_CHECK( handle );
}
// Check Anchor point and parent origin STRINGS
- map[ "parent-origin" ] = "TOP_LEFT";
- map[ "anchor-point" ] = "CENTER_LEFT";
+ map[ "parentOrigin" ] = "TOP_LEFT";
+ map[ "anchorPoint" ] = "CENTER_LEFT";
{
Actor handle = NewActor( map );
DALI_TEST_CHECK( handle );
DALI_TEST_EQUALS( map.Find( "color" )->Get< Vector4 >(), Color::MAGENTA, TEST_LOCATION );
DALI_TEST_CHECK( NULL != map.Find( "name" ) );
DALI_TEST_EQUALS( map.Find( "name")->Get< std::string >(), "MyActor", TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "anchor-point" ) );
- DALI_TEST_EQUALS( map.Find( "anchor-point" )->Get< Vector3 >(), AnchorPoint::CENTER_LEFT, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "parent-origin" ) );
- DALI_TEST_EQUALS( map.Find( "parent-origin" )->Get< Vector3 >(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
+ DALI_TEST_CHECK( NULL != map.Find( "anchorPoint" ) );
+ DALI_TEST_EQUALS( map.Find( "anchorPoint" )->Get< Vector3 >(), AnchorPoint::CENTER_LEFT, TEST_LOCATION );
+ DALI_TEST_CHECK( NULL != map.Find( "parentOrigin" ) );
+ DALI_TEST_EQUALS( map.Find( "parentOrigin" )->Get< Vector3 >(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
DALI_TEST_CHECK( NULL != map.Find( "sensitive" ) );
DALI_TEST_EQUALS( map.Find( "sensitive" )->Get< bool >(), false, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "leave-required" ) );
- DALI_TEST_EQUALS( map.Find( "leave-required" )->Get< bool >(), true, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "inherit-orientation" ) );
- DALI_TEST_EQUALS( map.Find( "inherit-orientation" )->Get< bool >(), false, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "inherit-scale" ) );
- DALI_TEST_EQUALS( map.Find( "inherit-scale" )->Get< bool >(), false, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "size-mode-factor" ) );
- DALI_TEST_EQUALS( map.Find( "size-mode-factor" )->Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_CHECK( NULL != map.Find( "leaveRequired" ) );
+ DALI_TEST_EQUALS( map.Find( "leaveRequired" )->Get< bool >(), true, TEST_LOCATION );
+ DALI_TEST_CHECK( NULL != map.Find( "inheritOrientation" ) );
+ DALI_TEST_EQUALS( map.Find( "inheritOrientation" )->Get< bool >(), false, TEST_LOCATION );
+ DALI_TEST_CHECK( NULL != map.Find( "inheritScale" ) );
+ DALI_TEST_EQUALS( map.Find( "inheritScale" )->Get< bool >(), false, TEST_LOCATION );
+ DALI_TEST_CHECK( NULL != map.Find( "sizeModeFactor" ) );
+ DALI_TEST_EQUALS( map.Find( "sizeModeFactor" )->Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
Stage::GetCurrent().Remove( actor );
}
// ColorMode
- TestEnumStrings< ColorMode >( "color-mode", application, COLOR_MODE_VALUES, COLOR_MODE_VALUES_COUNT, &Actor::SetColorMode );
+ TestEnumStrings< ColorMode >( "colorMode", application, COLOR_MODE_VALUES, COLOR_MODE_VALUES_COUNT, &Actor::SetColorMode );
// PositionInheritanceMode
- TestEnumStrings< PositionInheritanceMode >( "position-inheritance", application, POSITION_INHERITANCE_MODE_VALUES, POSITION_INHERITANCE_MODE_VALUES_COUNT, &Actor::SetPositionInheritanceMode );
+ TestEnumStrings< PositionInheritanceMode >( "positionInheritance", application, POSITION_INHERITANCE_MODE_VALUES, POSITION_INHERITANCE_MODE_VALUES_COUNT, &Actor::SetPositionInheritanceMode );
// DrawMode
- TestEnumStrings< DrawMode::Type >( "draw-mode", application, DRAW_MODE_VALUES, DRAW_MODE_VALUES_COUNT, &Actor::SetDrawMode );
+ TestEnumStrings< DrawMode::Type >( "drawMode", application, DRAW_MODE_VALUES, DRAW_MODE_VALUES_COUNT, &Actor::SetDrawMode );
// Children
{
DALI_TEST_EQUALS( map.Find( "type" )->Get< std::string >(), "ResourceImage", TEST_LOCATION );
DALI_TEST_CHECK( NULL != map.Find( "filename" ) );
DALI_TEST_EQUALS( map.Find( "filename" )->Get< std::string >(), "MY_PATH", TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "load-policy") );
- DALI_TEST_EQUALS( map.Find( "load-policy" )->Get< std::string >(), "IMMEDIATE", TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "release-policy") );
- DALI_TEST_EQUALS( map.Find( "release-policy" )->Get< std::string >(), "NEVER", TEST_LOCATION );
+ DALI_TEST_CHECK( NULL != map.Find( "loadPolicy") );
+ DALI_TEST_EQUALS( map.Find( "loadPolicy" )->Get< std::string >(), "IMMEDIATE", TEST_LOCATION );
+ DALI_TEST_CHECK( NULL != map.Find( "releasePolicy") );
+ DALI_TEST_EQUALS( map.Find( "releasePolicy" )->Get< std::string >(), "NEVER", TEST_LOCATION );
DALI_TEST_CHECK( NULL == map.Find( "width" ) );
DALI_TEST_CHECK( NULL == map.Find( "height" ) );
}
DALI_TEST_EQUALS( map.Find( "type" )->Get< std::string >(), "ResourceImage", TEST_LOCATION );
DALI_TEST_CHECK( NULL != map.Find( "filename" ) );
DALI_TEST_EQUALS( map.Find( "filename" )->Get< std::string >(), "MY_PATH", TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "load-policy") );
- DALI_TEST_EQUALS( map.Find( "load-policy" )->Get< std::string >(), "ON_DEMAND", TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "release-policy") );
- DALI_TEST_EQUALS( map.Find( "release-policy" )->Get< std::string >(), "UNUSED", TEST_LOCATION );
+ DALI_TEST_CHECK( NULL != map.Find( "loadPolicy") );
+ DALI_TEST_EQUALS( map.Find( "loadPolicy" )->Get< std::string >(), "ON_DEMAND", TEST_LOCATION );
+ DALI_TEST_CHECK( NULL != map.Find( "releasePolicy") );
+ DALI_TEST_EQUALS( map.Find( "releasePolicy" )->Get< std::string >(), "UNUSED", TEST_LOCATION );
DALI_TEST_CHECK( NULL != map.Find( "width" ) );
DALI_TEST_EQUALS( map.Find( "width" )->Get< int >(), 300, TEST_LOCATION );
DALI_TEST_CHECK( NULL != map.Find( "height" ) );
CreatePropertyMap( image, map );
DALI_TEST_CHECK( NULL != map.Find( "type" ) );
DALI_TEST_EQUALS( map.Find( "type" )->Get< std::string >(), "BufferImage", TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "pixel-format") );
- DALI_TEST_EQUALS( map.Find( "pixel-format" )->Get< std::string >(), "A8", TEST_LOCATION );
+ DALI_TEST_CHECK( NULL != map.Find( "pixelFormat") );
+ DALI_TEST_EQUALS( map.Find( "pixelFormat" )->Get< std::string >(), "A8", TEST_LOCATION );
}
// FrameBufferImage
// Set up an actor with a signal to connect to.
Actor connectActor = Actor::New();
- std::string connectSignal = "on-stage";
+ std::string connectSignal = "onStage";
// Create the test class (this will create the delegate, but not connect to it yet.
SignalDelegateTestClass testObject( connectActor, connectSignal );
// Set up an actor with a signal to connect to.
Actor connectActor = Actor::New();
- std::string connectSignal = "on-stage";
+ std::string connectSignal = "onStage";
// Create the test class (this will create the delegate, but not connect to it yet.
SignalDelegateTestClass testObject( connectActor, connectSignal );
// Set up an actor with a signal to connect to.
Actor connectActor = Actor::New();
- std::string connectSignal = "on-stage";
+ std::string connectSignal = "onStage";
gSignalReceived = false;
// Note: It is at this point that the delegate internally makes the connection.
testObject.ConnectToInternalMember();
- // Add the actor to the stage to trigger it's "on-stage" signal.
+ // Add the actor to the stage to trigger it's "onStage" signal.
// If the delegate connected correctly, this will call the member
// function in the test object and set a global flag.
Stage::GetCurrent().Add( connectActor );
// Set up an actor with a signal to connect to.
Actor connectActor = Actor::New();
- std::string connectSignal = "on-stage";
+ std::string connectSignal = "onStage";
gSignalReceived = false;
// Set up an actor with a signal to connect to.
Actor connectActor = Actor::New();
- std::string connectSignal = "on-stage";
+ std::string connectSignal = "onStage";
// Initialise the signal delegate with the actor to connect to and it's signal.
SignalDelegate signalDelegate( connectActor, connectSignal );
// Check the signal delegate has made the connection.
DALI_TEST_CHECK( signalDelegate.IsConnected() );
- // Add the actor to the stage to trigger it's "on-stage" signal.
+ // Add the actor to the stage to trigger it's "onStage" signal.
// If the delegate connected correctly, this will call the () operator of our
// passed-in functor, the functor will in turn set a global flag.
Stage::GetCurrent().Add( connectActor );
// Set up an actor with a signal to connect to.
Actor connectActor = Actor::New();
- std::string connectSignal = "on-stage";
+ std::string connectSignal = "onStage";
// Initialise the signal delegate with the actor to connect to and it's signal.
SignalDelegate signalDelegate( connectActor, connectSignal );
const PropertyStringIndex PROPERTY_TABLE[] =
{
- { "parent-origin", Actor::Property::PARENT_ORIGIN, Property::VECTOR3 },
- { "parent-origin-x", Actor::Property::PARENT_ORIGIN_X, Property::FLOAT },
- { "parent-origin-y", Actor::Property::PARENT_ORIGIN_Y, Property::FLOAT },
- { "parent-origin-z", Actor::Property::PARENT_ORIGIN_Z, Property::FLOAT },
- { "anchor-point", Actor::Property::ANCHOR_POINT, Property::VECTOR3 },
- { "anchor-point-x", Actor::Property::ANCHOR_POINT_X, Property::FLOAT },
- { "anchor-point-y", Actor::Property::ANCHOR_POINT_Y, Property::FLOAT },
- { "anchor-point-z", Actor::Property::ANCHOR_POINT_Z, Property::FLOAT },
+ { "parentOrigin", Actor::Property::PARENT_ORIGIN, Property::VECTOR3 },
+ { "parentOriginX", Actor::Property::PARENT_ORIGIN_X, Property::FLOAT },
+ { "parentOriginY", Actor::Property::PARENT_ORIGIN_Y, Property::FLOAT },
+ { "parentOriginZ", Actor::Property::PARENT_ORIGIN_Z, Property::FLOAT },
+ { "anchorPoint", Actor::Property::ANCHOR_POINT, Property::VECTOR3 },
+ { "anchorPointX", Actor::Property::ANCHOR_POINT_X, Property::FLOAT },
+ { "anchorPointY", Actor::Property::ANCHOR_POINT_Y, Property::FLOAT },
+ { "anchorPointZ", Actor::Property::ANCHOR_POINT_Z, Property::FLOAT },
{ "size", Actor::Property::SIZE, Property::VECTOR3 },
- { "size-width", Actor::Property::SIZE_WIDTH, Property::FLOAT },
- { "size-height", Actor::Property::SIZE_HEIGHT, Property::FLOAT },
- { "size-depth", Actor::Property::SIZE_DEPTH, Property::FLOAT },
+ { "sizeWidth", Actor::Property::SIZE_WIDTH, Property::FLOAT },
+ { "sizeHeight", Actor::Property::SIZE_HEIGHT, Property::FLOAT },
+ { "sizeDepth", Actor::Property::SIZE_DEPTH, Property::FLOAT },
{ "position", Actor::Property::POSITION, Property::VECTOR3 },
- { "position-x", Actor::Property::POSITION_X, Property::FLOAT },
- { "position-y", Actor::Property::POSITION_Y, Property::FLOAT },
- { "position-z", Actor::Property::POSITION_Z, Property::FLOAT },
- { "world-position", Actor::Property::WORLD_POSITION, Property::VECTOR3 },
- { "world-position-x", Actor::Property::WORLD_POSITION_X, Property::FLOAT },
- { "world-position-y", Actor::Property::WORLD_POSITION_Y, Property::FLOAT },
- { "world-position-z", Actor::Property::WORLD_POSITION_Z, Property::FLOAT },
+ { "positionX", Actor::Property::POSITION_X, Property::FLOAT },
+ { "positionY", Actor::Property::POSITION_Y, Property::FLOAT },
+ { "positionZ", Actor::Property::POSITION_Z, Property::FLOAT },
+ { "worldPosition", Actor::Property::WORLD_POSITION, Property::VECTOR3 },
+ { "worldPositionX", Actor::Property::WORLD_POSITION_X, Property::FLOAT },
+ { "worldPositionY", Actor::Property::WORLD_POSITION_Y, Property::FLOAT },
+ { "worldPositionZ", Actor::Property::WORLD_POSITION_Z, Property::FLOAT },
{ "orientation", Actor::Property::ORIENTATION, Property::ROTATION },
- { "world-orientation", Actor::Property::WORLD_ORIENTATION, Property::ROTATION },
+ { "worldOrientation", Actor::Property::WORLD_ORIENTATION, Property::ROTATION },
{ "scale", Actor::Property::SCALE, Property::VECTOR3 },
- { "scale-x", Actor::Property::SCALE_X, Property::FLOAT },
- { "scale-y", Actor::Property::SCALE_Y, Property::FLOAT },
- { "scale-z", Actor::Property::SCALE_Z, Property::FLOAT },
- { "world-scale", Actor::Property::WORLD_SCALE, Property::VECTOR3 },
+ { "scaleX", Actor::Property::SCALE_X, Property::FLOAT },
+ { "scaleY", Actor::Property::SCALE_Y, Property::FLOAT },
+ { "scaleZ", Actor::Property::SCALE_Z, Property::FLOAT },
+ { "worldScale", Actor::Property::WORLD_SCALE, Property::VECTOR3 },
{ "visible", Actor::Property::VISIBLE, Property::BOOLEAN },
{ "color", Actor::Property::COLOR, Property::VECTOR4 },
- { "color-red", Actor::Property::COLOR_RED, Property::FLOAT },
- { "color-green", Actor::Property::COLOR_GREEN, Property::FLOAT },
- { "color-blue", Actor::Property::COLOR_BLUE, Property::FLOAT },
- { "color-alpha", Actor::Property::COLOR_ALPHA, Property::FLOAT },
- { "world-color", Actor::Property::WORLD_COLOR, Property::VECTOR4 },
- { "world-matrix", Actor::Property::WORLD_MATRIX, Property::MATRIX },
+ { "colorRed", Actor::Property::COLOR_RED, Property::FLOAT },
+ { "colorGreen", Actor::Property::COLOR_GREEN, Property::FLOAT },
+ { "colorBlue", Actor::Property::COLOR_BLUE, Property::FLOAT },
+ { "colorAlpha", Actor::Property::COLOR_ALPHA, Property::FLOAT },
+ { "worldColor", Actor::Property::WORLD_COLOR, Property::VECTOR4 },
+ { "worldMatrix", Actor::Property::WORLD_MATRIX, Property::MATRIX },
{ "name", Actor::Property::NAME, Property::STRING },
{ "sensitive", Actor::Property::SENSITIVE, Property::BOOLEAN },
- { "leave-required", Actor::Property::LEAVE_REQUIRED, Property::BOOLEAN },
- { "inherit-orientation", Actor::Property::INHERIT_ORIENTATION, Property::BOOLEAN },
- { "inherit-scale", Actor::Property::INHERIT_SCALE, Property::BOOLEAN },
- { "color-mode", Actor::Property::COLOR_MODE, Property::STRING },
- { "position-inheritance", Actor::Property::POSITION_INHERITANCE, Property::STRING },
- { "draw-mode", Actor::Property::DRAW_MODE, Property::STRING },
- { "size-mode-factor", Actor::Property::SIZE_MODE_FACTOR, Property::VECTOR3 },
- { "width-resize-policy", Actor::Property::WIDTH_RESIZE_POLICY, Property::STRING },
- { "height-resize-policy", Actor::Property::HEIGHT_RESIZE_POLICY, Property::STRING },
- { "size-scale-policy", Actor::Property::SIZE_SCALE_POLICY, Property::STRING },
- { "width-for-height", Actor::Property::WIDTH_FOR_HEIGHT, Property::BOOLEAN },
- { "height-for-width", Actor::Property::HEIGHT_FOR_WIDTH, Property::BOOLEAN },
+ { "leaveRequired", Actor::Property::LEAVE_REQUIRED, Property::BOOLEAN },
+ { "inheritOrientation", Actor::Property::INHERIT_ORIENTATION, Property::BOOLEAN },
+ { "inheritScale", Actor::Property::INHERIT_SCALE, Property::BOOLEAN },
+ { "colorMode", Actor::Property::COLOR_MODE, Property::STRING },
+ { "positionInheritance", Actor::Property::POSITION_INHERITANCE, Property::STRING },
+ { "drawMode", Actor::Property::DRAW_MODE, Property::STRING },
+ { "sizeModeFactor", Actor::Property::SIZE_MODE_FACTOR, Property::VECTOR3 },
+ { "widthResizePolicy", Actor::Property::WIDTH_RESIZE_POLICY, Property::STRING },
+ { "heightResizePolicy", Actor::Property::HEIGHT_RESIZE_POLICY, Property::STRING },
+ { "sizeScalePolicy", Actor::Property::SIZE_SCALE_POLICY, Property::STRING },
+ { "widthForHeight", Actor::Property::WIDTH_FOR_HEIGHT, Property::BOOLEAN },
+ { "heightForWidth", Actor::Property::HEIGHT_FOR_WIDTH, Property::BOOLEAN },
{ "padding", Actor::Property::PADDING, Property::VECTOR4 },
- { "minimum-size", Actor::Property::MINIMUM_SIZE, Property::VECTOR2 },
- { "maximum-size", Actor::Property::MAXIMUM_SIZE, Property::VECTOR2 },
+ { "minimumSize", Actor::Property::MINIMUM_SIZE, Property::VECTOR2 },
+ { "maximumSize", Actor::Property::MAXIMUM_SIZE, Property::VECTOR2 },
};
const unsigned int PROPERTY_TABLE_COUNT = sizeof( PROPERTY_TABLE ) / sizeof( PROPERTY_TABLE[0] );
} // unnamed namespace
// Register a float property
float startValue(0.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
Vector2 controlPoint0 = Vector2(0.25f,0.5f);
Vector2 controlPoint1 = Vector2(0.75f,0.5f);
- animation.AnimateTo(Property(actor, "test-property"), targetValue, AlphaFunction(controlPoint0,controlPoint1));
+ animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction(controlPoint0,controlPoint1));
// Start the animation
animation.Play();
// Register a boolean property
bool startValue(false);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
// Register a boolean property
bool startValue(false);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
// Register a boolean property
bool startValue(false);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
// Register a boolean property
bool startValue(false);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
// Register a float property
float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
// Register a float property
float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
// Register a float property
float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
// Register a float property
float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
// Register an integer property
int startValue(1);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
// Register an integer property
int startValue(1);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
// Register an integer property
int startValue(10);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
// Register an integer property
int startValue(10);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
// Register a Vector2 property
Vector2 startValue(10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
// Register a Vector2 property
Vector2 startValue(100.0f, 100.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
// Register a Vector2 property
Vector2 startValue(10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
// Register a Vector2 property
Vector2 startValue(5.0f, 5.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
// Register a Vector3 property
Vector3 startValue(10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
// Register a Vector3 property
Vector3 startValue(100.0f, 100.0f, 100.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
// Register a Vector3 property
Vector3 startValue(10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
// Register a Vector3 property
Vector3 startValue(5.0f, 5.0f, 5.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
// Register a Vector4 property
Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
// Register a Vector4 property
Vector4 startValue(100.0f, 100.0f, 100.0f, 100.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
// Register a Vector4 property
Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
// Register a Vector4 property
Vector4 startValue(5.0f, 5.0f, 5.0f, 5.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
// Register a boolean property
const bool startValue(false);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
// Register a boolean property
const bool startValue(false);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
const bool targetValue( !startValue );
- animation.AnimateTo(Property(actor, "test-property"), targetValue, AlphaFunction::EASE_OUT);
+ animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction::EASE_OUT);
// Start the animation
animation.Play();
// Register a boolean property
bool startValue(false);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
// Register a boolean property
bool startValue(false);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
// Register a float property
float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
Animation animation = Animation::New(durationSeconds);
float targetValue(50.0f);
float relativeValue(targetValue - startValue);
- animation.AnimateTo(Property(actor, "test-property"), targetValue);
+ animation.AnimateTo(Property(actor, "testProperty"), targetValue);
float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
// Register a float property
float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
// Register a float property
float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
// Register a float property
float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
// Register an integer property
int startValue(10);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
Animation animation = Animation::New(durationSeconds);
int targetValue(50);
int relativeValue(targetValue - startValue);
- animation.AnimateTo(Property(actor, "test-property"), targetValue);
+ animation.AnimateTo(Property(actor, "testProperty"), targetValue);
int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
// Register an integer property
int startValue(10);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
// Register an integer property
int startValue(10);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
// Register an integer property
int startValue(10);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
// Register a Vector2 property
Vector2 startValue(-50.0f, -50.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
// Register a Vector2 property
Vector2 startValue(1000.0f, 1000.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
Animation animation = Animation::New(durationSeconds);
Vector2 targetValue(9000.0f, 9000.0f);
Vector2 relativeValue(targetValue - startValue);
- animation.AnimateTo(Property(actor, "test-property"), targetValue, AlphaFunction::EASE_OUT);
+ animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction::EASE_OUT);
Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
// Register a Vector2 property
Vector2 startValue(10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
// Register a Vector2 property
Vector2 startValue(10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
// Register a Vector3 property
Vector3 startValue(-50.0f, -50.0f, -50.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
// Register a Vector3 property
Vector3 startValue(1000.0f, 1000.0f, 1000.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
// Register a Vector3 property
Vector3 startValue(10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
// Register a Vector3 property
Vector3 startValue(10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
Vector3 targetValue(30.0f, 30.0f, 30.0f);
Vector3 relativeValue(targetValue - startValue);
float delay = 0.5f;
- animation.AnimateTo(Property(actor, "test-property"),
+ animation.AnimateTo(Property(actor, "testProperty"),
targetValue,
AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Register a Vector3 property
Vector3 startValue(10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
Vector3 targetValue(30.0f, 30.0f, 10.0f);
Vector3 relativeValue(targetValue - startValue);
float delay = 0.5f;
- animation.AnimateTo(Property(actor, "test-property", 0),
+ animation.AnimateTo(Property(actor, "testProperty", 0),
30.0f,
AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Register a Vector4 property
Vector4 startValue(-50.0f, -40.0f, -30.0f, -20.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
// Register a Vector4 property
Vector4 startValue(1000.0f, 1000.0f, 1000.0f, 1000.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
// Register a Vector4 property
Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, VECTOR4_EPSILON, TEST_LOCATION );
// Register a Vector4 property
Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
animation.FinishedSignal().Connect( &application, finishCheck );
Vector3 startValue(1.0f, 1.0f, 1.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Constraint constraint = Constraint::New<Vector3>( actor, index, UpdateManagerTestConstraint( application ) );
constraint.Apply();
// Register a float property
float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "test-property", startValue );
+ Property::Index index = actor.RegisterProperty( "testProperty", startValue );
Stage::GetCurrent().Add(actor);
DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
Stage::GetCurrent().Add(actor);
int startValue(0u);
- Property::Index index = actor.RegisterProperty("an-index", startValue);
+ Property::Index index = actor.RegisterProperty("anIndex", startValue);
DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
// Build the animation
int defaultPropertyCount( actor.GetPropertyCount() );
// Register a dynamic property
- actor.RegisterProperty( "test-property", float(123.0f) );
+ actor.RegisterProperty( "testProperty", float(123.0f) );
DALI_TEST_CHECK( (defaultPropertyCount + 1u) == actor.GetPropertyCount() );
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( "parent-origin" == actor.GetPropertyName( Actor::Property::PARENT_ORIGIN ) );
+ DALI_TEST_CHECK( "parentOrigin" == actor.GetPropertyName( Actor::Property::PARENT_ORIGIN ) );
// Register a dynamic property
- std::string name("this-name-should-match");
+ std::string name("thisNameShouldMatch");
Property::Index index = actor.RegisterProperty( name, float(123.0f) );
DALI_TEST_CHECK( name == actor.GetPropertyName( index ) );
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( Actor::Property::PARENT_ORIGIN == actor.GetPropertyIndex("parent-origin") );
+ DALI_TEST_CHECK( Actor::Property::PARENT_ORIGIN == actor.GetPropertyIndex("parentOrigin") );
// Register a dynamic property
- std::string name("this-name-should-match");
+ std::string name("thisNameShouldMatch");
Property::Index index = actor.RegisterProperty( name, float(123.0f) );
DALI_TEST_CHECK( index == actor.GetPropertyIndex( name ) );
END_TEST;
DALI_TEST_CHECK( Property::VECTOR4 == actor.GetPropertyType( Actor::Property::COLOR ) );
// Register some dynamic properties
- Property::Index boolIndex = actor.RegisterProperty( "bool-property", bool(true) );
- Property::Index floatIndex = actor.RegisterProperty( "float-property", float(123.0f) );
- Property::Index intIndex = actor.RegisterProperty( "int-property", 123 );
- Property::Index vector2Index = actor.RegisterProperty( "vector2-property", Vector2(1.0f, 2.0f) );
- Property::Index vector3Index = actor.RegisterProperty( "vector3-property", Vector3(1.0f, 2.0f, 3.0f) );
- Property::Index vector4Index = actor.RegisterProperty( "vector4-property", Vector4(1.0f, 2.0f, 3.0f, 4.0f) );
- Property::Index rotationIndex = actor.RegisterProperty( "rotation-property", AngleAxis(Degree(180.0f), Vector3::YAXIS) );
+ Property::Index boolIndex = actor.RegisterProperty( "boolProperty", bool(true) );
+ Property::Index floatIndex = actor.RegisterProperty( "floatProperty", float(123.0f) );
+ Property::Index intIndex = actor.RegisterProperty( "intProperty", 123 );
+ Property::Index vector2Index = actor.RegisterProperty( "vector2Property", Vector2(1.0f, 2.0f) );
+ Property::Index vector3Index = actor.RegisterProperty( "vector3Property", Vector3(1.0f, 2.0f, 3.0f) );
+ Property::Index vector4Index = actor.RegisterProperty( "vector4Property", Vector4(1.0f, 2.0f, 3.0f, 4.0f) );
+ Property::Index rotationIndex = actor.RegisterProperty( "rotationProperty", AngleAxis(Degree(180.0f), Vector3::YAXIS) );
DALI_TEST_CHECK( Property::BOOLEAN == actor.GetPropertyType( boolIndex ) );
DALI_TEST_CHECK( Property::FLOAT == actor.GetPropertyType( floatIndex ) );
DALI_TEST_CHECK( Property::ROTATION == actor.GetPropertyType( rotationIndex ) );
// Non animatable properties
- Property::Index nonAnimStringIndex = actor.RegisterProperty( "man-from-delmonte", std::string("yes"), Property::READ_WRITE);
+ Property::Index nonAnimStringIndex = actor.RegisterProperty( "manFromDelmonte", std::string("yes"), Property::READ_WRITE);
Property::Index nonAnimV2Index = actor.RegisterProperty( "v2", Vector2(1.f, 2.f), Property::READ_WRITE);
Property::Index nonAnimV3Index = actor.RegisterProperty( "v3", Vector3(1.f, 2.f, 3.f), Property::READ_WRITE);
Property::Index nonAnimV4Index = actor.RegisterProperty( "v4", Vector4(1.f, 2.f, 3.f, 4.f), Property::READ_WRITE);
Actor actor = Actor::New();
- Property::Index nonAnimStringIndex = actor.RegisterProperty( "man-from-delmonte", std::string("no"), Property::READ_WRITE);
+ Property::Index nonAnimStringIndex = actor.RegisterProperty( "manFromDelmonte", std::string("no"), Property::READ_WRITE);
//// modify writable?
try
try
{
Actor actor = Actor::New();
- actor.RegisterProperty( "man-from-delmonte", properties[i].value );
+ actor.RegisterProperty( "manFromDelmonte", properties[i].value );
}
catch (Dali::DaliException& e)
{
Handle handle = Handle::New();
float startValue(1.0f);
- Property::Index index = handle.RegisterProperty( "test-property", startValue );
+ Property::Index index = handle.RegisterProperty( "testProperty", startValue );
DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
application.SendNotification();
TestApplication application;
tet_infoline("Negative test for Dali::ImageActor::New()");
- Image image = ResourceImage::New("hopefully-this-image-file-does-not-exist");
+ Image image = ResourceImage::New("hopefullyThisImageFileDoesNotExist");
ImageActor actor = ImageActor::New(image);
DALI_TEST_CHECK(actor);
// Invalid Key
try
{
- constMap[ "invalid-key" ];
+ constMap[ "invalidKey" ];
tet_result( TET_FAIL );
}
catch ( DaliException& e )
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<int>() == 2 );
- value = map.Find( "invalid-key" );
+ value = map.Find( "invalidKey" );
DALI_TEST_CHECK( !value );
END_TEST;
programMap->Insert("vertex", vertexShader);
programMap->Insert("fragment", fragmentShader);
- programMap->Insert("vertex-prefix", vertexShaderPrefix);
- programMap->Insert("fragment-prefix", fragmentShaderPrefix);
+ programMap->Insert("vertexPrefix", vertexShaderPrefix);
+ programMap->Insert("fragmentPrefix", fragmentShaderPrefix);
effect.SetProperty(effect.GetPropertyIndex("program"), programValue);
DALI_TEST_CHECK( effect );
// dont set unknown
- effect.SetProperty( effect.GetPropertyIndex("geometry-hints"), "HINT_2" );
+ effect.SetProperty( effect.GetPropertyIndex("geometryHints"), "HINT_2" );
tet_result( TET_FAIL );
}
}
TypeRegistration namedActorType( "MyNamedActor", typeid(Dali::Actor), CreateNamedActorType );
-PropertyRegistration namedActorPropertyOne( namedActorType, "prop-name", PROPERTY_REGISTRATION_START_INDEX, Property::BOOLEAN, &SetProperty, &GetProperty );
+PropertyRegistration namedActorPropertyOne( namedActorType, "propName", PROPERTY_REGISTRATION_START_INDEX, Property::BOOLEAN, &SetProperty, &GetProperty );
} // Anonymous namespace
DALI_TEST_CHECK( handle );
Property::Map attributes;
- DALI_TEST_CHECK( !handle.DoAction( "unknown-action", attributes ) );
+ DALI_TEST_CHECK( !handle.DoAction( "unknownAction", attributes ) );
END_TEST;
}
DALI_TEST_CHECK( customActor );
unsigned int initialPropertyCount( customActor.GetPropertyCount() );
- std::string propertyName( "prop-1" );
+ std::string propertyName( "prop1" );
int propertyIndex( PROPERTY_REGISTRATION_START_INDEX );
Property::Type propertyType( Property::BOOLEAN );
PropertyRegistration property1( customType1, propertyName, propertyIndex, propertyType, &SetProperty, &GetProperty );
DALI_TEST_EQUALS( initialPropertyCount + 1u, postRegistrationPropertyCount, TEST_LOCATION );
// Add custom property and check property count
- customActor.RegisterProperty( "custom-prop-1", true );
+ customActor.RegisterProperty( "customProp1", true );
unsigned int customPropertyCount( customActor.GetPropertyCount() );
DALI_TEST_EQUALS( postRegistrationPropertyCount + 1u, customPropertyCount, TEST_LOCATION );
// Attempt to register a property type out-of-bounds index (less than)
try
{
- PropertyRegistration property1( customType1, "prop-name", PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN, &SetProperty, &GetProperty );
+ PropertyRegistration property1( customType1, "propName", PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN, &SetProperty, &GetProperty );
tet_result( TET_FAIL );
}
catch ( DaliException& e )
// Attempt to register a property type out-of-bounds index (greater than)
try
{
- PropertyRegistration property1( customType1, "prop-name", PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN, &SetProperty, &GetProperty );
+ PropertyRegistration property1( customType1, "propName", PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN, &SetProperty, &GetProperty );
tet_result( TET_FAIL );
}
catch ( DaliException& e )
unsigned int customPropertyCount( customActor.GetPropertyCount() );
// Register animatable property
- std::string animatablePropertyName( "animatable-prop-1" );
+ std::string animatablePropertyName( "animatableProp1" );
int animatablePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
Property::Type animatablePropertyType( Property::FLOAT );
AnimatablePropertyRegistration animatableProperty1( customType1, animatablePropertyName, animatablePropertyIndex, animatablePropertyType );
// Attempt to register an animatable property type out-of-bounds index (less than)
try
{
- AnimatablePropertyRegistration property1( customType1, "anim-prop-name", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN );
+ AnimatablePropertyRegistration property1( customType1, "animPropName", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN );
tet_result( TET_FAIL );
}
catch ( DaliException& e )
// Attempt to register an animatable property type out-of-bounds index (greater than)
try
{
- AnimatablePropertyRegistration property1( customType1, "anim-prop-name", ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN );
+ AnimatablePropertyRegistration property1( customType1, "animPropName", ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN );
tet_result( TET_FAIL );
}
catch ( DaliException& e )
unsigned int customPropertyCount( customActor.GetPropertyCount() );
// Register animatable property
- std::string animatablePropertyName( "animatable-prop-1" );
+ std::string animatablePropertyName( "animatableProp1" );
int animatablePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
Property::Type animatablePropertyType( Property::VECTOR2 );
AnimatablePropertyRegistration animatableProperty1( customType1, animatablePropertyName, animatablePropertyIndex, animatablePropertyType );
DALI_TEST_EQUALS( indices.Size(), 1u, TEST_LOCATION );
// Register animatable property components
- std::string animatablePropertyComponentName1( "animatable-prop-1-x" );
+ std::string animatablePropertyComponentName1( "animatableProp1X" );
int animatablePropertyComponentIndex1( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1 );
AnimatablePropertyComponentRegistration animatablePropertyComponent1( customType1, animatablePropertyComponentName1, animatablePropertyComponentIndex1, animatablePropertyIndex, 0 );
- std::string animatablePropertyComponentName2( "animatable-prop-1-y" );
+ std::string animatablePropertyComponentName2( "animatableProp1Y" );
int animatablePropertyComponentIndex2( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2 );
AnimatablePropertyComponentRegistration animatablePropertyComponent2( customType1, animatablePropertyComponentName2, animatablePropertyComponentIndex2, animatablePropertyIndex, 1 );
// Register animatable property with the type of Vector2
int animatablePropertyIndex1( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
- AnimatablePropertyRegistration animatableProperty1( customType1, "animatable-prop-1", animatablePropertyIndex1, Property::VECTOR2 );
+ AnimatablePropertyRegistration animatableProperty1( customType1, "animatableProp1", animatablePropertyIndex1, Property::VECTOR2 );
// Attempt to register an animatable property component out-of-bounds index (less than)
try
{
- AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatable-prop-1-x", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, animatablePropertyIndex1, 0 );
+ AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, animatablePropertyIndex1, 0 );
tet_result( TET_FAIL );
}
catch ( DaliException& e )
// Attempt to register an animatable property component out-of-bounds index (greater than)
try
{
- AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatable-prop-1-x", ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, animatablePropertyIndex1, 0 );
+ AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X", ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, animatablePropertyIndex1, 0 );
tet_result( TET_FAIL );
}
catch ( DaliException& e )
}
// Register an animatable property component
- AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatable-prop-1-x", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1, animatablePropertyIndex1, 0 );
+ AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1, animatablePropertyIndex1, 0 );
// Attempt to register another animatable property component with the same component index
try
{
- AnimatablePropertyComponentRegistration propertyComponent2( customType1, "animatable-prop-1-y", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2, animatablePropertyIndex1, 0 );
+ AnimatablePropertyComponentRegistration propertyComponent2( customType1, "animatableProp1Y", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2, animatablePropertyIndex1, 0 );
tet_result( TET_FAIL );
}
catch ( DaliException& e )
// Register animatable property with the type of boolean
int animatablePropertyIndex2( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2 );
- AnimatablePropertyRegistration animatableProperty2( customType1, "animatable-prop-2", animatablePropertyIndex2, Property::BOOLEAN );
+ AnimatablePropertyRegistration animatableProperty2( customType1, "animatableProp2", animatablePropertyIndex2, Property::BOOLEAN );
// Attempt to register an animatable property component for the above property with boolean type
try
{
- AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatable-prop-2-x", animatablePropertyIndex2 + 1, animatablePropertyIndex2, 0 );
+ AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp2X", animatablePropertyIndex2 + 1, animatablePropertyIndex2, 0 );
tet_result( TET_FAIL );
}
catch ( DaliException& e )
application.Render(0);
DALI_TEST_CHECK(a.IsVisible());
- DALI_TEST_CHECK(!hdl.DoAction("unknown-action", attributes));
+ DALI_TEST_CHECK(!hdl.DoAction("unknownAction", attributes));
END_TEST;
}
// Attempt to register a property without a setter
try
{
- PropertyRegistration property1( customType1, "prop-name", propertyIndex++, Property::BOOLEAN, NULL, &GetProperty );
+ PropertyRegistration property1( customType1, "propName", propertyIndex++, Property::BOOLEAN, NULL, &GetProperty );
tet_result( TET_PASS );
}
catch ( DaliException& e )
// Attempt to register a property without a getter
try
{
- PropertyRegistration property1( customType1, "prop-name", propertyIndex++, Property::BOOLEAN, NULL, NULL );
+ PropertyRegistration property1( customType1, "propName", propertyIndex++, Property::BOOLEAN, NULL, NULL );
tet_result( TET_FAIL );
}
catch ( DaliException& e )
int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 100;
// Add one property with a valid property index
- PropertyRegistration property1( customType1, "prop-name", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
+ PropertyRegistration property1( customType1, "propName", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
// Attempt to add another property with the same index
try
{
- PropertyRegistration property2( customType1, "prop-name-2", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
+ PropertyRegistration property2( customType1, "propName2", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
}
catch ( DaliException& e )
{
int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 100;
// Add one property with a valid property index
- AnimatablePropertyRegistration property3( customType1, "anim-prop-name", animatablePropertyIndex, Property::BOOLEAN );
+ AnimatablePropertyRegistration property3( customType1, "animPropName", animatablePropertyIndex, Property::BOOLEAN );
// Attempt to add another property with the same index
try
{
- AnimatablePropertyRegistration property4( customType1, "anim-prop-name-2", animatablePropertyIndex, Property::BOOLEAN );
+ AnimatablePropertyRegistration property4( customType1, "animPropName2", animatablePropertyIndex, Property::BOOLEAN );
}
catch ( DaliException& e )
{
int propertyIndex2 = PROPERTY_REGISTRATION_START_INDEX + 201;
// Add two properties, one with SetProperty, one without
- PropertyRegistration property1( customType1, "prop-name-readwrite", propertyIndex1, Property::BOOLEAN, &SetProperty, &GetProperty );
- PropertyRegistration property2( customType1, "prop-name-readonly", propertyIndex2, Property::BOOLEAN, NULL, &GetProperty );
+ PropertyRegistration property1( customType1, "propNameReadwrite", propertyIndex1, Property::BOOLEAN, &SetProperty, &GetProperty );
+ PropertyRegistration property2( customType1, "propNameReadonly", propertyIndex2, Property::BOOLEAN, NULL, &GetProperty );
// Create custom-actor
TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 400;
// These properties are not animatable
- PropertyRegistration property1( customType1, "prop-name", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
+ PropertyRegistration property1( customType1, "propName", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
// These properties are animatable
- AnimatablePropertyRegistration property2( customType1, "anim-prop-name", animatablePropertyIndex, Property::BOOLEAN );
+ AnimatablePropertyRegistration property2( customType1, "animPropName", animatablePropertyIndex, Property::BOOLEAN );
// Create custom-actor
TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, "long-press-detected", functor );
+ handle.ConnectSignal( &application, "longPressDetected", functor );
// Render and notify
application.SendNotification();
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, "pan-detected", functor );
+ handle.ConnectSignal( &application, "panDetected", functor );
// Render and notify
application.SendNotification();
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, "pinch-detected", functor );
+ handle.ConnectSignal( &application, "pinchDetected", functor );
// Render and notify
application.SendNotification();
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, "tap-detected", functor );
+ handle.ConnectSignal( &application, "tapDetected", functor );
// Render and notify
application.SendNotification();
{
FORWARD = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "forward" type Vector3
POINTS, ///< name "points" type Array of Vector3
- CONTROL_POINTS ///< name "control-points" type Array of Vector3
+ CONTROL_POINTS ///< name "controlPoints" type Array of Vector3
};
};
{
enum
{
- GEOMETRY_TYPE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "geometry-type", type STRING
- REQUIRES_DEPTH_TEST, ///< name "requires-depth-testing", type BOOLEAN
+ GEOMETRY_TYPE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "geometryType", type STRING
+ REQUIRES_DEPTH_TEST, ///< name "requiresDepthTesting", type BOOLEAN
};
};
{
enum
{
- FACE_CULLING_MODE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "face-culling-mode", type INTEGER
- BLENDING_MODE, ///< name "blending-mode", type INTEGER
- BLEND_EQUATION_RGB, ///< name "blend-equation-rgb", type INTEGER
- BLEND_EQUATION_ALPHA, ///< name "blend-equation-alpha", type INTEGER
- BLENDING_SRC_FACTOR_RGB, ///< name "source-blend-factor-rgb", type INTEGER
- BLENDING_DEST_FACTOR_RGB, ///< name "destination-blend-factor-rgb", type INTEGER
- BLENDING_SRC_FACTOR_ALPHA, ///< name "source-blend-factor-alpha", type INTEGER
- BLENDING_DEST_FACTOR_ALPHA, ///< name "destination-blend-factor-alpha", type INTEGER
- BLEND_COLOR, ///< name "blend-color", type VECTOR4
+ FACE_CULLING_MODE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "faceCullingMode", type INTEGER
+ BLENDING_MODE, ///< name "blendingMode", type INTEGER
+ BLEND_EQUATION_RGB, ///< name "blendEquationRgb", type INTEGER
+ BLEND_EQUATION_ALPHA, ///< name "blendEquationAlpha", type INTEGER
+ BLENDING_SRC_FACTOR_RGB, ///< name "sourceBlendFactorRgb", type INTEGER
+ BLENDING_DEST_FACTOR_RGB, ///< name "destinationBlendFactorRgb", type INTEGER
+ BLENDING_SRC_FACTOR_ALPHA, ///< name "sourceBlendFactorAlpha", type INTEGER
+ BLENDING_DEST_FACTOR_ALPHA, ///< name "destinationBlendFactorAlpha", type INTEGER
+ BLEND_COLOR, ///< name "blendColor", type VECTOR4
};
};
{
enum
{
- DEPTH_INDEX = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "depth-index", type INTEGER
+ DEPTH_INDEX = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "depthIndex", type INTEGER
};
};
{
enum
{
- PROGRAM = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "program", type MAP; {"vertex-prefix":"","fragment-prefix":"","vertex":"","fragment":""}
- SHADER_HINTS, ///< name "shader-hints", type INTEGER; (bitfield) values from enum Shader::Hints
+ PROGRAM = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "program", type MAP; {"vertexPrefix":"","fragmentPrefix":"","vertex":"","fragment":""}
+ SHADER_HINTS, ///< name "shaderHints", type INTEGER; (bitfield) values from enum Shader::Hints
};
};
}
}
- value = map->Find( "load-policy" );
+ value = map->Find( "loadPolicy" );
if( value )
{
std::string policy;
GetEnumeration< ResourceImage::LoadPolicy >( policy.c_str(), IMAGE_LOAD_POLICY_TABLE, IMAGE_LOAD_POLICY_TABLE_COUNT, loadPolicy );
}
- value = map->Find( "release-policy" );
+ value = map->Find( "releasePolicy" );
if( value )
{
std::string policy;
attributes.SetSize( width, height );
Pixel::Format pixelFormat = Pixel::RGBA8888;
- value = map->Find( "pixel-format" );
+ value = map->Find( "pixelFormat" );
if( value )
{
std::string format;
GetEnumeration< Pixel::Format >( format.c_str(), PIXEL_FORMAT_TABLE, PIXEL_FORMAT_TABLE_COUNT, pixelFormat );
}
- value = map->Find( "fitting-mode" );
+ value = map->Find( "fittingMode" );
if( value )
{
std::string fitting;
}
}
- value = map->Find( "sampling-mode" );
+ value = map->Find( "samplingMode" );
if( value )
{
std::string sampling;
actor.Add( NewActor( actorArray[i].Get< Property::Map >() ) );
}
}
- else if( key == "parent-origin" )
+ else if( key == "parentOrigin" )
{
// Parent Origin can be a string constant as well as a Vector3
actor.SetParentOrigin( GetAnchorConstant( value.Get< std::string >() ) );
}
}
- else if( key == "anchor-point" )
+ else if( key == "anchorPoint" )
{
// Anchor Point can be a string constant as well as a Vector3
if ( bufferImage )
{
imageType = "BufferImage";
- map[ "pixel-format" ] = GetEnumerationName< Pixel::Format >( bufferImage.GetPixelFormat(), PIXEL_FORMAT_TABLE, PIXEL_FORMAT_TABLE_COUNT );
+ map[ "pixelFormat" ] = GetEnumerationName< Pixel::Format >( bufferImage.GetPixelFormat(), PIXEL_FORMAT_TABLE, PIXEL_FORMAT_TABLE_COUNT );
}
else if ( FrameBufferImage::DownCast( image ) )
{
}
map[ "type" ] = imageType;
- map[ "release-policy" ] = GetEnumerationName< Image::ReleasePolicy >( image.GetReleasePolicy(), IMAGE_RELEASE_POLICY_TABLE, IMAGE_RELEASE_POLICY_TABLE_COUNT );
+ 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[ "load-policy" ] = GetEnumerationName< ResourceImage::LoadPolicy >( resourceImage.GetLoadPolicy(), IMAGE_LOAD_POLICY_TABLE, IMAGE_LOAD_POLICY_TABLE_COUNT );
+ map[ "loadPolicy" ] = GetEnumerationName< ResourceImage::LoadPolicy >( resourceImage.GetLoadPolicy(), IMAGE_LOAD_POLICY_TABLE, IMAGE_LOAD_POLICY_TABLE_COUNT );
}
int width( image.GetWidth() );
{
element->value = value;
}
- else if( key == "alpha-function" )
+ else if( key == "alphaFunction" )
{
std::string alphaFunctionValue = value.Get< std::string >();
element->alphaFunction = AlphaFunction::EASE_OUT_BACK;
}
}
- else if( key == "time-period" )
+ else if( key == "timePeriod" )
{
Property::Array timeArray = value.Get< Property::Array >();
*
* @param[in] property The property value map with the following valid fields:
* @code
- * "filename": type std::string
- * "load-policy" type std::string (enum)
- * "release-policy" type std::string (enum)
- * "width" type float
- * "height" type float
- * "pixel-format" type std::string (enum)
- * "fitting-mode" type std::string (enum)
- * "sampling-mode" type std::string (enum)
- * "orientation" type bool
- * "type" type std::string (FrameBufferImage|BufferImage|ResourceImage(default))
+ * "filename": type std::string
+ * "loadPolicy" type std::string (enum)
+ * "releasePolicy" type std::string (enum)
+ * "width" type float
+ * "height" type float
+ * "pixelFormat" type std::string (enum)
+ * "fittingMode" type std::string (enum)
+ * "samplingMode" type std::string (enum)
+ * "orientation" type bool
+ * "type" type std::string (FrameBufferImage|BufferImage|ResourceImage(default))
* @endcode
* Some fields are optional and some only pertain to a specific type.
*
* // some fields may be ignored depending on the geometry-type
* "program": type Map
* {
- * "vertex": type std::string
- * "fragment": type std::string
- * "vertex-prefix": type std::string
- * "fragment-prefix": type std::string
- * "text-vertex": type std::string
- * "text-fragment": type std::string
- * "vertex-filename": type std::string
- * "fragment-filename": type std::string
- * "vertex-prefix-filename": type std::string
- * "fragment-prefix-filename": type std::string
- * "text-vertex-filename": type std::string
- * "text-fragment-filename": type std::string
- * "geometry-type": type std::string (enum)
- * "geometry-hints": type std::string (enum)
+ * "vertex": type std::string
+ * "fragment": type std::string
+ * "vertexPrefix": type std::string
+ * "fragmentPrefix": type std::string
+ * "textVertex": type std::string
+ * "textFragment": type std::string
+ * "vertexFilename": type std::string
+ * "fragmentFilename": type std::string
+ * "vertexPrefixFilename": type std::string
+ * "fragmentPrefixFilename": type std::string
+ * "textVertexFilename": type std::string
+ * "textFragmentFilename": type std::string
+ * "geometryType": type std::string (enum)
+ * "geometryHints": type std::string (enum)
* }
* // uniforms must be specified to be registered
* "uUniform1": type float,
* Name Type writable animatable constraint-input enum for index-checking
*/
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "parent-origin", VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN )
-DALI_PROPERTY( "parent-origin-x", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X )
-DALI_PROPERTY( "parent-origin-y", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y )
-DALI_PROPERTY( "parent-origin-z", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z )
-DALI_PROPERTY( "anchor-point", VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT )
-DALI_PROPERTY( "anchor-point-x", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X )
-DALI_PROPERTY( "anchor-point-y", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y )
-DALI_PROPERTY( "anchor-point-z", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z )
+DALI_PROPERTY( "parentOrigin", VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN )
+DALI_PROPERTY( "parentOriginX", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X )
+DALI_PROPERTY( "parentOriginY", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y )
+DALI_PROPERTY( "parentOriginZ", FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z )
+DALI_PROPERTY( "anchorPoint", VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT )
+DALI_PROPERTY( "anchorPointX", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X )
+DALI_PROPERTY( "anchorPointY", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y )
+DALI_PROPERTY( "anchorPointZ", FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z )
DALI_PROPERTY( "size", VECTOR3, true, true, true, Dali::Actor::Property::SIZE )
-DALI_PROPERTY( "size-width", FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH )
-DALI_PROPERTY( "size-height", FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT )
-DALI_PROPERTY( "size-depth", FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH )
+DALI_PROPERTY( "sizeWidth", FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH )
+DALI_PROPERTY( "sizeHeight", FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT )
+DALI_PROPERTY( "sizeDepth", FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH )
DALI_PROPERTY( "position", VECTOR3, true, true, true, Dali::Actor::Property::POSITION )
-DALI_PROPERTY( "position-x", FLOAT, true, true, true, Dali::Actor::Property::POSITION_X )
-DALI_PROPERTY( "position-y", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y )
-DALI_PROPERTY( "position-z", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z )
-DALI_PROPERTY( "world-position", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION )
-DALI_PROPERTY( "world-position-x", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X )
-DALI_PROPERTY( "world-position-y", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y )
-DALI_PROPERTY( "world-position-z", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z )
+DALI_PROPERTY( "positionX", FLOAT, true, true, true, Dali::Actor::Property::POSITION_X )
+DALI_PROPERTY( "positionY", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y )
+DALI_PROPERTY( "positionZ", FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z )
+DALI_PROPERTY( "worldPosition", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION )
+DALI_PROPERTY( "worldPositionX", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X )
+DALI_PROPERTY( "worldPositionY", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y )
+DALI_PROPERTY( "worldPositionZ", FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z )
DALI_PROPERTY( "orientation", ROTATION, true, true, true, Dali::Actor::Property::ORIENTATION )
-DALI_PROPERTY( "world-orientation", ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION )
+DALI_PROPERTY( "worldOrientation", ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION )
DALI_PROPERTY( "scale", VECTOR3, true, true, true, Dali::Actor::Property::SCALE )
-DALI_PROPERTY( "scale-x", FLOAT, true, true, true, Dali::Actor::Property::SCALE_X )
-DALI_PROPERTY( "scale-y", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y )
-DALI_PROPERTY( "scale-z", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z )
-DALI_PROPERTY( "world-scale", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_SCALE )
+DALI_PROPERTY( "scaleX", FLOAT, true, true, true, Dali::Actor::Property::SCALE_X )
+DALI_PROPERTY( "scaleY", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y )
+DALI_PROPERTY( "scaleZ", FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z )
+DALI_PROPERTY( "worldScale", VECTOR3, false, false, true, Dali::Actor::Property::WORLD_SCALE )
DALI_PROPERTY( "visible", BOOLEAN, true, true, true, Dali::Actor::Property::VISIBLE )
DALI_PROPERTY( "color", VECTOR4, true, true, true, Dali::Actor::Property::COLOR )
-DALI_PROPERTY( "color-red", FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED )
-DALI_PROPERTY( "color-green", FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN )
-DALI_PROPERTY( "color-blue", FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE )
-DALI_PROPERTY( "color-alpha", FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA )
-DALI_PROPERTY( "world-color", VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR )
-DALI_PROPERTY( "world-matrix", MATRIX, false, false, true, Dali::Actor::Property::WORLD_MATRIX )
+DALI_PROPERTY( "colorRed", FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED )
+DALI_PROPERTY( "colorGreen", FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN )
+DALI_PROPERTY( "colorBlue", FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE )
+DALI_PROPERTY( "colorAlpha", FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA )
+DALI_PROPERTY( "worldColor", VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR )
+DALI_PROPERTY( "worldMatrix", MATRIX, false, false, true, Dali::Actor::Property::WORLD_MATRIX )
DALI_PROPERTY( "name", STRING, true, false, false, Dali::Actor::Property::NAME )
DALI_PROPERTY( "sensitive", BOOLEAN, true, false, false, Dali::Actor::Property::SENSITIVE )
-DALI_PROPERTY( "leave-required", BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED )
-DALI_PROPERTY( "inherit-orientation",BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION )
-DALI_PROPERTY( "inherit-scale", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE )
-DALI_PROPERTY( "color-mode", STRING, true, false, false, Dali::Actor::Property::COLOR_MODE )
-DALI_PROPERTY( "position-inheritance",STRING, true, false, false, Dali::Actor::Property::POSITION_INHERITANCE )
-DALI_PROPERTY( "draw-mode", STRING, true, false, false, Dali::Actor::Property::DRAW_MODE )
-DALI_PROPERTY( "size-mode-factor", VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR )
-DALI_PROPERTY( "width-resize-policy",STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY )
-DALI_PROPERTY( "height-resize-policy",STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY )
-DALI_PROPERTY( "size-scale-policy", STRING, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY )
-DALI_PROPERTY( "width-for-height", BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT )
-DALI_PROPERTY( "height-for-width", BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH )
+DALI_PROPERTY( "leaveRequired", BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED )
+DALI_PROPERTY( "inheritOrientation", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION )
+DALI_PROPERTY( "inheritScale", BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE )
+DALI_PROPERTY( "colorMode", STRING, true, false, false, Dali::Actor::Property::COLOR_MODE )
+DALI_PROPERTY( "positionInheritance", STRING, true, false, false, Dali::Actor::Property::POSITION_INHERITANCE )
+DALI_PROPERTY( "drawMode", STRING, true, false, false, Dali::Actor::Property::DRAW_MODE )
+DALI_PROPERTY( "sizeModeFactor", VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR )
+DALI_PROPERTY( "widthResizePolicy", STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY )
+DALI_PROPERTY( "heightResizePolicy", STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY )
+DALI_PROPERTY( "sizeScalePolicy", STRING, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY )
+DALI_PROPERTY( "widthForHeight", BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT )
+DALI_PROPERTY( "heightForWidth", BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH )
DALI_PROPERTY( "padding", VECTOR4, true, false, false, Dali::Actor::Property::PADDING )
-DALI_PROPERTY( "minimum-size", VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE )
-DALI_PROPERTY( "maximum-size", VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE )
+DALI_PROPERTY( "minimumSize", VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE )
+DALI_PROPERTY( "maximumSize", VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE )
DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
// Signals
const char* const SIGNAL_TOUCHED = "touched";
const char* const SIGNAL_HOVERED = "hovered";
-const char* const SIGNAL_WHEEL_EVENT = "wheel-event";
-const char* const SIGNAL_ON_STAGE = "on-stage";
-const char* const SIGNAL_OFF_STAGE = "off-stage";
+const char* const SIGNAL_WHEEL_EVENT = "wheelEvent";
+const char* const SIGNAL_ON_STAGE = "onStage";
+const char* const SIGNAL_OFF_STAGE = "offStage";
// Actions
*/
DALI_PROPERTY_TABLE_BEGIN
DALI_PROPERTY( "type", STRING, true, false, true, Dali::CameraActor::Property::TYPE )
-DALI_PROPERTY( "projection-mode", STRING, true, false, true, Dali::CameraActor::Property::PROJECTION_MODE )
-DALI_PROPERTY( "field-of-view", FLOAT, true, false, true, Dali::CameraActor::Property::FIELD_OF_VIEW )
-DALI_PROPERTY( "aspect-ratio", FLOAT, true, false, true, Dali::CameraActor::Property::ASPECT_RATIO )
-DALI_PROPERTY( "near-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::NEAR_PLANE_DISTANCE )
-DALI_PROPERTY( "far-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::FAR_PLANE_DISTANCE )
-DALI_PROPERTY( "left-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::LEFT_PLANE_DISTANCE )
-DALI_PROPERTY( "right-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE )
-DALI_PROPERTY( "top-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::TOP_PLANE_DISTANCE )
-DALI_PROPERTY( "bottom-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE )
-DALI_PROPERTY( "target-position", VECTOR3, true, false, true, Dali::CameraActor::Property::TARGET_POSITION )
-DALI_PROPERTY( "projection-matrix", MATRIX, false, false, true, Dali::CameraActor::Property::PROJECTION_MATRIX )
-DALI_PROPERTY( "view-matrix", MATRIX, false, false, true, Dali::CameraActor::Property::VIEW_MATRIX )
-DALI_PROPERTY( "invert-y-axis", BOOLEAN, true, false, true, Dali::CameraActor::Property::INVERT_Y_AXIS )
+DALI_PROPERTY( "projectionMode", STRING, true, false, true, Dali::CameraActor::Property::PROJECTION_MODE )
+DALI_PROPERTY( "fieldOfView", FLOAT, true, false, true, Dali::CameraActor::Property::FIELD_OF_VIEW )
+DALI_PROPERTY( "aspectRatio", FLOAT, true, false, true, Dali::CameraActor::Property::ASPECT_RATIO )
+DALI_PROPERTY( "nearPlaneDistance", FLOAT, true, false, true, Dali::CameraActor::Property::NEAR_PLANE_DISTANCE )
+DALI_PROPERTY( "farPlaneDistance", FLOAT, true, false, true, Dali::CameraActor::Property::FAR_PLANE_DISTANCE )
+DALI_PROPERTY( "leftPlaneDistance", FLOAT, true, false, true, Dali::CameraActor::Property::LEFT_PLANE_DISTANCE )
+DALI_PROPERTY( "rightPlaneDistance", FLOAT, true, false, true, Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE )
+DALI_PROPERTY( "topPlaneDistance", FLOAT, true, false, true, Dali::CameraActor::Property::TOP_PLANE_DISTANCE )
+DALI_PROPERTY( "bottomPlaneDistance", FLOAT, true, false, true, Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE )
+DALI_PROPERTY( "targetPosition", VECTOR3, true, false, true, Dali::CameraActor::Property::TARGET_POSITION )
+DALI_PROPERTY( "projectionMatrix", MATRIX, false, false, true, Dali::CameraActor::Property::PROJECTION_MATRIX )
+DALI_PROPERTY( "viewMatrix", MATRIX, false, false, true, Dali::CameraActor::Property::VIEW_MATRIX )
+DALI_PROPERTY( "invertYAxis", BOOLEAN, true, false, true, Dali::CameraActor::Property::INVERT_Y_AXIS )
DALI_PROPERTY_TABLE_END( DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX )
// calculate the far plane distance for a 16bit depth buffer with 4 bits per unit precision
// Name Type writable animatable constraint-input enum for index-checking
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "pixel-area", RECTANGLE, true, false, true, Dali::ImageActor::Property::PIXEL_AREA )
+DALI_PROPERTY( "pixelArea", RECTANGLE, true, false, true, Dali::ImageActor::Property::PIXEL_AREA )
DALI_PROPERTY( "style", STRING, true, false, true, Dali::ImageActor::Property::STYLE )
DALI_PROPERTY( "border", VECTOR4, true, false, true, Dali::ImageActor::Property::BORDER )
DALI_PROPERTY( "image", MAP, true, false, false, Dali::ImageActor::Property::IMAGE )
// Name Type writable animatable constraint-input enum for index-checking
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "clipping-enable", BOOLEAN, true, false, true, Dali::Layer::Property::CLIPPING_ENABLE )
-DALI_PROPERTY( "clipping-box", RECTANGLE, true, false, true, Dali::Layer::Property::CLIPPING_BOX )
+DALI_PROPERTY( "clippingEnable", BOOLEAN, true, false, true, Dali::Layer::Property::CLIPPING_ENABLE )
+DALI_PROPERTY( "clippingBox", RECTANGLE, true, false, true, Dali::Layer::Property::CLIPPING_BOX )
DALI_PROPERTY( "behavior", STRING, true, false, false, Dali::Layer::Property::BEHAVIOR )
DALI_PROPERTY_TABLE_END( DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX )
const char* const ACTION_RAISE = "raise";
const char* const ACTION_LOWER = "lower";
-const char* const ACTION_RAISE_TO_TOP = "raise-to-top";
-const char* const ACTION_LOWER_TO_BOTTOM = "lower-to-bottom";
+const char* const ACTION_RAISE_TO_TOP = "raiseToTop";
+const char* const ACTION_LOWER_TO_BOTTOM = "lowerToBottom";
BaseHandle Create()
{
DALI_PROPERTY_TABLE_BEGIN
DALI_PROPERTY( "forward", VECTOR3, true, false, false, Dali::PathConstrainer::Property::FORWARD )
DALI_PROPERTY( "points", ARRAY, true, false, false, Dali::PathConstrainer::Property::POINTS )
-DALI_PROPERTY( "control-points", ARRAY, true, false, false, Dali::PathConstrainer::Property::CONTROL_POINTS )
+DALI_PROPERTY( "controlPoints", ARRAY, true, false, false, Dali::PathConstrainer::Property::CONTROL_POINTS )
DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX )
} //Unnamed namespace
// Name Type writable animatable constraint-input enum for index-checking
DALI_PROPERTY_TABLE_BEGIN
DALI_PROPERTY( "points", ARRAY, true, false, false, Dali::Path::Property::POINTS )
-DALI_PROPERTY( "control-points", ARRAY, true, false, false, Dali::Path::Property::CONTROL_POINTS )
+DALI_PROPERTY( "controlPoints", ARRAY, true, false, false, Dali::Path::Property::CONTROL_POINTS )
DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX )
/**
// Signals
-const char* const SIGNAL_OBJECT_CREATED = "object-created";
-const char* const SIGNAL_OBJECT_DESTROYED = "object-destroyed";
+const char* const SIGNAL_OBJECT_CREATED = "objectCreated";
+const char* const SIGNAL_OBJECT_DESTROYED = "objectDestroyed";
TypeRegistration mType( typeid( Dali::ObjectRegistry ), typeid( Dali::BaseHandle ), NULL );
// Signals
-const char* const SIGNAL_KEY_EVENT = "key-event";
-const char* const SIGNAL_EVENT_PROCESSING_FINISHED = "event-processing-finished";
+const char* const SIGNAL_KEY_EVENT = "keyEvent";
+const char* const SIGNAL_EVENT_PROCESSING_FINISHED = "eventProcessingFinished";
const char* const SIGNAL_TOUCHED = "touched";
-const char* const SIGNAL_WHEEL_EVENT = "wheel-event";
-const char* const SIGNAL_CONTEXT_LOST = "context-lost";
-const char* const SIGNAL_CONTEXT_REGAINED = "context-regained";
-const char* const SIGNAL_SCENE_CREATED = "scene-created";
+const char* const SIGNAL_WHEEL_EVENT = "wheelEvent";
+const char* const SIGNAL_CONTEXT_LOST = "contextLost";
+const char* const SIGNAL_CONTEXT_REGAINED = "contextRegained";
+const char* const SIGNAL_SCENE_CREATED = "sceneCreated";
TypeRegistration mType( typeid(Dali::Stage), typeid(Dali::BaseHandle), NULL );
// Name Type writable animatable constraint-input enum for index-checking
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "grid-density", FLOAT, true, false, false, Dali::ShaderEffect::Property::GRID_DENSITY )
+DALI_PROPERTY( "gridDensity", FLOAT, true, false, false, Dali::ShaderEffect::Property::GRID_DENSITY )
DALI_PROPERTY( "image", MAP, true, false, false, Dali::ShaderEffect::Property::IMAGE )
DALI_PROPERTY( "program", MAP, true, false, false, Dali::ShaderEffect::Property::PROGRAM )
-DALI_PROPERTY( "geometry-hints", STRING, true, false, false, Dali::ShaderEffect::Property::GEOMETRY_HINTS )
+DALI_PROPERTY( "geometryHints", STRING, true, false, false, Dali::ShaderEffect::Property::GEOMETRY_HINTS )
DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
BaseHandle Create()
case Dali::ShaderEffect::Property::PROGRAM:
{
- std::string vertexPrefix = GetShader("vertex-prefix", propertyValue);
- std::string fragmentPrefix = GetShader("fragment-prefix", propertyValue);
+ std::string vertexPrefix = GetShader("vertexPrefix", propertyValue);
+ std::string fragmentPrefix = GetShader("fragmentPrefix", propertyValue);
std::string vertex = GetShader("vertex", propertyValue);
std::string fragment = GetShader("fragment", propertyValue);
// Signals
-const char* const SIGNAL_LONG_PRESS_DETECTED = "long-press-detected";
+const char* const SIGNAL_LONG_PRESS_DETECTED = "longPressDetected";
BaseHandle Create()
{
// Name Type writable animatable constraint-input enum for index-checking
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "screen-position", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::SCREEN_POSITION )
-DALI_PROPERTY( "screen-displacement", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT )
-DALI_PROPERTY( "screen-velocity", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::SCREEN_VELOCITY )
-DALI_PROPERTY( "local-position", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::LOCAL_POSITION )
-DALI_PROPERTY( "local-displacement", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT )
-DALI_PROPERTY( "local-velocity", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::LOCAL_VELOCITY )
+DALI_PROPERTY( "screenPosition", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::SCREEN_POSITION )
+DALI_PROPERTY( "screenDisplacement", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT )
+DALI_PROPERTY( "screenVelocity", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::SCREEN_VELOCITY )
+DALI_PROPERTY( "localPosition", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::LOCAL_POSITION )
+DALI_PROPERTY( "localDisplacement", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT )
+DALI_PROPERTY( "localVelocity", VECTOR2, false, false, true, Dali::PanGestureDetector::Property::LOCAL_VELOCITY )
DALI_PROPERTY( "panning", BOOLEAN, false, false, true, Dali::PanGestureDetector::Property::PANNING )
DALI_PROPERTY_TABLE_END( DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX )
// Signals
-const char* const SIGNAL_PAN_DETECTED = "pan-detected";
+const char* const SIGNAL_PAN_DETECTED = "panDetected";
BaseHandle Create()
{
// Signals
-const char* const SIGNAL_PINCH_DETECTED = "pinch-detected";
+const char* const SIGNAL_PINCH_DETECTED = "pinchDetected";
BaseHandle Create()
{
const unsigned int DEFAULT_TOUCHES_REQUIRED = 1u;
// Signals
-const char* const SIGNAL_TAP_DETECTED = "tap-detected";
+const char* const SIGNAL_TAP_DETECTED = "tapDetected";
BaseHandle Create()
{
// Signals
-const char* const SIGNAL_IMAGE_LOADING_FINISHED = "image-loading-finished";
+const char* const SIGNAL_IMAGE_LOADING_FINISHED = "imageLoadingFinished";
BaseHandle CreateImage()
{
// Name Type writable animatable constraint-input enum for index-checking
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "viewport-position", VECTOR2, true, true, true, Dali::RenderTask::Property::VIEWPORT_POSITION )
-DALI_PROPERTY( "viewport-size", VECTOR2, true, true, true, Dali::RenderTask::Property::VIEWPORT_SIZE )
-DALI_PROPERTY( "clear-color", VECTOR4, true, true, true, Dali::RenderTask::Property::CLEAR_COLOR )
+DALI_PROPERTY( "viewportPosition", VECTOR2, true, true, true, Dali::RenderTask::Property::VIEWPORT_POSITION )
+DALI_PROPERTY( "viewportSize", VECTOR2, true, true, true, Dali::RenderTask::Property::VIEWPORT_SIZE )
+DALI_PROPERTY( "clearColor", VECTOR4, true, true, true, Dali::RenderTask::Property::CLEAR_COLOR )
DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX )
// Signals
* |name |type |writable|animatable|constraint-input|enum for index-checking|
*/
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "geometry-type", STRING, true, false, true, Dali::Geometry::Property::GEOMETRY_TYPE )
-DALI_PROPERTY( "requires-depth-test", BOOLEAN, true, false, true, Dali::Geometry::Property::REQUIRES_DEPTH_TEST )
+DALI_PROPERTY( "geometryType", STRING, true, false, true, Dali::Geometry::Property::GEOMETRY_TYPE )
+DALI_PROPERTY( "requiresDepthTest", BOOLEAN, true, false, true, Dali::Geometry::Property::REQUIRES_DEPTH_TEST )
DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> GEOMETRY_IMPL = { DEFAULT_PROPERTY_DETAILS };
* |name |type |writable|animatable|constraint-input|enum for index-checking|
*/
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "face-culling-mode", INTEGER, true, false, false, Dali::Material::Property::FACE_CULLING_MODE )
-DALI_PROPERTY( "blending-mode", INTEGER, true, false, false, Dali::Material::Property::BLENDING_MODE )
-DALI_PROPERTY( "blend-equation-rgb", INTEGER, true, false, false, Dali::Material::Property::BLEND_EQUATION_RGB )
-DALI_PROPERTY( "blend-equation-alpha", INTEGER, true, false, false, Dali::Material::Property::BLEND_EQUATION_ALPHA )
-DALI_PROPERTY( "source-blend-factor-rgb", INTEGER, true, false, false, Dali::Material::Property::BLENDING_SRC_FACTOR_RGB )
-DALI_PROPERTY( "destination-blend-factor-rgb", INTEGER, true, false, false, Dali::Material::Property::BLENDING_DEST_FACTOR_RGB )
-DALI_PROPERTY( "source-blend-factor-alpha", INTEGER, true, false, false, Dali::Material::Property::BLENDING_SRC_FACTOR_ALPHA )
-DALI_PROPERTY( "destination-blend-factor-alpha", INTEGER, true, false, false, Dali::Material::Property::BLENDING_DEST_FACTOR_ALPHA )
-DALI_PROPERTY( "blend-color", VECTOR4, true, false, false, Dali::Material::Property::BLEND_COLOR )
+DALI_PROPERTY( "faceCullingMode", INTEGER, true, false, false, Dali::Material::Property::FACE_CULLING_MODE )
+DALI_PROPERTY( "blendingMode", INTEGER, true, false, false, Dali::Material::Property::BLENDING_MODE )
+DALI_PROPERTY( "blendEquationRgb", INTEGER, true, false, false, Dali::Material::Property::BLEND_EQUATION_RGB )
+DALI_PROPERTY( "blendEquationAlpha", INTEGER, true, false, false, Dali::Material::Property::BLEND_EQUATION_ALPHA )
+DALI_PROPERTY( "sourceBlendFactorRgb", INTEGER, true, false, false, Dali::Material::Property::BLENDING_SRC_FACTOR_RGB )
+DALI_PROPERTY( "destinationBlendFactorRgb", INTEGER, true, false, false, Dali::Material::Property::BLENDING_DEST_FACTOR_RGB )
+DALI_PROPERTY( "sourceBlendFactorAlpha", INTEGER, true, false, false, Dali::Material::Property::BLENDING_SRC_FACTOR_ALPHA )
+DALI_PROPERTY( "destinationBlendFactorAlpha", INTEGER, true, false, false, Dali::Material::Property::BLENDING_DEST_FACTOR_ALPHA )
+DALI_PROPERTY( "blendColor", VECTOR4, true, false, false, Dali::Material::Property::BLEND_COLOR )
DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> MATERIAL_IMPL = { DEFAULT_PROPERTY_DETAILS };
* |name |type |writable|animatable|constraint-input|enum for index-checking|
*/
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "depth-index", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_INDEX )
+DALI_PROPERTY( "depthIndex", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_INDEX )
DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX )
const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> RENDERER_IMPL = { DEFAULT_PROPERTY_DETAILS };
*/
DALI_PROPERTY_TABLE_BEGIN
DALI_PROPERTY( "program", MAP, true, false, false, Dali::Shader::Property::PROGRAM )
-DALI_PROPERTY( "shader-hints", INTEGER, true, false, true, Dali::Shader::Property::SHADER_HINTS )
+DALI_PROPERTY( "shaderHints", INTEGER, true, false, true, Dali::Shader::Property::SHADER_HINTS )
DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> SHADER_IMPL = { DEFAULT_PROPERTY_DETAILS };
Viewport mViewport; ///< Optional viewport
Vector4 mClearColor; ///< Optional color to clear with
bool mIsViewportSet:1; ///< Flag to determine whether the viewport is set
- bool mIsClearColorSet:1; ///< Flag to determine whether the clear-color is set
+ bool mIsClearColorSet:1; ///< Flag to determine whether the clearColor is set
bool mCullMode:1; ///< True if renderers should be frustum culled
unsigned int mOffscreenTextureId; ///< Optional offscreen target
// Properties
GesturePropertyBool mPanning; ///< panning flag
- GesturePropertyVector2 mScreenPosition; ///< screen-position
- GesturePropertyVector2 mScreenDisplacement; ///< screen-displacement
- GesturePropertyVector2 mScreenVelocity; ///< screen-velocity
- GesturePropertyVector2 mLocalPosition; ///< local-position
- GesturePropertyVector2 mLocalDisplacement; ///< local-displacement
- GesturePropertyVector2 mLocalVelocity; ///< local-velocity
+ GesturePropertyVector2 mScreenPosition; ///< screenPosition
+ GesturePropertyVector2 mScreenDisplacement; ///< screenDisplacement
+ GesturePropertyVector2 mScreenVelocity; ///< screenVelocity
+ GesturePropertyVector2 mLocalPosition; ///< localPosition
+ GesturePropertyVector2 mLocalDisplacement; ///< localDisplacement
+ GesturePropertyVector2 mLocalVelocity; ///< localVelocity
PanInfoHistory mPanHistory;
PanInfoHistory mPredictionHistory;
const PropertyInputImpl* GetProjectionMatrix() const;
/**
- * Retrieve the view-matrix property querying interface.
+ * Retrieve the viewMatrix property querying interface.
* @pre The attachment is on-stage.
- * @return The view-matrix property querying interface.
+ * @return The viewMatrix property querying interface.
*/
const PropertyInputImpl* GetViewMatrix() const;
Vector2 mStereoBias;
Vector3 mTargetPosition;
- InheritedMatrix mViewMatrix; ///< The view-matrix; this is double buffered for input handling.
- InheritedMatrix mProjectionMatrix; ///< The projection-matrix; this is double buffered for input handling.
+ InheritedMatrix mViewMatrix; ///< The viewMatrix; this is double buffered for input handling.
+ InheritedMatrix mProjectionMatrix; ///< The projectionMatrix; this is double buffered for input handling.
DoubleBuffered< FrustumPlanes > mFrustum; ///< Clipping frustum; double buffered for input handling
DoubleBuffered< Matrix > mInverseViewProjection; ///< Inverted viewprojection; double buffered for input handling
unsigned int GetFrameBufferId() const;
/**
- * Set the value of property viewport-position
+ * Set the value of property viewportPosition
* This value will persist only for the current frame.
* @param[in] updateBufferIndex The current update buffer index.
* @param[in] value The value of the property
void SetViewportPosition( BufferIndex updateBufferIndex, const Vector2& value );
/**
- * Get the value of property viewport-position
+ * Get the value of property viewportPosition
* @warning Should only be called from the Update thread
* @param[in] bufferIndex The buffer to read from.
* @return the value of the property.
const Vector2& GetViewportPosition( BufferIndex bufferIndex ) const;
/**
- * Bake the value of the property viewport-position
+ * Bake the value of the property viewportPosition
* This will also set the base value
* @param[in] updateBufferIndex The current update buffer index.
* @param[in] value The new value for property.
void BakeViewportPosition( BufferIndex updateBufferIndex, const Vector2& value );
/**
- * Set the value of property viewport-size
+ * Set the value of property viewportSize
* This value will persist only for the current frame.
* @param[in] updateBufferIndex The current update buffer index.
* @param[in] value The value of the property
void SetViewportSize( BufferIndex updateBufferIndex, const Vector2& value );
/**
- * Get the value of property viewport-size
+ * Get the value of property viewportSize
* @warning Should only be called from the Update thread
* @param[in] bufferIndex The buffer to read from.
* @return the value of the property.
const Vector2& GetViewportSize( BufferIndex bufferIndex ) const;
/**
- * Bake the value of the property viewport-size
+ * Bake the value of the property viewportSize
* This will also set the base value
* @param[in] updateBufferIndex The current update buffer index.
* @param[in] value The new value for property.
void BakeViewportSize( BufferIndex updateBufferIndex, const Vector2& value );
/**
- * Get the value of property viewport-enabled
+ * Get the value of property viewportEnabled
* @warning Should only be called from the Update thread
* @param[in] bufferIndex The buffer to read from.
* @return the value of the property.
bool QueryViewport( BufferIndex bufferIndex, Viewport& viewport ) const;
/**
- * Set the value of property clear-color
+ * Set the value of property clearColor
* This value will persist only for the current frame.
* @param[in] updateBufferIndex The current update buffer index.
* @param[in] value The value of the property
void SetClearColor( BufferIndex updateBufferIndex, const Vector4& value );
/**
- * Get the value of property clear-color
+ * Get the value of property clearColor
* @warning Should only be called from the Update thread
* @param[in] bufferIndex The buffer to read from.
* @return the value of the property.
const Vector4& GetClearColor( BufferIndex bufferIndex ) const;
/**
- * Bake the value of the property clear-color
+ * Bake the value of the property clearColor
* This will also set the base value
* @param[in] updateBufferIndex The current update buffer index.
* @param[in] value The new value for property.
virtual void ResetDefaultProperties( BufferIndex currentBufferIndex );
public: // Animatable Properties
- AnimatableProperty< Vector2 > mViewportPosition; ///< viewport-position
- AnimatableProperty< Vector2 > mViewportSize; ///< viewport-size
- AnimatableProperty< Vector4 > mClearColor; ///< clear-color
+ AnimatableProperty< Vector2 > mViewportPosition; ///< viewportPosition
+ AnimatableProperty< Vector2 > mViewportSize; ///< viewportSize
+ AnimatableProperty< Vector4 > mClearColor; ///< clearColor
private:
CompleteStatusManager* mCompleteStatusManager;
* |-------------------|------------------------------|
* | touched | @ref TouchedSignal() |
* | hovered | @ref HoveredSignal() |
- * | wheel-event | @ref WheelEventSignal() |
- * | on-stage | @ref OnStageSignal() |
- * | off-stage | @ref OffStageSignal() |
+ * | wheelEvent | @ref WheelEventSignal() |
+ * | onStage | @ref OnStageSignal() |
+ * | offStage | @ref OffStageSignal() |
*
* Actions
* | %Action Name | %Actor method called |
{
enum
{
- PARENT_ORIGIN = DEFAULT_ACTOR_PROPERTY_START_INDEX, ///< name "parent-origin", type Vector3
- PARENT_ORIGIN_X, ///< name "parent-origin-x", type float
- PARENT_ORIGIN_Y, ///< name "parent-origin-y", type float
- PARENT_ORIGIN_Z, ///< name "parent-origin-z", type float
- ANCHOR_POINT, ///< name "anchor-point", type Vector3
- ANCHOR_POINT_X, ///< name "anchor-point-x", type float
- ANCHOR_POINT_Y, ///< name "anchor-point-y", type float
- ANCHOR_POINT_Z, ///< name "anchor-point-z", type float
+ PARENT_ORIGIN = DEFAULT_ACTOR_PROPERTY_START_INDEX, ///< name "parentOrigin", type Vector3
+ PARENT_ORIGIN_X, ///< name "parentOriginX", type float
+ PARENT_ORIGIN_Y, ///< name "parentOriginY", type float
+ PARENT_ORIGIN_Z, ///< name "parentOriginZ", type float
+ ANCHOR_POINT, ///< name "anchorPoint", type Vector3
+ ANCHOR_POINT_X, ///< name "anchorPointX", type float
+ ANCHOR_POINT_Y, ///< name "anchorPointY", type float
+ ANCHOR_POINT_Z, ///< name "anchorPointZ", type float
SIZE, ///< name "size", type Vector3
- SIZE_WIDTH, ///< name "size-width", type float
- SIZE_HEIGHT, ///< name "size-height", type float
- SIZE_DEPTH, ///< name "size-depth", type float
+ SIZE_WIDTH, ///< name "sizeWidth", type float
+ SIZE_HEIGHT, ///< name "sizeHeight", type float
+ SIZE_DEPTH, ///< name "sizeDepth", type float
POSITION, ///< name "position", type Vector3
- POSITION_X, ///< name "position-x", type float
- POSITION_Y, ///< name "position-y", type float
- POSITION_Z, ///< name "position-z", type float
- WORLD_POSITION, ///< name "world-position", type Vector3 (read-only)
- WORLD_POSITION_X, ///< name "world-position-x", type float (read-only)
- WORLD_POSITION_Y, ///< name "world-position-y", type float (read-only)
- WORLD_POSITION_Z, ///< name "world-position-z", type float (read-only)
+ POSITION_X, ///< name "positionX", type float
+ POSITION_Y, ///< name "positionY", type float
+ POSITION_Z, ///< name "positionZ", type float
+ WORLD_POSITION, ///< name "worldPosition", type Vector3 (read-only)
+ WORLD_POSITION_X, ///< name "worldPositionX", type float (read-only)
+ WORLD_POSITION_Y, ///< name "worldPositionY", type float (read-only)
+ WORLD_POSITION_Z, ///< name "worldPositionZ", type float (read-only)
ORIENTATION, ///< name "orientation", type Quaternion
- WORLD_ORIENTATION, ///< name "world-orientation", type Quaternion (read-only)
+ WORLD_ORIENTATION, ///< name "worldOrientation", type Quaternion (read-only)
SCALE, ///< name "scale", type Vector3
- SCALE_X, ///< name "scale-x", type float
- SCALE_Y, ///< name "scale-y", type float
- SCALE_Z, ///< name "scale-z", type float
- WORLD_SCALE, ///< name "world-scale", type Vector3 (read-only)
+ SCALE_X, ///< name "scaleX", type float
+ SCALE_Y, ///< name "scaleY", type float
+ SCALE_Z, ///< name "scaleZ", type float
+ WORLD_SCALE, ///< name "worldScale", type Vector3 (read-only)
VISIBLE, ///< name "visible", type bool
COLOR, ///< name "color", type Vector4
- COLOR_RED, ///< name "color-red", type float
- COLOR_GREEN, ///< name "color-green", type float
- COLOR_BLUE, ///< name "color-blue", type float
- COLOR_ALPHA, ///< name "color-alpha", type float
- WORLD_COLOR, ///< name "world-color", type Vector4 (read-only)
- WORLD_MATRIX, ///< name "world-matrix", type Matrix (read-only)
+ COLOR_RED, ///< name "colorRed", type float
+ COLOR_GREEN, ///< name "colorGreen", type float
+ COLOR_BLUE, ///< name "colorBlue", type float
+ COLOR_ALPHA, ///< name "colorAlpha", type float
+ WORLD_COLOR, ///< name "worldColor", type Vector4 (read-only)
+ WORLD_MATRIX, ///< name "worldMatrix", type Matrix (read-only)
NAME, ///< name "name", type std::string
SENSITIVE, ///< name "sensitive", type bool
- LEAVE_REQUIRED, ///< name "leave-required", type bool
- INHERIT_ORIENTATION, ///< name "inherit-orientation", type bool
- INHERIT_SCALE, ///< name "inherit-scale", type bool
- COLOR_MODE, ///< name "color-mode", type std::string
- POSITION_INHERITANCE, ///< name "position-inheritance", type std::string
- DRAW_MODE, ///< name "draw-mode", type std::string
- SIZE_MODE_FACTOR, ///< name "size-mode-factor", type Vector3
- WIDTH_RESIZE_POLICY, ///< name "width-resize-policy", type String
- HEIGHT_RESIZE_POLICY, ///< name "height-resize-policy", type String
- SIZE_SCALE_POLICY, ///< name "size-scale-policy", type String
- WIDTH_FOR_HEIGHT, ///< name "width-for-height", type Boolean
- HEIGHT_FOR_WIDTH, ///< name "height-for-width", type Boolean
+ LEAVE_REQUIRED, ///< name "leaveRequired", type bool
+ INHERIT_ORIENTATION, ///< name "inheritOrientation", type bool
+ INHERIT_SCALE, ///< name "inheritScale", type bool
+ COLOR_MODE, ///< name "colorMode", type std::string
+ POSITION_INHERITANCE, ///< name "positionInheritance", type std::string
+ DRAW_MODE, ///< name "drawMode", type std::string
+ SIZE_MODE_FACTOR, ///< name "sizeModeFactor", type Vector3
+ WIDTH_RESIZE_POLICY, ///< name "widthResizePolicy", type String
+ HEIGHT_RESIZE_POLICY, ///< name "heightResizePolicy", type String
+ SIZE_SCALE_POLICY, ///< name "sizeScalePolicy", type String
+ WIDTH_FOR_HEIGHT, ///< name "widthForHeight", type Boolean
+ HEIGHT_FOR_WIDTH, ///< name "heightForWidth", type Boolean
PADDING, ///< name "padding", type Vector4
- MINIMUM_SIZE, ///< name "minimum-size", type Vector2
- MAXIMUM_SIZE, ///< name "maximum-size", type Vector2
+ MINIMUM_SIZE, ///< name "minimumSize", type Vector2
+ MAXIMUM_SIZE, ///< name "maximumSize", type Vector2
};
};
*
* If DrawMode::OVERLAY_2D is used, the actor and its children will be drawn as a 2D overlay.
* Overlay actors are drawn in a separate pass, after all non-overlay actors within the Layer.
- * For overlay actors, the drawing order is with respect to depth-index property of Renderers,
+ * For overlay actors, the drawing order is with respect to depthIndex property of Renderers,
* and depth-testing will not be used.
*
* If DrawMode::STENCIL is used, the actor and its children will be used to stencil-test other actors
enum
{
TYPE = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< name "type", type std::string
- PROJECTION_MODE, ///< name "projection-mode", type std::string
- FIELD_OF_VIEW, ///< name "field-of-view", type float
- ASPECT_RATIO, ///< name "aspect-ratio", type float
- NEAR_PLANE_DISTANCE, ///< name "near-plane-distance", type float
- FAR_PLANE_DISTANCE, ///< name "far-plane-distance", type float
- LEFT_PLANE_DISTANCE, ///< name "left-plane-distance", type float
- RIGHT_PLANE_DISTANCE, ///< name "right-plane-distance", type float
- TOP_PLANE_DISTANCE, ///< name "top-plane-distance", type float
- BOTTOM_PLANE_DISTANCE, ///< name "bottom-plane-distance", type float
- TARGET_POSITION, ///< name "target-position", type Vector3
- PROJECTION_MATRIX, ///< name "projection-matrix", type Matrix
- VIEW_MATRIX, ///< name "view-matrix", type Matrix
- INVERT_Y_AXIS, ///< name "invert-y-axis", type bool
+ PROJECTION_MODE, ///< name "projectionMode", type std::string
+ FIELD_OF_VIEW, ///< name "fieldOfView", type float
+ ASPECT_RATIO, ///< name "aspectRatio", type float
+ NEAR_PLANE_DISTANCE, ///< name "nearPlaneDistance", type float
+ FAR_PLANE_DISTANCE, ///< name "farPlaneDistance", type float
+ LEFT_PLANE_DISTANCE, ///< name "leftPlaneDistance", type float
+ RIGHT_PLANE_DISTANCE, ///< name "rightPlaneDistance", type float
+ TOP_PLANE_DISTANCE, ///< name "topPlaneDistance", type float
+ BOTTOM_PLANE_DISTANCE, ///< name "bottomPlaneDistance", type float
+ TARGET_POSITION, ///< name "targetPosition", type Vector3
+ PROJECTION_MATRIX, ///< name "projectionMatrix", type Matrix
+ VIEW_MATRIX, ///< name "viewMatrix", type Matrix
+ INVERT_Y_AXIS, ///< name "invertYAxis", type bool
};
};
{
enum
{
- PIXEL_AREA = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< name "pixel-area", type Rect<int>
+ PIXEL_AREA = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< name "pixelArea", type Rect<int>
STYLE, ///< name "style", type std::string
BORDER, ///< name "border", type Vector4
- IMAGE, ///< name "image", type Map {"filename":"", "load-policy":...}
+ IMAGE, ///< name "image", type Map {"filename":"", "loadPolicy":...}
};
};
* |-----------------|----------------------|
* | raise | @ref Raise() |
* | lower | @ref Lower() |
- * | raise-to-top | @ref RaiseToTop() |
- * | lower-to-bottom | @ref LowerToBottom() |
+ * | raiseToTop | @ref RaiseToTop() |
+ * | lowerToBottom | @ref LowerToBottom() |
*/
class DALI_IMPORT_API Layer : public Actor
{
{
enum
{
- CLIPPING_ENABLE = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< name "clipping-enable", type bool
- CLIPPING_BOX, ///< name "clipping-box", type Rect<int>
+ CLIPPING_ENABLE = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< name "clippingEnable", type bool
+ CLIPPING_BOX, ///< name "clippingBox", type Rect<int>
BEHAVIOR, ///< name "behavior", type String
};
};
* @brief Layer doesn't make use of the depth test.
*
* This mode is expected to have better performance than the 3D mode.
- * When using this mode any ordering would be with respect to depth-index property of Renderers.
+ * When using this mode any ordering would be with respect to depthIndex property of Renderers.
*/
LAYER_2D,
enum
{
POINTS = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "points", type Vector3
- CONTROL_POINTS, ///< name "control-points", type Vector3
+ CONTROL_POINTS, ///< name "controlPoints", type Vector3
};
};
* Multiple stage/window support is not currently provided.
*
* Signals
- * | %Signal Name | Method |
- * |---------------------------|--------------------------------------|
- * | key-event | @ref KeyEventSignal() |
- * | event-processing-finished | @ref EventProcessingFinishedSignal() |
- * | touched | @ref TouchedSignal() |
- * | wheel-event | @ref WheelEventSignal() |
- * | context-lost | @ref ContextLostSignal() |
- * | context-regained | @ref ContextRegainedSignal() |
- * | scene-created | @ref SceneCreatedSignal() |
+ * | %Signal Name | Method |
+ * |-------------------------|--------------------------------------|
+ * | keyEvent | @ref KeyEventSignal() |
+ * | eventProcessingFinished | @ref EventProcessingFinishedSignal() |
+ * | touched | @ref TouchedSignal() |
+ * | wheelEvent | @ref WheelEventSignal() |
+ * | contextLost | @ref ContextLostSignal() |
+ * | contextRegained | @ref ContextRegainedSignal() |
+ * | sceneCreated | @ref SceneCreatedSignal() |
*/
class DALI_IMPORT_API Stage : public BaseHandle
{
* @see LongPressGesture
*
* Signals
- * | %Signal Name | Method |
- * |---------------------|-----------------------|
- * | long-press-detected | @ref DetectedSignal() |
+ * | %Signal Name | Method |
+ * |-------------------|-----------------------|
+ * | longPressDetected | @ref DetectedSignal() |
*/
class DALI_IMPORT_API LongPressGestureDetector : public GestureDetector
{
* Signals
* | %Signal Name | Method |
* |--------------|-----------------------|
- * | pan-detected | @ref DetectedSignal() |
+ * | panDetected | @ref DetectedSignal() |
*/
class DALI_IMPORT_API PanGestureDetector : public GestureDetector
{
{
enum
{
- SCREEN_POSITION = DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX, ///< name "screen-position", type Vector2
- SCREEN_DISPLACEMENT, ///< name "screen-displacement", type Vector2
- SCREEN_VELOCITY, ///< name "screen-velocity", type Vector2
- LOCAL_POSITION, ///< name "local-position", type Vector2
- LOCAL_DISPLACEMENT, ///< name "local-displacement", type Vector2
- LOCAL_VELOCITY, ///< name "local-velocity", type Vector2
+ SCREEN_POSITION = DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX, ///< name "screenPosition", type Vector2
+ SCREEN_DISPLACEMENT, ///< name "screenDisplacement", type Vector2
+ SCREEN_VELOCITY, ///< name "screenVelocity", type Vector2
+ LOCAL_POSITION, ///< name "localPosition", type Vector2
+ LOCAL_DISPLACEMENT, ///< name "localDisplacement", type Vector2
+ LOCAL_VELOCITY, ///< name "localVelocity", type Vector2
PANNING, ///< name "panning", type bool
};
};
* Signals
* | %Signal Name | Method |
* |----------------|-----------------------|
- * | pinch-detected | @ref DetectedSignal() |
+ * | pinchDetected | @ref DetectedSignal() |
*/
class DALI_IMPORT_API PinchGestureDetector : public GestureDetector
{
* Signals
* | %Signal Name | Method |
* |--------------|-----------------------|
- * | tap-detected | @ref DetectedSignal() |
+ * | tapDetected | @ref DetectedSignal() |
*/
class DALI_IMPORT_API TapGestureDetector : public GestureDetector
{
* Reload only takes effect if the ResourceImage has already finished loading
*
* Signals
- * | %Signal Name | Method |
- * |------------------------|------------------------------|
- * | image-loading-finished | @ref LoadingFinishedSignal() |
+ * | %Signal Name | Method |
+ * |----------------------|------------------------------|
+ * | imageLoadingFinished | @ref LoadingFinishedSignal() |
*/
class DALI_IMPORT_API ResourceImage : public Image
{
* Signals
* | %Signal Name | Method |
* |------------------|------------------------------|
- * | object-created | @ref ObjectCreatedSignal() |
- * | object-destroyed | @ref ObjectDestroyedSignal() |
+ * | objectCreated | @ref ObjectCreatedSignal() |
+ * | objectDestroyed | @ref ObjectDestroyedSignal() |
*/
class DALI_IMPORT_API ObjectRegistry : public BaseHandle
{
{
enum
{
- VIEWPORT_POSITION = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "viewport-position", type Vector2
- VIEWPORT_SIZE, ///< name "viewport-size", type Vector2
- CLEAR_COLOR, ///< name "clear-color", type Vector4
+ VIEWPORT_POSITION = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "viewportPosition", type Vector2
+ VIEWPORT_SIZE, ///< name "viewportSize", type Vector2
+ CLEAR_COLOR, ///< name "clearColor", type Vector4
};
};
{
enum
{
- GRID_DENSITY = DEFAULT_ACTOR_PROPERTY_START_INDEX, ///< name "grid-density", type float
- IMAGE, ///< name "image", type Map {"filename":"", "load-policy":...}
- PROGRAM, ///< name "program", type Map {"vertex-prefix":"","fragment-prefix":"","vertex":"","fragment":""}
- GEOMETRY_HINTS ///< name "geometry-hints", type int (bitfield) values from enum GeometryHints
+ GRID_DENSITY = DEFAULT_ACTOR_PROPERTY_START_INDEX, ///< name "gridDensity", type float
+ IMAGE, ///< name "image", type Map {"filename":"", "loadPolicy":...}
+ PROGRAM, ///< name "program", type Map {"vertexPrefix":"","fragmentPrefix":"","vertex":"","fragment":""}
+ GEOMETRY_HINTS ///< name "geometryHints", type int (bitfield) values from enum GeometryHints
};
};
projects / platform / core / uifw / dali-core.git / commitdiff