"[{"
"\"type\": \"Actor\","
"\"size\": [100,100,1],"
- "\"parent-origin\": \"TOP_LEFT\","
- "\"anchor-point\": \"TOP_LEFT\","
+ "\"parentOrigin\": \"TOP_LEFT\","
+ "\"anchorPoint\": \"TOP_LEFT\","
"\"signals\": [{"
"\"name\": \"touched\","
"\"action\": \"quit\""
" \"animations\": {"
" \"animate\": {"
" \"loop\": true,"
- " \"end-action\": \"BAKE\","
- " \"disconnect-action\": \"BAKE\","
+ " \"endAction\": \"BAKE\","
+ " \"disconnectAction\": \"BAKE\","
" \"properties\":"
" [{"
" \"actor\": \"greeting\","
" \"property\": \"position\","
" \"value\": [300, 300, -1000],"
- " \"alpha-function\": \"{ALPHA_FUNCTION}\","
+ " \"alphaFunction\": \"{ALPHA_FUNCTION}\","
" \"relative\": true,"
- " \"time-period\": {"
+ " \"timePeriod\": {"
" \"delay\": 0,"
" \"duration\": 3"
" }"
" {"
" \"actor\": \"greeting\","
" \"property\": \"visible\","
- " \"alpha-function\": \"LINEAR\","
+ " \"alphaFunction\": \"LINEAR\","
" \"value\": true"
" },"
" {"
" \"actor\": \"greeting\","
- " \"property\": \"size-width\","
- " \"alpha-function\": \"REVERSE\","
+ " \"property\": \"sizeWidth\","
+ " \"alphaFunction\": \"REVERSE\","
" \"value\": 10.0"
" },"
" {"
" \"actor\": \"greeting\","
" \"property\": \"orientation\","
- " \"alpha-function\": \"EASE_IN\","
+ " \"alphaFunction\": \"EASE_IN\","
" \"value\": [10.0,20.0,30.0]"
" },"
" {"
" \"actor\": \"greeting\","
" \"property\": \"orientation\","
- " \"alpha-function\": \"EASE_OUT\","
+ " \"alphaFunction\": \"EASE_OUT\","
" \"value\": [0.0, 0.0, 0.0, 1.0]"
" },"
" {"
" \"actor\": \"greeting\","
" \"property\": \"orientation\","
- " \"alpha-function\": \"EASE_IN_OUT\","
+ " \"alphaFunction\": \"EASE_IN_OUT\","
" \"value\": [0.0, 0.0, 0.0, 1.0]"
" },"
" {"
" \"actor\": \"greeting\","
" \"property\": \"orientation\","
- " \"alpha-function\": \"EASE_IN_SINE\","
+ " \"alphaFunction\": \"EASE_IN_SINE\","
" \"value\": [0.0, 0.0, 0.0, 1.0]"
" },"
" {"
" \"actor\": \"greeting\","
" \"property\": \"orientation\","
- " \"alpha-function\": \"EASE_OUT_SINE\","
+ " \"alphaFunction\": \"EASE_OUT_SINE\","
" \"value\": [0.0, 0.0, 0.0, 1.0]"
" },"
" {"
" \"actor\": \"greeting\","
" \"property\": \"orientation\","
- " \"alpha-function\": \"EASE_IN_OUT_SINE\","
+ " \"alphaFunction\": \"EASE_IN_OUT_SINE\","
" \"value\": [0.0, 0.0, 0.0, 1.0]"
" },"
" {"
" \"actor\": \"greeting\","
" \"property\": \"orientation\","
- " \"alpha-function\": \"BOUNCE\","
+ " \"alphaFunction\": \"BOUNCE\","
" \"value\": [0.0, 0.0, 0.0, 1.0]"
" },"
" {"
" \"actor\": \"greeting\","
" \"property\": \"orientation\","
- " \"alpha-function\": \"SIN\","
+ " \"alphaFunction\": \"SIN\","
" \"value\": [0.0, 0.0, 0.0, 1.0]"
" },"
" {"
" \"actor\": \"greeting\","
" \"property\": \"orientation\","
- " \"alpha-function\": \"EASE_OUT_BACK\","
+ " \"alphaFunction\": \"EASE_OUT_BACK\","
" \"value\": [0.0, 0.0, 0.0, 1.0]"
" }"
" ]"
" },"
- " \"path-animation\": {"
+ " \"pathAnimation\": {"
" \"duration\": 3.0,"
- " \"end-action\": \"DISCARD\","
- " \"disconnect-action\": \"BAKE_FINAL\","
+ " \"endAction\": \"DISCARD\","
+ " \"disconnectAction\": \"BAKE_FINAL\","
" \"properties\": [{"
" \"actor\": \"greeting\","
" \"path\":\"path0\","
" \"forward\":[1,0,0],"
- " \"alpha-function\": \"EASE_IN_OUT\","
- " \"time-period\": {"
+ " \"alphaFunction\": \"EASE_IN_OUT\","
+ " \"timePeriod\": {"
" \"delay\": 0,"
" \"duration\": 3"
" }"
" \"name\": \"greeting\","
" \"type\": \"TextLabel\","
" \"text\": \"Touch me\","
- " \"styles\": [\"basic-text\"],"
+ " \"styles\": [\"basicText\"],"
" \"position\": [0, -120, 0],"
" \"size\": [200, 200, 1],"
" \"orientation\": [0, 0, 30],"
DALI_TEST_CHECK( anim );
- anim = builder.CreateAnimation("path-animation");
+ anim = builder.CreateAnimation("pathAnimation");
DALI_TEST_CHECK( anim );
" \"animations\": {"
" \"animate\": {"
" \"loop\": true,"
- " \"end-action\": \"BAKE\","
- " \"disconnect-action\": \"BAKE\","
+ " \"endAction\": \"BAKE\","
+ " \"disconnectAction\": \"BAKE\","
" \"properties\":"
" [{"
" \"actor\": \"{NAME}\","
" \"property\": \"positioninvalid\","
" \"value\": [300, 300, -1000],"
- " \"alpha-function\": \"EASE_IN_OUT\","
+ " \"alphaFunction\": \"EASE_IN_OUT\","
" \"relative\": true,"
- " \"time-period\": {"
+ " \"timePeriod\": {"
" \"delay\": 0,"
" \"duration\": 3"
" }"
" },"
" \"animate2\": {"
" \"loop\": true,"
- " \"end-action\": \"BAKE\","
- " \"disconnect-action\": \"BAKE\","
+ " \"endAction\": \"BAKE\","
+ " \"disconnectAction\": \"BAKE\","
" \"properties\":"
" [{"
" \"actor\": \"{NAME}\","
" \"property\": \"positioninvalid\","
" \"value\": [300, 300, -1000],"
- " \"alpha-function\": \"EGGS_OVER_EASY\","
+ " \"alphaFunction\": \"EGGS_OVER_EASY\","
" \"relative\": true,"
- " \"time-period\": {"
+ " \"timePeriod\": {"
" \"delay\": 0,"
" \"duration\": 3"
" }"
" }"
" ]"
" },"
- " \"path-animation\": {"
+ " \"pathAnimation\": {"
" \"duration\": 3.0,"
- " \"end-action\": \"DISCARD\","
- " \"disconnect-action\": \"BAKE_FINAL\","
+ " \"endAction\": \"DISCARD\","
+ " \"disconnectAction\": \"BAKE_FINAL\","
" \"properties\": [{"
" \"actor\": \"greeting\","
" \"path\":\"pathDoesntExist\","
" \"forward\":[1,0,0],"
- " \"alpha-function\": \"EASE_IN_OUT\","
- " \"time-period\": {"
+ " \"alphaFunction\": \"EASE_IN_OUT\","
+ " \"timePeriod\": {"
" \"delay\": 0,"
" \"duration\": 3"
" }"
" \"name\": \"greeting\","
" \"type\": \"TextLabel\","
" \"text\": \"Touch me\","
- " \"styles\": [\"basic-text\"],"
+ " \"styles\": [\"basicText\"],"
" \"position\": [0, -120, 0],"
" \"size\": [200, 200, 1],"
" \"orientation\": [0, 0, 30],"
Animation anim = builder.CreateAnimation("animate");
// log warning line coverage
- anim = builder.CreateAnimation("path-animation");
+ anim = builder.CreateAnimation("pathAnimation");
DALI_TEST_CHECK(anim);
anim = builder.CreateAnimation("animate");
" \"type\": \"ImageActor\","
" \"name\": \"{NAME}\","
" \"size\": [100,100,1],"
- " \"parent-origin\": \"TOP_LEFT\","
- " \"anchor-point\": \"{ANCHOR}\","
+ " \"parentOrigin\": \"TOP_LEFT\","
+ " \"anchorPoint\": \"{ANCHOR}\","
" \"padding\": \"{PADDING}\","
" \"image\": { \"filename\": \"dir/{IMAGE_PATH}\" },"
- " \"size-width\": \"{WIDTH}\","
+ " \"sizeWidth\": \"{WIDTH}\","
" \"signals\": [{"
" \"name\": \"touched\","
" \"action\": \"quit\""
"},"
"\"styles\":\n"
"{\n"
- " \"image-style\": \n"
+ " \"imageStyle\": \n"
" {\n"
" \"color\": [1,0,0,1],\n"
" \"actors\": {\n"
- " \"child-image\": {\n"
+ " \"childImage\": {\n"
" \"color\": [0,1,0,1]\n"
" }\n"
" }\n"
"},\n"
"\"templates\":\n"
"{\n"
- " \"image-tree\": { \n"
+ " \"imageTree\": { \n"
" \"type\": \"ImageActor\",\n"
- " \"styles\": [\"image-style\"],\n"
+ " \"styles\": [\"imageStyle\"],\n"
" \"name\": \"image\",\n"
" \"size\": \"{SIZE}\",\n"
" \"signals\": [{\n"
" \"actors\": [\n"
" {\n"
" \"type\":\"ImageActor\",\n"
- " \"name\":\"child-image\" \n"
+ " \"name\":\"childImage\" \n"
" }\n"
" ]\n"
" }\n"
"},\n"
"\"stage\":"
"[{"
- " \"type\": \"image-tree\","
+ " \"type\": \"imageTree\","
" \"size\": [100,100,1]"
"}]"
"}\n"
"{\n"
" \"color\": [1,0,0,1],\n"
" \"actors\": {\n"
- " \"child-image\": {\n"
+ " \"childImage\": {\n"
" \"color\": [0,1,0,1]\n"
" }\n"
" }\n"
std::string templatejson(
"{ \n"
" \"type\": \"ImageActor\",\n"
- " \"styles\": [\"image-style\"],\n"
+ " \"styles\": [\"imageStyle\"],\n"
" \"name\": \"image\",\n"
" \"size\": \"{SIZE}\",\n"
" \"signals\": [{\n"
" \"actors\": [\n"
" {\n"
" \"type\":\"ImageActor\",\n"
- " \"name\":\"child-image\" \n"
+ " \"name\":\"childImage\" \n"
" }\n"
" ]\n"
"}\n"
Builder builder = Builder::New();
builder.LoadFromString( json );
- ImageActor actor = ImageActor::DownCast( builder.Create( "image-tree" ) );
+ ImageActor actor = ImageActor::DownCast( builder.Create( "imageTree" ) );
DALI_TEST_CHECK( actor );
Dali::Property::Map map;
map["SIZE"] = Vector3(100,100,1);
- actor = ImageActor::DownCast( builder.Create( "image-tree", map ) );
+ actor = ImageActor::DownCast( builder.Create( "imageTree", map ) );
DALI_TEST_CHECK( actor );
// create from json snippet
// NB: already applied in create
- DALI_TEST_CHECK( builder.ApplyStyle( "image-style", actor ) );
+ DALI_TEST_CHECK( builder.ApplyStyle( "imageStyle", actor ) );
// apply from json snippet
DALI_TEST_CHECK( builder.ApplyFromJson( actor, stylejson ) );
// JSON with a quit event when the actor is touched
std::string json(
"{\n"
- "\"render-tasks\":\n"
+ "\"renderTasks\":\n"
"{\n"
" \"task0\": {\n"
- " \"source-actor\": \"image\",\n"
- " \"camera-actor\": \"camera\" \n"
+ " \"sourceActor\": \"image\",\n"
+ " \"cameraActor\": \"camera\" \n"
" }\n"
"},\n"
"\"stage\":\n"
" \"actors\": [\n"
" {\n"
" \"type\":\"ImageActor\",\n"
- " \"name\":\"child-image\" \n"
+ " \"name\":\"childImage\" \n"
" }\n"
" ]\n"
" }\n"
" \"type\": \"Actor\",\n"
" \"name\": \"actor\",\n"
" \"size\": [100,100,1],\n"
- " \"parent-origin\": \"TOP_LEFT\",\n"
- " \"anchor-point\": \"TOP_LEFT\",\n"
+ " \"parentOrigin\": \"TOP_LEFT\",\n"
+ " \"anchorPoint\": \"TOP_LEFT\",\n"
" \"actors\": [{\n"
" \"type\": \"Actor\",\n"
- " \"name\": \"sub-actor\"\n"
+ " \"name\": \"subActor\"\n"
" }],\n"
" \"signals\": [{\n"
" \"name\": \"touched\",\n"
" \"action\": \"hide\",\n"
" \"actor\": \"actor\",\n"
- " \"child-actor\": \"sub-actor\"\n"
+ " \"childActor\": \"subActor\"\n"
" }]\n"
" }]\n"
"}\n"
application.SendNotification();
application.Render();
- Actor actor = Stage::GetCurrent().GetRootLayer().FindChildByName("sub-actor");
+ Actor actor = Stage::GetCurrent().GetRootLayer().FindChildByName("subActor");
DALI_TEST_CHECK( actor );
DALI_TEST_CHECK( !actor.IsVisible() );
" \"type\": \"Actor\",\n"
" \"name\": \"actor\",\n"
" \"size\": [100,100,1],\n"
- " \"parent-origin\": \"TOP_LEFT\",\n"
- " \"anchor-point\": \"TOP_LEFT\",\n"
+ " \"parentOrigin\": \"TOP_LEFT\",\n"
+ " \"anchorPoint\": \"TOP_LEFT\",\n"
" \"actors\": [{\n"
" \"type\": \"Actor\",\n"
- " \"name\": \"sub-actor\"\n"
+ " \"name\": \"subActor\"\n"
" }],\n"
" \"signals\": [{\n"
" \"name\": \"touched\",\n"
" \"action\": \"set\",\n"
- " \"actor\": \"sub-actor\",\n"
+ " \"actor\": \"subActor\",\n"
" \"property\": \"visible\",\n"
" \"value\": false\n"
" }]\n"
application.SendNotification();
application.Render();
- Actor actor = Stage::GetCurrent().GetRootLayer().FindChildByName("sub-actor");
+ Actor actor = Stage::GetCurrent().GetRootLayer().FindChildByName("subActor");
DALI_TEST_CHECK( actor );
DALI_TEST_CHECK( !actor.IsVisible() );
" \"type\": \"Actor\",\n"
" \"name\": \"actor\",\n"
" \"size\": [100,100,1],\n"
- " \"parent-origin\": \"TOP_LEFT\",\n"
- " \"anchor-point\": \"TOP_LEFT\",\n"
+ " \"parentOrigin\": \"TOP_LEFT\",\n"
+ " \"anchorPoint\": \"TOP_LEFT\",\n"
" \"actors\": [{\n"
" \"type\": \"Actor\",\n"
- " \"name\": \"sub-actor\"\n"
+ " \"name\": \"subActor\"\n"
" }],\n"
" \"signals\": [{\n"
" \"name\": \"touched\",\n"
" \"type\": \"Actor\",\n"
" \"name\": \"actor\",\n"
" \"size\": [100,100,1],\n"
- " \"parent-origin\": \"TOP_LEFT\",\n"
- " \"anchor-point\": \"TOP_LEFT\",\n"
+ " \"parentOrigin\": \"TOP_LEFT\",\n"
+ " \"anchorPoint\": \"TOP_LEFT\",\n"
" \"actors\": [{\n"
" \"type\": \"Actor\",\n"
- " \"name\": \"sub-actor\"\n"
+ " \"name\": \"subActor\"\n"
" }],\n"
" \"signals\": [{\n"
" \"name\": \"touched\",\n"
"{\n"
"\"templates\":\n"
"{\n"
- " \"image-tree\": { \n"
+ " \"imageTree\": { \n"
" \"type\": \"ImageActor\",\n"
" \"name\": \"image\",\n"
" \"size\": [100,100,1],\n"
" \"name\": \"touched\",\n"
" \"action\": \"quit\"\n"
" }],\n"
- " \"custom-properties\": {\n"
+ " \"customProperties\": {\n"
" \"newproperty\": true\n"
" },\n"
" \"actors\": [\n"
" {\n"
" \"type\":\"ImageActor\",\n"
- " \"name\":\"child-image\" \n"
+ " \"name\":\"childImage\" \n"
" }\n"
" ]\n"
" }\n"
Builder builder = Builder::New();
builder.LoadFromString( json );
- ImageActor actor = ImageActor::DownCast( builder.Create( "image-tree" ) );
+ ImageActor actor = ImageActor::DownCast( builder.Create( "imageTree" ) );
DALI_TEST_CHECK( actor );
// NB: already applied in create
" 0.9150390625,\n"
" 0.0\n"
" ],\n"
- " \"parent-origin\": [0.5, 0.5, 0.5],\n"
+ " \"parentOrigin\": [0.5, 0.5, 0.5],\n"
" \"size\": [200, 200, 0],\n"
" \"effect\": \"Ripple2D\",\n"
" \"image\": {\n"
" \"filename\": \"{DALI_IMAGE_DIR}gallery-medium-25.jpg\",\n"
" \"width\": 200,\n"
" \"height\": 80,\n"
- " \"load-policy\": \"IMMEDIATE\",\n"
- " \"release-policy\": \"NEVER\"\n"
+ " \"loadPolicy\": \"IMMEDIATE\",\n"
+ " \"releasePolicy\": \"NEVER\"\n"
" },\n"
" \"signals\": [\n"
" {\n"
- " \"name\": \"on-stage\",\n"
+ " \"name\": \"onStage\",\n"
" \"action\": \"play\",\n"
" \"animation\": \"Animation_1\"\n"
" }\n"
" \"actor\": \"Image1\",\n"
" \"property\": \"uTime\",\n"
" \"value\": 10.0,\n"
- " \"alpha-function\": \"LINEAR\",\n"
- " \"time-period\": {\n"
+ " \"alphaFunction\": \"LINEAR\",\n"
+ " \"timePeriod\": {\n"
" \"delay\": 0,\n"
" \"duration\": 10.0\n"
" },\n"
" ]\n"
" }\n"
" },\n"
- " \"shader-effects\": {\n"
+ " \"shaderEffects\": {\n"
" \"Ripple2D\": {\n"
" \"program\": {\n"
" \"vertexPrefix\": \"\",\n"
" \"vertex\": \"void main(void)\\n{\\n gl_Position = uProjection * uModelView * vec4(aPosition, 1.0);\\n vTexCoord = aTexCoord;\\n}\\n\\n\",\n"
" \"fragmentPrefix\": \"\",\n"
" \"fragment\": \"precision mediump float;\\nuniform float uAmplitude; // 0.02; (< 1)\\nuniform float uTime;\\nvoid main()\\n{\\n highp vec2 textureSize = sTextureRect.zw - sTextureRect.xy;\\n highp vec2 pos = -1.0 + 2.0 * vTexCoord.st/textureSize;\\n highp float len = length(pos);\\n highp vec2 texCoord = vTexCoord.st/textureSize + pos/len * sin( len * 12.0 - uTime * 4.0 ) * uAmplitude; \\n gl_FragColor = texture2D(sTexture, texCoord) * uColor;\\n}\\n\\n\\n\",\n"
- " \"geometry-type\": \"GEOMETRY_TYPE_IMAGE\"\n"
+ " \"geometryType\": \"GEOMETRY_TYPE_IMAGE\"\n"
" },\n"
- " \"geometry-hints\": \"HINT_NONE\",\n"
- " \"grid-density\": 0,\n"
+ " \"geometryHints\": \"HINT_NONE\",\n"
+ " \"gridDensity\": 0,\n"
" \"loop\": true,\n"
" \"uAmplitude\": 0.02,\n"
" \"uTime\": 0.0\n"
"[{"
"\"type\": \"Actor\","
"\"size\": [100,100,1],"
- "\"parent-origin\": \"TOP_LEFT\","
- "\"anchor-point\": \"TOP_LEFT\","
+ "\"parentOrigin\": \"TOP_LEFT\","
+ "\"anchorPoint\": \"TOP_LEFT\","
"\"signals\": [{"
"\"name\": \"touched\","
"\"action\": \"quit\""
"{\n"
"\"templates\":\n"
"{\n"
- " \"image-tree\": { \n"
+ " \"imageTree\": { \n"
" \"type\": \"ImageActor\",\n"
" \"size\": [100,100,1],\n"
- " \"parent-origin\": [0.5, 0.5, 0.5],\n"
+ " \"parentOrigin\": [0.5, 0.5, 0.5],\n"
" \"position\": [\n"
" 0.40461349487305,\n"
" 0.9150390625,\n"
" \"actors\": [\n"
" {\n"
" \"type\":\"ImageActor\",\n"
- " \"name\":\"child-image\" \n"
+ " \"name\":\"childImage\" \n"
" }\n"
" ]\n"
" }\n"
"},\n"
" \"stage\": [\n"
" {\n"
- " \"type\": \"image-tree\",\n"
+ " \"type\": \"imageTree\",\n"
" \"name\": \"Image1\",\n"
" \"effect\": \"Ripple2D\",\n"
" \"image\": \"offscreen\""
" }\n"
" ],\n"
- " \"shader-effects\": {\n"
+ " \"shaderEffects\": {\n"
" \"Ripple2D\": {\n"
" \"program\": {\n"
" \"vertexPrefix\": \"\",\n"
" \"vertex\": \"void main(void)\\n{\\n gl_Position = uProjection * uModelView * vec4(aPosition, 1.0);\\n vTexCoord = aTexCoord;\\n}\\n\\n\",\n"
" \"fragmentPrefix\": \"\",\n"
" \"fragment\": \"precision mediump float;\\nuniform float uAmplitude; // 0.02; (< 1)\\nuniform float uTime;\\nvoid main()\\n{\\n highp vec2 textureSize = sTextureRect.zw - sTextureRect.xy;\\n highp vec2 pos = -1.0 + 2.0 * vTexCoord.st/textureSize;\\n highp float len = length(pos);\\n highp vec2 texCoord = vTexCoord.st/textureSize + pos/len * sin( len * 12.0 - uTime * 4.0 ) * uAmplitude; \\n gl_FragColor = texture2D(sTexture, texCoord) * uColor;\\n}\\n\\n\\n\",\n"
- " \"geometry-type\": \"GEOMETRY_TYPE_IMAGE\"\n"
+ " \"geometryType\": \"GEOMETRY_TYPE_IMAGE\"\n"
" },\n"
- " \"geometry-hints\": \"HINT_NONE\",\n"
- " \"grid-density\": 0,\n"
+ " \"geometryHints\": \"HINT_NONE\",\n"
+ " \"gridDensity\": 0,\n"
" \"loop\": true,\n"
" \"uAmplitude\": 0.02,\n"
" \"uTime\": 0.0\n"
" }\n"
" },\n"
- " \"frame-buffer-images\": {\n"
+ " \"frameBufferImages\": {\n"
" \"offscreen\": {\n"
" \"type\": \"FrameBufferImage\","
- " \"pixel-format\":\"RGBA8888\","
+ " \"pixelFormat\":\"RGBA8888\","
" \"width\": 400,"
" \"height\": 400"
" }"
" \"type\": \"Actor\",\n"
" \"name\": \"actor\",\n"
" \"size\": [100,100,1],\n"
- " \"parent-origin\": \"TOP_LEFT\",\n"
- " \"anchor-point\": \"TOP_LEFT\",\n"
+ " \"parentOrigin\": \"TOP_LEFT\",\n"
+ " \"anchorPoint\": \"TOP_LEFT\",\n"
" \"actors\": [{\n"
" \"type\": \"Actor\",\n"
- " \"name\": \"sub-actor\",\n"
+ " \"name\": \"subActor\",\n"
" \"visible\": false\n"
" }],\n"
" \"signals\": [{\n"
" \"name\": \"touched\",\n"
" \"action\": \"hide\",\n"
" \"actor\": \"actor\",\n"
- " \"child-actor\": \"sub-actor\"\n"
+ " \"childActor\": \"subActor\"\n"
" }]\n"
" }]\n"
"}\n"
application.SendNotification();
application.Render();
- Actor actor = Stage::GetCurrent().GetRootLayer().FindChildByName("sub-actor");
+ Actor actor = Stage::GetCurrent().GetRootLayer().FindChildByName("subActor");
DALI_TEST_CHECK( actor );
DALI_TEST_CHECK( !actor.IsVisible() );
" 0.9150390625,\n"
" 0.0\n"
" ],\n"
- " \"parent-origin\": [0.5, 0.5, 0.5],\n"
+ " \"parentOrigin\": [0.5, 0.5, 0.5],\n"
" \"size\": [300, 300, 0],\n"
" \"image\": \"fb0\",\n"
- " \"clear-color\": [1,0,0,1]\n"
+ " \"clearColor\": [1,0,0,1]\n"
" },\n"
" {\n"
" \"type\": \"ImageActor\",\n"
" \"name\": \"Image1\",\n"
" \"size\": [200, 200, 0],\n"
- " \"parent-origin\": [0.5, 0.5, 0.5],\n"
+ " \"parentOrigin\": [0.5, 0.5, 0.5],\n"
" \"effect\": \"Ripple2D\",\n"
" \"image\": {\n"
" \"filename\": \"{DALI_IMAGE_DIR}gallery-medium-25.jpg\",\n"
" \"width\": 200,\n"
" \"height\": 80,\n"
- " \"load-policy\": \"IMMEDIATE\",\n"
- " \"release-policy\": \"NEVER\"\n"
+ " \"loadPolicy\": \"IMMEDIATE\",\n"
+ " \"releasePolicy\": \"NEVER\"\n"
" },\n"
" \"signals\": [\n"
" {\n"
- " \"name\": \"on-stage\",\n"
+ " \"name\": \"onStage\",\n"
" \"action\": \"play\",\n"
" \"animation\": \"Animation_1\"\n"
" }\n"
" {\n"
" \"type\":\"CameraActor\",\n"
" \"name\":\"fbCam\",\n"
- " \"aspect-ratio\": \"{FB_ASPECT_RATIO}\",\n"
- " \"projection-mode\": \"PERSPECTIVE_PROJECTION\",\n"
- " \"field-of-view\": 0.785,\n"
- " \"invert-y-axis\": true\n"
+ " \"aspectRatio\": \"{FB_ASPECT_RATIO}\",\n"
+ " \"projectionMode\": \"PERSPECTIVE_PROJECTION\",\n"
+ " \"fieldOfView\": 0.785,\n"
+ " \"invertYAxis\": true\n"
" }\n"
" ],\n"
- " \"frame-buffer-images\":\n"
+ " \"frameBufferImages\":\n"
" {\n"
" \"fb0\":\n"
" {\n"
" \"type\": \"FrameBufferImage\",\n"
- " \"width\": { \"type-cast\":\"float\", \"value\":\"{FB_WIDTH}\" },\n"
- " \"height\": { \"type-cast\":\"float\", \"value\":\"{FB_HEIGHT}\" }\n"
+ " \"width\": { \"typeCast\":\"float\", \"value\":\"{FB_WIDTH}\" },\n"
+ " \"height\": { \"typeCast\":\"float\", \"value\":\"{FB_HEIGHT}\" }\n"
" }\n"
" },\n"
- " \"render-tasks\":\n"
+ " \"renderTasks\":\n"
" {\n"
" \"stage\":\n"
" [\n"
" {\n"
- " \"source-actor\": \"fbOnStage\"\n"
+ " \"sourceActor\": \"fbOnStage\"\n"
" },\n"
" {\n"
- " \"source-actor\": \"Image1\",\n"
- " \"target-frame-buffer\": \"fb0\",\n"
- " \"viewport-size\":\"{FB_SIZE}\",\n"
- " \"camera-actor\":\"fbCam\"\n"
+ " \"sourceActor\": \"Image1\",\n"
+ " \"targetFrameBuffer\": \"fb0\",\n"
+ " \"viewportSize\":\"{FB_SIZE}\",\n"
+ " \"cameraActor\":\"fbCam\"\n"
" }\n"
" ]\n"
" },\n"
" \"actor\": \"Image1\",\n"
" \"property\": \"uTime\",\n"
" \"value\": 10.0,\n"
- " \"alpha-function\": \"LINEAR\",\n"
- " \"time-period\": {\n"
+ " \"alphaFunction\": \"LINEAR\",\n"
+ " \"timePeriod\": {\n"
" \"delay\": 0,\n"
" \"duration\": 10.0\n"
" },\n"
" ]\n"
" }\n"
" },\n"
- " \"shader-effects\": {\n"
+ " \"shaderEffects\": {\n"
" \"Ripple2D\": {\n"
" \"program\": {\n"
" \"vertexPrefix\": \"\",\n"
" \"vertex\": \"void main(void)\\n{\\n gl_Position = uProjection * uModelView * vec4(aPosition, 1.0);\\n vTexCoord = aTexCoord;\\n}\\n\\n\",\n"
" \"fragmentPrefix\": \"\",\n"
" \"fragment\": \"precision mediump float;\\nuniform float uAmplitude; // 0.02; (< 1)\\nuniform float uTime;\\nvoid main()\\n{\\n highp vec2 textureSize = sTextureRect.zw - sTextureRect.xy;\\n highp vec2 pos = -1.0 + 2.0 * vTexCoord.st/textureSize;\\n highp float len = length(pos);\\n highp vec2 texCoord = vTexCoord.st/textureSize + pos/len * sin( len * 12.0 - uTime * 4.0 ) * uAmplitude; \\n gl_FragColor = texture2D(sTexture, texCoord) * uColor;\\n}\\n\\n\\n\",\n"
- " \"geometry-type\": \"GEOMETRY_TYPE_IMAGE\"\n"
+ " \"geometryType\": \"GEOMETRY_TYPE_IMAGE\"\n"
" },\n"
- " \"geometry-hints\": \"HINT_NONE\",\n"
- " \"grid-density\": 0,\n"
+ " \"geometryHints\": \"HINT_NONE\",\n"
+ " \"gridDensity\": 0,\n"
" \"loop\": true,\n"
" \"uAmplitude\": 0.02,\n"
" \"uTime\": 0.0\n"
" \"type\": \"ImageActor\",\n"
" \"name\": \"Image1\",\n"
" \"size\": [200, 200, 0],\n"
- " \"parent-origin\": [0.5, 0.5, 0.5],\n"
+ " \"parentOrigin\": [0.5, 0.5, 0.5],\n"
" \"effect\": \"Ripple2D\",\n"
" \"image\": {\n"
" \"filename\": \"{DALI_IMAGE_DIR}gallery-medium-25.jpg\",\n"
" \"width\": 200,\n"
" \"height\": 80,\n"
- " \"load-policy\": \"IMMEDIATE\",\n"
- " \"release-policy\": \"NEVER\"\n"
+ " \"loadPolicy\": \"IMMEDIATE\",\n"
+ " \"releasePolicy\": \"NEVER\"\n"
" },\n"
" \"signals\": [\n"
" {\n"
- " \"name\": \"on-stage\",\n"
+ " \"name\": \"onStage\",\n"
" \"action\": \"play\",\n"
- " \"animation\": \"path-animation\"\n"
+ " \"animation\": \"pathAnimation\"\n"
" },\n"
" {\n"
- " \"name\": \"on-stage\",\n"
+ " \"name\": \"onStage\",\n"
" \"action\": \"applyConstraint\",\n"
" \"constrainer\": \"constrainer0\",\n"
" \"properties\":\n"
" [\n"
" {\n"
" \"source\": \"Image1\",\n"
- " \"sourceProperty\": \"position-x\",\n"
+ " \"sourceProperty\": \"positionX\",\n"
" \"target\": \"Image1\",\n"
- " \"targetProperty\": \"color-red\",\n"
+ " \"targetProperty\": \"colorRed\",\n"
" \"range\": [-300,300]\n"
" }\n"
" ]\n"
" },\n"
" {\n"
- " \"name\": \"on-stage\",\n"
+ " \"name\": \"onStage\",\n"
" \"action\": \"applyConstraint\",\n"
" \"constrainer\": \"constrainer1\",\n"
" \"properties\":\n"
" [\n"
" {\n"
" \"source\": \"Image1\",\n"
- " \"sourceProperty\": \"position-x\",\n"
+ " \"sourceProperty\": \"positionX\",\n"
" \"target\": \"Image1\",\n"
- " \"targetProperty\": \"color-blue\",\n"
+ " \"targetProperty\": \"colorBlue\",\n"
" \"range\": [-300,300]\n"
" }\n"
" ]\n"
" {\n"
" \"type\": \"PathConstrainer\",\n"
" \"points\": [ [0, 0, 0], [0,0,0], [0,0,0] ],\n"
- " \"control-points\": [ [0, 0, 0], [0,0,0], [0,0,0] ]\n"
+ " \"controlPoints\": [ [0, 0, 0], [0,0,0], [0,0,0] ]\n"
" },\n"
" \"constrainer1\":\n"
" {\n"
" }\n"
" },\n"
" \"animations\": {\n"
- " \"path-animation\": {\n"
+ " \"pathAnimation\": {\n"
" \"duration\": 3.0,\n"
" \"properties\":\n"
" [{\n"
" \"actor\": \"Image1\",\n"
" \"path\":\"path0\",\n"
" \"forward\":[1,0,0],\n"
- " \"alpha-function\": \"EASE_IN_OUT\",\n"
- " \"time-period\": {\n"
+ " \"alphaFunction\": \"EASE_IN_OUT\",\n"
+ " \"timePeriod\": {\n"
" \"delay\": 0,\n"
" \"duration\": 3\n"
" }\n"
" \"actor\": \"Image1\",\n"
" \"property\": \"uTime\",\n"
" \"value\": 10.0,\n"
- " \"alpha-function\": \"LINEAR\",\n"
- " \"time-period\": {\n"
+ " \"alphaFunction\": \"LINEAR\",\n"
+ " \"timePeriod\": {\n"
" \"delay\": 0,\n"
" \"duration\": 10.0\n"
" },\n"
" \"actor\": \"Image1\",\n"
" \"property\": \"uTime\",\n"
" \"value\": 10.0,\n"
- " \"alpha-function\": \"LINEAR\",\n"
- " \"time-period\": {\n"
+ " \"alphaFunction\": \"LINEAR\",\n"
+ " \"timePeriod\": {\n"
" \"delay\": 0,\n"
" \"duration\": 10.0\n"
" },\n"
" ]\n"
" }\n"
" },\n"
- " \"shader-effects\": {\n"
+ " \"shaderEffects\": {\n"
" \"Ripple2D\": {\n"
" \"program\": {\n"
" \"vertexPrefix\": \"\",\n"
" \"vertex\": \"void main(void)\\n{\\n gl_Position = uProjection * uModelView * vec4(aPosition, 1.0);\\n vTexCoord = aTexCoord;\\n}\\n\\n\",\n"
" \"fragmentPrefix\": \"\",\n"
" \"fragment\": \"precision mediump float;\\nuniform float uAmplitude; // 0.02; (< 1)\\nuniform float uTime;\\nvoid main()\\n{\\n highp vec2 textureSize = sTextureRect.zw - sTextureRect.xy;\\n highp vec2 pos = -1.0 + 2.0 * vTexCoord.st/textureSize;\\n highp float len = length(pos);\\n highp vec2 texCoord = vTexCoord.st/textureSize + pos/len * sin( len * 12.0 - uTime * 4.0 ) * uAmplitude; \\n gl_FragColor = texture2D(sTexture, texCoord) * uColor;\\n}\\n\\n\\n\",\n"
- " \"geometry-type\": \"GEOMETRY_TYPE_IMAGE\"\n"
+ " \"geometryType\": \"GEOMETRY_TYPE_IMAGE\"\n"
" },\n"
- " \"geometry-hints\": \"HINT_NONE\",\n"
- " \"grid-density\": 0,\n"
+ " \"geometryHints\": \"HINT_NONE\",\n"
+ " \"gridDensity\": 0,\n"
" \"loop\": true,\n"
" \"uAmplitude\": 0.02,\n"
" \"uTime\": 0.0\n"
Actor footerActor = Actor::New();
// The confirmation popup can use any control type for the ok or cancel buttons.
- // It requires that the name is "control-ok" to provide the "control-signal-ok" signal.
+ // It requires that the name is "controlOk" to provide the "controlSignalOk" signal.
PushButton buttonOK = PushButton::New();
- buttonOK.SetName( "control-ok" );
+ buttonOK.SetName( "controlOk" );
footerActor.Add( buttonOK );
PushButton buttonCancel = PushButton::New();
- buttonCancel.SetName( "control-cancel" );
+ buttonCancel.SetName( "controlCancel" );
footerActor.Add( buttonCancel );
popup.SetFooter( footerActor );
- // Tell the confirmation popup to connect to the signal in our button called "on-stage".
- popup.SetProperty( Toolkit::ConfirmationPopup::Property::CONNECT_SIGNAL_OK_SELECTED, "on-stage" );
+ // Tell the confirmation popup to connect to the signal in our button called "onStage".
+ popup.SetProperty( Toolkit::ConfirmationPopup::Property::CONNECT_SIGNAL_OK_SELECTED, "onStage" );
std::string resultProperty;
DALI_TEST_CHECK( popup.GetProperty( Toolkit::ConfirmationPopup::Property::CONNECT_SIGNAL_OK_SELECTED ).Get( resultProperty ) );
- DALI_TEST_EQUALS( resultProperty, "on-stage", TEST_LOCATION );
+ DALI_TEST_EQUALS( resultProperty, "onStage", TEST_LOCATION );
// Connect to the confirmation popup's OK signal. This signal is dynamically created upon connection.
gSignalReceivedOK = false;
gSignalReceivedCancel = false;
TestConnectionTrackerObject* testTracker = new TestConnectionTrackerObject();
- popup.ConnectSignal( testTracker, "control-signal-ok", ConfirmationPopupOKTestFunctor() );
+ popup.ConnectSignal( testTracker, "controlSignalOk", ConfirmationPopupOKTestFunctor() );
// Check no signal has occurred yet.
DALI_TEST_CHECK( !gSignalReceivedOK );
// Remove the popup from the stage, and connect the cancel signal.
popup.Unparent();
- popup.SetProperty( Toolkit::ConfirmationPopup::Property::CONNECT_SIGNAL_CANCEL_SELECTED, "on-stage" );
+ popup.SetProperty( Toolkit::ConfirmationPopup::Property::CONNECT_SIGNAL_CANCEL_SELECTED, "onStage" );
DALI_TEST_CHECK( popup.GetProperty( Toolkit::ConfirmationPopup::Property::CONNECT_SIGNAL_CANCEL_SELECTED ).Get( resultProperty ) );
- DALI_TEST_EQUALS( resultProperty, "on-stage", TEST_LOCATION );
+ DALI_TEST_EQUALS( resultProperty, "onStage", TEST_LOCATION );
- popup.ConnectSignal( testTracker, "control-signal-cancel", ConfirmationPopupCancelTestFunctor() );
+ popup.ConnectSignal( testTracker, "controlSignalCancel", ConfirmationPopupCancelTestFunctor() );
// Check the cancel signal has not occurred yet.
DALI_TEST_CHECK( gSignalReceivedOK );
Actor footerActor = Actor::New();
PushButton buttonOK = PushButton::New();
- buttonOK.SetName( "control-ok-misnamed" );
+ buttonOK.SetName( "controlOkMisnamed" );
popup.SetFooter( buttonOK );
- // Tell the confirmation popup to connect to the signal in our button called "on-stage".
- popup.SetProperty( Toolkit::ConfirmationPopup::Property::CONNECT_SIGNAL_OK_SELECTED, "on-stage" );
+ // Tell the confirmation popup to connect to the signal in our button called "onStage".
+ popup.SetProperty( Toolkit::ConfirmationPopup::Property::CONNECT_SIGNAL_OK_SELECTED, "onStage" );
// Connect to the confirmation popup's OK signal.
gSignalReceivedOK = false;
- // The connection will fail at this point as no actor with the name "control-ok" will be located.
+ // The connection will fail at this point as no actor with the name "controlOk" will be located.
TestConnectionTrackerObject* testTracker = new TestConnectionTrackerObject();
- popup.ConnectSignal( testTracker, "control-signal-ok", ConfirmationPopupOKTestFunctor() );
+ popup.ConnectSignal( testTracker, "controlSignalOk", ConfirmationPopupOKTestFunctor() );
// Check no signal has occurred yet.
DALI_TEST_CHECK( !gSignalReceivedOK );
Property::Value propValue = control.GetProperty( Control::Property::BACKGROUND );
Property::Map* resultMap = propValue.GetMap();
- DALI_TEST_CHECK( resultMap->Find( "renderer-type" ) );
- DALI_TEST_CHECK( resultMap->Find( "renderer-type" )->Get<std::string>() == "color-renderer" );
- DALI_TEST_CHECK( resultMap->Find( "blend-color" ) );
- DALI_TEST_CHECK( resultMap->Find( "blend-color" )->Get<Vector4>() == Color::RED );
+ DALI_TEST_CHECK( resultMap->Find( "rendererType" ) );
+ DALI_TEST_CHECK( resultMap->Find( "rendererType" )->Get<std::string>() == "colorRenderer" );
+ DALI_TEST_CHECK( resultMap->Find( "blendColor" ) );
+ DALI_TEST_CHECK( resultMap->Find( "blendColor" )->Get<Vector4>() == Color::RED );
control.SetBackgroundColor( Color::YELLOW );
propValue = control.GetProperty( Control::Property::BACKGROUND );
resultMap = propValue.GetMap();
- DALI_TEST_CHECK( resultMap->Find( "blend-color" ) );
- DALI_TEST_CHECK( resultMap->Find( "blend-color" )->Get<Vector4>() == Color::YELLOW );
+ DALI_TEST_CHECK( resultMap->Find( "blendColor" ) );
+ DALI_TEST_CHECK( resultMap->Find( "blendColor" )->Get<Vector4>() == Color::YELLOW );
END_TEST;
}
Property::Value propValue = control.GetProperty( Control::Property::BACKGROUND );
Property::Map* resultMap = propValue.GetMap();
- DALI_TEST_CHECK( resultMap->Find( "renderer-type" ) );
- DALI_TEST_CHECK( resultMap->Find( "renderer-type" )->Get<std::string>() == "image-renderer" );
- DALI_TEST_CHECK( resultMap->Find( "image-url" ) );
- DALI_TEST_CHECK( resultMap->Find( "image-url" )->Get<std::string>() == "TestImage" );
+ DALI_TEST_CHECK( resultMap->Find( "rendererType" ) );
+ DALI_TEST_CHECK( resultMap->Find( "rendererType" )->Get<std::string>() == "imageRenderer" );
+ DALI_TEST_CHECK( resultMap->Find( "imageUrl" ) );
+ DALI_TEST_CHECK( resultMap->Find( "imageUrl" )->Get<std::string>() == "TestImage" );
image = ResourceImage::New("TestImage2");
control.SetBackgroundImage( image );
propValue = control.GetProperty( Control::Property::BACKGROUND );
resultMap = propValue.GetMap();
- DALI_TEST_CHECK( resultMap->Find( "image-url" ) );
- DALI_TEST_CHECK( resultMap->Find( "image-url" )->Get<std::string>() == "TestImage2" );
+ DALI_TEST_CHECK( resultMap->Find( "imageUrl" ) );
+ DALI_TEST_CHECK( resultMap->Find( "imageUrl" )->Get<std::string>() == "TestImage2" );
END_TEST;
}
control.SetProperty( Control::Property::BACKGROUND, colorMap );
Property::Value propValue = control.GetProperty( Control::Property::BACKGROUND );
Property::Map* resultMap = propValue.GetMap();
- DALI_TEST_CHECK( resultMap->Find( "renderer-type" ) );
- DALI_TEST_CHECK( resultMap->Find( "renderer-type" )->Get<std::string>() == "color-renderer" );
- DALI_TEST_CHECK( resultMap->Find( "blend-color" ) );
- DALI_TEST_CHECK( resultMap->Find( "blend-color" )->Get<Vector4>() == Color::RED );
+ DALI_TEST_CHECK( resultMap->Find( "rendererType" ) );
+ DALI_TEST_CHECK( resultMap->Find( "rendererType" )->Get<std::string>() == "colorRenderer" );
+ DALI_TEST_CHECK( resultMap->Find( "blendColor" ) );
+ DALI_TEST_CHECK( resultMap->Find( "blendColor" )->Get<Vector4>() == Color::RED );
Property::Map imageMap;
imageMap[ "filename" ] = "TestImage";
control.SetProperty( Control::Property::BACKGROUND, imageMap );
propValue = control.GetProperty( Control::Property::BACKGROUND );
resultMap = propValue.GetMap();
- DALI_TEST_CHECK( resultMap->Find( "renderer-type" ) );
- DALI_TEST_CHECK( resultMap->Find( "renderer-type" )->Get<std::string>() == "image-renderer" );
- DALI_TEST_CHECK( resultMap->Find( "image-url" ) );
- DALI_TEST_CHECK( resultMap->Find( "image-url" )->Get<std::string>() == "TestImage" );
+ DALI_TEST_CHECK( resultMap->Find( "rendererType" ) );
+ DALI_TEST_CHECK( resultMap->Find( "rendererType" )->Get<std::string>() == "imageRenderer" );
+ DALI_TEST_CHECK( resultMap->Find( "imageUrl" ) );
+ DALI_TEST_CHECK( resultMap->Find( "imageUrl" )->Get<std::string>() == "TestImage" );
Property::Map rendererMap;
- rendererMap["renderer-type"] = "color-renderer";
- rendererMap["blend-color"] = Color::CYAN;
+ rendererMap["rendererType"] = "colorRenderer";
+ rendererMap["blendColor"] = Color::CYAN;
control.SetProperty( Control::Property::BACKGROUND, rendererMap );
propValue = control.GetProperty( Control::Property::BACKGROUND );
resultMap = propValue.GetMap();
- DALI_TEST_CHECK( resultMap->Find( "renderer-type" ) );
- DALI_TEST_CHECK( resultMap->Find( "renderer-type" )->Get<std::string>() == "color-renderer" );
- DALI_TEST_CHECK( resultMap->Find( "blend-color" ) );
- DALI_TEST_CHECK( resultMap->Find( "blend-color" )->Get<Vector4>() == Color::CYAN );
+ DALI_TEST_CHECK( resultMap->Find( "rendererType" ) );
+ DALI_TEST_CHECK( resultMap->Find( "rendererType" )->Get<std::string>() == "colorRenderer" );
+ DALI_TEST_CHECK( resultMap->Find( "blendColor" ) );
+ DALI_TEST_CHECK( resultMap->Find( "blendColor" )->Get<Vector4>() == Color::CYAN );
Property::Map emptyMap;
control.SetProperty( Control::Property::BACKGROUND, emptyMap );
DALI_TEST_CHECK( control.GetPinchGestureDetector() );
DALI_TEST_CHECK( !control.GetLongPressGestureDetector() );
- control.ConnectSignal( &connectionTracker, "long-pressed", &TestVoidCallback );
+ control.ConnectSignal( &connectionTracker, "longPressed", &TestVoidCallback );
DALI_TEST_CHECK( control.GetLongPressGestureDetector() );
END_TEST;
DALI_TEST_CHECK( handle );
Property::Map attributes;
- DALI_TEST_EQUALS( false, handle.DoAction("accessibility-activated", attributes), TEST_LOCATION );
+ DALI_TEST_EQUALS( false, handle.DoAction("accessibilityActivated", attributes), TEST_LOCATION );
END_TEST;
}
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
- propertyMap.Insert("renderer-type", "color-renderer");
- propertyMap.Insert("blend-color", Color::BLUE);
+ propertyMap.Insert("rendererType", "colorRenderer");
+ propertyMap.Insert("blendColor", Color::BLUE);
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
ControlRenderer controlRendererCopy( controlRenderer );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
- propertyMap.Insert("renderer-type", "color-renderer");
- propertyMap.Insert("blend-color", Color::BLUE);
+ propertyMap.Insert("rendererType", "colorRenderer");
+ propertyMap.Insert("blendColor", Color::BLUE);
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
controlRenderer.SetDepthIndex( 1.f );
// gradient renderer
Property::Map propertyMap;
- propertyMap.Insert("renderer-type", "gradient-renderer");
+ propertyMap.Insert("rendererType", "gradientRenderer");
Vector2 start(-1.f, -1.f);
Vector2 end(1.f, 1.f);
- propertyMap.Insert("gradient-start-position", start);
- propertyMap.Insert("gradient-end-position", end);
- propertyMap.Insert("gradient-stop-offset", Vector2(0.f, 1.f));
+ propertyMap.Insert("gradientStartPosition", start);
+ propertyMap.Insert("gradientEndPosition", end);
+ propertyMap.Insert("gradientStopOffset", Vector2(0.f, 1.f));
Property::Array stopColors;
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::GREEN );
- propertyMap.Insert("gradient-stop-color", stopColors);
+ propertyMap.Insert("gradientStopColor", stopColors);
ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap);
gradientRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( gradientRenderer.GetSize(), rendererSize, TEST_LOCATION );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
- propertyMap.Insert("renderer-type", "color-renderer");
- propertyMap.Insert("blend-color", Color::BLUE);
+ propertyMap.Insert("rendererType", "colorRenderer");
+ propertyMap.Insert("blendColor", Color::BLUE);
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
Actor actor = Actor::New();
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
- propertyMap.Insert("renderer-type", "color-renderer");
- propertyMap.Insert("blend-color", Color::BLUE);
+ propertyMap.Insert("rendererType", "colorRenderer");
+ propertyMap.Insert("blendColor", Color::BLUE);
ControlRenderer colorRenderer = factory.GetControlRenderer( propertyMap );
Property::Map resultMap;
colorRenderer.CreatePropertyMap( resultMap );
- Property::Value* typeValue = resultMap.Find( "renderer-type", Property::STRING );
+ Property::Value* typeValue = resultMap.Find( "rendererType", Property::STRING );
DALI_TEST_CHECK( typeValue );
- DALI_TEST_CHECK( typeValue->Get<std::string>() == "color-renderer" );
+ DALI_TEST_CHECK( typeValue->Get<std::string>() == "colorRenderer" );
- Property::Value* colorValue = resultMap.Find( "blend-color", Property::VECTOR4 );
+ Property::Value* colorValue = resultMap.Find( "blendColor", Property::VECTOR4 );
DALI_TEST_CHECK( colorValue );
DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
factory.ResetRenderer( colorRenderer, actor, Color::CYAN );
colorRenderer.CreatePropertyMap( resultMap );
- colorValue = resultMap.Find( "blend-color", Property::VECTOR4 );
+ colorValue = resultMap.Find( "blendColor", Property::VECTOR4 );
DALI_TEST_CHECK( colorValue );
DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
- propertyMap.Insert("renderer-type", "border-renderer");
- propertyMap.Insert("border-color", Color::BLUE);
- propertyMap.Insert("border-size", 5.f);
+ propertyMap.Insert("rendererType", "borderRenderer");
+ propertyMap.Insert("borderColor", Color::BLUE);
+ propertyMap.Insert("borderSize", 5.f);
ControlRenderer borderRenderer = factory.GetControlRenderer( propertyMap );
Property::Map resultMap;
borderRenderer.CreatePropertyMap( resultMap );
// check the property values from the returned map from control renderer
- Property::Value* typeValue = resultMap.Find( "renderer-type", Property::STRING );
+ Property::Value* typeValue = resultMap.Find( "rendererType", Property::STRING );
DALI_TEST_CHECK( typeValue );
- DALI_TEST_CHECK( typeValue->Get<std::string>() == "border-renderer" );
+ DALI_TEST_CHECK( typeValue->Get<std::string>() == "borderRenderer" );
- Property::Value* colorValue = resultMap.Find( "border-color", Property::VECTOR4 );
+ Property::Value* colorValue = resultMap.Find( "borderColor", Property::VECTOR4 );
DALI_TEST_CHECK( colorValue );
DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
- Property::Value* sizeValue = resultMap.Find( "border-size", Property::FLOAT );
+ Property::Value* sizeValue = resultMap.Find( "borderSize", Property::FLOAT );
DALI_TEST_CHECK( sizeValue );
DALI_TEST_CHECK( sizeValue->Get<float>() == 5.f );
borderRenderer = factory.GetControlRenderer( 10.f, Color::CYAN );
borderRenderer.CreatePropertyMap( resultMap );
- typeValue = resultMap.Find( "renderer-type", Property::STRING );
+ typeValue = resultMap.Find( "rendererType", Property::STRING );
DALI_TEST_CHECK( typeValue );
- DALI_TEST_CHECK( typeValue->Get<std::string>() == "border-renderer" );
+ DALI_TEST_CHECK( typeValue->Get<std::string>() == "borderRenderer" );
- colorValue = resultMap.Find( "border-color", Property::VECTOR4 );
+ colorValue = resultMap.Find( "borderColor", Property::VECTOR4 );
DALI_TEST_CHECK( colorValue );
DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
- colorValue = resultMap.Find( "border-size", Property::FLOAT );
+ colorValue = resultMap.Find( "borderSize", Property::FLOAT );
DALI_TEST_CHECK( colorValue );
DALI_TEST_CHECK( colorValue->Get<float>() == 10.f );
DALI_TEST_CHECK( factory );
Property::Map propertyMap;
- propertyMap.Insert("renderer-type", "gradient-renderer");
+ propertyMap.Insert("rendererType", "gradientRenderer");
Vector2 start(-1.f, -1.f);
Vector2 end(1.f, 1.f);
- propertyMap.Insert("gradient-start-position", start);
- propertyMap.Insert("gradient-end-position", end);
- propertyMap.Insert("gradient-spread-method", "repeat");
+ propertyMap.Insert("gradientStartPosition", start);
+ propertyMap.Insert("gradientEndPosition", end);
+ propertyMap.Insert("gradientSpreadMethod", "repeat");
- propertyMap.Insert("gradient-stop-offset", Vector2(0.2f, 0.8f));
+ propertyMap.Insert("gradientStopOffset", Vector2(0.2f, 0.8f));
Property::Array stopColors;
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::GREEN );
- propertyMap.Insert("gradient-stop-color", stopColors);
+ propertyMap.Insert("gradientStopColor", stopColors);
ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap);
gradientRenderer.CreatePropertyMap( resultMap );
// check the property values from the returned map from control renderer
- Property::Value* value = resultMap.Find( "renderer-type", Property::STRING );
+ Property::Value* value = resultMap.Find( "rendererType", Property::STRING );
DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<std::string>() == "gradient-renderer" );
+ DALI_TEST_CHECK( value->Get<std::string>() == "gradientRenderer" );
- value = resultMap.Find( "gradient-units", Property::STRING );
+ value = resultMap.Find( "gradientUnits", Property::STRING );
DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<std::string>() == "object-bounding-box" );
+ DALI_TEST_CHECK( value->Get<std::string>() == "objectBoundingBox" );
- value = resultMap.Find( "gradient-spread-method", Property::STRING );
+ value = resultMap.Find( "gradientSpreadMethod", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "repeat" );
- value = resultMap.Find( "gradient-start-position", Property::VECTOR2 );
+ value = resultMap.Find( "gradientStartPosition", Property::VECTOR2 );
DALI_TEST_CHECK( value );
DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
- value = resultMap.Find( "gradient-end-position", Property::VECTOR2 );
+ value = resultMap.Find( "gradientEndPosition", Property::VECTOR2 );
DALI_TEST_CHECK( value );
DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
- value = resultMap.Find( "gradient-stop-offset", Property::ARRAY );
+ value = resultMap.Find( "gradientStopOffset", Property::ARRAY );
DALI_TEST_CHECK( value );
Property::Array* offsetArray = value->GetArray();
DALI_TEST_CHECK( offsetArray->Count() == 2 );
DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.2f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.8f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
- value = resultMap.Find( "gradient-stop-color", Property::ARRAY );
+ value = resultMap.Find( "gradientStopColor", Property::ARRAY );
DALI_TEST_CHECK( value );
Property::Array* colorArray = value->GetArray();
DALI_TEST_CHECK( colorArray->Count() == 2 );
DALI_TEST_CHECK( factory );
Property::Map propertyMap;
- propertyMap.Insert("renderer-type", "gradient-renderer");
+ propertyMap.Insert("rendererType", "gradientRenderer");
Vector2 center(100.f, 100.f);
float radius = 100.f;
- propertyMap.Insert("gradient-units", "user-space");
- propertyMap.Insert("gradient-center", center);
- propertyMap.Insert("gradient-radius", radius);
- propertyMap.Insert("gradient-stop-offset", Vector3(0.1f, 0.3f, 1.1f));
+ propertyMap.Insert("gradientUnits", "userSpace");
+ propertyMap.Insert("gradientCenter", center);
+ propertyMap.Insert("gradientRadius", radius);
+ propertyMap.Insert("gradientStopOffset", Vector3(0.1f, 0.3f, 1.1f));
Property::Array stopColors;
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::BLACK );
stopColors.PushBack( Color::GREEN );
- propertyMap.Insert("gradient-stop-color", stopColors);
+ propertyMap.Insert("gradientStopColor", stopColors);
ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap);
DALI_TEST_CHECK( gradientRenderer );
gradientRenderer.CreatePropertyMap( resultMap );
// check the property values from the returned map from control renderer
- Property::Value* value = resultMap.Find( "renderer-type", Property::STRING );
+ Property::Value* value = resultMap.Find( "rendererType", Property::STRING );
DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<std::string>() == "gradient-renderer" );
+ DALI_TEST_CHECK( value->Get<std::string>() == "gradientRenderer" );
- value = resultMap.Find( "gradient-units", Property::STRING );
+ value = resultMap.Find( "gradientUnits", Property::STRING );
DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<std::string>() == "user-space" );
+ DALI_TEST_CHECK( value->Get<std::string>() == "userSpace" );
- value = resultMap.Find( "gradient-spread-method", Property::STRING );
+ value = resultMap.Find( "gradientSpreadMethod", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "pad" );
- value = resultMap.Find( "gradient-center", Property::VECTOR2 );
+ value = resultMap.Find( "gradientCenter", Property::VECTOR2 );
DALI_TEST_CHECK( value );
DALI_TEST_EQUALS( value->Get<Vector2>(), center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
- value = resultMap.Find( "gradient-radius", Property::FLOAT );
+ value = resultMap.Find( "gradientRadius", Property::FLOAT );
DALI_TEST_CHECK( value );
DALI_TEST_EQUALS( value->Get<float>(), radius , Math::MACHINE_EPSILON_100, TEST_LOCATION );
- value = resultMap.Find( "gradient-stop-offset", Property::ARRAY );
+ value = resultMap.Find( "gradientStopOffset", Property::ARRAY );
DALI_TEST_CHECK( value );
Property::Array* offsetArray = value->GetArray();
DALI_TEST_CHECK( offsetArray->Count() == 3 );
// any stop value will be clamped to [0.0, 1.0];
DALI_TEST_EQUALS( offsetArray->GetElementAt(2).Get<float>(), 1.0f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
- value = resultMap.Find( "gradient-stop-color", Property::ARRAY );
+ value = resultMap.Find( "gradientStopColor", Property::ARRAY );
DALI_TEST_CHECK( value );
Property::Array* colorArray = value->GetArray();
DALI_TEST_CHECK( colorArray->Count() == 3 );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
- propertyMap.Insert( "renderer-type", "image-renderer" );
- propertyMap.Insert( "image-url", TEST_IMAGE_FILE_NAME );
- propertyMap.Insert( "image-desired-width", 20 );
- propertyMap.Insert( "image-desired-height", 30 );
- propertyMap.Insert( "image-fitting-mode", "fit-height" );
- propertyMap.Insert( "image-sampling-mode", "box-then-nearest" );
+ propertyMap.Insert( "rendererType", "imageRenderer" );
+ propertyMap.Insert( "imageUrl", TEST_IMAGE_FILE_NAME );
+ propertyMap.Insert( "imageDesiredWidth", 20 );
+ propertyMap.Insert( "imageDesiredHeight", 30 );
+ propertyMap.Insert( "imageFittingMode", "fitHeight" );
+ propertyMap.Insert( "imageSamplingMode", "boxThenNearest" );
ControlRenderer imageRenderer = factory.GetControlRenderer(propertyMap);
DALI_TEST_CHECK( imageRenderer );
imageRenderer.CreatePropertyMap( resultMap );
// check the property values from the returned map from control renderer
- Property::Value* value = resultMap.Find( "renderer-type", Property::STRING );
+ Property::Value* value = resultMap.Find( "rendererType", Property::STRING );
DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<std::string>() == "image-renderer" );
+ DALI_TEST_CHECK( value->Get<std::string>() == "imageRenderer" );
- value = resultMap.Find( "image-url", Property::STRING );
+ value = resultMap.Find( "imageUrl", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
- value = resultMap.Find( "image-fitting-mode", Property::STRING );
+ value = resultMap.Find( "imageFittingMode", Property::STRING );
DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<std::string>() == "fit-height" );
+ DALI_TEST_CHECK( value->Get<std::string>() == "fitHeight" );
- value = resultMap.Find( "image-sampling-mode", Property::STRING );
+ value = resultMap.Find( "imageSamplingMode", Property::STRING );
DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<std::string>() == "box-then-nearest" );
+ DALI_TEST_CHECK( value->Get<std::string>() == "boxThenNearest" );
- value = resultMap.Find( "image-desired-width", Property::INTEGER );
+ value = resultMap.Find( "imageDesiredWidth", Property::INTEGER );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<int>() == 20 );
- value = resultMap.Find( "image-desired-height", Property::INTEGER );
+ value = resultMap.Find( "imageDesiredHeight", Property::INTEGER );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<int>() == 30 );
imageRenderer = factory.GetControlRenderer(image);
imageRenderer.CreatePropertyMap( resultMap );
- value = resultMap.Find( "renderer-type", Property::STRING );
+ value = resultMap.Find( "rendererType", Property::STRING );
DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<std::string>() == "image-renderer" );
+ DALI_TEST_CHECK( value->Get<std::string>() == "imageRenderer" );
- value = resultMap.Find( "image-url", Property::STRING );
+ value = resultMap.Find( "imageUrl", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
- value = resultMap.Find( "image-fitting-mode", Property::STRING );
+ value = resultMap.Find( "imageFittingMode", Property::STRING );
DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<std::string>() == "shrink-to-fit" );
+ DALI_TEST_CHECK( value->Get<std::string>() == "shrinkToFit" );
- value = resultMap.Find( "image-sampling-mode", Property::STRING );
+ value = resultMap.Find( "imageSamplingMode", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == "box" );
- value = resultMap.Find( "image-desired-width", Property::INTEGER );
+ value = resultMap.Find( "imageDesiredWidth", Property::INTEGER );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<int>() == 100 );
- value = resultMap.Find( "image-desired-height", Property::INTEGER );
+ value = resultMap.Find( "imageDesiredHeight", Property::INTEGER );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<int>() == 200 );
RendererFactory factory = RendererFactory::Get();
Property::Map propertyMap;
- propertyMap.Insert( "renderer-type", "n-patch-renderer" );
- propertyMap.Insert( "image-url", TEST_NPATCH_FILE_NAME );
- propertyMap.Insert( "border-only", true );
+ propertyMap.Insert( "rendererType", "nPatchRenderer" );
+ propertyMap.Insert( "imageUrl", TEST_NPATCH_FILE_NAME );
+ propertyMap.Insert( "borderOnly", true );
ControlRenderer nPatchRenderer = factory.GetControlRenderer( propertyMap );
Property::Map resultMap;
nPatchRenderer.CreatePropertyMap( resultMap );
// check the property values from the returned map from control renderer
- Property::Value* value = resultMap.Find( "renderer-type", Property::STRING );
+ Property::Value* value = resultMap.Find( "rendererType", Property::STRING );
DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<std::string>() == "n-patch-renderer" );
+ DALI_TEST_CHECK( value->Get<std::string>() == "nPatchRenderer" );
- value = resultMap.Find( "image-url", Property::STRING );
+ value = resultMap.Find( "imageUrl", Property::STRING );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
- value = resultMap.Find( "border-only", Property::BOOLEAN );
+ value = resultMap.Find( "borderOnly", Property::BOOLEAN );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<bool>() );
'actor':'bump-image', \
'property':'uLightPosition', \
'value':[0.8, 0.0, -1.5], \
- 'alpha-function': 'BOUNCE', \
- 'time-period': { 'duration': 2.5 } \
+ 'alphaFunction': 'BOUNCE', \
+ 'timePeriod': { 'duration': 2.5 } \
} \
] \
} \
{ \
'duration': 5.0, \
'loop': true, \
- 'end-action':'DISCARD' \
+ 'endAction':'DISCARD' \
} \
} \
} \
'actor':'bump-image', \
'property':'uLightPosition', \
'value':[0.8, 0.0, -1.5], \
- 'alpha-function': 'BOUNCE', \
- 'time-period': { 'duration': 2.5 } \
+ 'alphaFunction': 'BOUNCE', \
+ 'timePeriod': { 'duration': 2.5 } \
} \
] \
} \
'actor':'bump-image', \
'property':'uLightPosition', \
'value':[0.8, 0.0, -1.5], \
- 'alpha-function': 'BOUNCE', \
- 'time-period': { 'duration': 2.5 } \
+ 'alphaFunction': 'BOUNCE', \
+ 'timePeriod': { 'duration': 2.5 } \
} \
] \
} \
Stage::GetCurrent().Add( landscapeView );
- // Test "page-size" property
- DALI_TEST_CHECK( landscapeView.GetPropertyIndex("page-size") == PageTurnView::Property::PAGE_SIZE );
+ // Test "pageSize" property
+ DALI_TEST_CHECK( landscapeView.GetPropertyIndex("pageSize") == PageTurnView::Property::PAGE_SIZE );
DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::PAGE_SIZE).Get<Vector2>(), PAGE_SIZE, TEST_LOCATION );
Vector2 newSize( PAGE_SIZE.x*0.75, PAGE_SIZE.y*0.5f );
Wait( application);
DALI_TEST_EQUALS( Vector2(landscapeView.GetTargetSize()), Vector2(newSize.x*3.f, newSize.y*1.5f), TEST_LOCATION);
- // Test "current-page-id" property
- DALI_TEST_CHECK( landscapeView.GetPropertyIndex("current-page-id") == PageTurnView::Property::CURRENT_PAGE_ID );
+ // Test "currentPageId" property
+ DALI_TEST_CHECK( landscapeView.GetPropertyIndex("currentPageId") == PageTurnView::Property::CURRENT_PAGE_ID );
DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION );
int pageId = static_cast<int>(TOTAL_PAGE_NUMBER)/3;
landscapeView.SetProperty( PageTurnView::Property::CURRENT_PAGE_ID, pageId*2 );
DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), pageId*2, TEST_LOCATION );
- // Test "spin-shadow" property
- DALI_TEST_CHECK( landscapeView.GetPropertyIndex( "spine-shadow" ) == PageTurnView::Property::SPINE_SHADOW );
+ // Test "spinShadow" property
+ DALI_TEST_CHECK( landscapeView.GetPropertyIndex( "spineShadow" ) == PageTurnView::Property::SPINE_SHADOW );
landscapeView.SetProperty( PageTurnView::Property::SPINE_SHADOW, SPINE_SHADOW_PARAMETER );
DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::SPINE_SHADOW).Get<Vector2>(), SPINE_SHADOW_PARAMETER, TEST_LOCATION );
popup.SetProperty( Popup::Property::ANIMATION_DURATION, 0.0f );
Stage::GetCurrent().Add( popup );
- Actor backing = popup.FindChildByName( "popup-backing" );
+ Actor backing = popup.FindChildByName( "popupBacking" );
DALI_TEST_CHECK( backing );
DALI_TEST_EQUALS( backing.GetCurrentOpacity(), 1.0f, Math::MACHINE_EPSILON_0, TEST_LOCATION );
popup.SetProperty( Popup::Property::ANIMATION_DURATION, 1.0f );
popup.SetProperty( Popup::Property::ANIMATION_MODE, "CUSTOM" );
- Actor popupContainer = popup.FindChildByName( "popup-container" );
+ Actor popupContainer = popup.FindChildByName( "popupContainer" );
DALI_TEST_CHECK( popupContainer );
Vector3 entryAnimationDestination( 300.0f, 200.0f, 0.0f );
Vector3 exitAnimationDestination( -300.0f, -200.0f, 0.0f );
Property::Map animationMapEntry;
- animationMapEntry.Insert( "actor", "custom-animation-popup" );
+ animationMapEntry.Insert( "actor", "customAnimationPopup" );
animationMapEntry.Insert( "property", "position" );
animationMapEntry.Insert( "value", entryAnimationDestination );
- animationMapEntry.Insert( "alpha-function", "EASE_OUT" );
+ animationMapEntry.Insert( "alphaFunction", "EASE_OUT" );
Property::Array timePeriodMapEntry;
timePeriodMapEntry.PushBack( 0.0f );
timePeriodMapEntry.PushBack( 1.0f );
- animationMapEntry.Insert( "time-period", timePeriodMapEntry );
+ animationMapEntry.Insert( "timePeriod", timePeriodMapEntry );
Property::Map animationMapExit;
- animationMapExit.Insert( "actor", "custom-animation-popup" );
+ animationMapExit.Insert( "actor", "customAnimationPopup" );
animationMapExit.Insert( "property", "position" );
animationMapExit.Insert( "value", exitAnimationDestination );
- animationMapExit.Insert( "alpha-function", "EASE_IN" );
+ animationMapExit.Insert( "alphaFunction", "EASE_IN" );
Property::Array timePeriodMapExit;
timePeriodMapExit.PushBack( 0.0f );
timePeriodMapExit.PushBack( 1.0f );
- animationMapExit.Insert( "time-period", timePeriodMapExit );
+ animationMapExit.Insert( "timePeriod", timePeriodMapExit );
popup.SetProperty( Toolkit::Popup::Property::ENTRY_ANIMATION, animationMapEntry );
popup.SetProperty( Toolkit::Popup::Property::EXIT_ANIMATION, animationMapExit );
popup.SetDisplayState( Popup::SHOWN );
application.SendNotification();
application.Render();
- tailActor = popup.FindChildByName( "tail-image" );
+ tailActor = popup.FindChildByName( "tailImage" );
DALI_TEST_CHECK( tailActor );
float baseValX = tailActor.GetCurrentWorldPosition().x;
popup.SetDisplayState( Popup::SHOWN );
application.SendNotification();
application.Render();
- tailActor = popup.FindChildByName( "tail-image" );
+ tailActor = popup.FindChildByName( "tailImage" );
DALI_TEST_CHECK( tailActor );
float baseValY = tailActor.GetCurrentWorldPosition().y;
popup.SetDisplayState( Popup::SHOWN );
application.SendNotification();
application.Render();
- tailActor = popup.FindChildByName( "tail-image" );
+ tailActor = popup.FindChildByName( "tailImage" );
DALI_TEST_CHECK( tailActor );
DALI_TEST_EQUALS( tailActor.GetCurrentWorldPosition().x, baseValX, TEST_LOCATION );
DALI_TEST_GREATER( tailActor.GetCurrentWorldPosition().y, baseValY, TEST_LOCATION );
popup.SetDisplayState( Popup::SHOWN );
application.SendNotification();
application.Render();
- tailActor = popup.FindChildByName( "tail-image" );
+ tailActor = popup.FindChildByName( "tailImage" );
DALI_TEST_CHECK( tailActor );
DALI_TEST_GREATER( tailActor.GetCurrentWorldPosition().x, baseValX, TEST_LOCATION );
DALI_TEST_EQUALS( tailActor.GetCurrentWorldPosition().y, baseValY, TEST_LOCATION );
ToolkitTestApplication application;
tet_infoline( " UtcDaliPopupTypeToast" );
- TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( "popup-toast" );
+ TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( "PopupToast" );
DALI_TEST_CHECK( typeInfo )
BaseHandle baseHandle = typeInfo.CreateInstance();
TestConnectionTrackerObject* testTracker = new TestConnectionTrackerObject();
// Note: The emmision of this signals has already been tested in other tests.
- DALI_TEST_CHECK( popup.ConnectSignal( testTracker, "touched-outside", PopupTestFunctor() ) );
+ DALI_TEST_CHECK( popup.ConnectSignal( testTracker, "touchedOutside", PopupTestFunctor() ) );
DALI_TEST_CHECK( popup.ConnectSignal( testTracker, "showing", PopupTestFunctor() ) );
DALI_TEST_CHECK( popup.ConnectSignal( testTracker, "shown", PopupTestFunctor() ) );
DALI_TEST_CHECK( popup.ConnectSignal( testTracker, "hiding", PopupTestFunctor() ) );
Property::Map propertyMap;
Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
- propertyMap.Insert("renderer-type", "color-renderer");
- propertyMap.Insert("blend-color", testColor);
+ propertyMap.Insert("rendererType", "colorRenderer");
+ propertyMap.Insert("blendColor", testColor);
ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
DALI_TEST_CHECK( controlRenderer );
Property::Map propertyMap;
Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
float testSize = 5.f;
- propertyMap.Insert("renderer-type", "border-renderer");
- propertyMap.Insert("border-color", testColor);
- propertyMap.Insert("border-size", testSize);
+ propertyMap.Insert("rendererType", "borderRenderer");
+ propertyMap.Insert("borderColor", testColor);
+ propertyMap.Insert("borderSize", testSize);
ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
DALI_TEST_CHECK( controlRenderer );
DALI_TEST_CHECK( factory );
Property::Map propertyMap;
- propertyMap.Insert("renderer-type", "gradient-renderer");
+ propertyMap.Insert("rendererType", "gradientRenderer");
Vector2 start(-1.f, -1.f);
Vector2 end(1.f, 1.f);
- propertyMap.Insert("gradient-start-position", start);
- propertyMap.Insert("gradient-end-position", end);
- propertyMap.Insert("gradient-spread-method", "repeat");
+ propertyMap.Insert("gradientStartPosition", start);
+ propertyMap.Insert("gradientEndPosition", end);
+ propertyMap.Insert("gradientSpreadMethod", "repeat");
Property::Array stopOffsets;
stopOffsets.PushBack( 0.2f );
stopOffsets.PushBack( 0.8f );
- propertyMap.Insert("gradient-stop-offset", stopOffsets);
+ propertyMap.Insert("gradientStopOffset", stopOffsets);
Property::Array stopColors;
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::GREEN );
- propertyMap.Insert("gradient-stop-color", stopColors);
+ propertyMap.Insert("gradientStopColor", stopColors);
ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
DALI_TEST_CHECK( controlRenderer );
DALI_TEST_CHECK( factory );
Property::Map propertyMap;
- propertyMap.Insert("renderer-type", "gradient-renderer");
+ propertyMap.Insert("rendererType", "gradientRenderer");
Vector2 center(100.f, 100.f);
float radius = 100.f;
- propertyMap.Insert("gradient-units", "user-space");
- propertyMap.Insert("gradient-center", center);
- propertyMap.Insert("gradient-radius", radius);
+ propertyMap.Insert("gradientUnits", "userSpace");
+ propertyMap.Insert("gradientCenter", center);
+ propertyMap.Insert("gradientRadius", radius);
Property::Array stopOffsets;
stopOffsets.PushBack( 0.0f );
stopOffsets.PushBack( 1.f );
- propertyMap.Insert("gradient-stop-offset", stopOffsets);
+ propertyMap.Insert("gradientStopOffset", stopOffsets);
Property::Array stopColors;
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::GREEN );
- propertyMap.Insert("gradient-stop-color", stopColors);
+ propertyMap.Insert("gradientStopColor", stopColors);
ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
DALI_TEST_CHECK( controlRenderer );
DALI_TEST_CHECK( factory );
Property::Map propertyMap;
- propertyMap.Insert( "renderer-type", "image-renderer" );
- propertyMap.Insert( "image-url", TEST_IMAGE_FILE_NAME );
+ propertyMap.Insert( "rendererType", "imageRenderer" );
+ propertyMap.Insert( "imageUrl", TEST_IMAGE_FILE_NAME );
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
Property::Map propertyMap;
- propertyMap.Insert( "renderer-type", "n-patch-renderer" );
- propertyMap.Insert( "image-url", TEST_NPATCH_FILE_NAME );
+ propertyMap.Insert( "rendererType", "nPatchRenderer" );
+ propertyMap.Insert( "imageUrl", TEST_NPATCH_FILE_NAME );
{
tet_infoline( "whole grid" );
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
}
- propertyMap.Insert( "border-only", true );
+ propertyMap.Insert( "borderOnly", true );
{
tet_infoline( "border only" );
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
Property::Map propertyMap;
- propertyMap.Insert( "renderer-type", "n-patch-renderer" );
- propertyMap.Insert( "image-url", TEST_NPATCH_FILE_NAME );
+ propertyMap.Insert( "rendererType", "nPatchRenderer" );
+ propertyMap.Insert( "imageUrl", TEST_NPATCH_FILE_NAME );
{
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
}
- propertyMap.Insert( "border-only", true );
+ propertyMap.Insert( "borderOnly", true );
{
tet_infoline( "border only" );
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
DALI_TEST_CHECK( factory );
Property::Map propertyMap;
- propertyMap.Insert( "renderer-type", "n-patch-renderer" );
- propertyMap.Insert( "image-url", 111 );
+ propertyMap.Insert( "rendererType", "nPatchRenderer" );
+ propertyMap.Insert( "imageUrl", 111 );
ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
Stage::GetCurrent().Add( sourceActor );
// Register the scroll properties
- Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "source-position", 0.0f );
- Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "source-position-min", 0.0f );
- Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "source-position-max", 100.0f );
- Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "source-content-size", 500.0f );
+ Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "sourcePosition", 0.0f );
+ Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "sourcePositionMin", 0.0f );
+ Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "sourcePositionMax", 100.0f );
+ Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "sourceContentSize", 500.0f );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position" ), propertyScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-min" ), propertyMinScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-max" ), propertyMaxScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-content-size" ), propertyScrollContentSize, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePosition" ), propertyScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMin" ), propertyMinScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMax" ), propertyMaxScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourceContentSize" ), propertyScrollContentSize, TEST_LOCATION );
// Set the source of the scroll position properties.
scrollBar.SetScrollPropertySource(sourceActor, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
Stage::GetCurrent().Add( newSourceActor );
// Register the scroll properties
- Property::Index newPropertyScrollPosition = newSourceActor.RegisterProperty( "source-position", 0.0f );
- Property::Index newPropertyMinScrollPosition = newSourceActor.RegisterProperty( "source-position-min", 0.0f );
- Property::Index newPropertyMaxScrollPosition = newSourceActor.RegisterProperty( "source-position-max", 200.0f );
- Property::Index newPropertyScrollContentSize = newSourceActor.RegisterProperty( "source-content-size", 400.0f );
+ Property::Index newPropertyScrollPosition = newSourceActor.RegisterProperty( "sourcePosition", 0.0f );
+ Property::Index newPropertyMinScrollPosition = newSourceActor.RegisterProperty( "sourcePositionMin", 0.0f );
+ Property::Index newPropertyMaxScrollPosition = newSourceActor.RegisterProperty( "sourcePositionMax", 200.0f );
+ Property::Index newPropertyScrollContentSize = newSourceActor.RegisterProperty( "sourceContentSize", 400.0f );
- DALI_TEST_EQUALS( newSourceActor.GetPropertyIndex( "source-position" ), newPropertyScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( newSourceActor.GetPropertyIndex( "source-position-min" ), newPropertyMinScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( newSourceActor.GetPropertyIndex( "source-position-max" ), newPropertyMaxScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( newSourceActor.GetPropertyIndex( "source-content-size" ), newPropertyScrollContentSize, TEST_LOCATION );
+ DALI_TEST_EQUALS( newSourceActor.GetPropertyIndex( "sourcePosition" ), newPropertyScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( newSourceActor.GetPropertyIndex( "sourcePositionMin" ), newPropertyMinScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( newSourceActor.GetPropertyIndex( "sourcePositionMax" ), newPropertyMaxScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( newSourceActor.GetPropertyIndex( "sourceContentSize" ), newPropertyScrollContentSize, TEST_LOCATION );
// Change the source of the scroll position properties to be the new source actor.
scrollBar.SetScrollPropertySource(newSourceActor, newPropertyScrollPosition, newPropertyMinScrollPosition, newPropertyMaxScrollPosition, newPropertyScrollContentSize);
Stage::GetCurrent().Add( sourceActor );
// Register the scroll properties
- Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "source-position", 0.0f );
- Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "source-position-min", 0.0f );
- Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "source-position-max", 800.0f );
- Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "source-content-size", 2000.0f );
+ Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "sourcePosition", 0.0f );
+ Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "sourcePositionMin", 0.0f );
+ Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "sourcePositionMax", 800.0f );
+ Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "sourceContentSize", 2000.0f );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position" ), propertyScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-min" ), propertyMinScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-max" ), propertyMaxScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-content-size" ), propertyScrollContentSize, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePosition" ), propertyScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMin" ), propertyMinScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMax" ), propertyMaxScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourceContentSize" ), propertyScrollContentSize, TEST_LOCATION );
// Set the source of the scroll position properties.
scrollBar.SetScrollPropertySource(sourceActor, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
Stage::GetCurrent().Add( sourceActor );
// Register the scroll properties
- Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "source-position", 0.0f );
- Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "source-position-min", 0.0f );
- Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "source-position-max", 100.0f );
- Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "source-content-size", 500.0f );
+ Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "sourcePosition", 0.0f );
+ Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "sourcePositionMin", 0.0f );
+ Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "sourcePositionMax", 100.0f );
+ Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "sourceContentSize", 500.0f );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position" ), propertyScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-min" ), propertyMinScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-max" ), propertyMaxScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-content-size" ), propertyScrollContentSize, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePosition" ), propertyScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMin" ), propertyMinScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMax" ), propertyMaxScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourceContentSize" ), propertyScrollContentSize, TEST_LOCATION );
// Set the source of the scroll position properties.
scrollBar.SetScrollPropertySource(sourceActor, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
Stage::GetCurrent().Add( sourceActor );
// Register the scroll properties
- Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "source-position", 0.0f );
- Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "source-position-min", 0.0f );
- Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "source-position-max", 100.0f );
- Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "source-content-size", 500.0f );
+ Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "sourcePosition", 0.0f );
+ Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "sourcePositionMin", 0.0f );
+ Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "sourcePositionMax", 100.0f );
+ Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "sourceContentSize", 500.0f );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position" ), propertyScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-min" ), propertyMinScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-max" ), propertyMaxScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-content-size" ), propertyScrollContentSize, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePosition" ), propertyScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMin" ), propertyMinScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMax" ), propertyMaxScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourceContentSize" ), propertyScrollContentSize, TEST_LOCATION );
// Set the source of the scroll position properties.
scrollBar.SetScrollPropertySource(sourceActor, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
Stage::GetCurrent().Add( sourceActor );
// Register the scroll properties
- Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "source-position", 0.0f );
- Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "source-position-min", 0.0f );
- Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "source-position-max", 100.0f );
- Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "source-content-size", 500.0f );
+ Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "sourcePosition", 0.0f );
+ Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "sourcePositionMin", 0.0f );
+ Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "sourcePositionMax", 100.0f );
+ Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "sourceContentSize", 500.0f );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position" ), propertyScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-min" ), propertyMinScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-max" ), propertyMaxScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-content-size" ), propertyScrollContentSize, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePosition" ), propertyScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMin" ), propertyMinScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMax" ), propertyMaxScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourceContentSize" ), propertyScrollContentSize, TEST_LOCATION );
// Set the source of the scroll position properties.
scrollBar.SetScrollPropertySource(sourceActor, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
Stage::GetCurrent().Add( sourceActor );
// Register the scroll properties
- Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "source-position", 0.0f );
- Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "source-position-min", 0.0f );
- Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "source-position-max", 800.0f );
- Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "source-content-size", 2000.0f );
+ Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "sourcePosition", 0.0f );
+ Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "sourcePositionMin", 0.0f );
+ Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "sourcePositionMax", 800.0f );
+ Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "sourceContentSize", 2000.0f );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position" ), propertyScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-min" ), propertyMinScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-max" ), propertyMaxScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-content-size" ), propertyScrollContentSize, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePosition" ), propertyScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMin" ), propertyMinScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMax" ), propertyMaxScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourceContentSize" ), propertyScrollContentSize, TEST_LOCATION );
// Set the source of the scroll position properties.
scrollBar.SetScrollPropertySource(sourceActor, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
Stage::GetCurrent().Add( sourceActor );
// Register the scroll properties
- Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "source-position", 0.0f );
- Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "source-position-min", 0.0f );
- Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "source-position-max", 800.0f );
- Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "source-content-size", 2000.0f );
-
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position" ), propertyScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-min" ), propertyMinScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-position-max" ), propertyMaxScrollPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "source-content-size" ), propertyScrollContentSize, TEST_LOCATION );
+ Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "sourcePosition", 0.0f );
+ Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "sourcePositionMin", 0.0f );
+ Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "sourcePositionMax", 800.0f );
+ Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "sourceContentSize", 2000.0f );
+
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePosition" ), propertyScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMin" ), propertyMinScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourcePositionMax" ), propertyMaxScrollPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS( sourceActor.GetPropertyIndex( "sourceContentSize" ), propertyScrollContentSize, TEST_LOCATION );
// Set the source of the scroll position properties.
scrollBar.SetScrollPropertySource(sourceActor, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
Property::Map customShader;
DALI_TEST_CHECK( customShaderValue->Get( customShader ) );
- Property::Value* vertexShaderValue = customShader.Find( "vertex-shader" );
+ Property::Value* vertexShaderValue = customShader.Find( "vertexShader" );
DALI_TEST_CHECK( vertexShaderValue );
std::string vertexShader;
DALI_TEST_CHECK( vertexShaderValue->Get( vertexShader ) );
DALI_TEST_CHECK( !vertexShader.empty() );
- Property::Value* fragmentShaderValue = customShader.Find( "fragment-shader" );
+ Property::Value* fragmentShaderValue = customShader.Find( "fragmentShader" );
DALI_TEST_CHECK( fragmentShaderValue );
std::string fragmentShader;
DALI_TEST_CHECK( fragmentShaderValue->Get( fragmentShader ) );
DALI_TEST_CHECK( !fragmentShader.empty() );
- Property::Value* gridXValue = customShader.Find( "subdivide-grid-x" );
+ Property::Value* gridXValue = customShader.Find( "subdivideGridX" );
DALI_TEST_CHECK( gridXValue );
int gridX = 0;
DALI_TEST_CHECK( gridXValue->Get( gridX ) );
DALI_TEST_CHECK( gridX > 1 );
- Property::Value* gridYValue = customShader.Find( "subdivide-grid-y" );
+ Property::Value* gridYValue = customShader.Find( "subdivideGridY" );
DALI_TEST_CHECK( gridYValue );
int gridY = 0;
std::string hints;
DALI_TEST_CHECK( hintsValue->Get( hints ) );
- DALI_TEST_CHECK( hints == "output-is-transparent" );
+ DALI_TEST_CHECK( hints == "outputIsTransparent" );
Actor actor = Actor::New();
Toolkit::DissolveEffectSetCentralLine( actor, Vector2::ONE, Vector2::ONE, 0.0f );
Property::Map customShader;
DALI_TEST_CHECK( customShaderValue->Get( customShader ) );
- Property::Value* vertexShaderValue = customShader.Find( "vertex-shader" );
+ Property::Value* vertexShaderValue = customShader.Find( "vertexShader" );
DALI_TEST_CHECK( !vertexShaderValue );
- Property::Value* fragmentShaderValue = customShader.Find( "fragment-shader" );
+ Property::Value* fragmentShaderValue = customShader.Find( "fragmentShader" );
DALI_TEST_CHECK( fragmentShaderValue );
std::string fragmentShader;
DALI_TEST_CHECK( fragmentShaderValue->Get( fragmentShader ) );
DALI_TEST_CHECK( !fragmentShader.empty() );
- Property::Value* gridXValue = customShader.Find( "subdivide-grid-x" );
+ Property::Value* gridXValue = customShader.Find( "subdivideGridX" );
DALI_TEST_CHECK( !gridXValue );
Property::Value* hintsValue = customShader.Find( "hints" );
std::string hints;
DALI_TEST_CHECK( hintsValue->Get( hints ) );
- DALI_TEST_CHECK( hints == "output-is-transparent" );
+ DALI_TEST_CHECK( hints == "outputIsTransparent" );
END_TEST;
}
Property::Map customShader;
DALI_TEST_CHECK( customShaderValue->Get( customShader ) );
- Property::Value* vertexShaderValue = customShader.Find( "vertex-shader" );
+ Property::Value* vertexShaderValue = customShader.Find( "vertexShader" );
DALI_TEST_CHECK( vertexShaderValue );
std::string vertexShader;
DALI_TEST_CHECK( vertexShaderValue->Get( vertexShader ) );
DALI_TEST_CHECK( !vertexShader.empty() );
- Property::Value* fragmentShaderValue = customShader.Find( "fragment-shader" );
+ Property::Value* fragmentShaderValue = customShader.Find( "fragmentShader" );
DALI_TEST_CHECK( fragmentShaderValue );
std::string fragmentShader;
DALI_TEST_CHECK( fragmentShaderValue->Get( fragmentShader ) );
DALI_TEST_CHECK( !fragmentShader.empty() );
- Property::Value* gridXValue = customShader.Find( "subdivide-grid-x" );
+ Property::Value* gridXValue = customShader.Find( "subdivideGridX" );
DALI_TEST_CHECK( gridXValue );
int gridX = 0;
DALI_TEST_CHECK( gridXValue->Get( gridX ) );
DALI_TEST_CHECK( gridX > 1 );
- Property::Value* gridYValue = customShader.Find( "subdivide-grid-y" );
+ Property::Value* gridYValue = customShader.Find( "subdivideGridY" );
DALI_TEST_CHECK( gridYValue );
int gridY = 0;
std::string hints;
DALI_TEST_CHECK( hintsValue->Get( hints ) );
- DALI_TEST_CHECK( hints == "output-is-transparent" );
+ DALI_TEST_CHECK( hints == "outputIsTransparent" );
unsigned int sampleCount( 4 );
Actor actor = Actor::New();
Property::Map customShader;
DALI_TEST_CHECK( customShaderValue->Get( customShader ) );
- Property::Value* vertexShaderValue = customShader.Find( "vertex-shader" );
+ Property::Value* vertexShaderValue = customShader.Find( "vertexShader" );
DALI_TEST_CHECK( vertexShaderValue );
std::string vertexShader;
DALI_TEST_CHECK( vertexShaderValue->Get( vertexShader ) );
DALI_TEST_CHECK( !vertexShader.empty() );
- Property::Value* fragmentShaderValue = customShader.Find( "fragment-shader" );
+ Property::Value* fragmentShaderValue = customShader.Find( "fragmentShader" );
DALI_TEST_CHECK( fragmentShaderValue );
std::string fragmentShader;
DALI_TEST_CHECK( fragmentShaderValue->Get( fragmentShader ) );
DALI_TEST_CHECK( !fragmentShader.empty() );
- Property::Value* gridXValue = customShader.Find( "subdivide-grid-x" );
+ Property::Value* gridXValue = customShader.Find( "subdivideGridX" );
DALI_TEST_CHECK( gridXValue );
int gridX = 0;
DALI_TEST_CHECK( gridXValue->Get( gridX ) );
DALI_TEST_CHECK( gridX > 1 );
- Property::Value* gridYValue = customShader.Find( "subdivide-grid-y" );
+ Property::Value* gridYValue = customShader.Find( "subdivideGridY" );
DALI_TEST_CHECK( gridYValue );
int gridY = 0;
std::string hints;
DALI_TEST_CHECK( hintsValue->Get( hints ) );
- DALI_TEST_CHECK( hints == "output-is-transparent" );
+ DALI_TEST_CHECK( hints == "outputIsTransparent" );
Actor actor = Actor::New();
Toolkit::SetMotionStretchProperties( actor );
const char* const PROPERTY_NAME_ROWS = "rows";
const char* const PROPERTY_NAME_COLUMNS = "columns";
-const char* const PROPERTY_NAME_CELL_PADDING = "cell-padding";
-const char* const PROPERTY_NAME_LAYOUT_ROWS = "layout-rows";
-const char* const PROPERTY_NAME_LAYOUT_COLUMNS = "layout-columns";
+const char* const PROPERTY_NAME_CELL_PADDING = "cellPadding";
+const char* const PROPERTY_NAME_LAYOUT_ROWS = "layoutRows";
+const char* const PROPERTY_NAME_LAYOUT_COLUMNS = "layoutColumns";
const Vector2 CELL_SIZE( 10, 10 );
static bool gObjectCreatedCallBackCalled;
DALI_TEST_CHECK( tableView.GetColumns() == 5u );
DALI_TEST_CHECK( tableView.GetProperty(TableView::Property::COLUMNS).Get<int>() == 5 );
- // Test "cell-padding" property
+ // Test "cellPadding" property
DALI_TEST_CHECK( tableView.GetPropertyIndex( PROPERTY_NAME_CELL_PADDING ) == TableView::Property::CELL_PADDING );
tableView.SetProperty( TableView::Property::CELL_PADDING, Size( 6.f, 8.f ) );
item2[ "policy" ] = "relative";
item2[ "value" ] = 0.2f;
- // Test "layout-rows" property
+ // Test "layoutRows" property
DALI_TEST_CHECK( tableView.GetPropertyIndex(PROPERTY_NAME_LAYOUT_ROWS) == TableView::Property::LAYOUT_ROWS );
/*
- * "layout-rows":
+ * "layoutRows":
* {
* "1": { "policy": "fixed", "value": 30 },
* "3": { "policy": "relative", "value": 0.2 }
DALI_TEST_CHECK( childMap->Find( "policy" )->Get<std::string>().compare("relative") == 0 );
DALI_TEST_EQUALS( childMap->Find( "value" )->Get<float>(), 0.2f, TEST_LOCATION );
- // Test "layout-columns" property
+ // Test "layoutColumns" property
DALI_TEST_CHECK( tableView.GetPropertyIndex( PROPERTY_NAME_LAYOUT_COLUMNS ) == TableView::Property::LAYOUT_COLUMNS );
/*
- * "layout-columns":
+ * "layoutColumns":
* {
* "2": { "policy": "relative", "value": 0.2 },
* "3": { "policy": "fixed", "value": 30 }
// Create a child actor with the custom properties
Actor child1 = Actor::New();
- child1.RegisterProperty( "cell-index", Vector2( 3, 4 ), Property::READ_WRITE );
+ child1.RegisterProperty( "cellIndex", Vector2( 3, 4 ), Property::READ_WRITE );
tableView.Add( child1 );
// Check for actors at actual positions.
DALI_TEST_CHECK( tableView.GetChildAt(TableView::CellPosition(3,4)) == child1);
Actor child2 = Actor::New();
float rowSpan = 3.f;
float columnSpan = 2.f;
- child2.RegisterProperty( "cell-index", Vector2( 6, 1 ), Property::READ_WRITE );
- child2.RegisterProperty( "row-span", rowSpan, Property::READ_WRITE );
- child2.RegisterProperty( "column-span", columnSpan, Property::READ_WRITE );
+ child2.RegisterProperty( "cellIndex", Vector2( 6, 1 ), Property::READ_WRITE );
+ child2.RegisterProperty( "rowSpan", rowSpan, Property::READ_WRITE );
+ child2.RegisterProperty( "columnSpan", columnSpan, Property::READ_WRITE );
tableView.Add( child2 );
// Check for actors at actual positions.
for( int i=0; i<rowSpan; i++ )
// Create a third child actor with the cell alignment properties
Actor child3 = Actor::New();
child3.SetSize( 5.f,5.f );
- child3.RegisterProperty( "cell-horizontal-alignment", "center", Property::READ_WRITE );
- child3.RegisterProperty( "cell-vertical-alignment", "bottom", Property::READ_WRITE );
+ child3.RegisterProperty( "cellHorizontalAlignment", "center", Property::READ_WRITE );
+ child3.RegisterProperty( "cellVerticalAlignment", "bottom", Property::READ_WRITE );
tableView.Add( child3 );
// store the actor in the first available cell
namespace
{
-const char* const PROPERTY_NAME_RENDERING_BACKEND = "rendering-backend";
+const char* const PROPERTY_NAME_RENDERING_BACKEND = "renderingBackend";
const char* const PROPERTY_NAME_TEXT = "text";
-const char* const PROPERTY_NAME_PLACEHOLDER_TEXT = "placeholder-text";
-const char* const PROPERTY_NAME_PLACEHOLDER_TEXT_FOCUSED = "placeholder-text-focused";
-const char* const PROPERTY_NAME_FONT_FAMILY = "font-family";
-const char* const PROPERTY_NAME_FONT_STYLE = "font-style";
-const char* const PROPERTY_NAME_POINT_SIZE = "point-size";
-const char* const PROPERTY_NAME_MAX_LENGTH = "max-length";
-const char* const PROPERTY_NAME_EXCEED_POLICY = "exceed-policy";
-const char* const PROPERTY_NAME_HORIZONTAL_ALIGNMENT = "horizontal-alignment";
-const char* const PROPERTY_NAME_VERTICAL_ALIGNMENT = "vertical-alignment";
-const char* const PROPERTY_NAME_TEXT_COLOR = "text-color";
-const char* const PROPERTY_NAME_PLACEHOLDER_TEXT_COLOR = "placeholder-text-color";
-const char* const PROPERTY_NAME_SHADOW_OFFSET = "shadow-offset";
-const char* const PROPERTY_NAME_SHADOW_COLOR = "shadow-color";
-const char* const PROPERTY_NAME_PRIMARY_CURSOR_COLOR = "primary-cursor-color";
-const char* const PROPERTY_NAME_SECONDARY_CURSOR_COLOR = "secondary-cursor-color";
-const char* const PROPERTY_NAME_ENABLE_CURSOR_BLINK = "enable-cursor-blink";
-const char* const PROPERTY_NAME_CURSOR_BLINK_INTERVAL = "cursor-blink-interval";
-const char* const PROPERTY_NAME_CURSOR_BLINK_DURATION = "cursor-blink-duration";
-const char* const PROPERTY_NAME_CURSOR_WIDTH = "cursor-width";
-const char* const PROPERTY_NAME_GRAB_HANDLE_IMAGE = "grab-handle-image";
-const char* const PROPERTY_NAME_GRAB_HANDLE_PRESSED_IMAGE = "grab-handle-pressed-image";
-const char* const PROPERTY_NAME_SCROLL_THRESHOLD = "scroll-threshold";
-const char* const PROPERTY_NAME_SCROLL_SPEED = "scroll-speed";
-const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_LEFT = "selection-handle-image-left";
-const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_RIGHT = "selection-handle-image-right";
-const char* const PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_LEFT = "selection-handle-pressed-image-left";
-const char* const PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT = "selection-handle-pressed-image-right";
-const char* const PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_LEFT = "selection-handle-marker-image-left";
-const char* const PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_RIGHT = "selection-handle-marker-image-right";
-const char* const PROPERTY_NAME_SELECTION_HIGHLIGHT_COLOR = "selection-highlight-color";
-const char* const PROPERTY_NAME_DECORATION_BOUNDING_BOX = "decoration-bounding-box";
-const char* const PROPERTY_NAME_INPUT_METHOD_SETTINGS = "input-method-settings";
+const char* const PROPERTY_NAME_PLACEHOLDER_TEXT = "placeholderText";
+const char* const PROPERTY_NAME_PLACEHOLDER_TEXT_FOCUSED = "placeholderTextFocused";
+const char* const PROPERTY_NAME_FONT_FAMILY = "fontFamily";
+const char* const PROPERTY_NAME_FONT_STYLE = "fontStyle";
+const char* const PROPERTY_NAME_POINT_SIZE = "pointSize";
+const char* const PROPERTY_NAME_MAX_LENGTH = "maxLength";
+const char* const PROPERTY_NAME_EXCEED_POLICY = "exceedPolicy";
+const char* const PROPERTY_NAME_HORIZONTAL_ALIGNMENT = "horizontalAlignment";
+const char* const PROPERTY_NAME_VERTICAL_ALIGNMENT = "verticalAlignment";
+const char* const PROPERTY_NAME_TEXT_COLOR = "textColor";
+const char* const PROPERTY_NAME_PLACEHOLDER_TEXT_COLOR = "placeholderTextColor";
+const char* const PROPERTY_NAME_SHADOW_OFFSET = "shadowOffset";
+const char* const PROPERTY_NAME_SHADOW_COLOR = "shadowColor";
+const char* const PROPERTY_NAME_PRIMARY_CURSOR_COLOR = "primaryCursorColor";
+const char* const PROPERTY_NAME_SECONDARY_CURSOR_COLOR = "secondaryCursorColor";
+const char* const PROPERTY_NAME_ENABLE_CURSOR_BLINK = "enableCursorBlink";
+const char* const PROPERTY_NAME_CURSOR_BLINK_INTERVAL = "cursorBlinkInterval";
+const char* const PROPERTY_NAME_CURSOR_BLINK_DURATION = "cursorBlinkDuration";
+const char* const PROPERTY_NAME_CURSOR_WIDTH = "cursorWidth";
+const char* const PROPERTY_NAME_GRAB_HANDLE_IMAGE = "grabHandleImage";
+const char* const PROPERTY_NAME_GRAB_HANDLE_PRESSED_IMAGE = "grabHandlePressedImage";
+const char* const PROPERTY_NAME_SCROLL_THRESHOLD = "scrollThreshold";
+const char* const PROPERTY_NAME_SCROLL_SPEED = "scrollSpeed";
+const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_LEFT = "selectionHandleImageLeft";
+const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_RIGHT = "selectionHandleImageRight";
+const char* const PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_LEFT = "selectionHandlePressedImageLeft";
+const char* const PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT = "selectionHandlePressedImageRight";
+const char* const PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_LEFT = "selectionHandleMarkerImageLeft";
+const char* const PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_RIGHT = "selectionHandleMarkerImageRight";
+const char* const PROPERTY_NAME_SELECTION_HIGHLIGHT_COLOR = "selectionHighlightColor";
+const char* const PROPERTY_NAME_DECORATION_BOUNDING_BOX = "decorationBoundingBox";
+const char* const PROPERTY_NAME_INPUT_METHOD_SETTINGS = "inputMethodSettings";
const int DEFAULT_RENDERING_BACKEND = Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
END_TEST;
}
-// Positive test for the text-changed signal.
+// Positive test for the textChanged signal.
int utcDaliTextFieldTextChangedP(void)
{
ToolkitTestApplication application;
END_TEST;
}
-// Negative test for the text-changed signal.
+// Negative test for the textChanged signal.
int utcDaliTextFieldTextChangedN(void)
{
ToolkitTestApplication application;
namespace
{
-const char* const PROPERTY_NAME_RENDERING_BACKEND = "rendering-backend";
+const char* const PROPERTY_NAME_RENDERING_BACKEND = "renderingBackend";
const char* const PROPERTY_NAME_TEXT = "text";
-const char* const PROPERTY_NAME_FONT_FAMILY = "font-family";
-const char* const PROPERTY_NAME_FONT_STYLE = "font-style";
-const char* const PROPERTY_NAME_POINT_SIZE = "point-size";
-const char* const PROPERTY_NAME_MULTI_LINE = "multi-line";
-const char* const PROPERTY_NAME_HORIZONTAL_ALIGNMENT = "horizontal-alignment";
-const char* const PROPERTY_NAME_VERTICAL_ALIGNMENT = "vertical-alignment";
-const char* const PROPERTY_NAME_TEXT_COLOR = "text-color";
-const char* const PROPERTY_NAME_SHADOW_OFFSET = "shadow-offset";
-const char* const PROPERTY_NAME_SHADOW_COLOR = "shadow-color";
-const char* const PROPERTY_NAME_UNDERLINE_ENABLED = "underline-enabled";
-const char* const PROPERTY_NAME_UNDERLINE_COLOR = "underline-color";
-const char* const PROPERTY_NAME_UNDERLINE_HEIGHT = "underline-height";
+const char* const PROPERTY_NAME_FONT_FAMILY = "fontFamily";
+const char* const PROPERTY_NAME_FONT_STYLE = "fontStyle";
+const char* const PROPERTY_NAME_POINT_SIZE = "pointSize";
+const char* const PROPERTY_NAME_MULTI_LINE = "multiLine";
+const char* const PROPERTY_NAME_HORIZONTAL_ALIGNMENT = "horizontalAlignment";
+const char* const PROPERTY_NAME_VERTICAL_ALIGNMENT = "verticalAlignment";
+const char* const PROPERTY_NAME_TEXT_COLOR = "textColor";
+const char* const PROPERTY_NAME_SHADOW_OFFSET = "shadowOffset";
+const char* const PROPERTY_NAME_SHADOW_COLOR = "shadowColor";
+const char* const PROPERTY_NAME_UNDERLINE_ENABLED = "underlineEnabled";
+const char* const PROPERTY_NAME_UNDERLINE_COLOR = "underlineColor";
+const char* const PROPERTY_NAME_UNDERLINE_HEIGHT = "underlineHeight";
const int DEFAULT_RENDERING_BACKEND = Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
* {
* "templates": // are named instantiable actor trees
* {
- * "default-text":
+ * "defaultText":
* {
* "type":"TextActor",
* "font":"",
- * "parent-origin":[0.5,0.5,0],
+ * "parentOrigin":[0.5,0.5,0],
* "scale": [50,50,1]
* }
* },
* "styles": // are named property sets applied to actor trees
* {
- * "my-style":
+ * "myStyle":
* {
* "size": [10,10,1] // root properties applied to a given root actor
* "actors": // properties applied to actors found by name from root
* "stage":
* [
* {
- * "type":"default-text",
+ * "type":"defaultText",
* "text":"Hello World",
* "position":[0,0,0]
* },
*
* - Create an actor tree from the "templates" section
* @code
- * TextActor actor = TextActor::DownCast( builder.Create( "default-text" ) );
+ * TextActor actor = TextActor::DownCast( builder.Create( "defaultText" ) );
* @endcode
*
* - Style an actor tree from the "styles" section
* @code
- * builder.ApplyStyle( "my-style", actor );
+ * builder.ApplyStyle( "myStyle", actor );
* @endcode
*
* - Create an actor tree from json
*
* The animation is applied to a specific actor.
* e.g.
- * Actor myInstance = builder.Create( "template-actor-tree" )
+ * Actor myInstance = builder.Create( "templateActorTree" )
* Animation a = builder.CreateAnimation( "wobble", myInstance );
*
* @pre The Builder has been initialized.
* e.g.
* Property::Map map;
* map["ACTOR"] = actor.GetName(); // replaces '{ACTOR} in the template
- * Actor myInstance = builder.Create( "template-actor-tree" )
+ * Actor myInstance = builder.Create( "templateActorTree" )
* Animation a = builder.CreateAnimation( "wobble", myInstance);
*
* @pre The Builder has been initialized.
* @brief Creates an object (e.g. an actor) from the set of known style templates
*
* e.g.
- * mActor.Add( Actor::DownCast(builder.Create( "default-text")) );
+ * mActor.Add( Actor::DownCast(builder.Create( "defaultText")) );
*
* @pre The Builder has been initialized.
* @pre Preconditions have been met for creating dali objects ie Images, Actors etc
* e.g.
* Property::Map map;
* map["IMAGE_DIR"] = "/usr/share/images"; // replaces '{IMAGE_DIR} in the template
- * mActor.Add( Actor::DownCast(builder.Create( "default-image", map) ) );
+ * mActor.Add( Actor::DownCast(builder.Create( "defaultImage", map) ) );
*
* @pre The Builder has been initialized.
* @pre Preconditions have been met for creating dali objects ie Images, Actors etc
/**
* Get or create a PathConstrainer from the set of known PathConstrainers
* e.g.
- * PathConstrainer a = builder.GetPathConstrainer( "my-path-constrainer");
+ * PathConstrainer a = builder.GetPathConstrainer( "myPathConstrainer");
*
* @pre The Builder has been initialized.
* @pre The pathConstrainerName exists in the Constrainers section of the data representation
/**
* Get or create a LinearConstrainer from the set of known LinearConstrainers
* e.g.
- * LinearConstrainer a = builder.GetLinearConstrainer( "my-linear-constrainer");
+ * LinearConstrainer a = builder.GetLinearConstrainer( "myLinearConstrainer");
*
* @pre The Builder has been initialized.
* @pre The linearConstrainerName exists in the Constrainers section of the data representation
enum
{
// Event side properties
- FRAME_VISIBILITY = PROPERTY_START_INDEX, ///< name "frame-visibility", Whether a frame is visible or not, type boolean
- MAGNIFICATION_FACTOR, ///< name "magnification-factor", Larger value means greater magnification, type float
+ FRAME_VISIBILITY = PROPERTY_START_INDEX, ///< name "frameVisibility", Whether a frame is visible or not, type boolean
+ MAGNIFICATION_FACTOR, ///< name "magnificationFactor", Larger value means greater magnification, type float
// Animatable properties
- SOURCE_POSITION = ANIMATABLE_PROPERTY_START_INDEX, ///< name "source-position", The position of the source, type Vector3
+ SOURCE_POSITION = ANIMATABLE_PROPERTY_START_INDEX, ///< name "sourcePosition", The position of the source, type Vector3
};
};
* Please see the programming guide for a detailed description of the ConfirmationPopup including examples.
*
* Signals (these are dynamically created upon connect).
- * | %Signal Name | Actor name to connect to | Property to set signal type (eg clicked) |
- * |-----------------------|--------------------------|------------------------------------------|
- * | control-signal-ok | control-ok | connect-signal-ok-selected |
- * | control-signal-cancel | control-cancel | connect-signal-cancel-selected |
+ * | %Signal Name | Actor name to connect to | Property to set signal type (eg clicked) |
+ * |---------------------|--------------------------|------------------------------------------|
+ * | controlSignalOk | controlOk | connectSignalOkSelected |
+ * | controlSignalCancel | controlCancel | connectSignalCancelSelected |
*/
class DALI_IMPORT_API ConfirmationPopup : public Popup
{
{
enum
{
- CONNECT_SIGNAL_OK_SELECTED = PROPERTY_START_INDEX, ///< name "connect-signal-ok-selected", type std::string
- CONNECT_SIGNAL_CANCEL_SELECTED ///< name "connect-signal-cancel-selected", type std::string
+ CONNECT_SIGNAL_OK_SELECTED = PROPERTY_START_INDEX, ///< name "connectSignalOkSelected", type std::string
+ CONNECT_SIGNAL_CANCEL_SELECTED ///< name "connectSignalCancelSelected", type std::string
};
};
* Signals
* | %Signal Name | Method |
* |-------------------|------------------------------|
- * | touched-outside | @ref OutsideTouchedSignal() |
+ * | touchedOutside | @ref OutsideTouchedSignal() |
* | showing | @ref ShowingSignal() |
* | shown | @ref ShownSignal() |
* | hiding | @ref HidingSignal() |
TITLE = PROPERTY_START_INDEX, ///< name "title", type Property::Map
CONTENT, ///< name "content", type Property::Map
FOOTER, ///< name "footer", type Property::Map
- DISPLAY_STATE, ///< name "display-state", type std::string
- TOUCH_TRANSPARENT, ///< name "touch-transparent", type bool
- TAIL_VISIBILITY, ///< name "tail-visibility", type bool
- TAIL_POSITION, ///< name "tail-position", type Vector3
- CONTEXTUAL_MODE, ///< name "contextual-mode", type std::string
- ANIMATION_DURATION, ///< name "animation-duration", type float
- ANIMATION_MODE, ///< name "animation-mode", type std::string
- ENTRY_ANIMATION, ///< name "entry-animation", type Property::Map
- EXIT_ANIMATION, ///< name "exit-animation", type Property::Map
- AUTO_HIDE_DELAY, ///< name "auto-hide-delay", type int
- BACKING_ENABLED, ///< name "backing-enabled", type bool
- BACKING_COLOR, ///< name "backing-color", type Vector4
- POPUP_BACKGROUND_IMAGE, ///< name "popup-background-image", type std::string
- TAIL_UP_IMAGE, ///< name "tail-up-image", type std::string
- TAIL_DOWN_IMAGE, ///< name "tail-down-image", type std::string
- TAIL_LEFT_IMAGE, ///< name "tail-left-image", type std::string
- TAIL_RIGHT_IMAGE, ///< name "tail-right-image", type std::string
+ DISPLAY_STATE, ///< name "displayState", type std::string
+ TOUCH_TRANSPARENT, ///< name "touchTransparent", type bool
+ TAIL_VISIBILITY, ///< name "tailVisibility", type bool
+ TAIL_POSITION, ///< name "tailPosition", type Vector3
+ CONTEXTUAL_MODE, ///< name "contextualMode", type std::string
+ ANIMATION_DURATION, ///< name "animationDuration", type float
+ ANIMATION_MODE, ///< name "animationMode", type std::string
+ ENTRY_ANIMATION, ///< name "entryAnimation", type Property::Map
+ EXIT_ANIMATION, ///< name "exitAnimation", type Property::Map
+ AUTO_HIDE_DELAY, ///< name "autoHideDelay", type int
+ BACKING_ENABLED, ///< name "backingEnabled", type bool
+ BACKING_COLOR, ///< name "backingColor", type Vector4
+ POPUP_BACKGROUND_IMAGE, ///< name "popupBackgroundImage", type std::string
+ TAIL_UP_IMAGE, ///< name "tailUpImage", type std::string
+ TAIL_DOWN_IMAGE, ///< name "tailDownImage", type std::string
+ TAIL_LEFT_IMAGE, ///< name "tailLeftImage", type std::string
+ TAIL_RIGHT_IMAGE, ///< name "tailRightImage", type std::string
};
};
*
* The renderer type is required in the property map for requesting a control renderer.
*
- * | %Property Name | Type |
- * |---------------------------|------------------|
- * | renderer-type | STRING |
+ * | %Property Name | Type |
+ * |--------------------------|------------------|
+ * | rendererType | STRING |
*/
class DALI_IMPORT_API RendererFactory : public BaseHandle
{
* Signals
* | %Signal Name | Method |
* |-------------------|-----------------------------|
- * | value-changed | @ref ValueChangedSignal() |
+ * | valueChanged | @ref ValueChangedSignal() |
* | mark | @ref MarkSignal() |
*/
class DALI_IMPORT_API Slider : public Control
{
enum
{
- LOWER_BOUND = PROPERTY_START_INDEX, ///< Property, name "lower-bound", type float
- UPPER_BOUND, ///< Property, name "upper-bound", type float
+ LOWER_BOUND = PROPERTY_START_INDEX, ///< Property, name "lowerBound", type float
+ UPPER_BOUND, ///< Property, name "upperBound", type float
VALUE, ///< Property, name "value", type float
- HIT_REGION, ///< Property, name "hit-region", type Vector2
- BACKING_REGION, ///< Property, name "backing-region", type Vector2
- HANDLE_REGION, ///< Property, name "handle-region", type Vector2
- BACKING_IMAGE_NAME, ///< Property, name "backing-image-name", type std::string
- HANDLE_IMAGE_NAME, ///< Property, name "handle-image-name", type std::string
- PROGRESS_IMAGE_NAME, ///< Property, name "progress-image-name", type std::string
- POPUP_IMAGE_NAME, ///< Property, name "popup-image-name", type std::string
- POPUP_ARROW_IMAGE_NAME, ///< Property, name "popup-arrow-image-name", type std::string
- DISABLE_COLOR, ///< Property, name "disable-color", type Vector4
- POPUP_TEXT_COLOR, ///< Property, name "popup-text-color", type Vector4
- VALUE_PRECISION, ///< Property, name "value-precision", type int
- SHOW_POPUP, ///< Property, name "show-popup", type bool
- SHOW_VALUE, ///< Property, name "show-value", type bool
+ HIT_REGION, ///< Property, name "hitRegion", type Vector2
+ BACKING_REGION, ///< Property, name "backingRegion", type Vector2
+ HANDLE_REGION, ///< Property, name "handleRegion", type Vector2
+ BACKING_IMAGE_NAME, ///< Property, name "backingImageName", type std::string
+ HANDLE_IMAGE_NAME, ///< Property, name "handleImageName", type std::string
+ PROGRESS_IMAGE_NAME, ///< Property, name "progressImageName", type std::string
+ POPUP_IMAGE_NAME, ///< Property, name "popupImageName", type std::string
+ POPUP_ARROW_IMAGE_NAME, ///< Property, name "popupArrowImageName", type std::string
+ DISABLE_COLOR, ///< Property, name "disableColor", type Vector4
+ POPUP_TEXT_COLOR, ///< Property, name "popupTextColor", type Vector4
+ VALUE_PRECISION, ///< Property, name "valuePrecision", type int
+ SHOW_POPUP, ///< Property, name "showPopup", type bool
+ SHOW_VALUE, ///< Property, name "showValue", type bool
ENABLED, ///< Property, name "enabled", type bool
MARKS, ///< Property, name "marks", type Property::Array<float>
- SNAP_TO_MARKS, ///< Property, name "snap-to-marks", type bool
- MARK_TOLERANCE, ///< Property, name "mark-tolerance", type float
+ SNAP_TO_MARKS, ///< Property, name "snapToMarks", type bool
+ MARK_TOLERANCE, ///< Property, name "markTolerance", type float
};
};
{
enum
{
- POPUP_MAX_SIZE = PROPERTY_START_INDEX, ///< name "popup-max-size", maximum size the Popup can be, type VECTOR2
- POPUP_MIN_SIZE, ///< name "popup-min-size", minimum size the Popup can be, type VECTOR2
- OPTION_MAX_SIZE, ///< name "option-max-size", maximum size an option can be, type VECTOR2
- OPTION_MIN_SIZE, ///< name "option-min-size", minimum size an option can be, type VECTOR2
- OPTION_DIVIDER_SIZE, ///< name "option-divider-size", size of the divider between options type VECTOR2
- POPUP_CLIPBOARD_BUTTON_ICON_IMAGE, ///< name "popup-clipboard-button-image", The image to use as the popup clipboard icon, type STRING
- POPUP_CUT_BUTTON_ICON_IMAGE, ///< name "popup-cut-button-image", The image to use as the popup cut icon, type STRING
- POPUP_COPY_BUTTON_ICON_IMAGE, ///< name "popup-copy-button-image", The image to use as the popup copy icon, type STRING
- POPUP_PASTE_BUTTON_ICON_IMAGE, ///< name "popup-paste-button-image", The image to use as the popup paste icon, type STRING
- POPUP_SELECT_BUTTON_ICON_IMAGE, ///< name "popup-select-button-image", The image to use as the popup select icon, type STRING
- POPUP_SELECT_ALL_BUTTON_ICON_IMAGE, ///< name "popup-select-all-button-image", The image to use as the popup select all icon, type STRING
- POPUP_DIVIDER_COLOR, ///< name "popup-divider-color", The color of the divider between options, type VECTOR4
- POPUP_ICON_COLOR, ///< name "popup-icon-color", The color of the icons (if supplied), type VECTOR4
- POPUP_PRESSED_COLOR, ///< name "popup-pressed-color", The color of the option when pressed, type VECTOR4
- POPUP_PRESSED_IMAGE, ///< name "popup-pressed-image", The image to use for the option when pressed, type STRING
- POPUP_FADE_IN_DURATION, ///< name "popup-fade-in-duration", The duration of the fade-in animation, type FLOAT
- POPUP_FADE_OUT_DURATION, ///< name "popup-fade-out-duration", The duration of the fade-out animation, type FLOAT
+ POPUP_MAX_SIZE = PROPERTY_START_INDEX, ///< name "popupMaxSize", maximum size the Popup can be, type VECTOR2
+ POPUP_MIN_SIZE, ///< name "popupMinSize", minimum size the Popup can be, type VECTOR2
+ OPTION_MAX_SIZE, ///< name "optionMaxSize", maximum size an option can be, type VECTOR2
+ OPTION_MIN_SIZE, ///< name "optionMinSize", minimum size an option can be, type VECTOR2
+ OPTION_DIVIDER_SIZE, ///< name "optionDividerSize", size of the divider between options type VECTOR2
+ POPUP_CLIPBOARD_BUTTON_ICON_IMAGE, ///< name "popupClipboardButtonImage", The image to use as the popup clipboard icon, type STRING
+ POPUP_CUT_BUTTON_ICON_IMAGE, ///< name "popupCutButtonImage", The image to use as the popup cut icon, type STRING
+ POPUP_COPY_BUTTON_ICON_IMAGE, ///< name "popupCopyButtonImage", The image to use as the popup copy icon, type STRING
+ POPUP_PASTE_BUTTON_ICON_IMAGE, ///< name "popupPasteButtonImage", The image to use as the popup paste icon, type STRING
+ POPUP_SELECT_BUTTON_ICON_IMAGE, ///< name "popupSelectButtonImage", The image to use as the popup select icon, type STRING
+ POPUP_SELECT_ALL_BUTTON_ICON_IMAGE, ///< name "popupSelectAllButtonImage", The image to use as the popup select all icon, type STRING
+ POPUP_DIVIDER_COLOR, ///< name "popupDividerColor", The color of the divider between options, type VECTOR4
+ POPUP_ICON_COLOR, ///< name "popupIconColor", The color of the icons (if supplied), type VECTOR4
+ POPUP_PRESSED_COLOR, ///< name "popupPressedColor", The color of the option when pressed, type VECTOR4
+ POPUP_PRESSED_IMAGE, ///< name "popupPressedImage", The image to use for the option when pressed, type STRING
+ POPUP_FADE_IN_DURATION, ///< name "popupFadeInDuration", The duration of the fade-in animation, type FLOAT
+ POPUP_FADE_OUT_DURATION, ///< name "popupFadeOutDuration", The duration of the fade-out animation, type FLOAT
};
};
{
enum
{
- MAX_SIZE = PROPERTY_START_INDEX, ///< name "max-size", The maximum size the Popup can be, type VECTOR2
- ENABLE_OVERSHOOT, ///< name "enable-overshoot", Whether the overshoot image is enabled, type BOOLEAN
- SCROLL_VIEW, ///< name "scroll-view", Properties to set on scroll view type Property::Map
+ MAX_SIZE = PROPERTY_START_INDEX, ///< name "maxSize", The maximum size the Popup can be, type VECTOR2
+ ENABLE_OVERSHOOT, ///< name "enableOvershoot", Whether the overshoot image is enabled, type BOOLEAN
+ SCROLL_VIEW, ///< name "scrollView", Properties to set on scroll view type Property::Map
};
};
* UnhandledKeyEventSignal() is emitted.
*
* Signals
- * | %Signal Name | Method |
- * |-------------------------|-----------------------------------|
- * | key-input-focus-changed | @ref KeyInputFocusChangedSignal() |
- * | unhandled-key-event | @ref UnhandledKeyEventSignal() |
+ * | %Signal Name | Method |
+ * |----------------------|-----------------------------------|
+ * | keyInputFocusChanged | @ref KeyInputFocusChangedSignal() |
+ * | unhandledKeyEvent | @ref UnhandledKeyEventSignal() |
*/
class DALI_IMPORT_API KeyInputFocusManager : public BaseHandle
{
vertexShaderString.append( vertexShader );
fragmentShaderString.append( fragmentShader );
- customShader[ "vertex-shader" ] = vertexShaderString;
- customShader[ "fragment-shader" ] = fragmentShaderString;
+ customShader[ "vertexShader" ] = vertexShaderString;
+ customShader[ "fragmentShader" ] = fragmentShaderString;
- customShader[ "subdivide-grid-x" ] = 20;
- customShader[ "subdivide-grid-y" ] = 20;
+ customShader[ "subdivideGridX" ] = 20;
+ customShader[ "subdivideGridY" ] = 20;
- customShader[ "hints" ] = "output-is-transparent";
+ customShader[ "hints" ] = "outputIsTransparent";
map[ "shader" ] = customShader;
return map;
fragmentShaderString.append( fragmentShaderPrefix );
fragmentShaderString.append( fragmentShader );
- customShader[ "fragment-shader" ] = fragmentShaderString;
- customShader[ "hints" ] = "output-is-transparent";
+ customShader[ "fragmentShader" ] = fragmentShaderString;
+ customShader[ "hints" ] = "outputIsTransparent";
map[ "shader" ] = customShader;
return map;
Property::Map map;
Property::Map customShader;
- customShader[ "vertex-shader" ] = vertexSource;
- customShader[ "fragment-shader" ] = fragmentSource;
+ customShader[ "vertexShader" ] = vertexSource;
+ customShader[ "fragmentShader" ] = fragmentSource;
- customShader[ "subdivide-grid-x" ] = 10;
- customShader[ "subdivide-grid-y" ] = 10;
+ customShader[ "subdivideGridX" ] = 10;
+ customShader[ "subdivideGridY" ] = 10;
// NOTE: we must turn on alpha blending for the actor (HINT_BLENDING)
- customShader[ "hints" ] = "output-is-transparent";
+ customShader[ "hints" ] = "outputIsTransparent";
map[ "shader" ] = customShader;
return map;
Property::Map map;
Property::Map customShader;
- customShader[ "vertex-shader" ] = vertexSource;
- customShader[ "fragment-shader" ] = fragmentSource;
+ customShader[ "vertexShader" ] = vertexSource;
+ customShader[ "fragmentShader" ] = fragmentSource;
- customShader[ "subdivide-grid-x" ] = 10;
- customShader[ "subdivide-grid-y" ] = 10;
+ customShader[ "subdivideGridX" ] = 10;
+ customShader[ "subdivideGridY" ] = 10;
// NOTE: we must turn on alpha blending for the actor (HINT_BLENDING)
- customShader[ "hints" ] = "output-is-transparent";
+ customShader[ "hints" ] = "outputIsTransparent";
map[ "shader" ] = customShader;
return map;
/**
* @brief Set a constant for use when building styles
*
- * A constant is used in JSON files e.g. "my-image":"{ROOT_PATH}/mypath/image.jpg"
+ * A constant is used in JSON files e.g. "myImage":"{ROOT_PATH}/mypath/image.jpg"
* where the string "{ROOT_PATH}" is substituted with the value.
*
* @param[in] key The key of the constant
* @endcode
*
* Signals
- * | %Signal Name | Method |
- * |----------------------|----------------------------------|
- * | transition-completed | @ref TransitionCompletedSignal() |
+ * | %Signal Name | Method |
+ * |---------------------|----------------------------------|
+ * | transitionCompleted | @ref TransitionCompletedSignal() |
*/
class DALI_IMPORT_API CubeTransitionEffect : public Control
{
// Signals
-const char* const SIGNAL_FOCUS_CHANGED = "focus-changed";
-const char* const SIGNAL_FOCUS_OVERSHOT = "focus-overshot";
-const char* const SIGNAL_FOCUSED_ACTOR_ACTIVATED = "focused-actor-activated";
+const char* const SIGNAL_FOCUS_CHANGED = "focusChanged";
+const char* const SIGNAL_FOCUS_OVERSHOT = "focusOvershot";
+const char* const SIGNAL_FOCUSED_ACTOR_ACTIVATED = "focusedActorActivated";
#if defined(DEBUG_ENABLED)
Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_FOCUS_MANAGER");
#endif
const char* const ACTOR_FOCUSABLE("focusable");
-const char* const IS_FOCUS_GROUP("is-focus-group");
+const char* const IS_FOCUS_GROUP("isFocusGroup");
const char* FOCUS_BORDER_IMAGE_PATH = DALI_IMAGE_DIR "B16-8_TTS_focus.png";
const Vector4 FOCUS_BORDER_IMAGE_BORDER = Vector4(7.0f, 7.0f, 7.0f, 7.0f);
// we allow enums strings for parent-origin and anchor-point but as with the current json
// strings always succeed if they exist then check its not vector. If they are Vec3s then
// this has already been set as a generic property.
- if( !IsVector3( child, "parent-origin") )
+ if( !IsVector3( child, "parentOrigin") )
{
- if( OptionalVector3 v = constant.IsVector3( IsChild(child, "parent-origin") ) )
+ if( OptionalVector3 v = constant.IsVector3( IsChild(child, "parentOrigin") ) )
{
actor.SetParentOrigin( *v );
}
- else if( OptionalString origin = constant.IsString( IsChild(child, "parent-origin") ) )
+ else if( OptionalString origin = constant.IsString( IsChild(child, "parentOrigin") ) )
{
actor.SetParentOrigin( GetAnchorConstant(*origin) );
}
}
- if( !IsVector3(child, "anchor-point") )
+ if( !IsVector3(child, "anchorPoint") )
{
- if( OptionalVector3 v = constant.IsVector3( IsChild(child, "anchor-point") ) )
+ if( OptionalVector3 v = constant.IsVector3( IsChild(child, "anchorPoint") ) )
{
actor.SetAnchorPoint( *v );
}
- else if( OptionalString anchor = constant.IsString( IsChild(child, "anchor-point") ) )
+ else if( OptionalString anchor = constant.IsString( IsChild(child, "anchorPoint") ) )
{
actor.SetAnchorPoint( GetAnchorConstant(*anchor) );
}
}
// Add custom properties
- if( OptionalChild customPropertiesChild = IsChild(child, "custom-properties") )
+ if( OptionalChild customPropertiesChild = IsChild(child, "customProperties") )
{
const TreeNode& customPropertiesNode = *customPropertiesChild;
const TreeConstIter endIter = customPropertiesNode.CEnd();
Animation animation( Animation::New( 0.f ) );
- // duration needs to be set before AnimateTo calls for correct operation when AnimateTo has no "time-period".
+ // duration needs to be set before AnimateTo calls for correct operation when AnimateTo has no "timePeriod".
OptionalFloat duration = constant.IsFloat( IsChild(child, "duration" ) );
if( duration )
animation.SetLooping( *looping );
}
- if( OptionalString endAction = constant.IsString( IsChild(child, "end-action" ) ) )
+ if( OptionalString endAction = constant.IsString( IsChild(child, "endAction" ) ) )
{
if("BAKE" == *endAction)
{
}
}
- if( OptionalString endAction = constant.IsString( IsChild(child, "disconnect-action" ) ) )
+ if( OptionalString endAction = constant.IsString( IsChild(child, "disconnectAction" ) ) )
{
if("BAKE" == *endAction)
{
AlphaFunction alphaFunction( AlphaFunction::DEFAULT );
TimePeriod timePeriod( 0.f );
- OptionalChild timeChild = IsChild( pKeyChild.second, "time-period" );
+ OptionalChild timeChild = IsChild( pKeyChild.second, "timePeriod" );
if( timeChild )
{
durationSum = std::max( durationSum, timePeriod.delaySeconds + timePeriod.durationSeconds );
- if( OptionalString alphaChild = constant.IsString( IsChild(pKeyChild.second, "alpha-function" ) ) )
+ if( OptionalString alphaChild = constant.IsString( IsChild(pKeyChild.second, "alphaFunction" ) ) )
{
alphaFunction = GetAlphaFunction( *alphaChild );
}
- if( OptionalChild keyFrameChild = IsChild(pKeyChild.second, "key-frames") )
+ if( OptionalChild keyFrameChild = IsChild(pKeyChild.second, "keyFrames") )
{
DALI_ASSERT_ALWAYS( property && "Animation must specify a property name" );
Property prop = Property( targetHandle, propIndex );
}
AlphaFunction kfAlphaFunction( AlphaFunction::DEFAULT );
- if( OptionalString alphaFuncStr = constant.IsString( IsChild(pKeyChild.second, "alpha-function") ) )
+ if( OptionalString alphaFuncStr = constant.IsString( IsChild(pKeyChild.second, "alphaFunction") ) )
{
kfAlphaFunction = GetAlphaFunction( *alphaFuncStr );
}
if( !SetPropertyFromNode( keyChild.second, type, value, constant ) )
{
// verbose as this might not be a problem
- // eg parent-origin can be a string which is picked up later
+ // eg parentOrigin can be a string which is picked up later
DALI_SCRIPT_VERBOSE("Could not convert property:%s\n", key.c_str());
}
else
const Stage& stage = Stage::GetCurrent();
Layer root = stage.GetRootLayer();
- if( OptionalString s = constant.IsString( IsChild(node, "source-actor") ) )
+ if( OptionalString s = constant.IsString( IsChild(node, "sourceActor") ) )
{
Actor actor = root.FindChildByName(*s);
if(actor)
}
}
- if( OptionalString s = constant.IsString( IsChild(node, "camera-actor") ) )
+ if( OptionalString s = constant.IsString( IsChild(node, "cameraActor") ) )
{
CameraActor actor = CameraActor::DownCast( root.FindChildByName(*s) );
if(actor)
}
}
- if( OptionalString s = constant.IsString( IsChild(node, "target-frame-buffer") ) )
+ if( OptionalString s = constant.IsString( IsChild(node, "targetFrameBuffer") ) )
{
FrameBufferImage fb = GetFrameBufferImage( *s, constant );
if(fb)
}
}
- if( OptionalString s = constant.IsString( IsChild(node, "screen-to-frame-buffer-function") ) )
+ if( OptionalString s = constant.IsString( IsChild(node, "screenToFrameBufferFunction") ) )
{
if("DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION" == *s)
{
}
// other setup is via the property system
- SetProperties( node, task, constant ); // @ todo, remove 'source-actor', 'camera-actor'?
-
+ SetProperties( node, task, constant );
}
void Builder::CreateRenderTask( const std::string &name )
const Stage& stage = Stage::GetCurrent();
- OptionalChild tasks = IsChild(*mParser.GetRoot(), "render-tasks");
+ OptionalChild tasks = IsChild(*mParser.GetRoot(), "renderTasks");
if(tasks)
{
}
else
{
- if( OptionalChild effects = IsChild( *mParser.GetRoot(), "shader-effects") )
+ if( OptionalChild effects = IsChild( *mParser.GetRoot(), "shaderEffects") )
{
if( OptionalChild effect = IsChild( *effects, name ) )
{
}
else
{
- if( OptionalChild images = IsChild( *mParser.GetRoot(), "frame-buffer-images") )
+ if( OptionalChild images = IsChild( *mParser.GetRoot(), "frameBufferImages") )
{
if( OptionalChild image = IsChild( *images, name ) )
{
ret = Path::New();
ret.SetProperty( Path::Property::POINTS, points);
- //control-points property
- if( OptionalChild pointsProperty = IsChild( *path, "control-points") )
+ //controlPoints property
+ if( OptionalChild pointsProperty = IsChild( *path, "controlPoints") )
{
Dali::Property::Value points(Property::ARRAY);
if( SetPropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
ret = PathConstrainer::New();
ret.SetProperty( PathConstrainer::Property::POINTS, points);
- //control-points property
- if( OptionalChild pointsProperty = IsChild( *pathConstrainer, "control-points") )
+ //controlPoints property
+ if( OptionalChild pointsProperty = IsChild( *pathConstrainer, "controlPoints") )
{
Dali::Property::Value points(Property::ARRAY);
if( SetPropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
ret = Dali::LinearConstrainer::New();
ret.SetProperty( LinearConstrainer::Property::VALUE, points);
- //control-points property
+ //controlPoints property
if( OptionalChild pointsProperty = IsChild( *linearConstrainer, "progress") )
{
Dali::Property::Value points(Property::ARRAY);
// to add automatically
if( "stage" == sectionName )
{
- if( OptionalChild renderTasks = IsChild(*mParser.GetRoot(), "render-tasks") )
+ if( OptionalChild renderTasks = IsChild(*mParser.GetRoot(), "renderTasks") )
{
if( OptionalChild tasks = IsChild(*renderTasks, "stage") )
{
/**
* A property value type can be forced when its unknown by a disambiguation convention in the json
* ie "myarray": [1,2,3,4] ; would be a vector but
- * "myarray": {"type-cast":"array", "value":[1,2,3,4]} would be an array
+ * "myarray": {"typeCast":"array", "value":[1,2,3,4]} would be an array
* @param child The node whos string to search for a disambiguated type
* @param value The value to set
* @param overrideMap The user overriding constant map
Dali::Property::Value& value,
const Replacement& replacement )
{
- OptionalString childType = IsString( IsChild(child, "type-cast") );
+ OptionalString childType = IsString( IsChild(child, "typeCast") );
OptionalChild childValue = IsChild(child, "value");
if( childType && childValue && (2 == child.Size()) )
template <typename T>
void SetActionOnSignal(const TreeNode &root, const TreeNode &child, Actor actor, Dali::Toolkit::Internal::Builder* const builder, SignalConnector<T>& connector)
{
- OptionalString childActorName(IsString( IsChild(&child, "child-actor")) );
+ OptionalString childActorName(IsString( IsChild(&child, "childActor")) );
OptionalString actorName(IsString( IsChild(&child, "actor")) );
OptionalString propertyName(IsString( IsChild(&child, "property")) );
OptionalChild valueChild( IsChild(&child, "value") );
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Button, Toolkit::Control, Create );
DALI_PROPERTY_REGISTRATION( Toolkit, Button, "disabled", BOOLEAN, DISABLED )
-DALI_PROPERTY_REGISTRATION( Toolkit, Button, "auto-repeating", BOOLEAN, AUTO_REPEATING )
-DALI_PROPERTY_REGISTRATION( Toolkit, Button, "initial-auto-repeating-delay", FLOAT, INITIAL_AUTO_REPEATING_DELAY )
-DALI_PROPERTY_REGISTRATION( Toolkit, Button, "next-auto-repeating-delay", FLOAT, NEXT_AUTO_REPEATING_DELAY )
+DALI_PROPERTY_REGISTRATION( Toolkit, Button, "autoRepeating", BOOLEAN, AUTO_REPEATING )
+DALI_PROPERTY_REGISTRATION( Toolkit, Button, "initialAutoRepeatingDelay", FLOAT, INITIAL_AUTO_REPEATING_DELAY )
+DALI_PROPERTY_REGISTRATION( Toolkit, Button, "nextAutoRepeatingDelay", FLOAT, NEXT_AUTO_REPEATING_DELAY )
DALI_PROPERTY_REGISTRATION( Toolkit, Button, "togglable", BOOLEAN, TOGGLABLE )
DALI_PROPERTY_REGISTRATION( Toolkit, Button, "selected", BOOLEAN, SELECTED )
-DALI_PROPERTY_REGISTRATION( Toolkit, Button, "unselected-state-image", STRING, UNSELECTED_STATE_IMAGE )
-DALI_PROPERTY_REGISTRATION( Toolkit, Button, "selected-state-image", STRING, SELECTED_STATE_IMAGE )
-DALI_PROPERTY_REGISTRATION( Toolkit, Button, "disabled-state-image", STRING, DISABLED_STATE_IMAGE )
-DALI_PROPERTY_REGISTRATION( Toolkit, Button, "unselected-color", VECTOR4, UNSELECTED_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, Button, "selected-color", VECTOR4, SELECTED_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, Button, "unselectedStateImage", STRING, UNSELECTED_STATE_IMAGE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Button, "selectedStateImage", STRING, SELECTED_STATE_IMAGE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Button, "disabledStateImage", STRING, DISABLED_STATE_IMAGE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Button, "unselectedColor", VECTOR4, UNSELECTED_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, Button, "selectedColor", VECTOR4, SELECTED_COLOR )
DALI_PROPERTY_REGISTRATION( Toolkit, Button, "label", MAP, LABEL )
// Deprecated properties:
-DALI_PROPERTY_REGISTRATION( Toolkit, Button, "label-text", STRING, LABEL_TEXT )
+DALI_PROPERTY_REGISTRATION( Toolkit, Button, "labelText", STRING, LABEL_TEXT )
// Signals:
DALI_SIGNAL_REGISTRATION( Toolkit, Button, "pressed", SIGNAL_PRESSED )
DALI_SIGNAL_REGISTRATION( Toolkit, Button, "released", SIGNAL_RELEASED )
DALI_SIGNAL_REGISTRATION( Toolkit, Button, "clicked", SIGNAL_CLICKED )
-DALI_SIGNAL_REGISTRATION( Toolkit, Button, "state-changed", SIGNAL_STATE_CHANGED )
+DALI_SIGNAL_REGISTRATION( Toolkit, Button, "stateChanged", SIGNAL_STATE_CHANGED )
// Actions:
-DALI_ACTION_REGISTRATION( Toolkit, Button, "button-click", ACTION_BUTTON_CLICK )
+DALI_ACTION_REGISTRATION( Toolkit, Button, "buttonClick", ACTION_BUTTON_CLICK )
DALI_TYPE_REGISTRATION_END()
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::PushButton, Toolkit::Button, Create )
-DALI_PROPERTY_REGISTRATION( Toolkit, PushButton, "unselected-icon", STRING, UNSELECTED_ICON )
-DALI_PROPERTY_REGISTRATION( Toolkit, PushButton, "selected-icon", STRING, SELECTED_ICON )
-DALI_PROPERTY_REGISTRATION( Toolkit, PushButton, "icon-alignment", STRING, ICON_ALIGNMENT )
-DALI_PROPERTY_REGISTRATION( Toolkit, PushButton, "label-padding", STRING, LABEL_PADDING )
-DALI_PROPERTY_REGISTRATION( Toolkit, PushButton, "icon-padding", STRING, ICON_PADDING )
+DALI_PROPERTY_REGISTRATION( Toolkit, PushButton, "unselectedIcon", STRING, UNSELECTED_ICON )
+DALI_PROPERTY_REGISTRATION( Toolkit, PushButton, "selectedIcon", STRING, SELECTED_ICON )
+DALI_PROPERTY_REGISTRATION( Toolkit, PushButton, "iconAlignment", STRING, ICON_ALIGNMENT )
+DALI_PROPERTY_REGISTRATION( Toolkit, PushButton, "labelPadding", STRING, LABEL_PADDING )
+DALI_PROPERTY_REGISTRATION( Toolkit, PushButton, "iconPadding", STRING, ICON_PADDING )
DALI_TYPE_REGISTRATION_END()
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Magnifier, Toolkit::Control, Create )
-DALI_PROPERTY_REGISTRATION( Toolkit, Magnifier, "frame-visibility", BOOLEAN, FRAME_VISIBILITY )
-DALI_PROPERTY_REGISTRATION( Toolkit, Magnifier, "magnification-factor", FLOAT, MAGNIFICATION_FACTOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, Magnifier, "frameVisibility", BOOLEAN, FRAME_VISIBILITY )
+DALI_PROPERTY_REGISTRATION( Toolkit, Magnifier, "magnificationFactor", FLOAT, MAGNIFICATION_FACTOR )
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Magnifier, "source-position", VECTOR3, SOURCE_POSITION )
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Magnifier, "sourcePosition", VECTOR3, SOURCE_POSITION )
DALI_TYPE_REGISTRATION_END()
// Use a 1 frame delayed source position to determine the camera actor's position.
// This is necessary as the viewport is determined by the Magnifier's Actor's World position (which is computed
// at the end of the update cycle i.e. after constraints have been applied.)
- //Property::Index propertySourcePositionDelayed = mCameraActor.RegisterProperty("delayed-source-position", Vector3::ZERO);
+ //Property::Index propertySourcePositionDelayed = mCameraActor.RegisterProperty("delayedSourcePosition", Vector3::ZERO);
constraint = Constraint::New<Vector3>( mCameraActor, Actor::Property::POSITION, CameraActorPositionConstraint(stageSize, mDefaultCameraDistance) );
constraint.AddSource( Source( mSourceActor, Actor::Property::WORLD_POSITION ) );
// Setup properties, signals and actions using the type-registry.
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Model3dView, Toolkit::Control, Create );
-DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "geometry-url", STRING, GEOMETRY_URL)
-DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "material-url", STRING, MATERIAL_URL)
-DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "images-url", STRING, IMAGES_URL)
-DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "illumination-type", INTEGER, ILLUMINATION_TYPE)
-DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture0-url", STRING, TEXTURE0_URL)
-DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture1-url", STRING, TEXTURE1_URL)
-DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture2-url", STRING, TEXTURE2_URL)
+DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "geometryUrl", STRING, GEOMETRY_URL)
+DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "materialUrl", STRING, MATERIAL_URL)
+DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "imagesUrl", STRING, IMAGES_URL)
+DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "illuminationType", INTEGER, ILLUMINATION_TYPE)
+DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture0Url", STRING, TEXTURE0_URL)
+DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture1Url", STRING, TEXTURE1_URL)
+DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture2Url", STRING, TEXTURE2_URL)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Model3dView, "light-position", VECTOR3, LIGHT_POSITION)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Model3dView, "lightPosition", VECTOR3, LIGHT_POSITION)
DALI_TYPE_REGISTRATION_END()
Image tex0 = ResourceImage::New( imgUrl );
if( tex0 )
{
- size_t index = mMaterial.AddTexture( tex0, "sDiffuse" );
- mMaterial.SetTextureAffectsTransparency(index, false );
+ mMaterial.AddTexture( tex0, "sDiffuse" );
}
}
Image tex1 = ResourceImage::New( imgUrl );
if (tex1)
{
- size_t index = mMaterial.AddTexture( tex1, "sNormal" );
- mMaterial.SetTextureAffectsTransparency(index, false );
+ mMaterial.AddTexture( tex1, "sNormal" );
}
}
Image tex2 = ResourceImage::New( imgUrl );
if( tex2 )
{
- size_t index = mMaterial.AddTexture( tex2, "sGloss" );
- mMaterial.SetTextureAffectsTransparency(index, false );
+ mMaterial.AddTexture( tex2, "sGloss" );
}
}
}
}
surface.SetRequiresDepthTesting(true);
- //surface.SetProperty(Geometry::Property::GEOMETRY_HALF_EXTENTS, GetSize() * 0.5);
vertices.Clear();
verticesExt.Clear();
// Setup properties, signals and actions using the type-registry.
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::PageTurnView, Toolkit::Control, Create );
-DALI_PROPERTY_REGISTRATION( Toolkit, PageTurnView, "page-size", VECTOR2, PAGE_SIZE )
-DALI_PROPERTY_REGISTRATION( Toolkit, PageTurnView, "current-page-id", INTEGER, CURRENT_PAGE_ID )
-DALI_PROPERTY_REGISTRATION( Toolkit, PageTurnView, "spine-shadow", VECTOR2, SPINE_SHADOW )
-
-DALI_SIGNAL_REGISTRATION( Toolkit, PageTurnView, "page-turn-started", SIGNAL_PAGE_TURN_STARTED )
-DALI_SIGNAL_REGISTRATION( Toolkit, PageTurnView, "page-turn-finished", SIGNAL_PAGE_TURN_FINISHED )
-DALI_SIGNAL_REGISTRATION( Toolkit, PageTurnView, "page-pan-started", SIGNAL_PAGE_PAN_STARTED )
-DALI_SIGNAL_REGISTRATION( Toolkit, PageTurnView, "page-pan-finished", SIGNAL_PAGE_PAN_FINISHED )
+DALI_PROPERTY_REGISTRATION( Toolkit, PageTurnView, "pageSize", VECTOR2, PAGE_SIZE )
+DALI_PROPERTY_REGISTRATION( Toolkit, PageTurnView, "currentPageId", INTEGER, CURRENT_PAGE_ID )
+DALI_PROPERTY_REGISTRATION( Toolkit, PageTurnView, "spineShadow", VECTOR2, SPINE_SHADOW )
+
+DALI_SIGNAL_REGISTRATION( Toolkit, PageTurnView, "pageTurnStarted", SIGNAL_PAGE_TURN_STARTED )
+DALI_SIGNAL_REGISTRATION( Toolkit, PageTurnView, "pageTurnFinished", SIGNAL_PAGE_TURN_FINISHED )
+DALI_SIGNAL_REGISTRATION( Toolkit, PageTurnView, "pagePanStarted", SIGNAL_PAGE_PAN_STARTED )
+DALI_SIGNAL_REGISTRATION( Toolkit, PageTurnView, "pagePanFinished", SIGNAL_PAGE_PAN_FINISHED )
DALI_TYPE_REGISTRATION_END()
* the app-developer | which will provide | app developer choose which signal
* can connect to. | the signal. | within the control to connect to. */
const ControlDetailType ControlDetails[] = {
- { "control-signal-ok", "control-ok", "connect-signal-ok-selected" },
- { "control-signal-cancel", "control-cancel", "connect-signal-cancel-selected" },
+ { "controlSignalOk", "controlOk", "connectSignalOkSelected" },
+ { "controlSignalCancel", "controlCancel", "connectSignalCancelSelected" },
};
const unsigned int ControlDetailsCount = sizeof( ControlDetails ) / sizeof( ControlDetails[0] );
const Vector3 DEFAULT_TOAST_WIDTH_OF_STAGE_RATIO( 0.75f, 0.75f, 0.75f ); ///< Amount of the stage's width that the toast popup will take up.
/**
- * Creation function for named type "popup-toast".
+ * Creation function for named type "popupToast".
* @return Handle to the new toast popup object.
*/
BaseHandle CreateToast()
DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "title", MAP, TITLE )
DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "content", MAP, CONTENT )
DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "footer", MAP, FOOTER )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "display-state", STRING, DISPLAY_STATE )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "touch-transparent", BOOLEAN, TOUCH_TRANSPARENT )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "displayState", STRING, DISPLAY_STATE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "touchTransparent", BOOLEAN, TOUCH_TRANSPARENT )
// Contextual related properties.
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tail-visibility", BOOLEAN, TAIL_VISIBILITY )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tail-position", VECTOR3, TAIL_POSITION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "contextual-mode", STRING, CONTEXTUAL_MODE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tailVisibility", BOOLEAN, TAIL_VISIBILITY )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tailPosition", VECTOR3, TAIL_POSITION )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "contextualMode", STRING, CONTEXTUAL_MODE )
// Animation related properties.
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "animation-duration", FLOAT, ANIMATION_DURATION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "animation-mode", STRING, ANIMATION_MODE )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "entry-animation", MAP, ENTRY_ANIMATION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "exit-animation", MAP, EXIT_ANIMATION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "auto-hide-delay", INTEGER, AUTO_HIDE_DELAY )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "animationDuration", FLOAT, ANIMATION_DURATION )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "animationMode", STRING, ANIMATION_MODE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "entryAnimation", MAP, ENTRY_ANIMATION )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "exitAnimation", MAP, EXIT_ANIMATION )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "autoHideDelay", INTEGER, AUTO_HIDE_DELAY )
// Style related properties.
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "backing-enabled", BOOLEAN, BACKING_ENABLED )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "backing-color", VECTOR4, BACKING_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "popup-background-image", STRING, POPUP_BACKGROUND_IMAGE )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tail-up-image", STRING, TAIL_UP_IMAGE )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tail-down-image", STRING, TAIL_DOWN_IMAGE )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tail-left-image", STRING, TAIL_LEFT_IMAGE )
-DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tail-right-image", STRING, TAIL_RIGHT_IMAGE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "backingEnabled", BOOLEAN, BACKING_ENABLED )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "backingColor", VECTOR4, BACKING_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "popupBackgroundImage", STRING, POPUP_BACKGROUND_IMAGE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tailUpImage", STRING, TAIL_UP_IMAGE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tailDownImage", STRING, TAIL_DOWN_IMAGE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tailLeftImage", STRING, TAIL_LEFT_IMAGE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Popup, "tailRightImage", STRING, TAIL_RIGHT_IMAGE )
// Signals.
-DALI_SIGNAL_REGISTRATION( Toolkit, Popup, "touched-outside", SIGNAL_TOUCHED_OUTSIDE )
+DALI_SIGNAL_REGISTRATION( Toolkit, Popup, "touchedOutside", SIGNAL_TOUCHED_OUTSIDE )
DALI_SIGNAL_REGISTRATION( Toolkit, Popup, "showing", SIGNAL_SHOWING )
DALI_SIGNAL_REGISTRATION( Toolkit, Popup, "shown", SIGNAL_SHOWN )
DALI_SIGNAL_REGISTRATION( Toolkit, Popup, "hiding", SIGNAL_HIDING )
// Named type registration.
// Toast Popup: Non-modal popup that displays information at the bottom of the screen.
-TypeRegistration typeRegistrationToast( "popup-toast", typeid( Toolkit::Popup ), CreateToast );
+TypeRegistration typeRegistrationToast( "PopupToast", typeid( Toolkit::Popup ), CreateToast );
// Enumeration to / from string conversion tables
// Create a new layer so all Popup components can appear above all other actors.
mLayer = Layer::New();
- mLayer.SetName( "popup-layer" );
+ mLayer.SetName( "popupLayer" );
mLayer.SetParentOrigin( ParentOrigin::CENTER );
mLayer.SetAnchorPoint( AnchorPoint::CENTER );
mLayer.Add( mBacking );
mPopupContainer = Actor::New();
- mPopupContainer.SetName( "popup-container" );
+ mPopupContainer.SetName( "popupContainer" );
mPopupContainer.SetParentOrigin( ParentOrigin::CENTER );
mPopupContainer.SetAnchorPoint( AnchorPoint::CENTER );
mPopupContainer.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::ALL_DIMENSIONS );
// Adds the default background image.
SetPopupBackgroundImage( ImageActor::New( ResourceImage::New( DEFAULT_BACKGROUND_IMAGE_PATH ) ) );
- mPopupLayout.SetName( "popup-layout-table" );
+ mPopupLayout.SetName( "popupLayoutTable" );
mPopupLayout.SetParentOrigin( ParentOrigin::CENTER );
mPopupLayout.SetAnchorPoint( AnchorPoint::CENTER );
// Adds new background to the dialog.
mPopupBackgroundImage = image;
- mPopupBackgroundImage.SetName( "popup-background-image" );
+ mPopupBackgroundImage.SetName( "popupBackgroundImage" );
mPopupBackgroundImage.SetAnchorPoint( AnchorPoint::CENTER );
mPopupBackgroundImage.SetParentOrigin( ParentOrigin::CENTER );
if( mContent )
{
- mContent.SetName( "popup-content" );
+ mContent.SetName( "popupContent" );
mPopupLayout.AddChild( mContent, Toolkit::TableView::CellPosition( 1, 0 ) );
}
// Adds the tail actor.
Image tail = ResourceImage::New( image );
mTailImage = ImageActor::New( tail );
- mTailImage.SetName( "tail-image" );
+ mTailImage.SetName( "tailImage" );
const Vector3 anchorPoint = AnchorPoint::BOTTOM_RIGHT - position;
mTailImage.SetParentOrigin( position );
mTailImage.SetAnchorPoint( anchorPoint );
{
Toolkit::Control backing = Control::New();
backing.SetBackgroundColor( Vector4( mBackingColor.r, mBackingColor.g, mBackingColor.b, 1.0f ) );
- backing.SetName( "popup-backing" );
+ backing.SetName( "popupBacking" );
// Must always be positioned top-left of stage, regardless of parent.
backing.SetPositionInheritanceMode( DONT_INHERIT_POSITION );
namespace
{
-const char * const RENDERER_TYPE("renderer-type");
-const char * const RENDERER_TYPE_VALUE("border-renderer");
+const char * const RENDERER_TYPE("rendererType");
+const char * const RENDERER_TYPE_VALUE("borderRenderer");
-const char * const COLOR_NAME("border-color");
+const char * const COLOR_NAME("borderColor");
const char * const COLOR_UNIFORM_NAME("uBorderColor");
-const char * const SIZE_NAME("border-size");
+const char * const SIZE_NAME("borderSize");
const char * const SIZE_UNIFORM_NAME("uBorderSize");
const char * const POSITION_ATTRIBUTE_NAME("aPosition");
*
* The following properties are required for create a BorderRender
*
- * | %Property Name | Type |
- * |------------------|-------------|
- * | border-color | VECTOR4 |
- * | border-size | FLOAT |
+ * | %Property Name | Type |
+ * |-----------------|-------------|
+ * | borderColor | VECTOR4 |
+ * | borderSize | FLOAT |
*/
class BorderRenderer : public ControlRenderer
namespace
{
-const char * const RENDERER_TYPE("renderer-type");
-const char * const RENDERER_TYPE_VALUE("color-renderer");
-const char * const COLOR_NAME("blend-color");
+const char * const RENDERER_TYPE("rendererType");
+const char * const RENDERER_TYPE_VALUE("colorRenderer");
+const char * const COLOR_NAME("blendColor");
const char * const COLOR_UNIFORM_NAME("uBlendColor");
*
* The following properties are required for create a ColorRender
*
- * | %Property Name | Type |
- * |------------------|-------------|
- * | blend-color | VECTOR4 |
+ * | %Property Name | Type |
+ * |-----------------|-------------|
+ * | blendColor | VECTOR4 |
*/
class ColorRenderer: public ControlRenderer
{
{
//custom shader
const char * const CUSTOM_SHADER( "shader" );
-const char * const CUSTOM_VERTEX_SHADER( "vertex-shader" );
-const char * const CUSTOM_FRAGMENT_SHADER( "fragment-shader" );
-const char * const CUSTOM_SUBDIVIDE_GRID_X( "subdivide-grid-x" );
-const char * const CUSTOM_SUBDIVIDE_GRID_Y( "subdivide-grid-y" );
+const char * const CUSTOM_VERTEX_SHADER( "vertexShader" );
+const char * const CUSTOM_FRAGMENT_SHADER( "fragmentShader" );
+const char * const CUSTOM_SUBDIVIDE_GRID_X( "subdivideGridX" );
+const char * const CUSTOM_SUBDIVIDE_GRID_Y( "subdivideGridY" );
const char * const CUSTOM_SHADER_HINTS( "hints" ); ///< type STRING for a hint from the below hint strings or an ARRAY of of hint strings
/**
* where hints should be contain strings of the following shader hints:
- * "none" | corresponds to HINT_NONE
- * "requires-self-depth-test" | corresponds to HINT_REQUIRES_SELF_DEPTH_TEST
- * "output-is-transparent" | corresponds to HINT_OUTPUT_IS_TRANSPARENT
- * "output-is-opaque" | corresponds to HINT_OUTPUT_IS_OPAQUE
- * "modifies-geometry" | corresponds to HINT_MODIFIES_GEOMETRY
+ * "none" | corresponds to HINT_NONE
+ * "requiresSelfDepthTest" | corresponds to HINT_REQUIRES_SELF_DEPTH_TEST
+ * "outputIsTransparent" | corresponds to HINT_OUTPUT_IS_TRANSPARENT
+ * "outputIsOpaque" | corresponds to HINT_OUTPUT_IS_OPAQUE
+ * "modifiesGeometry" | corresponds to HINT_MODIFIES_GEOMETRY
*/
Shader::ShaderHints HintFromString( std::string hintString )
{
return Shader::HINT_NONE;
}
- else if( hintString == "requires-self-depth-test" )
+ else if( hintString == "requiresSelfDepthTest" )
{
return Shader::HINT_REQUIRES_SELF_DEPTH_TEST;
}
- else if( hintString == "output-is-transparent" )
+ else if( hintString == "outputIsTransparent" )
{
return Shader::HINT_OUTPUT_IS_TRANSPARENT;
}
- else if( hintString == "output-is-opaque" )
+ else if( hintString == "outputIsOpaque" )
{
return Shader::HINT_OUTPUT_IS_OPAQUE;
}
- else if( hintString == "modifies-geometry" )
+ else if( hintString == "modifiesGeometry" )
{
return Shader::HINT_MODIFIES_GEOMETRY;
}
{
//custom shader
const char * const CUSTOM_SHADER( "shader" );
-const char * const CUSTOM_VERTEX_SHADER( "vertex-shader" );
-const char * const CUSTOM_FRAGMENT_SHADER( "fragment-shader" );
-const char * const CUSTOM_SUBDIVIDE_GRID_X( "subdivide-grid-x" );
-const char * const CUSTOM_SUBDIVIDE_GRID_Y( "subdivide-grid-y" );
+const char * const CUSTOM_VERTEX_SHADER( "vertexShader" );
+const char * const CUSTOM_FRAGMENT_SHADER( "fragmentShader" );
+const char * const CUSTOM_SUBDIVIDE_GRID_X( "subdivideGridX" );
+const char * const CUSTOM_SUBDIVIDE_GRID_Y( "subdivideGridY" );
const char * const CUSTOM_SHADER_HINTS( "hints" ); ///< type INTEGER; (bitfield) values from enum Shader::Hints
}
*
* The following properties are optional
*
- * | %Property Name | Type |
- * |---------------------------|------------------|
- * | custom-shader | MAP |
+ * | %Property Name | Type |
+ * |-------------------------|------------------|
+ * | customShader | MAP |
*
* where custom-shader is a map with the following properties:
- * | %Property Name | Type |
- * |---------------------------|------------------|
- * | vertex-shader | STRING |
- * | fragment-shader | STRING |
- * | subdivide-grid-x | INT |
- * | subdivide-grid-y | INT |
- * | shader-hints | INT |
+ * | %Property Name | Type |
+ * |-------------------------|------------------|
+ * | vertexShader | STRING |
+ * | fragmentShader | STRING |
+ * | subdivideGridX | INT |
+ * | subdivideGridY | INT |
+ * | shaderHints | INT |
*/
class ControlRenderer : public BaseObject
{
namespace
{
-const char * const RENDERER_TYPE("renderer-type");
-const char * const RENDERER_TYPE_VALUE("gradient-renderer");
+const char * const RENDERER_TYPE("rendererType");
+const char * const RENDERER_TYPE_VALUE("gradientRenderer");
// properties: linear gradient
-const char * const GRADIENT_START_POSITION_NAME("gradient-start-position"); // Property::VECTOR2
-const char * const GRADIENT_END_POSITION_NAME("gradient-end-position"); // Property::VECTOR2
+const char * const GRADIENT_START_POSITION_NAME("gradientStartPosition"); // Property::VECTOR2
+const char * const GRADIENT_END_POSITION_NAME("gradientEndPosition"); // Property::VECTOR2
// properties: radial gradient
-const char * const GRADIENT_CENTER_NAME("gradient-center"); // Property::VECTOR2
-const char * const GRADIENT_RADIUS_NAME("gradient-radius"); // Property::FLOAT
+const char * const GRADIENT_CENTER_NAME("gradientCenter"); // Property::VECTOR2
+const char * const GRADIENT_RADIUS_NAME("gradientRadius"); // Property::FLOAT
// properties: linear&radial gradient
-const char * const GRADIENT_STOP_OFFSET_NAME("gradient-stop-offset"); // Property::Array FLOAT
-const char * const GRADIENT_STOP_COLOR_NAME("gradient-stop-color"); // Property::Array VECTOR4
-const char * const GRADIENT_UNITS_NAME("gradient-units"); // Property::String "userSpaceOnUse | objectBoundingBox"
-const char * const GRADIENT_SPREAD_METHOD_NAME("gradient-spread-method"); // Property::String "pad | reflect | repeat"
+const char * const GRADIENT_STOP_OFFSET_NAME("gradientStopOffset"); // Property::Array FLOAT
+const char * const GRADIENT_STOP_COLOR_NAME("gradientStopColor"); // Property::Array VECTOR4
+const char * const GRADIENT_UNITS_NAME("gradientUnits"); // Property::String "userSpaceOnUse | objectBoundingBox"
+const char * const GRADIENT_SPREAD_METHOD_NAME("gradientSpreadMethod"); // Property::String "pad | reflect | repeat"
// string values
-const char * const UNIT_USER_SPACE("user-space");
-const char * const UNIT_BOUNDING_BOX("object-bounding-box");
+const char * const UNIT_USER_SPACE("userSpace");
+const char * const UNIT_BOUNDING_BOX("objectBoundingBox");
const char * const SPREAD_PAD("pad");
const char * const SPREAD_REFLECT("reflect");
const char * const SPREAD_REPEAT("repeat");
*
* The following properties are essential for create a LINEAR GradientRender
*
- * | %Property Name | Type |
- * |---------------------------|------------------|
- * | gradient-start-position | VECTOR2 |
- * | gradient-end-position | VECTOR2 |
- * | gradient-stop-offset | ARRAY of FLOAT |
- * | gradient-stop-color | ARRAY of VECTOR4 |
+ * | %Property Name | Type |
+ * |-------------------------|------------------|
+ * | gradientStartPosition | VECTOR2 |
+ * | gradientEndPosition | VECTOR2 |
+ * | gradientStopOffset | ARRAY of FLOAT |
+ * | gradientStopColor | ARRAY of VECTOR4 |
*
* The following properties are essential for create a RADIAL GradientRender
*
- * | %Property Name | Type |
- * |---------------------------|------------------|
- * | gradient-center | VECTOR2 |
- * | gradient-radius | FLOAT |
- * | gradient-stop-offset | ARRAY of FLOAT |
- * | gradient-stop-color | ARRAY of VECTOR4 |
+ * | %Property Name | Type |
+ * |-------------------------|------------------|
+ * | gradientCenter | VECTOR2 |
+ * | gradientRadius | FLOAT |
+ * | gradientStopOffset | ARRAY of FLOAT |
+ * | gradientStopColor | ARRAY of VECTOR4 |
*
* The following properties are optional for both LINEAR and RADIAL GradientRender.
*
- * | %Property Name | Type |
- * |---------------------------|------------------|
- * | gradient-units | STRING |
- * | gradient-spread-method | STRING |
+ * | %Property Name | Type |
+ * |-------------------------|------------------|
+ * | gradientUnits | STRING |
+ * | gradientSpreadMethod | STRING |
*
- * Valid values for gradient-units are 'user-space' and 'object-bounding-box'.
- * Valid values for gradient-spread-method are 'pad', 'repeat' and 'reflect.'
+ * Valid values for gradientUnits are 'userSpace' and 'objectBoundingBox'.
+ * Valid values for gradientSpreadMethod are 'pad', 'repeat' and 'reflect.'
* If not provided, 'objectBoundingBox' is used as default gradient units, and 'pad' is used as default spread method.
*/
class GradientRenderer: public ControlRenderer
namespace
{
-const char * const RENDERER_TYPE("renderer-type");
-const char * const RENDERER_TYPE_VALUE("image-renderer");
+const char * const RENDERER_TYPE("rendererType");
+const char * const RENDERER_TYPE_VALUE("imageRenderer");
// property names
-const char * const IMAGE_URL_NAME( "image-url" );
-const char * const IMAGE_FITTING_MODE( "image-fitting-mode" );
-const char * const IMAGE_SAMPLING_MODE( "image-sampling-mode" );
-const char * const IMAGE_DESIRED_WIDTH( "image-desired-width" );
-const char * const IMAGE_DESIRED_HEIGHT( "image-desired-height" );
+const char * const IMAGE_URL_NAME( "imageUrl" );
+const char * const IMAGE_FITTING_MODE( "imageFittingMode" );
+const char * const IMAGE_SAMPLING_MODE( "imageSamplingMode" );
+const char * const IMAGE_DESIRED_WIDTH( "imageDesiredWidth" );
+const char * const IMAGE_DESIRED_HEIGHT( "imageDesiredHeight" );
// fitting modes
-const char * const SHRINK_TO_FIT("shrink-to-fit");
-const char * const SCALE_TO_FILL("scale-to-fill");
-const char * const FIT_WIDTH("fit-width");
-const char * const FIT_HEIGHT("fit-height");
+const char * const SHRINK_TO_FIT("shrinkToFit");
+const char * const SCALE_TO_FILL("scaleToFill");
+const char * const FIT_WIDTH("fitWidth");
+const char * const FIT_HEIGHT("fitHeight");
const char * const DEFAULT("default");
// sampling modes
const char * const BOX("box");
const char * const NEAREST("nearest");
const char * const LINEAR("linear");
-const char * const BOX_THEN_NEAREST("box-then-nearest");
-const char * const BOX_THEN_LINEAR("box-then-linear");
-const char * const NO_FILTER("no-filter");
-const char * const DONT_CARE("dont-care");
+const char * const BOX_THEN_NEAREST("boxThenNearest");
+const char * const BOX_THEN_LINEAR("boxThenLinear");
+const char * const NO_FILTER("noFilter");
+const char * const DONT_CARE("dontCare");
std::string TEXTURE_UNIFORM_NAME = "sTexture";
*
* The following properties are optional
*
- * | %Property Name | Type |
- * |---------------------------|------------------|
- * | image-url | STRING |
- * | image-fitting-mode | STRING |
- * | image-sampling-mode | STRING |
- * | image-desired-width | INT |
- * | image-desired-height | INT |
+ * | %Property Name | Type |
+ * |-------------------------|------------------|
+ * | imageUrl | STRING |
+ * | imageFittingMode | STRING |
+ * | imageSamplingMode | STRING |
+ * | imageDesiredWidth | INT |
+ * | imageDesiredHeight | INT |
*
- * where image-fitting-mode should be one of the following fitting modes:
- * "shrink-to-fit"
- * "scale-to-fill"
- * "fit-width"
- * "fit-height"
+ * where imageFittingMode should be one of the following fitting modes:
+ * "shrinkToFit"
+ * "scaleToFill"
+ * "fitWidth"
+ * "fitHeight"
* "default"
*
- * where image-sampling-mode should be one of the following sampling modes:
+ * where imageSamplingMode should be one of the following sampling modes:
* "box"
* "nearest"
* "linear"
- * "box-then-nearest"
- * "box-then-linear"
- * "no-filter"
- * "dont-care"
+ * "boxThenNearest"
+ * "boxThenLinear"
+ * "noFilter"
+ * "dontCare"
* "default"
*
*/
namespace
{
-const char * const RENDERER_TYPE("renderer-type");
-const char * const RENDERER_TYPE_VALUE("n-patch-renderer");
+const char * const RENDERER_TYPE("rendererType");
+const char * const RENDERER_TYPE_VALUE("nPatchRenderer");
-const char * const IMAGE_URL_NAME("image-url");
-const char * const BORDER_ONLY("border-only");
+const char * const IMAGE_URL_NAME("imageUrl");
+const char * const BORDER_ONLY("borderOnly");
std::string TEXTURE_UNIFORM_NAME = "sTexture";
Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
if( imageURLValue )
{
- //Read the border-only property first since InitialiseFromImage relies on mBorderOnly to be properly set
+ //Read the borderOnly property first since InitialiseFromImage relies on mBorderOnly to be properly set
Property::Value* borderOnlyValue = propertyMap.Find( BORDER_ONLY );
if( borderOnlyValue )
{
*
* The following properties are optional
*
- * | %Property Name | Type |
- * |---------------------------|------------------|
- * | image-url | STRING |
- * | border-only | BOOLEAN
+ * | %Property Name | Type |
+ * |--------------------------|------------------|
+ * | imageUrl | STRING |
+ * | borderOnly | BOOLEAN
*
*/
class NPatchRenderer: public ControlRenderer
namespace
{
-const char * const RENDERER_TYPE_NAME( "renderer-type" );
+const char * const RENDERER_TYPE_NAME( "rendererType" );
-const char * const COLOR_RENDERER("color-renderer");
-const char * const BORDER_RENDERER("border-renderer");
-const char * const GRADIENT_RENDERER("gradient-renderer");
-const char * const IMAGE_RENDERER("image-renderer");
-const char * const N_PATCH_RENDERER("n-patch-renderer");
+const char * const COLOR_RENDERER("colorRenderer");
+const char * const BORDER_RENDERER("borderRenderer");
+const char * const GRADIENT_RENDERER("gradientRenderer");
+const char * const IMAGE_RENDERER("imageRenderer");
+const char * const N_PATCH_RENDERER("nPatchRenderer");
const char * const BROKEN_RENDERER_IMAGE_URL( DALI_IMAGE_DIR "broken.png");
}
void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Vector4& color )
{
- ColorRenderer* rendererPtr = dynamic_cast< ColorRenderer* >( &GetImplementation( renderer ) );
- if( rendererPtr )
- {
- rendererPtr->SetColor( color );
- }
- else
+ if( renderer )
{
- renderer.RemoveAndReset( actor );
- renderer = GetControlRenderer( color );
-
- if( actor.OnStage() )
+ ColorRenderer* rendererPtr = dynamic_cast< ColorRenderer* >( &GetImplementation( renderer ) );
+ if( rendererPtr )
{
- renderer.SetOnStage( actor );
+ rendererPtr->SetColor( color );
+ return;
}
+
+ renderer.RemoveAndReset( actor );
+ }
+
+ renderer = GetControlRenderer( color );
+ if( actor && actor.OnStage() )
+ {
+ renderer.SetOnStage( actor );
}
}
return;
}
}
+
+ renderer.RemoveAndReset( actor );
}
- renderer.RemoveAndReset( actor );
renderer = GetControlRenderer( image );
- if( actor.OnStage() )
+ if( actor && actor.OnStage() )
{
renderer.SetOnStage( actor );
}
return;
}
}
+
+ renderer.RemoveAndReset( actor );
}
- renderer.RemoveAndReset( actor );
renderer = GetControlRenderer( url );
- if( actor.OnStage() )
+ if( actor && actor.OnStage() )
{
renderer.SetOnStage( actor );
}
{
if( renderer )
{
+ ControlRenderer& controlRenderer = GetImplementation( renderer );
+
Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
std::string typeValue ;
- if( type && type->Get( typeValue ))
+
+ //If there's no renderer type specified or if there hasn't been a renderer type change then we can reuse the renderer
+ if( !type || !type->Get( typeValue ) ||
+ ( typeValue == IMAGE_RENDERER && typeid( controlRenderer ) == typeid( ImageRenderer ) ) ||
+ ( typeValue == N_PATCH_RENDERER && typeid( controlRenderer ) == typeid( NPatchRenderer ) ) ||
+ ( typeValue == COLOR_RENDERER && typeid( controlRenderer ) == typeid( ColorRenderer ) )||
+ ( typeValue == GRADIENT_RENDERER && typeid( controlRenderer ) == typeid( GradientRenderer ) ) ||
+ ( typeValue == BORDER_RENDERER && typeid( controlRenderer ) == typeid( BorderRenderer ) ) )
{
- //If there's been a renderer type change then we have to return a new shader
- if( typeValue == COLOR_RENDERER && typeid( renderer ) != typeid( ColorRenderer ) )
- {
- renderer = GetControlRenderer( propertyMap );
- return;
- }
- else if( typeValue == GRADIENT_RENDERER && typeid( renderer ) != typeid( GradientRenderer ) )
- {
- renderer = GetControlRenderer( propertyMap );
- return;
- }
- else if( typeValue == IMAGE_RENDERER && typeid( renderer ) != typeid( ImageRenderer ) )
- {
- renderer = GetControlRenderer( propertyMap );
- return;
- }
- else if( typeValue == N_PATCH_RENDERER && typeid( renderer ) != typeid( NPatchRenderer ) )
- {
- renderer = GetControlRenderer( propertyMap );
- return;
- }
- else if( typeValue == BORDER_RENDERER && typeid( renderer ) != typeid( BorderRenderer ) )
- {
- renderer = GetControlRenderer( propertyMap );
- return;
- }
+ controlRenderer.Initialize( actor, propertyMap );
+ return;
}
- GetImplementation( renderer ).Initialize( actor, propertyMap );
+ renderer.RemoveAndReset( actor );
}
- else
+
+ renderer = GetControlRenderer( propertyMap );
+ if( actor && actor.OnStage() )
{
- renderer = GetControlRenderer( propertyMap );
+ renderer.SetOnStage( actor );
}
-
}
Image RendererFactory::GetBrokenRendererImage()
// Setup properties, signals and actions using the type-registry.
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ScrollBar, Toolkit::Control, Create );
-DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "scroll-direction", STRING, SCROLL_DIRECTION )
-DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicator-height-policy", STRING, INDICATOR_HEIGHT_POLICY )
-DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicator-fixed-height", FLOAT, INDICATOR_FIXED_HEIGHT )
-DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicator-show-duration", FLOAT, INDICATOR_SHOW_DURATION )
-DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicator-hide-duration", FLOAT, INDICATOR_HIDE_DURATION )
-DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "scroll-position-intervals", ARRAY, SCROLL_POSITION_INTERVALS )
-
-DALI_SIGNAL_REGISTRATION( Toolkit, ScrollBar, "pan-finished", PAN_FINISHED_SIGNAL )
-DALI_SIGNAL_REGISTRATION( Toolkit, ScrollBar, "scroll-position-interval-reached", SCROLL_POSITION_INTERVAL_REACHED_SIGNAL )
+DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "scrollDirection", STRING, SCROLL_DIRECTION )
+DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicatorHeightPolicy", STRING, INDICATOR_HEIGHT_POLICY )
+DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicatorFixedHeight", FLOAT, INDICATOR_FIXED_HEIGHT )
+DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicatorShowDuration", FLOAT, INDICATOR_SHOW_DURATION )
+DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicatorHideDuration", FLOAT, INDICATOR_HIDE_DURATION )
+DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "scrollPositionIntervals", ARRAY, SCROLL_POSITION_INTERVALS )
+
+DALI_SIGNAL_REGISTRATION( Toolkit, ScrollBar, "panFinished", PAN_FINISHED_SIGNAL )
+DALI_SIGNAL_REGISTRATION( Toolkit, ScrollBar, "scrollPositionIntervalReached", SCROLL_POSITION_INTERVAL_REACHED_SIGNAL )
DALI_TYPE_REGISTRATION_END()
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ItemView, Toolkit::Scrollable, NULL)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "layout-position", FLOAT, LAYOUT_POSITION)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "scroll-speed", FLOAT, SCROLL_SPEED)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "layoutPosition", FLOAT, LAYOUT_POSITION)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "scrollSpeed", FLOAT, SCROLL_SPEED)
DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "overshoot", FLOAT, OVERSHOOT)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "scroll-direction", VECTOR2, SCROLL_DIRECTION)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "layout-orientation", INTEGER, LAYOUT_ORIENTATION)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "scroll-content-size", FLOAT, SCROLL_CONTENT_SIZE)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "scrollDirection", VECTOR2, SCROLL_DIRECTION)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "layoutOrientation", INTEGER, LAYOUT_ORIENTATION)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ItemView, "scrollContentSize", FLOAT, SCROLL_CONTENT_SIZE)
-DALI_SIGNAL_REGISTRATION( Toolkit, ItemView, "layout-activated", LAYOUT_ACTIVATED_SIGNAL )
+DALI_SIGNAL_REGISTRATION( Toolkit, ItemView, "layoutActivated", LAYOUT_ACTIVATED_SIGNAL )
DALI_TYPE_REGISTRATION_END()
}
}
-float ItemView::ClampFirstItemPosition(float targetPosition, const Vector3& targetSize, ItemLayout& layout)
+float ItemView::ClampFirstItemPosition( float targetPosition, const Vector3& targetSize, ItemLayout& layout, bool updateOvershoot )
{
Actor self = Self();
float minLayoutPosition = layout.GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), targetSize);
float clamppedPosition = std::min(0.0f, std::max(minLayoutPosition, targetPosition));
- mScrollOvershoot = targetPosition - clamppedPosition;
self.SetProperty(Toolkit::Scrollable::Property::SCROLL_POSITION_MAX, Vector2(0.0f, -minLayoutPosition));
+ if( updateOvershoot )
+ {
+ mScrollOvershoot = targetPosition - clamppedPosition;
+ }
+
return clamppedPosition;
}
{
Actor self = Self();
- float currentLayoutPosition = ClampFirstItemPosition( GetCurrentLayoutPosition(0), layoutSize, *mActiveLayout );
- float forwardClampedPosition = ClampFirstItemPosition(currentLayoutPosition + 1.0, layoutSize, *mActiveLayout);
- float backwardClampedPosition = ClampFirstItemPosition(currentLayoutPosition - 1.0, layoutSize, *mActiveLayout);
+ float currentLayoutPosition = ClampFirstItemPosition( GetCurrentLayoutPosition(0), layoutSize, *mActiveLayout, false );
+ float forwardClampedPosition = ClampFirstItemPosition( currentLayoutPosition + 1.0, layoutSize, *mActiveLayout, false );
+ float backwardClampedPosition = ClampFirstItemPosition( currentLayoutPosition - 1.0, layoutSize, *mActiveLayout, false );
return (fabs(forwardClampedPosition - backwardClampedPosition) > Math::MACHINE_EPSILON_0);
}
* @param[in] targetPosition The target position of the drag etc.
* @param[in] targetSize The target ItemView & layout size.
* @param[in] layout The current layout.
+ * @param[in] updateOvershoot False stops the current overshoot value from being clamped also.
* @return The clamped first-item position.
*/
- float ClampFirstItemPosition(float targetPosition, const Vector3& targetSize, ItemLayout& layout);
+ float ClampFirstItemPosition(float targetPosition, const Vector3& targetSize, ItemLayout& layout, bool updateOvershoot = true);
/**
* Called upon pan gesture event.
const float TOUCH_DOWN_TIMER_INTERVAL = 100.0f;
const float DEFAULT_SCROLL_UPDATE_DISTANCE( 30.0f ); ///< Default distance to travel in pixels for scroll update signal
-const std::string INTERNAL_MAX_POSITION_PROPERTY_NAME( "internal-max-position" );
+const std::string INTERNAL_MAX_POSITION_PROPERTY_NAME( "internalMaxPosition" );
// Helpers ////////////////////////////////////////////////////////////////////////////////////////
// Setup properties, signals and actions using the type-registry.
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ScrollView, Toolkit::Scrollable, Create )
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scroll-position", VECTOR2, SCROLL_POSITION)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scroll-pre-position", VECTOR2, SCROLL_PRE_POSITION)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scroll-pre-position-x", SCROLL_PRE_POSITION_X, SCROLL_PRE_POSITION, 0)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scroll-pre-position-y", SCROLL_PRE_POSITION_Y, SCROLL_PRE_POSITION, 1)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scroll-pre-position-max", VECTOR2, SCROLL_PRE_POSITION_MAX)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scroll-pre-position-max-x", SCROLL_PRE_POSITION_MAX_X, SCROLL_PRE_POSITION_MAX, 0)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scroll-pre-position-max-y", SCROLL_PRE_POSITION_MAX_Y, SCROLL_PRE_POSITION_MAX, 1)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "overshoot-x", FLOAT, OVERSHOOT_X)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "overshoot-y", FLOAT, OVERSHOOT_Y)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scroll-final", VECTOR2, SCROLL_FINAL)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scroll-final-x", SCROLL_FINAL_X, SCROLL_FINAL,0)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scroll-final-y", SCROLL_FINAL_Y, SCROLL_FINAL,1)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollPosition", VECTOR2, SCROLL_POSITION)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollPrePosition", VECTOR2, SCROLL_PRE_POSITION)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollPrePositionX", SCROLL_PRE_POSITION_X, SCROLL_PRE_POSITION, 0)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollPrePositionY", SCROLL_PRE_POSITION_Y, SCROLL_PRE_POSITION, 1)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollPrePositionMax", VECTOR2, SCROLL_PRE_POSITION_MAX)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollPrePositionMaxX", SCROLL_PRE_POSITION_MAX_X, SCROLL_PRE_POSITION_MAX, 0)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollPrePositionMaxY", SCROLL_PRE_POSITION_MAX_Y, SCROLL_PRE_POSITION_MAX, 1)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "overshootX", FLOAT, OVERSHOOT_X)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "overshootY", FLOAT, OVERSHOOT_Y)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollFinal", VECTOR2, SCROLL_FINAL)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollFinalX", SCROLL_FINAL_X, SCROLL_FINAL,0)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollFinalY", SCROLL_FINAL_Y, SCROLL_FINAL,1)
DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "wrap", BOOLEAN, WRAP)
DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "panning", BOOLEAN, PANNING)
DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrolling", BOOLEAN, SCROLLING)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scroll-domain-size", VECTOR2, SCROLL_DOMAIN_SIZE)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scroll-domain-size-x", SCROLL_DOMAIN_SIZE_X, SCROLL_DOMAIN_SIZE, 0)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scroll-domain-size-y", SCROLL_DOMAIN_SIZE_Y, SCROLL_DOMAIN_SIZE, 1)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scroll-domain-offset", VECTOR2, SCROLL_DOMAIN_OFFSET)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scroll-position-delta", VECTOR2, SCROLL_POSITION_DELTA)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "start-page-position", VECTOR3, START_PAGE_POSITION)
-
-DALI_SIGNAL_REGISTRATION( Toolkit, ScrollView, "value-changed", SIGNAL_SNAP_STARTED )
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollDomainSize", VECTOR2, SCROLL_DOMAIN_SIZE)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollDomainSizeX", SCROLL_DOMAIN_SIZE_X, SCROLL_DOMAIN_SIZE, 0)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollDomainSizeY", SCROLL_DOMAIN_SIZE_Y, SCROLL_DOMAIN_SIZE, 1)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollDomainOffset", VECTOR2, SCROLL_DOMAIN_OFFSET)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollPositionDelta", VECTOR2, SCROLL_POSITION_DELTA)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "startPagePosition", VECTOR3, START_PAGE_POSITION)
+
+DALI_SIGNAL_REGISTRATION( Toolkit, ScrollView, "valueChanged", SIGNAL_SNAP_STARTED )
DALI_TYPE_REGISTRATION_END()
virtual void OnChildRemove(Actor& child);
/**
- * From CustomActorImpl; called after a touch-signal is received by the owning actor.
+ * From CustomActorImpl; called after a touchSignal is received by the owning actor.
*
* We don't listen to these events as content within the contain may consume events.
*
virtual bool OnTouchEvent(const TouchEvent& event);
/**
- * From CustomActorImpl; called after a wheel-event is received by the owning actor.
+ * From CustomActorImpl; called after a wheelEvent is received by the owning actor.
* @param[in] event The wheel event.
* @return True if the event should be consumed.
*/
/**
* This is called internally whenever the Scroll Rulers are
- * modified. This will update the properties: 'scroll-position-min'
- * and 'scroll-position-max' to reflect the changes.
+ * modified. This will update the properties: 'scrollPositionMin'
+ * and 'scrollPositionMax' to reflect the changes.
*/
void UpdatePropertyDomain();
// Setup properties, signals and actions using the type-registry.
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Scrollable, Toolkit::Control, Create );
-DALI_PROPERTY_REGISTRATION( Toolkit, Scrollable, "overshoot-effect-color", VECTOR4, OVERSHOOT_EFFECT_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, Scrollable, "overshoot-animation-speed", FLOAT, OVERSHOOT_ANIMATION_SPEED )
+DALI_PROPERTY_REGISTRATION( Toolkit, Scrollable, "overshootEffectColor", VECTOR4, OVERSHOOT_EFFECT_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, Scrollable, "overshootAnimationSpeed", FLOAT, OVERSHOOT_ANIMATION_SPEED )
const int OVERSHOOT_SIZE = Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED + 1; // OVERSHOOT_SIZE is not public yet
-Dali::PropertyRegistration p1( typeRegistration, "overshoot-size", OVERSHOOT_SIZE, Property::VECTOR2, Dali::Toolkit::Internal::Scrollable::SetProperty, Dali::Toolkit::Internal::Scrollable::GetProperty );
-
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Scrollable, "scroll-relative-position", VECTOR2, SCROLL_RELATIVE_POSITION)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Scrollable, "scroll-position-min", VECTOR2, SCROLL_POSITION_MIN)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, Scrollable, "scroll-position-min-x", SCROLL_POSITION_MIN_X, SCROLL_POSITION_MIN, 0)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, Scrollable, "scroll-position-min-y", SCROLL_POSITION_MIN_Y, SCROLL_POSITION_MIN, 1)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Scrollable, "scroll-position-max", VECTOR2, SCROLL_POSITION_MAX)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, Scrollable, "scroll-position-max-x", SCROLL_POSITION_MAX_X, SCROLL_POSITION_MAX, 0)
-DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, Scrollable, "scroll-position-max-y", SCROLL_POSITION_MAX_Y, SCROLL_POSITION_MAX, 1)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Scrollable, "can-scroll-vertical", BOOLEAN, CAN_SCROLL_VERTICAL)
-DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Scrollable, "can-scroll-horizontal", BOOLEAN, CAN_SCROLL_HORIZONTAL)
-
-DALI_SIGNAL_REGISTRATION( Toolkit, Scrollable, "scroll-started", SIGNAL_SCROLL_STARTED )
-DALI_SIGNAL_REGISTRATION( Toolkit, Scrollable, "scroll-completed", SIGNAL_SCROLL_COMPLETED )
-DALI_SIGNAL_REGISTRATION( Toolkit, Scrollable, "scroll-updated", SIGNAL_SCROLL_UPDATED )
+Dali::PropertyRegistration p1( typeRegistration, "overshootSize", OVERSHOOT_SIZE, Property::VECTOR2, Dali::Toolkit::Internal::Scrollable::SetProperty, Dali::Toolkit::Internal::Scrollable::GetProperty );
+
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Scrollable, "scrollRelativePosition", VECTOR2, SCROLL_RELATIVE_POSITION)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Scrollable, "scrollPositionMin", VECTOR2, SCROLL_POSITION_MIN)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, Scrollable, "scrollPositionMinX", SCROLL_POSITION_MIN_X, SCROLL_POSITION_MIN, 0)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, Scrollable, "scrollPositionMinY", SCROLL_POSITION_MIN_Y, SCROLL_POSITION_MIN, 1)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Scrollable, "scrollPositionMax", VECTOR2, SCROLL_POSITION_MAX)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, Scrollable, "scrollPositionMaxX", SCROLL_POSITION_MAX_X, SCROLL_POSITION_MAX, 0)
+DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, Scrollable, "scrollPositionMaxY", SCROLL_POSITION_MAX_Y, SCROLL_POSITION_MAX, 1)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Scrollable, "canScrollVertical", BOOLEAN, CAN_SCROLL_VERTICAL)
+DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Scrollable, "canScrollHorizontal", BOOLEAN, CAN_SCROLL_HORIZONTAL)
+
+DALI_SIGNAL_REGISTRATION( Toolkit, Scrollable, "scrollStarted", SIGNAL_SCROLL_STARTED )
+DALI_SIGNAL_REGISTRATION( Toolkit, Scrollable, "scrollCompleted", SIGNAL_SCROLL_COMPLETED )
+DALI_SIGNAL_REGISTRATION( Toolkit, Scrollable, "scrollUpdated", SIGNAL_SCROLL_UPDATED )
DALI_TYPE_REGISTRATION_END()
Property::Map customShader;
- customShader[ "vertex-shader" ] = RENDER_SHADOW_VERTEX_SOURCE;
- customShader[ "fragment-shader" ] = RENDER_SHADOW_FRAGMENT_SOURCE;
+ customShader[ "vertexShader" ] = RENDER_SHADOW_VERTEX_SOURCE;
+ customShader[ "fragmentShader" ] = RENDER_SHADOW_FRAGMENT_SOURCE;
- customShader[ "subdivide-grid-x" ] = 20;
- customShader[ "subdivide-grid-y" ] = 20;
+ customShader[ "subdivideGridX" ] = 20;
+ customShader[ "subdivideGridY" ] = 20;
- customShader[ "hints" ] = "output-is-transparent";
+ customShader[ "hints" ] = "outputIsTransparent";
mShadowRenderShader[ "shader" ] = customShader;
// Setup properties, signals and actions using the type-registry.
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Slider, Toolkit::Control, Create )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "lower-bound", FLOAT, LOWER_BOUND )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "upper-bound", FLOAT, UPPER_BOUND )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "lowerBound", FLOAT, LOWER_BOUND )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "upperBound", FLOAT, UPPER_BOUND )
DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "value", FLOAT, VALUE )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "hit-region", VECTOR2, HIT_REGION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "backing-region", VECTOR2, BACKING_REGION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handle-region", VECTOR2, HANDLE_REGION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "backing-image-name", STRING, BACKING_IMAGE_NAME )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handle-image-name", STRING, HANDLE_IMAGE_NAME )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "progress-image-name", STRING, PROGRESS_IMAGE_NAME )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popup-image-name", STRING, POPUP_IMAGE_NAME )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popup-arrow-image-name", STRING, POPUP_ARROW_IMAGE_NAME )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "disable-color", VECTOR4, DISABLE_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popup-text-color", VECTOR4, POPUP_TEXT_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "value-precision", INTEGER, VALUE_PRECISION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "show-popup", BOOLEAN, SHOW_POPUP )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "show-value", BOOLEAN, SHOW_VALUE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "hitRegion", VECTOR2, HIT_REGION )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "backingRegion", VECTOR2, BACKING_REGION )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handleRegion", VECTOR2, HANDLE_REGION )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "backingImageName", STRING, BACKING_IMAGE_NAME )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handleImageName", STRING, HANDLE_IMAGE_NAME )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "progressImageName", STRING, PROGRESS_IMAGE_NAME )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupImageName", STRING, POPUP_IMAGE_NAME )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupArrowImageName", STRING, POPUP_ARROW_IMAGE_NAME )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "disableColor", VECTOR4, DISABLE_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupTextColor", VECTOR4, POPUP_TEXT_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "valuePrecision", INTEGER, VALUE_PRECISION )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showPopup", BOOLEAN, SHOW_POPUP )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showValue", BOOLEAN, SHOW_VALUE )
DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "enabled", BOOLEAN, ENABLED )
DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "marks", ARRAY, MARKS )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "snap-to-marks", BOOLEAN, SNAP_TO_MARKS )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "mark-tolerance", FLOAT, MARK_TOLERANCE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "snapToMarks", BOOLEAN, SNAP_TO_MARKS )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "markTolerance", FLOAT, MARK_TOLERANCE )
-DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "value-changed", SIGNAL_VALUE_CHANGED )
+DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "valueChanged", SIGNAL_VALUE_CHANGED )
DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "mark", SIGNAL_MARK )
DALI_TYPE_REGISTRATION_END()
void SuperBlurView::OnInitialize()
{
- mBlurStrengthPropertyIndex = Self().RegisterProperty( "blur-strength",0.f );
+ mBlurStrengthPropertyIndex = Self().RegisterProperty( "blurStrength", 0.f );
DALI_ASSERT_ALWAYS( mImageActors.size() == mBlurLevels+1 && "must synchronize the ImageActor group if blur levels got changed " );
for(unsigned int i=0; i<=mBlurLevels;i++)
*
* These non-animatable properties should be registered to the child which would be added to the table
*/
-const char * const CELL_INDEX_PROPERTY_NAME("cell-index");
-const char * const ROW_SPAN_PROPERTY_NAME("row-span");
-const char * const COLUMN_SPAN_PROPERTY_NAME("column-span");
-const char * const CELL_HORIZONTAL_ALIGNMENT_PROPERTY_NAME("cell-horizontal-alignment");
-const char * const CELL_VERTICAL_ALIGNMENT_PROPERTY_NAME("cell-vertical-alignment");
+const char * const CELL_INDEX_PROPERTY_NAME("cellIndex");
+const char * const ROW_SPAN_PROPERTY_NAME("rowSpan");
+const char * const COLUMN_SPAN_PROPERTY_NAME("columnSpan");
+const char * const CELL_HORIZONTAL_ALIGNMENT_PROPERTY_NAME("cellHorizontalAlignment");
+const char * const CELL_VERTICAL_ALIGNMENT_PROPERTY_NAME("cellVerticalAlignment");
/**
* @brief Should the tableview fit around the given actor
DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "rows", INTEGER, ROWS )
DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "columns", INTEGER, COLUMNS )
-DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "cell-padding", VECTOR2, CELL_PADDING )
-DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "layout-rows", MAP, LAYOUT_ROWS )
-DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "layout-columns", MAP, LAYOUT_COLUMNS )
+DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "cellPadding", VECTOR2, CELL_PADDING )
+DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "layoutRows", MAP, LAYOUT_ROWS )
+DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "layoutColumns", MAP, LAYOUT_COLUMNS )
DALI_TYPE_REGISTRATION_END()
// Setup properties, signals and actions using the type-registry.
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::TextField, Toolkit::Control, Create );
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "rendering-backend", INTEGER, RENDERING_BACKEND )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "renderingBackend", INTEGER, RENDERING_BACKEND )
DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "text", STRING, TEXT )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "placeholder-text", STRING, PLACEHOLDER_TEXT )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "placeholder-text-focused", STRING, PLACEHOLDER_TEXT_FOCUSED )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "font-family", STRING, FONT_FAMILY )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "font-style", STRING, FONT_STYLE )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "point-size", FLOAT, POINT_SIZE )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "max-length", INTEGER, MAX_LENGTH )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "exceed-policy", INTEGER, EXCEED_POLICY )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "horizontal-alignment", STRING, HORIZONTAL_ALIGNMENT )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "vertical-alignment", STRING, VERTICAL_ALIGNMENT )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "text-color", VECTOR4, TEXT_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "placeholder-text-color", VECTOR4, PLACEHOLDER_TEXT_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "shadow-offset", VECTOR2, SHADOW_OFFSET )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "shadow-color", VECTOR4, SHADOW_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "primary-cursor-color", VECTOR4, PRIMARY_CURSOR_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "secondary-cursor-color", VECTOR4, SECONDARY_CURSOR_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "enable-cursor-blink", BOOLEAN, ENABLE_CURSOR_BLINK )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "cursor-blink-interval", FLOAT, CURSOR_BLINK_INTERVAL )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "cursor-blink-duration", FLOAT, CURSOR_BLINK_DURATION )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "cursor-width", INTEGER, CURSOR_WIDTH )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "grab-handle-image", STRING, GRAB_HANDLE_IMAGE )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "grab-handle-pressed-image", STRING, GRAB_HANDLE_PRESSED_IMAGE )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "scroll-threshold", FLOAT, SCROLL_THRESHOLD )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "scroll-speed", FLOAT, SCROLL_SPEED )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-handle-image-left", MAP, SELECTION_HANDLE_IMAGE_LEFT )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-handle-image-right", MAP, SELECTION_HANDLE_IMAGE_RIGHT )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-handle-pressed-image-left", MAP, SELECTION_HANDLE_PRESSED_IMAGE_LEFT )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-handle-pressed-image-right", MAP, SELECTION_HANDLE_PRESSED_IMAGE_RIGHT )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-handle-marker-image-left", MAP, SELECTION_HANDLE_MARKER_IMAGE_LEFT )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-handle-marker-image-right", MAP, SELECTION_HANDLE_MARKER_IMAGE_RIGHT )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-highlight-color", VECTOR4, SELECTION_HIGHLIGHT_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "decoration-bounding-box", RECTANGLE, DECORATION_BOUNDING_BOX )
-DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "input-method-settings", MAP, INPUT_METHOD_SETTINGS )
-
-DALI_SIGNAL_REGISTRATION( Toolkit, TextField, "text-changed", SIGNAL_TEXT_CHANGED )
-DALI_SIGNAL_REGISTRATION( Toolkit, TextField, "max-length-reached", SIGNAL_MAX_LENGTH_REACHED )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "placeholderText", STRING, PLACEHOLDER_TEXT )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "placeholderTextFocused", STRING, PLACEHOLDER_TEXT_FOCUSED )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "fontFamily", STRING, FONT_FAMILY )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "fontStyle", STRING, FONT_STYLE )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "pointSize", FLOAT, POINT_SIZE )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "maxLength", INTEGER, MAX_LENGTH )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "exceedPolicy", INTEGER, EXCEED_POLICY )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "horizontalAlignment", STRING, HORIZONTAL_ALIGNMENT )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "verticalAlignment", STRING, VERTICAL_ALIGNMENT )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "textColor", VECTOR4, TEXT_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "placeholderTextColor", VECTOR4, PLACEHOLDER_TEXT_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "shadowOffset", VECTOR2, SHADOW_OFFSET )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "shadowColor", VECTOR4, SHADOW_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "primaryCursorColor", VECTOR4, PRIMARY_CURSOR_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "secondaryCursorColor", VECTOR4, SECONDARY_CURSOR_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "enableCursorBlink", BOOLEAN, ENABLE_CURSOR_BLINK )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "cursorBlinkInterval", FLOAT, CURSOR_BLINK_INTERVAL )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "cursorBlinkDuration", FLOAT, CURSOR_BLINK_DURATION )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "cursorWidth", INTEGER, CURSOR_WIDTH )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "grabHandleImage", STRING, GRAB_HANDLE_IMAGE )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "grabHandlePressedImage", STRING, GRAB_HANDLE_PRESSED_IMAGE )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "scrollThreshold", FLOAT, SCROLL_THRESHOLD
projects / platform / core / uifw / dali-toolkit.git / commitdiff