utc-Dali-DebugRendering.cpp
utc-Dali-ItemView-internal.cpp
utc-Dali-PropertyHelper.cpp
+ utc-Dali-ColorConversion.cpp
)
# Append list of test harness files (Won't get parsed for test cases)
--- /dev/null
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali-toolkit-test-suite-utils.h>
+#include <dali-toolkit/internal/helpers/color-conversion.h>
+
+using namespace Dali;
+using namespace Dali::Toolkit;
+
+void dali_color_conversion_startup(void)
+{
+ test_return_value = TET_UNDEF;
+}
+
+void dali_color_conversion_cleanup(void)
+{
+ test_return_value = TET_PASS;
+}
+
+int UtcDaliPropertyHelperConvertHtmlStringToColor(void)
+{
+ tet_infoline( "Test to check whether An HTML style hex string can be converted" );
+
+ const std::string stringColor( "#FF0000" );
+
+ Vector4 result;
+ DALI_TEST_CHECK( Toolkit::Internal::ConvertStringToColor( stringColor, result ) );
+
+ DALI_TEST_EQUALS( result, Color::RED, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliPropertyHelperConvertStringPropertyToColor(void)
+{
+ tet_infoline( "Test to check whether A Property value containing a string can be converted" );
+
+ const std::string stringColor( "#00FF00" );
+ Property::Value colorProperty( stringColor );
+
+ Vector4 result;
+ DALI_TEST_CHECK( Toolkit::Internal::ConvertPropertyToColor( colorProperty, result ) );
+
+ DALI_TEST_EQUALS( result, Color::GREEN, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliPropertyHelperConvertVector4PropertyToColor(void)
+{
+ tet_infoline( "Test to check whether A Property value containing a string can be converted" );
+
+ const Vector4 color( 0.0, 0.0, 1.0, 1.0 );
+ Property::Value colorProperty( color );
+
+ Vector4 result;
+ DALI_TEST_CHECK( Toolkit::Internal::ConvertPropertyToColor( colorProperty, result ) );
+
+ DALI_TEST_EQUALS( result, Color::BLUE, TEST_LOCATION );
+
+ END_TEST;
+}
--- /dev/null
+{
+ "styles":
+ {
+ "testbutton":
+ {
+ "backgroundColor":[1.0,1.0,0.0,1.0]
+ }
+ }
+}
--- /dev/null
+{
+ "styles":
+ {
+ "testbutton":
+ {
+ "backgroundColor":[1.0,1.0,0.0,1.0]
+// Deliberate Error: trailing comma
+ },
+ },
+}
-/*
+ /*
* Copyright (c) 2016 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
#include <test-button.h>
#include <test-animation-data.h>
#include <toolkit-style-monitor.h>
+#include <dummy-control.h>
+#include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
using namespace Dali;
using namespace Dali::Toolkit;
{
const char* defaultTheme =
"{\n"
+" \"constants\":\n"
+" {\n"
+" \"CONFIG_SCRIPT_LOG_LEVEL\":\"NoLogging\"\n"
+" },\n"
" \"styles\":\n"
" {\n"
" \"textlabel\":\n"
" \"grabHandleImage\" : \"{DALI_STYLE_IMAGE_DIR}cursor_handler_drop_center.png\",\n"
" \"selectionHandleImageLeft\" : {\"filename\":\"{DALI_STYLE_IMAGE_DIR}selection_handle_drop_left.png\" },\n"
" \"selectionHandleImageRight\": {\"filename\":\"{DALI_STYLE_IMAGE_DIR}selection_handle_drop_right.png\" }\n"
+" },\n"
+" \"ComplexControl\":\n"
+" {\n"
+" \"states\":\n"
+" {\n"
+" \"NORMAL\":\n"
+" {\n"
+" \"states\":\n"
+" {\n"
+" \"SELECTED\":\n"
+" {\n"
+" \"visuals\":\n"
+" {\n"
+" \"foregroundVisual\":\n"
+" {\n"
+" \"visualType\":\"GRADIENT\",\n"
+" \"startPosition\": [-1, -1],\n"
+" \"endPosition\": [1, 1],\n"
+" \"spreadMethod\": \"REPEAT\",\n"
+" \"stopOffset\": [0.2, 0.8],\n"
+" \"stopColor\": [ [ 1,0,0,1], [0,1,0,1] ]\n"
+" }\n"
+" }\n"
+" },\n"
+" \"UNSELECTED\":\n"
+" {\n"
+" \"visuals\":\n"
+" {\n"
+" \"foregroundVisual\":\n"
+" {\n"
+" \"visualType\":\"COLOR\",\n"
+" \"mixColor\": [ 1,0,0,1]\n"
+" }\n"
+" }\n"
+" }\n"
+" },\n"
+" \"transitions\":\n"
+" {\n"
+" \"visualName\":\"*\",\n"
+" \"effect\":\"CROSSFADE\",\n"
+" \"animator\":\n"
+" {\n"
+" \"alphaFunction\":\"EASE_IN_OUT\",\n"
+" \"duration\":0.3\n"
+" }\n"
+" }\n"
+" },\n"
+" \"FOCUSED\":\n"
+" {\n"
+" \"visuals\":\n"
+" {\n"
+" \"foregroundVisual\":\n"
+" {\n"
+" \"visualType\":\"GRADIENT\",\n"
+" \"startPosition\": [-1, -1],\n"
+" \"endPosition\": [1, 1],\n"
+" \"spreadMethod\": \"REPEAT\",\n"
+" \"stopOffset\": [0.3, 0.9],\n"
+" \"stopColor\": [ [ 0,0,1,1], [0,1,1,1] ]\n"
+" },\n"
+" \"focusVisual\":\n"
+" {\n"
+" \"visualType\":\"IMAGE\",\n"
+" \"url\": \"focus.png\"\n"
+" }\n"
+" },\n"
+" \"entryTransition\":\n"
+" {\n"
+" \"target\":\"focusVisual\",\n"
+" \"property\":\"mixColor\",\n"
+" \"initialValue\":[0,0,0,0],\n"
+" \"targetValue\":[1,1,1,1],\n"
+" \"animator\":\n"
+" {\n"
+" \"alphaFunction\":\"EASE_IN_OUT_SINE\",\n"
+" \"timePeriod\": \n"
+" {\n"
+" \"duration\":0.5,\n"
+" \"delay\":0\n"
+" }\n"
+" }\n"
+" },\n"
+" \"exitTransition\":\n"
+" {\n"
+" \"target\":\"focusVisual\",\n"
+" \"property\":\"mixColor\",\n"
+" \"initialValue\":[1,1,1,1],\n"
+" \"targetValue\":[0,0,0,0],\n"
+" \"animator\":\n"
+" {\n"
+" \"alphaFunction\":\"EASE_IN_OUT_SINE\",\n"
+" \"timePeriod\": \n"
+" {\n"
+" \"duration\":0.5,\n"
+" \"delay\":0\n"
+" }\n"
+" }\n"
+" }\n"
+" },\n"
+" \"DISABLED\":\n"
+" {\n"
+" \"visuals\":\n"
+" {\n"
+" \"foregroundVisual\":\n"
+" {\n"
+" \"visualType\":\"COLOR\",\n"
+" \"mixColor\": [1,0,0,1]\n"
+" }\n"
+" }\n"
+" }\n"
+" },\n"
+" \"transitions\":\n"
+" [\n"
+" {\n"
+" \"effect\":\"CROSSFADE\",\n"
+" \"animator\":\n"
+" {\n"
+" \"alphaFunction\":\"EASE_IN_OUT\",\n"
+" \"duration\":0.3\n"
+" }\n"
+" }\n"
+" ]\n"
+" },\n"
+" \"BasicControl\":\n"
+" {\n"
+" \"states\":\n"
+" {\n"
+" \"NORMAL\":\n"
+" {\n"
+" \"visuals\":\n"
+" {\n"
+" \"foregroundVisual\":\n"
+" {\n"
+" \"visualType\":\"GRADIENT\",\n"
+" \"startPosition\": [-1, -1],\n"
+" \"endPosition\": [1, 1],\n"
+" \"spreadMethod\": \"REPEAT\",\n"
+" \"stopOffset\": [0.2, 0.8],\n"
+" \"stopColor\": [ [ 1,0,0,1], [0,1,0,1] ]\n"
+" }\n"
+" }\n"
+" },\n"
+" \"FOCUSED\":\n"
+" {\n"
+" \"visuals\":\n"
+" {\n"
+" \"foregroundVisual\":\n"
+" {\n"
+" \"visualType\":\"GRADIENT\",\n"
+" \"startPosition\": [-1, -1],\n"
+" \"endPosition\": [1, 1],\n"
+" \"spreadMethod\": \"REPEAT\",\n"
+" \"stopOffset\": [0.3, 0.9],\n"
+" \"stopColor\": [ [ 0,0,1,1], [0,1,1,1] ]\n"
+" },\n"
+" \"focusVisual\":\n"
+" {\n"
+" \"visualType\":\"IMAGE\",\n"
+" \"url\": \"focus.png\"\n"
+" }\n"
+" },\n"
+" \"entryTransition\":\n"
+" {\n"
+" \"target\":\"focusVisual\",\n"
+" \"property\":\"mixColor\",\n"
+" \"initialValue\":[0,0,0,0],\n"
+" \"targetValue\":[1,1,1,1],\n"
+" \"animator\":\n"
+" {\n"
+" \"alphaFunction\":\"EASE_IN_OUT_SINE\",\n"
+" \"timePeriod\": \n"
+" {\n"
+" \"duration\":0.5,\n"
+" \"delay\":0\n"
+" }\n"
+" }\n"
+" },\n"
+" \"exitTransition\":\n"
+" {\n"
+" \"target\":\"focusVisual\",\n"
+" \"property\":\"mixColor\",\n"
+" \"initialValue\":[1,1,1,1],\n"
+" \"targetValue\":[0,0,0,0],\n"
+" \"animator\":\n"
+" {\n"
+" \"alphaFunction\":\"EASE_IN_OUT_SINE\",\n"
+" \"timePeriod\": \n"
+" {\n"
+" \"duration\":0.5,\n"
+" \"delay\":0\n"
+" }\n"
+" }\n"
+" }\n"
+" },\n"
+" \"DISABLED\":\n"
+" {\n"
+" \"visuals\":\n"
+" {\n"
+" \"foregroundVisual\":\n"
+" {\n"
+" \"visualType\":\"COLOR\",\n"
+" \"mixColor\": [1,0,0,1]\n"
+" }\n"
+" }\n"
+" }\n"
+" },\n"
+" \"transitions\":\n"
+" [\n"
+" {\n"
+" \"effect\":\"CROSSFADE\",\n"
+" \"animator\":\n"
+" {\n"
+" \"alphaFunction\":\"EASE_IN_OUT\",\n"
+" \"duration\":0.3\n"
+" }\n"
+" }\n"
+" ]\n"
" }\n"
" }\n"
"}\n";
+
void dali_style_manager_startup(void)
{
test_return_value = TET_UNDEF;
const char* json1 =
"{\n"
+ " \"constants\":\n"
+ " {\n"
+ " \"CONFIG_SCRIPT_LOG_LEVEL\":\"Verbose\"\n"
+ " },\n"
" \"styles\":\n"
" {\n"
" \"testbutton\":\n"
const char* defaultTheme =
"{\n"
+ " \"constants\":\n"
+ " {\n"
+ " \"CONFIG_SCRIPT_LOG_LEVEL\":\"Concise\"\n"
+ " },\n"
" \"styles\":\n"
" {\n"
" \"testbutton\":\n"
const char* json1 =
"{\n"
+ " \"constants\":\n"
+ " {\n"
+ " \"CONFIG_SCRIPT_LOG_LEVEL\":\"General\"\n"
+ " },\n"
" \"styles\":\n"
" {\n"
" \"testbutton\":\n"
}
+int UtcDaliStyleManagerIncludeStyleP(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline( "UtcDaliStyleManagerIncludeStyle - test that style sheet inclusion works" );
+
+ const char* json1 =
+ "{\n"
+ " \"includes\":\n"
+ " [\n"
+ " \"src/dali-toolkit-styling/theme2.json\"\n"
+ " ],\n"
+ " \"styles\":\n"
+ " {\n"
+ " \"testbutton\":\n"
+ " {\n"
+ " \"foregroundColor\":[0.0,0.0,1.0,1.0]\n"
+ " }\n"
+ " }\n"
+ "}\n";
+
+ // Add 2 buttons
+ Test::TestButton testButton = Test::TestButton::New();
+ Test::TestButton testButton2 = Test::TestButton::New();
+ Stage::GetCurrent().Add( testButton );
+ Stage::GetCurrent().Add( testButton2 );
+ StyleChangedSignalChecker styleChangedSignalHandler;
+ StyleManager styleManager = StyleManager::Get();
+
+ styleManager.StyleChangedSignal().Connect(&styleChangedSignalHandler, &StyleChangedSignalChecker::OnStyleChanged);
+
+ tet_infoline("Apply the style");
+
+ std::string themeFile("ThemeOne");
+ Test::StyleMonitor::SetThemeFileOutput(themeFile, json1);
+
+ styleManager.ApplyTheme(themeFile);
+
+ // Render and notify
+ application.SendNotification();
+ application.Render();
+
+ Property::Value themedBgColor( testButton.GetProperty(Test::TestButton::Property::BACKGROUND_COLOR) );
+ Property::Value themedFgColor( testButton.GetProperty(Test::TestButton::Property::FOREGROUND_COLOR) );
+
+ DALI_TEST_EQUALS( themedBgColor, Property::Value(Color::YELLOW), 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS( themedFgColor, Property::Value(Color::BLUE), 0.001, TEST_LOCATION );
+
+ END_TEST;
+}
+
+
+int UtcDaliStyleManagerIncludeStyleN(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline( "UtcDaliStyleManagerIncludeStyle - test that style sheet inclusion works, but included stylesheet is bad json" );
+
+ const char* json1 =
+ "{\n"
+ " \"includes\":\n"
+ " [\n"
+ " \"src/dali-toolkit-styling/theme3.json\"\n"
+ " ],\n"
+ " \"styles\":\n"
+ " {\n"
+ " \"testbutton\":\n"
+ " {\n"
+ " \"foregroundColor\":[0.0,0.0,1.0,1.0]\n"
+ " }\n"
+ " }\n"
+ "}\n";
+
+ // Add 2 buttons
+ Test::TestButton testButton = Test::TestButton::New();
+ Test::TestButton testButton2 = Test::TestButton::New();
+ Stage::GetCurrent().Add( testButton );
+ Stage::GetCurrent().Add( testButton2 );
+ StyleChangedSignalChecker styleChangedSignalHandler;
+ StyleManager styleManager = StyleManager::Get();
+
+ styleManager.StyleChangedSignal().Connect(&styleChangedSignalHandler, &StyleChangedSignalChecker::OnStyleChanged);
+
+ tet_infoline("Apply the style");
+
+ std::string themeFile("ThemeOne");
+ Test::StyleMonitor::SetThemeFileOutput(themeFile, json1);
+
+ try
+ {
+ styleManager.ApplyTheme(themeFile);
+ }
+ catch( Dali::DaliException& e )
+ {
+ DALI_TEST_ASSERT( e, "!\"Cannot parse JSON\"", TEST_LOCATION );
+ }
+
+ END_TEST;
+}
+
+
int UtcDaliStyleManagerStyleChangedSignalFontFamily(void)
{
tet_infoline("Test that the StyleChange signal is fired when the font family is altered" );
END_TEST;
}
+
+
+int UtcDaliStyleManagerVisualTransitionParsing(void)
+{
+ tet_infoline("Instantiate dummy control and test state/visual/transition capture" );
+ Test::StyleMonitor::SetThemeFileOutput( DALI_STYLE_DIR "dali-toolkit-default-theme.json",
+ defaultTheme );
+
+ ToolkitTestApplication application;
+
+ StyleChangedSignalChecker styleChangedSignalHandler;
+ Dali::StyleMonitor styleMonitor = Dali::StyleMonitor::Get();
+ StyleManager styleManager = StyleManager::Get();
+
+ DummyControl actor = DummyControl::New(true);
+ actor.SetStyleName("BasicControl");
+ Stage::GetCurrent().Add(actor);
+
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+
+ DALI_TEST_EQUALS(dummyImpl.IsVisualEnabled(DummyControl::Property::FOREGROUND_VISUAL), true, TEST_LOCATION);
+ Visual::Base visual1 = dummyImpl.GetVisual(DummyControl::Property::FOREGROUND_VISUAL);
+
+ actor.SetProperty( DevelControl::Property::STATE, DevelControl::FOCUSED );
+
+ DALI_TEST_EQUALS(dummyImpl.IsVisualEnabled(DummyControl::Property::FOREGROUND_VISUAL), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(dummyImpl.IsVisualEnabled(DummyControl::Property::FOCUS_VISUAL), true, TEST_LOCATION);
+
+ Visual::Base visual2 = dummyImpl.GetVisual(DummyControl::Property::FOREGROUND_VISUAL);
+ DALI_TEST_CHECK( visual1 != visual2 );
+
+ actor.SetProperty( DevelControl::Property::STATE, DevelControl::DISABLED );
+
+ DALI_TEST_EQUALS(dummyImpl.IsVisualEnabled(DummyControl::Property::FOREGROUND_VISUAL), true, TEST_LOCATION);
+
+ Visual::Base visual3 = dummyImpl.GetVisual(DummyControl::Property::FOREGROUND_VISUAL);
+ Visual::Base focusVisual = dummyImpl.GetVisual(DummyControl::Property::FOCUS_VISUAL);
+ DALI_TEST_CHECK( !focusVisual );
+ DALI_TEST_EQUALS(dummyImpl.IsVisualEnabled(DummyControl::Property::FOCUS_VISUAL), false, TEST_LOCATION);
+
+ DALI_TEST_CHECK( visual1 != visual3 );
+ DALI_TEST_CHECK( visual2 != visual3 );
+
+ END_TEST;
+}
+
+
+int UtcDaliStyleManagerVisualTransitionParsing02(void)
+{
+ tet_infoline("Instantiate dummy control and test state/visual/transition capture" );
+ Test::StyleMonitor::SetThemeFileOutput( DALI_STYLE_DIR "dali-toolkit-default-theme.json",
+ defaultTheme );
+
+ ToolkitTestApplication application;
+
+ StyleChangedSignalChecker styleChangedSignalHandler;
+ Dali::StyleMonitor styleMonitor = Dali::StyleMonitor::Get();
+ StyleManager styleManager = StyleManager::Get();
+
+ DummyControl actor = DummyControl::New(true);
+ actor.SetProperty(DevelControl::Property::STATE, "FOCUSED");
+
+ actor.SetStyleName("ComplexControl");
+ Stage::GetCurrent().Add(actor);
+
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+
+ DALI_TEST_EQUALS(dummyImpl.IsVisualEnabled(DummyControl::Property::FOREGROUND_VISUAL), true, TEST_LOCATION);
+ Visual::Base visual1 = dummyImpl.GetVisual(DummyControl::Property::FOREGROUND_VISUAL);
+ DALI_TEST_CHECK( visual1 );
+ Property::Map map;
+ visual1.CreatePropertyMap( map );
+ Property::Value* value = map.Find( Visual::Property::TYPE );
+ DALI_TEST_CHECK( value );
+
+ int visualType;
+ value->Get( visualType );
+
+ DALI_TEST_EQUALS( visualType, (int)Toolkit::Visual::GRADIENT, TEST_LOCATION );
+
+ END_TEST;
+}
// EXTERNAL INCLUDES
#include <cstdarg>
+#include <cstdio>
#include <iostream>
+#include <cstring>
// INTERNAL INCLUDES
#include <dali/public-api/dali-core.h>
+#include <test-compare-types.h>
void tet_infoline(const char*str);
void tet_printf(const char *format, ...);
throw("TET_FAIL"); \
}
-template <typename Type>
-inline bool CompareType(Type value1, Type value2, float epsilon);
-
-/**
- * A helper for fuzzy-comparing Vector2 objects
- * @param[in] vector1 the first object
- * @param[in] vector2 the second object
- * @param[in] epsilon difference threshold
- * @returns true if difference is smaller than epsilon threshold, false otherwise
- */
-template <>
-inline bool CompareType<float>(float value1, float value2, float epsilon)
-{
- return fabsf(value1 - value2) < epsilon;
-}
-
-/**
- * A helper for fuzzy-comparing Vector2 objects
- * @param[in] vector1 the first object
- * @param[in] vector2 the second object
- * @param[in] epsilon difference threshold
- * @returns true if difference is smaller than epsilon threshold, false otherwise
- */
-template <>
-inline bool CompareType<Vector2>(Vector2 vector1, Vector2 vector2, float epsilon)
-{
- return fabsf(vector1.x - vector2.x)<epsilon && fabsf(vector1.y - vector2.y)<epsilon;
-}
-
-/**
- * A helper for fuzzy-comparing Vector3 objects
- * @param[in] vector1 the first object
- * @param[in] vector2 the second object
- * @param[in] epsilon difference threshold
- * @returns true if difference is smaller than epsilon threshold, false otherwise
- */
-template <>
-inline bool CompareType<Vector3>(Vector3 vector1, Vector3 vector2, float epsilon)
-{
- return fabsf(vector1.x - vector2.x)<epsilon &&
- fabsf(vector1.y - vector2.y)<epsilon &&
- fabsf(vector1.z - vector2.z)<epsilon;
-}
-
-
-/**
- * A helper for fuzzy-comparing Vector4 objects
- * @param[in] vector1 the first object
- * @param[in] vector2 the second object
- * @param[in] epsilon difference threshold
- * @returns true if difference is smaller than epsilon threshold, false otherwise
- */
-template <>
-inline bool CompareType<Vector4>(Vector4 vector1, Vector4 vector2, float epsilon)
-{
- return fabsf(vector1.x - vector2.x)<epsilon &&
- fabsf(vector1.y - vector2.y)<epsilon &&
- fabsf(vector1.z - vector2.z)<epsilon &&
- fabsf(vector1.w - vector2.w)<epsilon;
-}
-
-template <>
-inline bool CompareType<Quaternion>(Quaternion q1, Quaternion q2, float epsilon)
-{
- Quaternion q2N = -q2; // These quaternions represent the same rotation
- return CompareType<Vector4>(q1.mVector, q2.mVector, epsilon) || CompareType<Vector4>(q1.mVector, q2N.mVector, epsilon);
-}
-
-template <>
-inline bool CompareType<Radian>(Radian q1, Radian q2, float epsilon)
-{
- return CompareType<float>(q1.radian, q2.radian, epsilon);
-}
-
-template <>
-inline bool CompareType<Degree>(Degree q1, Degree q2, float epsilon)
-{
- return CompareType<float>(q1.degree, q2.degree, epsilon);
-}
-
-template <>
-inline bool CompareType<Property::Value>(Property::Value q1, Property::Value q2, float epsilon)
-{
- Property::Type type = q1.GetType();
- if( type != q2.GetType() )
- {
- return false;
- }
-
- bool result = false;
- switch(type)
- {
- case Property::BOOLEAN:
- {
- bool a, b;
- q1.Get(a);
- q2.Get(b);
- result = a == b;
- break;
- }
- case Property::INTEGER:
- {
- int a, b;
- q1.Get(a);
- q2.Get(b);
- result = a == b;
- break;
- }
- case Property::FLOAT:
- {
- float a, b;
- q1.Get(a);
- q2.Get(b);
- result = CompareType<float>(a, b, epsilon);
- break;
- }
- case Property::VECTOR2:
- {
- Vector2 a, b;
- q1.Get(a);
- q2.Get(b);
- result = CompareType<Vector2>(a, b, epsilon);
- break;
- }
- case Property::VECTOR3:
- {
- Vector3 a, b;
- q1.Get(a);
- q2.Get(b);
- result = CompareType<Vector3>(a, b, epsilon);
- break;
- }
- case Property::RECTANGLE:
- case Property::VECTOR4:
- {
- Vector4 a, b;
- q1.Get(a);
- q2.Get(b);
- result = CompareType<Vector4>(a, b, epsilon);
- break;
- }
- case Property::ROTATION:
- {
- Quaternion a, b;
- q1.Get(a);
- q2.Get(b);
- result = CompareType<Quaternion>(a, b, epsilon);
- break;
- }
- case Property::MATRIX:
- case Property::MATRIX3:
- case Property::STRING:
- case Property::ARRAY:
- case Property::MAP:
- {
- //TODO: Implement this?
- DALI_ASSERT_ALWAYS( 0 && "Not implemented");
- result = false;
- break;
- }
- case Property::NONE:
- {
- result = false;
- break;
- }
- }
-
- return result;
-}
-
bool operator==(TimePeriod a, TimePeriod b);
std::ostream& operator<<( std::ostream& ostream, TimePeriod value );
template<typename Type>
inline void DALI_TEST_EQUALS(Type value1, Type value2, const char* location)
{
- if (!(value1 == value2))
+ if( !CompareType<Type>(value1, value2, 0.01f) )
{
std::ostringstream o;
o << value1 << " == " << value2 << std::endl;
BufferImage CreateBufferImage();
BufferImage CreateBufferImage(int width, int height, const Vector4& color);
+
// Prepare a resource image to be loaded. Should be called before creating the ResourceImage
void PrepareResourceImage( TestApplication& application, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat );
Dali::PropertyRegistration dummyControlVisualProperty02(
typeRegistration, "testVisual", Dali::Toolkit::DummyControl::Property::TEST_VISUAL2, Dali::Property::MAP, &Dali::Toolkit::DummyControlImpl::SetProperty, &Dali::Toolkit::DummyControlImpl::GetProperty );
+Dali::PropertyRegistration dummyControlVisualProperty03(
+ typeRegistration, "foregroundVisual", Dali::Toolkit::DummyControl::Property::FOREGROUND_VISUAL, Dali::Property::MAP, &Dali::Toolkit::DummyControlImpl::SetProperty, &Dali::Toolkit::DummyControlImpl::GetProperty );
+
+Dali::PropertyRegistration dummyControlVisualProperty04(
+ typeRegistration, "focusVisual", Dali::Toolkit::DummyControl::Property::FOCUS_VISUAL, Dali::Property::MAP, &Dali::Toolkit::DummyControlImpl::SetProperty, &Dali::Toolkit::DummyControlImpl::GetProperty );
+
}
DummyControl DummyControlImpl::New()
void DummyControlImpl::SetProperty( BaseObject* object, Dali::Property::Index index, const Dali::Property::Value& value )
{
+ Toolkit::DummyControl control = Toolkit::DummyControl::DownCast( Dali::BaseHandle( object ) );
+ DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(control.GetImplementation());
+
+ switch(index)
+ {
+ case Toolkit::DummyControl::Property::TEST_VISUAL:
+ case Toolkit::DummyControl::Property::TEST_VISUAL2:
+ case Toolkit::DummyControl::Property::FOREGROUND_VISUAL:
+ case Toolkit::DummyControl::Property::FOCUS_VISUAL:
+ {
+ Property::Map* map = value.GetMap();
+ if( map != NULL )
+ {
+ VisualFactory visualFactory = VisualFactory::Get();
+ Visual::Base visual = visualFactory.CreateVisual(*map);
+ dummyImpl.RegisterVisual(index, visual);
+ }
+ break;
+ }
+ }
}
Property::Value DummyControlImpl::GetProperty( BaseObject* object, Dali::Property::Index propertyIndex )
enum Type
{
TEST_VISUAL = PROPERTY_START_INDEX,
- TEST_VISUAL2
+ TEST_VISUAL2,
+ FOREGROUND_VISUAL,
+ FOCUS_VISUAL
};
};
void RegisterVisual( Property::Index index, Toolkit::Visual::Base visual, bool enabled );
void UnregisterVisual( Property::Index index );
void EnableVisual( Property::Index index, bool enabled );
- bool IsVisualEnabled( Property::Index indepx );
+ bool IsVisualEnabled( Property::Index index );
Toolkit::Visual::Base GetVisual( Property::Index index );
Animation CreateTransition( const Toolkit::TransitionData& transition );
--- /dev/null
+#ifndef DALI_TEST_COMPARE_TYPES_H
+#define DALI_TEST_COMPARE_TYPES_H
+
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dali/public-api/dali-core.h>
+using namespace Dali;
+
+
+template <typename Type>
+inline bool CompareType(Type value1, Type value2, float epsilon)
+{
+ return value1 == value2;
+}
+
+/**
+ * A helper for fuzzy-comparing Vector2 objects
+ * @param[in] vector1 the first object
+ * @param[in] vector2 the second object
+ * @param[in] epsilon difference threshold
+ * @returns true if difference is smaller than epsilon threshold, false otherwise
+ */
+template <>
+inline bool CompareType<float>(float value1, float value2, float epsilon)
+{
+ return fabsf(value1 - value2) < epsilon;
+}
+
+/**
+ * A helper for fuzzy-comparing Vector2 objects
+ * @param[in] vector1 the first object
+ * @param[in] vector2 the second object
+ * @param[in] epsilon difference threshold
+ * @returns true if difference is smaller than epsilon threshold, false otherwise
+ */
+template <>
+inline bool CompareType<Vector2>(Vector2 vector1, Vector2 vector2, float epsilon)
+{
+ return fabsf(vector1.x - vector2.x)<epsilon && fabsf(vector1.y - vector2.y)<epsilon;
+}
+
+/**
+ * A helper for fuzzy-comparing Vector3 objects
+ * @param[in] vector1 the first object
+ * @param[in] vector2 the second object
+ * @param[in] epsilon difference threshold
+ * @returns true if difference is smaller than epsilon threshold, false otherwise
+ */
+template <>
+inline bool CompareType<Vector3>(Vector3 vector1, Vector3 vector2, float epsilon)
+{
+ return fabsf(vector1.x - vector2.x)<epsilon &&
+ fabsf(vector1.y - vector2.y)<epsilon &&
+ fabsf(vector1.z - vector2.z)<epsilon;
+}
+
+
+/**
+ * A helper for fuzzy-comparing Vector4 objects
+ * @param[in] vector1 the first object
+ * @param[in] vector2 the second object
+ * @param[in] epsilon difference threshold
+ * @returns true if difference is smaller than epsilon threshold, false otherwise
+ */
+template <>
+inline bool CompareType<Vector4>(Vector4 vector1, Vector4 vector2, float epsilon)
+{
+ return fabsf(vector1.x - vector2.x)<epsilon &&
+ fabsf(vector1.y - vector2.y)<epsilon &&
+ fabsf(vector1.z - vector2.z)<epsilon &&
+ fabsf(vector1.w - vector2.w)<epsilon;
+}
+
+template <>
+inline bool CompareType<Quaternion>(Quaternion q1, Quaternion q2, float epsilon)
+{
+ Quaternion q2N = -q2; // These quaternions represent the same rotation
+ return CompareType<Vector4>(q1.mVector, q2.mVector, epsilon) || CompareType<Vector4>(q1.mVector, q2N.mVector, epsilon);
+}
+
+template <>
+inline bool CompareType<Radian>(Radian q1, Radian q2, float epsilon)
+{
+ return CompareType<float>(q1.radian, q2.radian, epsilon);
+}
+
+template <>
+inline bool CompareType<Degree>(Degree q1, Degree q2, float epsilon)
+{
+ return CompareType<float>(q1.degree, q2.degree, epsilon);
+}
+
+template <>
+inline bool CompareType<Property::Value>(Property::Value q1, Property::Value q2, float epsilon)
+{
+ Property::Type type = q1.GetType();
+ if( type != q2.GetType() )
+ {
+ return false;
+ }
+
+ bool result = false;
+ switch(type)
+ {
+ case Property::BOOLEAN:
+ {
+ bool a, b;
+ q1.Get(a);
+ q2.Get(b);
+ result = a == b;
+ break;
+ }
+ case Property::INTEGER:
+ {
+ int a, b;
+ q1.Get(a);
+ q2.Get(b);
+ result = a == b;
+ break;
+ }
+ case Property::FLOAT:
+ {
+ float a, b;
+ q1.Get(a);
+ q2.Get(b);
+ result = CompareType<float>(a, b, epsilon);
+ break;
+ }
+ case Property::VECTOR2:
+ {
+ Vector2 a, b;
+ q1.Get(a);
+ q2.Get(b);
+ result = CompareType<Vector2>(a, b, epsilon);
+ break;
+ }
+ case Property::VECTOR3:
+ {
+ Vector3 a, b;
+ q1.Get(a);
+ q2.Get(b);
+ result = CompareType<Vector3>(a, b, epsilon);
+ break;
+ }
+ case Property::RECTANGLE:
+ case Property::VECTOR4:
+ {
+ Vector4 a, b;
+ q1.Get(a);
+ q2.Get(b);
+ result = CompareType<Vector4>(a, b, epsilon);
+ break;
+ }
+ case Property::ROTATION:
+ {
+ Quaternion a, b;
+ q1.Get(a);
+ q2.Get(b);
+ result = CompareType<Quaternion>(a, b, epsilon);
+ break;
+ }
+ case Property::MATRIX:
+ case Property::MATRIX3:
+ case Property::STRING:
+ case Property::ARRAY:
+ case Property::MAP:
+ {
+ //TODO: Implement this?
+ DALI_ASSERT_ALWAYS( 0 && "Not implemented");
+ result = false;
+ break;
+ }
+ case Property::NONE:
+ {
+ result = false;
+ break;
+ }
+ }
+
+ return result;
+}
+
+
+
+#endif
#include <map>
#include <cstdio>
#include <cstring> // for strcmp
+#include <typeinfo>
// INTERNAL INCLUDES
#include <dali/public-api/dali-core.h>
#include <dali/integration-api/core.h>
#include <dali/integration-api/gl-abstraction.h>
#include <dali/integration-api/gl-defines.h>
-#include "test-trace-call-stack.h"
+#include <test-trace-call-stack.h>
+#include <test-compare-types.h>
namespace Dali
{
T uniformValue;
if ( GetUniformValue( program, uniform, uniformValue ) )
{
- return value == uniformValue;
+ return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
}
return false;
ProgramUniformValue<Matrix> mProgramUniformsMat4;
ProgramUniformValue<Matrix3> mProgramUniformsMat3;
+
+
+
inline const ProgramUniformValue<int>& GetProgramUniformsForType( const int ) const
{
return mProgramUniforms1i;
" \"name\": \"greeting\","
" \"type\": \"TextLabel\","
" \"text\": \"Touch me\","
- " \"styles\": [\"basicText\"],"
+ " \"inherit\": [\"basicText\"],"
" \"position\": [0, -120, 0],"
" \"size\": [200, 200, 1],"
" \"orientation\": [0, 0, 30],"
" \"name\": \"greeting\","
" \"type\": \"TextLabel\","
" \"text\": \"Touch me\","
- " \"styles\": [\"basicText\"],"
+ " \"inherit\": [\"basicText\"],"
" \"position\": [0, -120, 0],"
" \"size\": [200, 200, 1],"
" \"orientation\": [0, 0, 30],"
#include <stdlib.h>
#include <dali-toolkit-test-suite-utils.h>
#include <dali-toolkit/dali-toolkit.h>
-
+#include <test-application.h>
#include <dali-toolkit/devel-api/controls/buttons/button-devel.h>
#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
#include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
#include <dali-toolkit-test-suite-utils.h>
#include <dali.h>
+#include <dali/public-api/dali-core.h>
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/devel-api/controls/control-wrapper.h>
#include <dali-toolkit/devel-api/controls/control-wrapper-impl.h>
bool mNego;
unsigned int mDepth;
};
+
}
+static std::string customControlTypeName = "TestCustomControl";
+static TypeRegistration customControl( customControlTypeName, typeid(Dali::Toolkit::Control), NULL );
+
int UtcDaliControlWrapperConstructor(void)
{
ToolkitTestApplication application; // Exceptions require ToolkitTestApplication
DALI_TEST_CHECK( !ControlWrapper::DownCast( controlWrapper ) );
- controlWrapper = ControlWrapper::New( *controlWrapperImpl );
+ controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
DALI_TEST_CHECK( ControlWrapper::DownCast( controlWrapper ) );
+
END_TEST;
}
{
TestApplication application;
- ControlWrapper control = ControlWrapper::New( *( new Toolkit::Internal::ControlWrapper( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ) ) );
+ ControlWrapper control = ControlWrapper::New( customControlTypeName, *( new Toolkit::Internal::ControlWrapper( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ) ) );
ControlWrapper control2( control );
DALI_TEST_EQUALS( gOnRelayout, false, TEST_LOCATION );
Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
- ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl );
+ ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
Stage::GetCurrent().Add( controlWrapper );
TestApplication application;
Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
- ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl );
+ ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
float width = 300.0f;
float v = 0.0f;
TestApplication application;
Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
- ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl );
+ ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
float height = 300.0f;
float v = 0.0f;
TestApplication application;
Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
- ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl );
+ ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
Actor child = Actor::New();
child.SetResizePolicy( Dali::ResizePolicy::FIXED, Dali::Dimension::ALL_DIMENSIONS );
TestApplication application;
Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
- ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl );
+ ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
bool v = false;
{
Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
- ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl );
+ ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
objectDestructionTracker.Start( controlWrapper );
ToolkitTestApplication application;
Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
- ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl );
+ ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
Property::Index TEST_PROPERTY = 1;
ToolkitTestApplication application;
Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
- ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl );
+ ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
Property::Index index = 1;
Dali::Toolkit::TransitionData transition = TransitionData::New( map );
Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
- ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl );
+ ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
//DummyControl actor = DummyControl::New();
controlWrapper.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
ToolkitTestApplication application;
Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
- ControlWrapper controlWrapper = ControlWrapper::New( *controlWrapperImpl );
+ ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
controlWrapperImpl->ApplyThemeStyle();
DALI_TEST_CHECK( true );
END_TEST;
}
+
+int UtcDaliControlWrapperTestControlProperties(void)
+{
+ ToolkitTestApplication application;
+
+ Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
+ ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
+
+ Stage::GetCurrent().Add( controlWrapper );
+
+ // "background" property
+ Property::Map rendererMap;
+ rendererMap[Visual::Property::TYPE] = Visual::COLOR;
+ rendererMap[ColorVisual::Property::MIX_COLOR] = Color::RED;
+ controlWrapper.SetProperty( Control::Property::BACKGROUND, rendererMap );
+ Property::Value propertyValue = controlWrapper.GetProperty( Control::Property::BACKGROUND );
+ Property::Map* resultMap = propertyValue.GetMap();
+ DALI_TEST_CHECK( resultMap->Find( Visual::Property::TYPE ) );
+ DALI_TEST_EQUALS( resultMap->Find( Visual::Property::TYPE )->Get<int>(), (int)Visual::COLOR, TEST_LOCATION );
+ DALI_TEST_CHECK( resultMap->Find( ColorVisual::Property::MIX_COLOR ) );
+ DALI_TEST_EQUALS( resultMap->Find( ColorVisual::Property::MIX_COLOR )->Get<Vector4>(), Color::RED, TEST_LOCATION );
+
+ // "keyInputFocus" property
+ controlWrapper.SetProperty( Control::Property::KEY_INPUT_FOCUS, true );
+ DALI_TEST_EQUALS( true, controlWrapper.GetProperty( Control::Property::KEY_INPUT_FOCUS ).Get< bool >(), TEST_LOCATION );
+
+ // "styleName" property
+ controlWrapper.SetProperty( Control::Property::STYLE_NAME, "MyCustomStyle" );
+ DALI_TEST_EQUALS( "MyCustomStyle", controlWrapper.GetProperty( Control::Property::STYLE_NAME ).Get< std::string >(), TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliControlWrapperTypeRegistryCreation(void)
+{
+ ToolkitTestApplication application;
+
+ TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( "ControlWrapper" );
+ DALI_TEST_CHECK( typeInfo )
+
+ // Check that we can't create a ControlWrapper instance
+ BaseHandle baseHandle = typeInfo.CreateInstance();
+ DALI_TEST_CHECK( !baseHandle )
+
+ END_TEST;
+}
#include <dali-toolkit/dali-toolkit.h>
#include <dali/integration-api/events/key-event-integ.h>
-
+#include <dali-toolkit/devel-api/controls/control-devel.h>
using namespace Dali;
using namespace Dali::Toolkit;
Integration::KeyEvent returnEvent("Return", "", 0, 0, 0, Integration::KeyEvent::Up);
+ // Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
+ // It makes mIsFocusIndicatorEnabled true
+ application.ProcessEvent(returnEvent);
+
// Create the first button and add it to the stage
PushButton firstPushButton = PushButton::New();
firstPushButton.SetKeyboardFocusable(true);
Integration::KeyEvent tabEvent("Tab", "", 0, 0, 0, Integration::KeyEvent::Down);
Integration::KeyEvent shiftTabEvent("Tab", "", 0, 1, 0, Integration::KeyEvent::Down);
+ // Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
+ // It makes mIsFocusIndicatorEnabled true
+ application.ProcessEvent(tabEvent);
+
// Send the tab event to change focus group in the forward direction
application.ProcessEvent(tabEvent);
DALI_TEST_CHECK(focusGroupChangedCallback.mSignalVerified);
Integration::KeyEvent pageUpEvent("Prior", "", 0, 0, 0, Integration::KeyEvent::Down);
Integration::KeyEvent pageDownEvent("Next", "", 0, 0, 0, Integration::KeyEvent::Down);
+ // Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
+ // It makes mIsFocusIndicatorEnabled true
+ application.ProcessEvent(leftEvent);
+
// Create a 2x2 table view and try to move focus inside it
TableView tableView = TableView::New( 2, 2 );
Stage::GetCurrent().Add(tableView);
}
+
+
+
+int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline(" UtcDaliKeyboardFocusManagerMoveFocusTestStateChange");
+
+ // Register Type
+ TypeInfo type;
+ type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
+ DALI_TEST_CHECK( type );
+ BaseHandle handle = type.CreateInstance();
+ DALI_TEST_CHECK( handle );
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(manager);
+
+ bool preFocusChangeSignalVerified = false;
+ PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
+ manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
+
+ bool focusChangedSignalVerified = false;
+ FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
+ manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+
+ // Create the first actor and add it to the stage
+ Control first = Control::New();
+ first.SetKeyboardFocusable(true);
+ Stage::GetCurrent().Add(first);
+
+ // Create the second actor and add it to the stage
+ Control second = Control::New();
+ second.SetKeyboardFocusable(true);
+ Stage::GetCurrent().Add(second);
+
+ // Move the focus to the right
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
+
+ // Because no layout control in the stage and no actor is focused, it should emit the PreFocusChange signal
+ DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+ DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == Actor());
+ DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
+ DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::RIGHT);
+ preFocusChangeCallback.Reset();
+
+ // Check that the focus is set on the first actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
+ DALI_TEST_EQUALS(first.GetProperty<std::string>(DevelControl::Property::STATE), "FOCUSED", TEST_LOCATION );
+ focusChangedCallback.Reset();
+
+ // Move the focus towards right
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
+
+ // Because no layout control in the stage and the first actor is focused, it should emit the PreFocusChange signal
+ DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+ DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == first);
+ DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
+ DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::RIGHT);
+ preFocusChangeCallback.Reset();
+
+ // Check that the focus is set on the second actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == second);
+ DALI_TEST_EQUALS(first.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(second.GetProperty<std::string>(DevelControl::Property::STATE), "FOCUSED", TEST_LOCATION );
+ focusChangedCallback.Reset();
+
+ // Move the focus towards up
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == false);
+
+ // Because no layout control in the stage and no actor is focused, it should emit the PreFocusChange signal
+ DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+ DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == second);
+ DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
+ DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::UP);
+ preFocusChangeCallback.Reset();
+ DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
+
+ // Create a 2x2 table view and try to move focus inside it
+ TableView tableView = TableView::New( 2, 2 );
+ Stage::GetCurrent().Add(tableView);
+
+ // Create the third actor
+ Control third = Control::New();
+ third.SetKeyboardFocusable(true);
+
+ // Create the fourth actor
+ Control fourth = Control::New();
+ fourth.SetKeyboardFocusable(true);
+
+ // Add the four children to table view
+ tableView.AddChild(first, TableView::CellPosition(0, 0));
+ tableView.AddChild(second, TableView::CellPosition(0, 1));
+ tableView.AddChild(third, TableView::CellPosition(1, 0));
+ tableView.AddChild(fourth, TableView::CellPosition(1, 1));
+
+ // Set the focus to the first actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == second);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
+
+ DALI_TEST_EQUALS(first.GetProperty<std::string>(DevelControl::Property::STATE), "FOCUSED", TEST_LOCATION );
+ DALI_TEST_EQUALS(second.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+
+ focusChangedCallback.Reset();
+
+ // Move the focus towards right
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == second);
+ DALI_TEST_EQUALS(first.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(second.GetProperty<std::string>(DevelControl::Property::STATE), "FOCUSED", TEST_LOCATION );
+
+ focusChangedCallback.Reset();
+
+ // Move the focus towards down
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::DOWN) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == fourth);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == second);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == fourth);
+
+ DALI_TEST_EQUALS(first.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(second.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(third.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(fourth.GetProperty<std::string>(DevelControl::Property::STATE), "FOCUSED", TEST_LOCATION );
+
+ focusChangedCallback.Reset();
+
+ // Move the focus towards left
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == fourth);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == third);
+
+ DALI_TEST_EQUALS(first.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(second.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(third.GetProperty<std::string>(DevelControl::Property::STATE), "FOCUSED", TEST_LOCATION );
+ DALI_TEST_EQUALS(fourth.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+
+ focusChangedCallback.Reset();
+
+ // Move the focus towards up
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == third);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
+ DALI_TEST_EQUALS(first.GetProperty<std::string>(DevelControl::Property::STATE), "FOCUSED", TEST_LOCATION );
+ DALI_TEST_EQUALS(second.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(third.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(fourth.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ focusChangedCallback.Reset();
+
+ // Move the focus towards left. The focus move will fail as no way to move it upwards
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == false);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+ DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+ DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == first);
+ DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
+ DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::LEFT);
+ DALI_TEST_EQUALS(first.GetProperty<std::string>(DevelControl::Property::STATE), "FOCUSED", TEST_LOCATION );
+ DALI_TEST_EQUALS(second.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(third.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(fourth.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+
+ preFocusChangeCallback.Reset();
+ DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
+
+ // Enable the loop
+ manager.SetFocusGroupLoop(true);
+ DALI_TEST_CHECK(manager.GetFocusGroupLoop() == true);
+
+ // Move the focus towards left again. The focus should move to the fourth actor.
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == fourth);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == fourth);
+
+ DALI_TEST_EQUALS(first.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(second.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(third.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(fourth.GetProperty<std::string>(DevelControl::Property::STATE), "FOCUSED", TEST_LOCATION );
+
+ focusChangedCallback.Reset();
+
+ // Clear the focus
+ manager.ClearFocus();
+ DALI_TEST_EQUALS(first.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(second.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(third.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+ DALI_TEST_EQUALS(fourth.GetProperty<std::string>(DevelControl::Property::STATE), "NORMAL", TEST_LOCATION );
+
+
+ END_TEST;
+}
// Test all contextual modes.
const char* mode[5] = { "NON_CONTEXTUAL", "ABOVE", "RIGHT", "BELOW", "LEFT" };
Vector2 offsetValues[5];
- offsetValues[0] = Vector2( 0.0f, 0.0f );
- offsetValues[1] = Vector2( 0.0f, -10.0f );
- offsetValues[2] = Vector2( 10.0f, 0.0f );
- offsetValues[3] = Vector2( 0.0f, 10.0f );
- offsetValues[4] = Vector2( -10.0f, 0.0f );
+ offsetValues[0] = Vector2( 0.375f, 0.0f );
+ offsetValues[1] = Vector2( -0.125f, -10.5f );
+ offsetValues[2] = Vector2( 10.875f, -0.5f );
+ offsetValues[3] = Vector2( -0.125f, 10.5f );
+ offsetValues[4] = Vector2( -10.875f, -0.5f );
for( int i = 0; i < 5; ++i )
{
using namespace Dali;
using namespace Toolkit;
+namespace
+{
+
+const char* TEST_IMAGE_FILE_NAME = "selection-popup-border.9.png";
+
+}
+
void dali_textselectionpopup_startup(void)
{
test_return_value = TET_UNDEF;
END_TEST;
}
+int UtcDaliToolkitTextSelectionPopupBackgroundBorderP(void)
+{
+ ToolkitTestApplication application;
+ TextSelectionPopup textSelectionPopup;
+ textSelectionPopup = TextSelectionPopup::New( NULL );
+
+ textSelectionPopup.SetProperty( TextSelectionPopup::Property::BACKGROUND_BORDER,
+ Property::Map().Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME ) );
+
+ Property::Value value = textSelectionPopup.GetProperty( TextSelectionPopup::Property::BACKGROUND_BORDER );
+
+ Property::Map map;
+ value.Get( map );
+
+ Property::Value* returnValue = map.Find( Dali::Toolkit::ImageVisual::Property::URL );
+ DALI_TEST_CHECK( NULL != returnValue );
+
+ if( returnValue )
+ {
+ std::string url;
+ returnValue->Get( url );
+ DALI_TEST_EQUALS( TEST_IMAGE_FILE_NAME, url, TEST_LOCATION );
+ }
+
+ END_TEST;
+}
+
// TextSelectionToolBar is used TextSelectionPopup, below tests it individually
int UtcDaliToolkitTextSelectionToolBarP(void)
{
-
// Creates Toolbar, adds 2 options and a divider then resizes divider
ToolkitTestApplication application;
DALI_TEST_CHECK( toolbar );
END_TEST;
}
+
+int UtcDaliToolkitTextSelectionToolBarScrollBarP(void)
+{
+ // Creates Toolbar, adds 2 options and a divider then resizes divider
+ ToolkitTestApplication application;
+
+ TextSelectionToolbar toolbar = TextSelectionToolbar::New();
+
+ toolbar.SetProperty( Toolkit::TextSelectionToolbar::Property::MAX_SIZE, Size( 100.0f, 60.0f) );
+
+ Toolkit::PushButton option = Toolkit::PushButton::New();
+ option.SetName( "test-option" );
+ option.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
+ toolbar.AddOption( option );
+
+ // Add a scroll-bar
+ toolbar.SetProperty( Toolkit::TextSelectionToolbar::Property::ENABLE_SCROLL_BAR, true );
+
+ bool enabled = toolbar.GetProperty<bool>( Toolkit::TextSelectionToolbar::Property::ENABLE_SCROLL_BAR );
+ DALI_TEST_CHECK( enabled );
+
+ DALI_TEST_CHECK( toolbar );
+ END_TEST;
+}
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/devel-api/visual-factory/transition-data.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
#include "dummy-control.h"
using namespace Dali;
Renderer renderer = actor.GetRendererAt(0);
Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
+ Property::Index opacityIndex = DevelHandle::GetPropertyIndex( renderer, DevelVisual::Property::OPACITY );
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(mixColorIndex), Color::MAGENTA, TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
anim.Play();
application.Render(500); // Start animation
application.Render(500); // Halfway thru anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(mixColorIndex), (Color::MAGENTA+Color::RED)*0.5f, TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA+Color::RED)*0.5f, TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
application.Render(500); // End of anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(mixColorIndex), Color::RED, TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::RED), TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
END_TEST;
}
+
+
int UtcDaliTransitionDataMap2P(void)
{
TestApplication application;
Property::Map map;
map["target"] = "visual1";
- //Control::CONTROL_PROPERTY_END_INDEX + 1
map["property"] = ColorVisual::Property::MIX_COLOR;
map["initialValue"] = Color::MAGENTA;
map["targetValue"] = Color::RED;
Renderer renderer = actor.GetRendererAt(0);
Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
+ Property::Index opacityIndex = DevelHandle::GetPropertyIndex( renderer, DevelVisual::Property::OPACITY );
+ application.SendNotification();
+ application.Render(0);
+
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
+
+ anim.Play();
+
+ application.SendNotification();
+ application.Render(0);
+ application.Render(500); // Start animation
+ application.Render(500); // Halfway thru anim
+ application.SendNotification();
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA+Color::RED)*0.5f, TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
+
+ application.Render(500); // End of anim
+ application.SendNotification();
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::RED), TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
+
+ END_TEST;
+}
+
+
+int UtcDaliTransitionDataMap2Pb(void)
+{
+ TestApplication application;
+
+ tet_printf("Testing animation of a visual property using programmatic maps\n");
+
+ Property::Map map;
+ map["target"] = "visual1";
+ map["property"] = PrimitiveVisual::Property::MIX_COLOR;
+ map["initialValue"] = Color::MAGENTA;
+ map["targetValue"] = Color::RED;
+ map["animator"] = Property::Map()
+ .Add("alphaFunction", "LINEAR")
+ .Add("timePeriod", Property::Map()
+ .Add("delay", 0.5f)
+ .Add("duration", 1.0f));
+
+ Dali::Toolkit::TransitionData transition = TransitionData::New( map );
+
+ DummyControl actor = DummyControl::New();
+ actor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ actor.SetName("Actor1");
+ actor.SetColor(Color::CYAN);
+ Stage::GetCurrent().Add(actor);
+
+ DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
+
+ Property::Map visualMap;
+ visualMap[Visual::Property::TYPE] = Visual::PRIMITIVE;
+ visualMap[PrimitiveVisual::Property::MIX_COLOR] = Color::MAGENTA;
+ visualMap[ PrimitiveVisual::Property::SHAPE ] = PrimitiveVisual::Shape::SPHERE;
+ visualMap[ PrimitiveVisual::Property::SLICES ] = 10;
+ visualMap[ PrimitiveVisual::Property::STACKS ] = 10;
+
+ Visual::Base visual = VisualFactory::Get().CreateVisual( visualMap );
+ visual.SetName( "visual1" );
+
+ Property::Index visualIndex = Control::CONTROL_PROPERTY_END_INDEX + 1;
+ dummyImpl.RegisterVisual( visualIndex, visual );
+
+ Animation anim = dummyImpl.CreateTransition( transition );
+ DALI_TEST_CHECK( anim );
+
+ Renderer renderer = actor.GetRendererAt(0);
+ Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, PrimitiveVisual::Property::MIX_COLOR );
+ Property::Index opacityIndex = DevelHandle::GetPropertyIndex( renderer, DevelVisual::Property::OPACITY );
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(mixColorIndex), Color::MAGENTA, TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
anim.Play();
application.Render(500); // Start animation
application.Render(500); // Halfway thru anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(mixColorIndex), (Color::MAGENTA+Color::RED)*0.5f, TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA+Color::RED)*0.5f, TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
application.Render(500); // End of anim
application.SendNotification();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(mixColorIndex), Color::RED, TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::RED), TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
+
int UtcDaliTransitionDataMap3P(void)
{
TestApplication application;
END_TEST;
}
+int UtcDaliTransitionDataMap5P(void)
+{
+ TestApplication application;
+
+ tet_printf("Testing animation visual opacity using stylesheet equivalent maps\n");
+
+ Property::Map map;
+ map["target"] = "visual1";
+ map["property"] = "opacity";
+ map["initialValue"] = 0.0f;
+ map["targetValue"] = 1.0f;
+ map["animator"] = Property::Map()
+ .Add("alphaFunction", "EASE_IN_OUT")
+ .Add("timePeriod", Property::Map()
+ .Add("delay", 0.5f)
+ .Add("duration", 1.0f));
+
+ Dali::Toolkit::TransitionData transition = TransitionData::New( map );
+
+ DummyControl actor = DummyControl::New();
+ actor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ actor.SetName("Actor1");
+ actor.SetColor(Color::CYAN);
+ Stage::GetCurrent().Add(actor);
+
+ DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
+
+ Property::Map visualMap;
+ visualMap[Visual::Property::TYPE] = Visual::COLOR;
+ visualMap[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
+ Visual::Base visual = VisualFactory::Get().CreateVisual( visualMap );
+ visual.SetName( "visual1" );
+
+ Property::Index visualIndex = Control::CONTROL_PROPERTY_END_INDEX + 1;
+ dummyImpl.RegisterVisual( visualIndex, visual );
+
+ Animation anim = dummyImpl.CreateTransition( transition );
+ DALI_TEST_CHECK( anim );
+
+ Renderer renderer = actor.GetRendererAt(0);
+ Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
+ Property::Index opacityIndex = DevelHandle::GetPropertyIndex( renderer, DevelVisual::Property::OPACITY );
+ application.SendNotification();
+ application.Render(0);
+
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::ON, TEST_LOCATION );
+
+ anim.Play();
+
+ application.SendNotification();
+ application.Render(500); // Start animation
+ application.Render(500); // Halfway thru anim
+ application.SendNotification();
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 0.5f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::ON, TEST_LOCATION );
+
+ application.Render(501); // End of anim
+ application.SendNotification();
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::AUTO, TEST_LOCATION );
+
+ END_TEST;
+}
+
+
+int UtcDaliTransitionDataMap6P(void)
+{
+ TestApplication application;
+
+ tet_printf("Testing animation visual opacity using stylesheet equivalent maps\n");
+
+ Property::Map map;
+ map["target"] = "visual1";
+ map["property"] = "opacity";
+ map["targetValue"] = 0.0f;
+ map["animator"] = Property::Map()
+ .Add("alphaFunction", "EASE_IN_OUT")
+ .Add("timePeriod", Property::Map()
+ .Add("delay", 0.5f)
+ .Add("duration", 1.0f));
+
+ Dali::Toolkit::TransitionData transition = TransitionData::New( map );
+
+ DummyControl actor = DummyControl::New();
+ actor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ actor.SetName("Actor1");
+ actor.SetColor(Color::CYAN);
+ Stage::GetCurrent().Add(actor);
+
+ DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
+
+ Property::Map visualMap;
+ visualMap[Visual::Property::TYPE] = Visual::COLOR;
+ visualMap[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
+ Visual::Base visual = VisualFactory::Get().CreateVisual( visualMap );
+ visual.SetName( "visual1" );
+
+ Property::Index visualIndex = Control::CONTROL_PROPERTY_END_INDEX + 1;
+ dummyImpl.RegisterVisual( visualIndex, visual );
+
+ Animation anim = dummyImpl.CreateTransition( transition );
+ DALI_TEST_CHECK( anim );
+
+ Renderer renderer = actor.GetRendererAt(0);
+ Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
+ Property::Index opacityIndex = DevelHandle::GetPropertyIndex( renderer, DevelVisual::Property::OPACITY );
+ application.SendNotification();
+ application.Render(0);
+
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 1.0f, 0.001f, TEST_LOCATION );
+
+ // Note, This should be testing for AUTO
+ // this is the same problem as C# target value being set before Play is called.
+ // @todo How was this solved?
+ DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::ON, TEST_LOCATION );
+
+ anim.Play();
+
+ application.SendNotification();
+ application.Render(500); // Start animation
+ application.Render(500); // Halfway thru anim
+ application.SendNotification();
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION);
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 0.5f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::ON, TEST_LOCATION );
+
+ application.Render(500); // End of anim
+ application.SendNotification();
+ DALI_TEST_EQUALS( renderer.GetProperty<Vector3>(mixColorIndex), Vector3(Color::MAGENTA), TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<float>(opacityIndex), 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::BLEND_MODE), (int)BlendMode::ON, TEST_LOCATION );
+
+ END_TEST;
+}
+
int UtcDaliTransitionDataMap1N(void)
{
Property::Map map;
map["target"] = "visual1";
map["property"] = "mixColor";
- map["initialValue"] = Color::MAGENTA;
- map["targetValue"] = Color::RED;
+ map["initialValue"] = Vector3(Color::MAGENTA);
+ map["targetValue"] = Vector3(Color::RED);
map["animator"] = Property::Map()
.Add("alphaFunction", "EASE_OUT_BACK")
.Add("timePeriod", Property::Map()
DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
Property::Map visualMap;
visualMap[Visual::Property::TYPE] = Visual::COLOR;
- visualMap[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
+ visualMap[ColorVisual::Property::MIX_COLOR] = Vector3(Color::MAGENTA);
Visual::Base visual = VisualFactory::Get().CreateVisual( visualMap );
visual.SetName( "visual1" );
Property::Map map;
map["target"] = "visual1";
map["property"] = "mixColor";
- map["initialValue"] = Color::MAGENTA;
- map["targetValue"] = Color::RED;
+ map["initialValue"] = Vector3(Color::MAGENTA);
+ map["targetValue"] = Vector3(Color::RED);
map["animator"] = Property::Map()
.Add("alphaFunction", Vector3(.1f,1.0f,0.5f))
.Add("timePeriod", Property::Map()
Renderer renderer = actor.GetRendererAt(0);
Property::Index mixColorIdx = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
+ Property::Index opacityIdx = DevelHandle::GetPropertyIndex( renderer, DevelVisual::Property::OPACITY );
tet_printf( "Test that the property has been set to target value\n");
- DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(mixColorIdx), Color::RED, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector3>(mixColorIdx), Vector3(Color::RED), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(renderer.GetProperty<float>(opacityIdx), 1.0f, 0.001, TEST_LOCATION);
END_TEST;
}
Property::Index mixColorIdx = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
tet_printf( "Test that the property has been set to target value\n");
- DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(mixColorIdx), Color::RED, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector3>(mixColorIdx), Vector3(Color::RED), 0.001, TEST_LOCATION);
END_TEST;
}
Renderer renderer = actor.GetRendererAt(0);
Property::Index mixColorIdx = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
+ Property::Index opacityIdx = DevelHandle::GetPropertyIndex( renderer, DevelVisual::Property::OPACITY );
tet_printf( "Test that the property has been set to target value\n");
- DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(mixColorIdx), Color::RED, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector3>(mixColorIdx), Vector3(Color::RED), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(renderer.GetProperty<float>(opacityIdx), 1.0f, 0.001, TEST_LOCATION);
END_TEST;
}
Property::Map map8;
map8["target"] = "Visual1";
- map8["property"] = "colorAlpha";
+ map8["property"] = "opacity";
+ map8["initialValue"] = 0.0f;
map8["targetValue"] = 1.0f;
map8["animator"] = Property::Map()
.Add("alphaFunction", "EASE_IN")
visual.CreatePropertyMap(map);
Property::Value* value = map.Find( mixColorIndex );
DALI_TEST_CHECK( value );
- Vector4 mixColor;
- DALI_TEST_CHECK( value->Get( mixColor ) );
- DALI_TEST_EQUALS( mixColor, testColor, 0.001, TEST_LOCATION );
+ Vector3 mixColor1;
+ DALI_TEST_CHECK( value->Get( mixColor1 ) );
+ DALI_TEST_EQUALS( mixColor1, Vector3(testColor), 0.001, TEST_LOCATION );
+
+ value = map.Find( DevelVisual::Property::MIX_COLOR );
+ DALI_TEST_CHECK( value );
+ Vector4 mixColor2;
+ DALI_TEST_CHECK( value->Get( mixColor2 ) );
+ DALI_TEST_EQUALS( mixColor2, testColor, 0.001, TEST_LOCATION );
+
+ value = map.Find( DevelVisual::Property::OPACITY );
+ DALI_TEST_CHECK( value );
+ float opacity;
+ DALI_TEST_CHECK( value->Get( opacity ) );
+ DALI_TEST_EQUALS( opacity, testColor.a, 0.001, TEST_LOCATION );
}
svgVisual2.GetNaturalSize(naturalSize);
DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 100.f), TEST_LOCATION ); // Natural size should still be 100, 100
- // Batch Image visual
- TestPlatformAbstraction& platform = application.GetPlatform();
- Vector2 testSize(80.f, 160.f);
- platform.SetClosestImageSize(testSize);
- propertyMap.Clear();
- propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
- propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
- propertyMap.Insert( "batchingEnabled", true );
- Visual::Base batchImageVisual = factory.CreateVisual( propertyMap );
- batchImageVisual.SetTransformAndSize(DefaultTransform(), controlSize );
- batchImageVisual.GetNaturalSize( naturalSize );
- DALI_TEST_EQUALS( naturalSize, Vector2( 80.0f, 160.0f ), TEST_LOCATION );
-
// Text visual.
// Load some fonts to get the same metrics on different platforms.
END_TEST;
}
-int UtcDaliVisualGetPropertyMapBatchImageVisual(void)
-{
- ToolkitTestApplication application;
- tet_infoline( "UtcDaliVisualGetPropertyMapBatchImageVisual:" );
-
- VisualFactory factory = VisualFactory::Get();
- Property::Map propertyMap;
- propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
- propertyMap.Insert( ImageVisual::Property::BATCHING_ENABLED, true );
- propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
- propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH, 20 );
- propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT, 30 );
-
- Visual::Base batchImageVisual = factory.CreateVisual( propertyMap );
- DALI_TEST_CHECK( batchImageVisual );
-
- Property::Map resultMap;
- batchImageVisual.CreatePropertyMap( resultMap );
-
- // Check the property values from the returned map from visual
- Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
- DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
-
- value = resultMap.Find( ImageVisual::Property::URL, Property::STRING );
- DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
-
- value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER );
- DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<int>() == 20 );
-
- value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER );
- DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<int>() == 30 );
-
- END_TEST;
-}
-
//Text shape visual
int UtcDaliVisualGetPropertyMap10(void)
{
END_TEST;
}
-int UtcDaliVisualGetPropertyMapBatchImageVisualNoAtlas(void)
-{
- ToolkitTestApplication application;
- tet_infoline( "UtcDaliVisualGetPropertyMapBatchImageVisualNoAtlas:" );
-
- VisualFactory factory = VisualFactory::Get();
- Property::Map propertyMap;
- propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
- propertyMap.Insert( ImageVisual::Property::BATCHING_ENABLED, true );
- propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
-
- // Set the desired size to be larger than the atlas limit of 1024x1024.
- propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH, 2048 );
- propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT, 2048 );
-
- // Create the visual.
- Visual::Base batchImageVisual = factory.CreateVisual( propertyMap );
-
- DALI_TEST_CHECK( batchImageVisual );
-
- DummyControl dummyControl = DummyControl::New(true);
- Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
- dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, batchImageVisual );
- Stage::GetCurrent().Add( dummyControl );
-
- DALI_TEST_CHECK( dummyControl.GetRendererCount() == 1u );
-
- END_TEST;
-}
-
int UtcDaliVisualAnimateBorderVisual01(void)
{
ToolkitTestApplication application;
DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor ), true, TEST_LOCATION );
- color = renderer.GetProperty<Vector4>( mixColorIndex );
+ color = renderer.GetProperty<Vector3>( mixColorIndex );
testColor = Vector4( 1,1,1,0.4f );
- DALI_TEST_EQUALS( color, testColor, 0.0001f, TEST_LOCATION );
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("mixColor", testColor ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", testColor.a ) , true, TEST_LOCATION );
- application.Render(2000u); // halfway point between blue and white
+ application.Render(2000u);
color = renderer.GetProperty<Vector4>( borderColorIndex );
DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
color = renderer.GetProperty<Vector4>( mixColorIndex );
testColor = Vector4(1,1,1,0);
DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("mixColor", testColor ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", testColor.a ), true, TEST_LOCATION );
END_TEST;
}
DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
Renderer renderer = actor.GetRendererAt(0);
- Property::Index index = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
+ Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
Animation animation = Animation::New(4.0f);
- animation.AnimateTo( Property(renderer, index), Color::WHITE );
+ animation.AnimateTo( Property(renderer, mixColorIndex), Vector3(Color::WHITE) );
animation.Play();
application.SendNotification();
application.Render(0);
application.Render(2000u); // halfway point
- Vector4 color = renderer.GetProperty<Vector4>( index );
- Vector4 testColor = (Color::BLUE + Color::WHITE)*0.5f;
+ Vector3 color = renderer.GetProperty<Vector3>( mixColorIndex );
+ Vector3 testColor = Vector3(Color::BLUE + Color::WHITE)*0.5f;
DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("mixColor", testColor ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor ), true, TEST_LOCATION );
application.Render(2000u); // halfway point between blue and white
- color = renderer.GetProperty<Vector4>( index );
- DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
+ color = renderer.GetProperty<Vector3>( mixColorIndex );
+ DALI_TEST_EQUALS( color, Vector3(Color::WHITE), TEST_LOCATION );
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("mixColor", Color::WHITE ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE) ), true, TEST_LOCATION );
blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, 1.0f )), true, TEST_LOCATION );
Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR)*0.5;
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("mixColor", halfwayColor ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor) ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", halfwayColor.a ), true, TEST_LOCATION );
application.Render(2001u); // go past end
application.SendNotification(); // Trigger signals
DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Color::WHITE ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("mixColor", TARGET_MIX_COLOR ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR) ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", TARGET_MIX_COLOR.a ), true, TEST_LOCATION );
blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
application.SendNotification();
application.Render(0);
application.Render(2000u); // halfway point
+ Vector4 testColor(1.0f, 0.0f, 0.5f, 0.75f );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, 1.0f )), true, TEST_LOCATION );
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("mixColor", Vector4(1.0f, 0.0f, 0.5f, 0.75f )), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", testColor.a), true, TEST_LOCATION );
application.Render(2000u); // halfway point between blue and white
DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Color::WHITE ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", TARGET_MIX_COLOR.a), true, TEST_LOCATION );
TestMixColor( visual, DevelVisual::Property::MIX_COLOR, TARGET_MIX_COLOR );
END_TEST;
}
+
+int UtcDaliVisualAnimateImageVisualOpacity(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliAnimateImageVisual mix color" );
+
+ application.GetPlatform().SetClosestImageSize( Vector2(100, 100) );
+
+ VisualFactory factory = VisualFactory::Get();
+ Property::Map propertyMap;
+ propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
+ propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
+ propertyMap.Insert("opacity", 0.5f);
+ propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
+ Visual::Base visual = factory.CreateVisual( propertyMap );
+
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+
+ actor.SetSize(2000, 2000);
+ actor.SetParentOrigin(ParentOrigin::CENTER);
+ actor.SetColor(Color::BLACK);
+ Stage::GetCurrent().Add(actor);
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
+
+ Renderer renderer = actor.GetRendererAt(0);
+ tet_infoline("Test that the renderer has the opacity property");
+ Property::Index index = DevelHandle::GetPropertyIndex( renderer, DevelVisual::Property::OPACITY );
+ DALI_TEST_CHECK( index != Property::INVALID_INDEX );
+
+
+ Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON, TEST_LOCATION );
+
+ {
+ tet_infoline( "Test that the opacity can be increased to full via animation, and that the blend mode is set appropriately at the start and end of the animation." );
+
+ Property::Map map;
+ map["target"] = "testVisual";
+ map["property"] = "opacity";
+ map["targetValue"] = 1.0f;
+ map["animator"] = Property::Map()
+ .Add("alphaFunction", "LINEAR")
+ .Add("timePeriod", Property::Map()
+ .Add("delay", 0.0f)
+ .Add("duration", 4.0f));
+
+ Dali::Toolkit::TransitionData transition = TransitionData::New( map );
+ Animation animation = dummyImpl.CreateTransition( transition );
+ animation.Play();
+
+ application.SendNotification();
+ application.Render(0);
+ application.Render(2000u); // halfway point
+ application.SendNotification();
+
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", 0.75f), true, TEST_LOCATION );
+
+ application.Render(2001u); // end
+ application.SendNotification();
+
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", 1.0f), true, TEST_LOCATION );
+
+ blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
+ }
+
+
+ {
+ tet_infoline( "Test that the opacity can be reduced via animation, and that the blend mode is set appropriately at the start and end of the animation." );
+
+ Property::Map map;
+ map["target"] = "testVisual";
+ map["property"] = DevelVisual::Property::OPACITY;
+ map["targetValue"] = 0.1f;
+ map["animator"] = Property::Map()
+ .Add("alphaFunction", "LINEAR")
+ .Add("timePeriod", Property::Map()
+ .Add("delay", 0.0f)
+ .Add("duration", 4.0f));
+
+ Dali::Toolkit::TransitionData transition = TransitionData::New( map );
+ Animation animation = dummyImpl.CreateTransition( transition );
+ animation.Play();
+
+ blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON, TEST_LOCATION );
+
+ application.SendNotification();
+ application.Render(0);
+ application.Render(2000u); // halfway point
+ application.SendNotification();
+
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", 0.55f), true, TEST_LOCATION );
+
+ application.Render(2016u); // end
+ application.SendNotification();
+
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", 0.1f), true, TEST_LOCATION );
+
+ blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON, TEST_LOCATION );
+ }
+
+
+ END_TEST;
+}
+
int UtcDaliVisualAnimateImageVisualPixelArea(void)
{
ToolkitTestApplication application;
DummyControl actor = DummyControl::New();
TestVisualRender( application, actor, visual );
- Vector4 actualValue(Vector4::ZERO);
+ Vector3 actualValue(Vector4::ZERO);
+ float opacity=0.0f;
TestGlAbstraction& gl = application.GetGlAbstraction();
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
+ DALI_TEST_CHECK( gl.GetUniformValue<Vector3>( "mixColor", actualValue ) );
+ DALI_TEST_CHECK( gl.GetUniformValue<float>( "opacity", opacity ) );
+ DALI_TEST_EQUALS( actualValue, Vector3(testColor), TEST_LOCATION );
+ DALI_TEST_EQUALS( opacity, testColor.a, TEST_LOCATION );
END_TEST;
}
DummyControl actor = DummyControl::New();
TestVisualRender( application, actor, visual );
- Vector4 actualValue(Vector4::ZERO);
+ Vector3 actualValue;
+ float opacity;
TestGlAbstraction& gl = application.GetGlAbstraction();
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
+ DALI_TEST_CHECK( gl.GetUniformValue<Vector3>( "mixColor", actualValue ) );
+ DALI_TEST_CHECK( gl.GetUniformValue<float>( "opacity", opacity ) );
+ DALI_TEST_EQUALS( actualValue, Vector3(testColor), TEST_LOCATION );
+ DALI_TEST_EQUALS( opacity, testColor.a, TEST_LOCATION );
Stage::GetCurrent().Remove(actor);
DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
END_TEST;
}
-int UtcDaliVisualFactoryGetBatchImageVisual1(void)
-{
- ToolkitTestApplication application;
- tet_infoline( "UtcDaliVisualFactoryGetBatchImageVisual1: Request a Batch Image visual with a Property::Map" );
-
- VisualFactory factory = VisualFactory::Get();
- DALI_TEST_CHECK( factory );
-
- Property::Map propertyMap;
- propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
- propertyMap.Insert( ImageVisual::Property::BATCHING_ENABLED, true );
- propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
-
- Visual::Base visual = factory.CreateVisual( propertyMap );
- DALI_TEST_CHECK( visual );
-
- DummyControl actor = DummyControl::New();
- DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
- dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
-
- actor.SetSize( 200.0f, 200.0f );
- Stage::GetCurrent().Add( actor );
- visual.SetTransformAndSize(DefaultTransform(), Vector2( 200.0f, 200.0f ) );
-
- // Test SetOnStage().
- DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
-
- application.SendNotification();
- application.Render();
-
- // Test SetOffStage().
- actor.Unparent();
- DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
-
- END_TEST;
-}
-
-int UtcDaliVisualFactoryGetBatchImageVisual2(void)
-{
- ToolkitTestApplication application;
- tet_infoline( "UtcDaliVisualFactoryGetBatchImageVisual2: Request Batch Image visual from an Image Visual with batchingEnabled set" );
-
- VisualFactory factory = VisualFactory::Get();
- DALI_TEST_CHECK( factory );
-
- Property::Map propertyMap;
- // Create a normal Image Visual.
- propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
- // Instruct the factory to change Image Visuals to Batch-Image Visuals.
- propertyMap.Insert( ImageVisual::Property::BATCHING_ENABLED, true );
-
- // Properties for the Batch-Image Visual.
- propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
-
- Visual::Base visual = factory.CreateVisual( propertyMap );
- DALI_TEST_CHECK( visual );
-
- // Check that a Batch-Image visual was created instead of an Image visual.
- Property::Map resultMap;
- visual.CreatePropertyMap( resultMap );
-
- Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::IMAGE, TEST_LOCATION );
-
- DummyControl actor = DummyControl::New();
- DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
- dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
-
- actor.SetSize( 200.0f, 200.0f );
- Stage::GetCurrent().Add( actor );
- visual.SetTransformAndSize(DefaultTransform(), Vector2( 200.0f, 200.0f ) );
-
- // Test SetOnStage().
- DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
-
- application.SendNotification();
- application.Render();
-
- // Test SetOffStage().
- actor.Unparent();
- DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
-
- END_TEST;
-}
-
-int UtcDaliVisualFactoryGetBatchImageVisual3(void)
-{
- ToolkitTestApplication application;
- tet_infoline( "UtcDaliVisualFactoryGetBatchImageVisual3: Create an ImageView that uses a batched visual internally" );
-
- VisualFactory factory = VisualFactory::Get();
- DALI_TEST_CHECK( factory );
-
- // Create a property-map that enables batching.
- Property::Map propertyMap;
- propertyMap[ Dali::Toolkit::ImageVisual::Property::URL ] = TEST_IMAGE_FILE_NAME ;
- propertyMap[ "desiredHeight" ] = 200;
- propertyMap[ "desiredWidth" ] = 200;
- propertyMap[ "batchingEnabled" ] = true;
-
- // Create an ImageView, passing the property-map in to instruct it to use batching.
- Toolkit::ImageView imageView = Toolkit::ImageView::New();
- imageView.SetProperty( Toolkit::ImageView::Property::IMAGE, propertyMap );
-
- imageView.SetSize( 200.0f, 200.0f );
- Stage::GetCurrent().Add( imageView );
-
- END_TEST;
-}
-
-int UtcDaliVisualFactoryGetBatchImageVisual4N(void)
-{
- ToolkitTestApplication application;
- tet_infoline( "UtcDaliVisualFactoryGetBatchImageVisual4: Create an ImageView that uses a batched visual, with desired properties of the wrong type" );
-
- VisualFactory factory = VisualFactory::Get();
- DALI_TEST_CHECK( factory );
-
- // Create a property-map that enables batching.
- Property::Map propertyMap;
- propertyMap[ Dali::Toolkit::ImageVisual::Property::URL ] = TEST_IMAGE_FILE_NAME ;
- propertyMap[ "desiredHeight" ] = Vector2(100, 100);
- propertyMap[ "desiredWidth" ] = Vector3(1, 1, 1);
- propertyMap[ "batchingEnabled" ] = true;
-
- // Create an ImageView, passing the property-map in to instruct it to use batching.
- Toolkit::ImageView imageView = Toolkit::ImageView::New();
- imageView.SetProperty( Toolkit::ImageView::Property::IMAGE, propertyMap );
-
- imageView.SetSize( 200.0f, 200.0f );
- Stage::GetCurrent().Add( imageView );
-
- END_TEST;
-}
-
int UtcDaliVisualFactoryGetAnimatedImageVisual1(void)
{
ToolkitTestApplication application;
#include "dali-toolkit/devel-api/builder/tree-node.h"
#include "dali-toolkit/internal/builder/tree-node-manipulator.h"
-namespace
+
+namespace Dali
{
bool CaseInsensitiveCharacterCompare( unsigned char a, unsigned char b )
return result;
}
-} // anonymous namespace
-
-
-namespace Dali
-{
-
namespace Toolkit
{
namespace DevelControl
{
+enum State
+{
+ NORMAL,
+ FOCUSED,
+ DISABLED
+};
+
namespace Property
{
* @see Toolkit::Tooltip
*/
TOOLTIP = BACKGROUND + 1,
+
+ /**
+ * @brief The current state of the control.
+ * @details Name "state", type DevelControl::State ( Property::INTEGER ) or Property::STRING
+ *
+ * @see DevelControl::State
+ */
+ STATE = BACKGROUND + 2,
+
+ /**
+ * @brief The current sub state of the control.
+ * @details Name "subState", type Property::INTEGER or Property::STRING. The enumeration used is dependent on the derived control.
+ *
+ * @see DevelControl::State
+ */
+ SUB_STATE = BACKGROUND + 3
};
} // namespace Property
// CLASS HEADER
#include <dali-toolkit/devel-api/controls/control-wrapper-impl.h>
-// INTERNAL INCLUDES
+// EXTERNAL INCLUDES
#include <dali/public-api/animation/animation.h>
+#include <dali/public-api/object/type-registry.h>
+#include <dali/public-api/object/type-registry-helper.h>
+#include <dali/devel-api/object/handle-devel.h>
+
+// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
#include <dali-toolkit/public-api/styling/style-manager.h>
namespace Internal
{
+namespace
+{
+
+BaseHandle Create()
+{
+ // empty handle as we cannot create control wrapper
+ return BaseHandle();
+}
+
+// Setup type-registry.
+DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ControlWrapper, Toolkit::Control, Create )
+DALI_TYPE_REGISTRATION_END()
+
+}
+
/*
* Implementation.
*/
-Dali::Toolkit::ControlWrapper ControlWrapper::New( ControlWrapper* controlWrapper )
+Dali::Toolkit::ControlWrapper ControlWrapper::New( const std::string& typeName, ControlWrapper* controlWrapper )
{
ControlWrapperPtr wrapper( controlWrapper );
// This can only be done after the CustomActor connection has been made.
wrapper->Initialize();
+ // Different types of C# custom view registered themselves using type registry,
+ // but their type names are registered per type not per instance, so they still
+ // have the same wrong type name in native side when type registry queries the
+ // unique type name of each instance using typeid() because of the binding.
+ // Therefore, we have to link each instance with its correct type info if already
+ // pre-registered.
+
+ TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeName );
+ if(typeInfo)
+ {
+ Dali::DevelHandle::SetTypeInfo( handle, typeInfo );
+ }
+
return handle;
}
/**
* Create a new ControlWrapper.
+ *
+ * @param[in] typeName The name of the type that is registered with this control
+ * @param[in] controlWrapper The implementation of this control
+ *
* @return A public handle to the newly allocated ControlWrapper.
*/
- static Dali::Toolkit::ControlWrapper New( ControlWrapper* controlWrapper );
+ static Dali::Toolkit::ControlWrapper New( const std::string& typeName, ControlWrapper* controlWrapper );
public: // From CustomActorImpl
// ControlWrapper
///////////////////////////////////////////////////////////////////////////////////////////////////
-ControlWrapper ControlWrapper::New( Internal::ControlWrapper& implementation )
+ControlWrapper ControlWrapper::New( const std::string& typeName, Internal::ControlWrapper& implementation )
{
- return Internal::ControlWrapper::New( &implementation );
+ return Internal::ControlWrapper::New( typeName, &implementation );
}
ControlWrapper::ControlWrapper()
/**
* @brief Create a new instance of a ControlWrapper.
*
+ * @param[in] typeName The name of the type that is registered with this control
+ * @param[in] implementation The implementation of this control
+ *
* @return A handle to a new ControlWrapper.
*/
- static ControlWrapper New( Internal::ControlWrapper& implementation );
+ static ControlWrapper New( const std::string& typeName, Internal::ControlWrapper& implementation );
/**
* @brief Creates an empty ControlWrapper handle.
{
enum
{
- 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
+ /**
+ * @brief The maximum size the Popup can be.
+ * @details Name "popupMaxSize", type Vector2.
+ */
+ POPUP_MAX_SIZE = PROPERTY_START_INDEX,
+
+ /**
+ * @brief The minimum size the Popup can be.
+ * @details Name "popupMinSize", type Vector2.
+ */
+ POPUP_MIN_SIZE,
+
+ /**
+ * @brief The maximum size an option can be.
+ * @details Name "optionMaxSize", type Vector2.
+ */
+ OPTION_MAX_SIZE,
+
+ /**
+ * @brief The minimum size an option can be.
+ * @details Name "optionMinSize", type Vector2.
+ */
+ OPTION_MIN_SIZE,
+
+ /**
+ * @brief The size of the divider between options.
+ * @details Name "optionDividerSize", type Vector2.
+ */
+ OPTION_DIVIDER_SIZE,
+
+ /**
+ * @brief The image to use as the popup clipboard icon.
+ * @details Name "popupClipboardButtonImage", type string.
+ */
+ POPUP_CLIPBOARD_BUTTON_ICON_IMAGE,
+
+ /**
+ * @brief The image to use as the popup cut icon.
+ * @details Name "popupCutButtonImage", type string.
+ */
+ POPUP_CUT_BUTTON_ICON_IMAGE,
+
+ /**
+ * @brief The image to use as the popup copy icon.
+ * @details Name "popupCopyButtonImage", type string.
+ */
+ POPUP_COPY_BUTTON_ICON_IMAGE,
+
+ /**
+ * @brief The image to use as the popup paste icon.
+ * @details Name "popupPasteButtonImage", type string.
+ */
+ POPUP_PASTE_BUTTON_ICON_IMAGE,
+
+ /**
+ * @brief The image to use as the popup select icon.
+ * @details Name "popupSelectButtonImage", type string.
+ */
+ POPUP_SELECT_BUTTON_ICON_IMAGE,
+
+ /**
+ * @brief The image to use as the popup select all icon.
+ * @details Name "popupSelectAllButtonImage", type string.
+ */
+ POPUP_SELECT_ALL_BUTTON_ICON_IMAGE,
+
+ /**
+ * @brief The color of the divider between options.
+ * @details Name "popupDividerColor", type Vector4.
+ */
+ POPUP_DIVIDER_COLOR,
+
+ /**
+ * @brief The color of the icons (if supplied).
+ * @details Name "popupIconColor", type Vector4.
+ */
+ POPUP_ICON_COLOR,
+
+ /**
+ * @brief The color of the option when pressed.
+ * @details Name "popupPressedColor", type Vector4.
+ */
+ POPUP_PRESSED_COLOR,
+
+ /**
+ * @brief The image to use for the option when pressed.
+ * @details Name "popupPressedImage", type string.
+ */
+ POPUP_PRESSED_IMAGE,
+
+ /**
+ * @brief The duration of the fade-in animation.
+ * @details Name "popupFadeInDuration", type float.
+ */
+ POPUP_FADE_IN_DURATION,
+
+ /**
+ * @brief The duration of the fade-out animation.
+ * @details Name "popupFadeOutDuration", type float.
+ */
+ POPUP_FADE_OUT_DURATION,
+
+ /**
+ * @brief The popup background can have a separate border with a different color.
+ * @details Name "backgroundBorder", type Property::Map.
+ * @note Optional.
+ */
+ BACKGROUND_BORDER
};
};
/**
* @brief Mix color is a blend color for any visual.
- * @details Name "mixColor", type Property::VECTOR4
+ * @details Name "mixColor", type Property::VECTOR3 or Property::VECTOR4
*
* @note Optional
*/
MIX_COLOR = SHADER + 3,
+
+ /**
+ * @brief Opacity is the alpha component of the mixColor, above.
+ * @details Name "opacity", type Property::FLOAT
+ *
+ * @note Optional
+ */
+ OPACITY = SHADER + 4
};
} //namespace Property
#include <sys/stat.h>
#include <sstream>
-#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali/public-api/actors/camera-actor.h>
+#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/object/property-array.h>
#include <dali/public-api/object/type-info.h>
#include <dali/public-api/object/type-registry.h>
-#include <dali/public-api/object/property-array.h>
-#include <dali/public-api/actors/layer.h>
-#include <dali/public-api/actors/camera-actor.h>
-#include <dali/devel-api/scripting/scripting.h>
+#include <dali/public-api/render-tasks/render-task-list.h>
#include <dali/public-api/signals/functor-delegate.h>
+#include <dali/devel-api/scripting/scripting.h>
#include <dali/integration-api/debug.h>
+#include <dali-toolkit/devel-api/controls/control-devel.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/devel-api/builder/json-parser.h>
-#include <dali-toolkit/internal/builder/builder-get-is.inl.h>
-#include <dali-toolkit/internal/builder/builder-filesystem.h>
#include <dali-toolkit/internal/builder/builder-declarations.h>
+#include <dali-toolkit/internal/builder/builder-filesystem.h>
+#include <dali-toolkit/internal/builder/builder-get-is.inl.h>
+#include <dali-toolkit/internal/builder/builder-impl-debug.h>
#include <dali-toolkit/internal/builder/builder-set-property.h>
#include <dali-toolkit/internal/builder/replacement.h>
#include <dali-toolkit/internal/builder/tree-node-manipulator.h>
-#include <dali-toolkit/internal/builder/builder-impl-debug.h>
-
namespace Dali
{
class Replacement;
extern Animation CreateAnimation(const TreeNode& child, const Replacement& replacements, const Dali::Actor searchRoot, Builder* const builder );
+
extern Actor SetupSignalAction(ConnectionTracker* tracker, const TreeNode &root, const TreeNode &child, Actor actor, Dali::Toolkit::Internal::Builder* const builder);
+
extern Actor SetupPropertyNotification(ConnectionTracker* tracker, const TreeNode &root, const TreeNode &child, Actor actor, Dali::Toolkit::Internal::Builder* const builder);
+
#if defined(DEBUG_ENABLED)
Integration::Log::Filter* gFilterScript = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_SCRIPT");
#endif
#define TOKEN_STRING(x) #x
-const std::string KEYNAME_STYLES = "styles";
-const std::string KEYNAME_TYPE = "type";
-const std::string KEYNAME_ACTORS = "actors";
-const std::string KEYNAME_SIGNALS = "signals";
-const std::string KEYNAME_NAME = "name";
-const std::string KEYNAME_TEMPLATES = "templates";
-const std::string KEYNAME_INCLUDES = "includes";
-const std::string KEYNAME_MAPPINGS = "mappings";
+const std::string KEYNAME_ACTORS = "actors";
+const std::string KEYNAME_ENTRY_TRANSITION = "entryTransition";
+const std::string KEYNAME_EXIT_TRANSITION = "exitTransition";
+const std::string KEYNAME_INCLUDES = "includes";
+const std::string KEYNAME_INHERIT = "inherit";
+const std::string KEYNAME_MAPPINGS = "mappings";
+const std::string KEYNAME_NAME = "name";
+const std::string KEYNAME_SIGNALS = "signals";
+const std::string KEYNAME_STATES = "states";
+const std::string KEYNAME_STYLES = "styles";
+const std::string KEYNAME_TEMPLATES = "templates";
+const std::string KEYNAME_TRANSITIONS = "transitions";
+const std::string KEYNAME_TYPE = "type";
+const std::string KEYNAME_VISUALS = "visuals";
const std::string PROPERTIES = "properties";
const std::string ANIMATABLE_PROPERTIES = "animatableProperties";
{
styleList.push_back( &(*node) );
- if( OptionalChild subStyle = IsChild( *node, KEYNAME_STYLES ) )
+ OptionalChild subStyle = IsChild( *node, KEYNAME_INHERIT );
+ if( ! subStyle )
+ {
+ subStyle = IsChild( *node, KEYNAME_STYLES );
+ }
+ if( subStyle )
{
CollectAllStyles( stylesCollection, *subStyle, styleList );
}
} // namespace anon
-/*
- * Sets the handle properties found in the tree node
- */
-void Builder::SetProperties( const TreeNode& node, Handle& handle, const Replacement& constant )
+
+Builder::Builder()
+: mSlotDelegate( this )
{
- if( handle )
- {
+ mParser = Dali::Toolkit::JsonParser::New();
- for( TreeNode::ConstIterator iter = node.CBegin(); iter != node.CEnd(); ++iter )
- {
- const TreeNode::KeyNodePair& keyChild = *iter;
+ Property::Map defaultDirs;
+ defaultDirs[ TOKEN_STRING(DALI_IMAGE_DIR) ] = DALI_IMAGE_DIR;
+ defaultDirs[ TOKEN_STRING(DALI_SOUND_DIR) ] = DALI_SOUND_DIR;
+ defaultDirs[ TOKEN_STRING(DALI_STYLE_DIR) ] = DALI_STYLE_DIR;
+ defaultDirs[ TOKEN_STRING(DALI_STYLE_IMAGE_DIR) ] = DALI_STYLE_IMAGE_DIR;
- std::string key( keyChild.first );
+ AddConstants( defaultDirs );
+}
- // ignore special fields; type,actors,signals,styles
- if(key == KEYNAME_TYPE || key == KEYNAME_ACTORS || key == KEYNAME_SIGNALS || key == KEYNAME_STYLES || key == KEYNAME_MAPPINGS )
- {
- continue;
- }
+void Builder::LoadFromString( std::string const& data, Dali::Toolkit::Builder::UIFormat format )
+{
+ // parser to get constants and includes only
+ Dali::Toolkit::JsonParser parser = Dali::Toolkit::JsonParser::New();
+
+ if( !parser.Parse( data ) )
+ {
+ DALI_LOG_WARNING( "JSON Parse Error:%d:%d:'%s'\n",
+ parser.GetErrorLineNumber(),
+ parser.GetErrorColumn(),
+ parser.GetErrorDescription().c_str() );
- Handle propertyObject( handle );
+ DALI_ASSERT_ALWAYS(!"Cannot parse JSON");
+ }
+ else
+ {
+ // load constant map (allows the user to override the constants in the json after loading)
+ LoadConstants( *parser.GetRoot(), mReplacementMap );
- Dali::Property::Index index = propertyObject.GetPropertyIndex( key );
+ // merge includes
+ if( OptionalChild includes = IsChild(*parser.GetRoot(), KEYNAME_INCLUDES) )
+ {
+ Replacement replacer( mReplacementMap );
- if( Property::INVALID_INDEX != index )
+ for(TreeNode::ConstIterator iter = (*includes).CBegin(); iter != (*includes).CEnd(); ++iter)
{
- Property::Type type = propertyObject.GetPropertyType(index);
- Property::Value value;
- bool mapped = false;
+ OptionalString filename = replacer.IsString( (*iter).second );
- // if node.value is a mapping, get the property value from the "mappings" table
- if( keyChild.second.GetType() == TreeNode::STRING )
- {
- std::string mappingKey;
- if( GetMappingKey(keyChild.second.GetString(), mappingKey) )
- {
- OptionalChild mappingRoot = IsChild( mParser.GetRoot(), KEYNAME_MAPPINGS );
- mapped = GetPropertyMap( *mappingRoot, mappingKey.c_str(), type, value );
- }
- }
- if( ! mapped )
- {
- mapped = DeterminePropertyFromNode( keyChild.second, type, value, constant );
- if( ! mapped )
- {
- // Just determine the property from the node and if it's valid, let the property object handle it
- DeterminePropertyFromNode( keyChild.second, value, constant );
- mapped = ( value.GetType() != Property::NONE );
- }
- }
- if( mapped )
+ if( filename )
{
- DALI_SCRIPT_VERBOSE("SetProperty '%s' Index=:%d Value Type=%d Value '%s'\n", key.c_str(), index, value.GetType(), PropertyValueToString(value).c_str() );
-
- propertyObject.SetProperty( index, value );
+#if defined(DEBUG_ENABLED)
+ DALI_SCRIPT_VERBOSE("Loading Include '%s'\n", (*filename).c_str());
+#endif
+ LoadFromString( GetFileContents(*filename) );
}
}
- else
- {
- DALI_LOG_ERROR("Key '%s' not found.\n", key.c_str());
- }
+ }
- // Add custom properties
- SetCustomProperties(node, handle, constant, PROPERTIES, Property::READ_WRITE);
- SetCustomProperties(node, handle, constant, ANIMATABLE_PROPERTIES, Property::ANIMATABLE);
+ if( !mParser.Parse( data ) )
+ {
+ DALI_LOG_WARNING( "JSON Parse Error:%d:%d:'%s'\n",
+ mParser.GetErrorLineNumber(),
+ mParser.GetErrorColumn(),
+ mParser.GetErrorDescription().c_str() );
- } // for property nodes
- }
- else
- {
- DALI_SCRIPT_WARNING("Style applied to empty handle\n");
+ DALI_ASSERT_ALWAYS(!"Cannot parse JSON");
+ }
}
+
+ DUMP_PARSE_TREE(parser); // This macro only writes out if DEBUG is enabled and the "DUMP_TREE" constant is defined in the stylesheet.
+ DUMP_TEST_MAPPINGS(parser);
+
+ DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Cannot parse JSON");
}
-void Builder::SetCustomProperties( const TreeNode& node, Handle& handle, const Replacement& constant,
- const std::string& childName, Property::AccessMode accessMode )
+void Builder::AddConstants( const Property::Map& map )
{
- // Add custom properties
- if( OptionalChild customPropertiesChild = IsChild(node, childName) )
- {
- const TreeNode& customPropertiesNode = *customPropertiesChild;
- const TreeConstIter endIter = customPropertiesNode.CEnd();
- for( TreeConstIter iter = customPropertiesNode.CBegin(); endIter != iter; ++iter )
- {
- const TreeNode::KeyNodePair& keyChild = *iter;
- std::string key( keyChild.first );
+ mReplacementMap.Merge( map );
+}
- Property::Value value;
- DeterminePropertyFromNode( keyChild.second, value, constant );
- // Register/Set property.
- handle.RegisterProperty( key, value, accessMode );
- }
- }
+void Builder::AddConstant( const std::string& key, const Property::Value& value )
+{
+ mReplacementMap[key] = value;
}
-// Set properties from node on handle.
-void Builder::ApplyProperties( const TreeNode& root, const TreeNode& node,
- Dali::Handle& handle, const Replacement& constant )
+const Property::Map& Builder::GetConstants() const
{
- if( Actor actor = Actor::DownCast(handle) )
- {
- SetProperties( node, actor, constant );
+ return mReplacementMap;
+}
- if( actor )
- {
- // add signals
- SetupSignalAction( mSlotDelegate.GetConnectionTracker(), root, node, actor, this );
- SetupPropertyNotification( mSlotDelegate.GetConnectionTracker(), root, node, actor, this );
- }
+const Property::Value& Builder::GetConstant( const std::string& key ) const
+{
+ Property::Value* match = mReplacementMap.Find( key );
+ if( match )
+ {
+ return (*match);
}
else
{
- SetProperties( node, handle, constant );
+ static Property::Value invalid;
+ return invalid;
}
}
-// Appling by style helper
-// use FindChildByName() to apply properties referenced in KEYNAME_ACTORS in the node
-void Builder::ApplyStylesByActor( const TreeNode& root, const TreeNode& node,
- Dali::Handle& handle, const Replacement& constant )
+Animation Builder::CreateAnimation( const std::string& animationName, const Property::Map& map, Dali::Actor sourceActor )
{
- if( Dali::Actor actor = Dali::Actor::DownCast( handle ) )
- {
- if( const TreeNode* actors = node.GetChild( KEYNAME_ACTORS ) )
- {
- // in a style the actor subtree properties referenced by actor name
- for( TreeConstIter iter = actors->CBegin(); iter != actors->CEnd(); ++iter )
- {
- Dali::Actor foundActor;
-
- if( (*iter).first )
- {
- foundActor = actor.FindChildByName( (*iter).first );
- }
-
- if( !foundActor )
- {
- // debug log cannot find searched for actor
-#if defined(DEBUG_ENABLED)
- DALI_SCRIPT_VERBOSE("Cannot find actor in style application '%s'\n", (*iter).first);
-#endif
- }
- else
- {
-#if defined(DEBUG_ENABLED)
- DALI_SCRIPT_VERBOSE("Styles applied to actor '%s'\n", (*iter).first);
-#endif
- ApplyProperties( root, (*iter).second, foundActor, constant );
- }
- }
- }
- }
+ Replacement replacement(map, mReplacementMap);
+ return CreateAnimation( animationName, replacement, sourceActor);
}
+Animation Builder::CreateAnimation( const std::string& animationName, const Property::Map& map )
+{
+ Replacement replacement(map, mReplacementMap);
+ return CreateAnimation( animationName, replacement, Stage::GetCurrent().GetRootLayer() );
+}
-void Builder::ApplyAllStyleProperties( const TreeNode& root, const TreeNode& node,
- Dali::Handle& handle, const Replacement& constant )
+Animation Builder::CreateAnimation( const std::string& animationName, Dali::Actor sourceActor )
{
- OptionalChild styles = IsChild(root, KEYNAME_STYLES);
- OptionalChild style = IsChild(node, KEYNAME_STYLES);
+ Replacement replacement( mReplacementMap );
- if( styles && style )
- {
- TreeNodeList additionalStyles;
+ return CreateAnimation( animationName, replacement, sourceActor );
+}
- CollectAllStyles( *styles, *style, additionalStyles );
+Animation Builder::CreateAnimation( const std::string& animationName )
+{
+ Replacement replacement( mReplacementMap );
-#if defined(DEBUG_ENABLED)
- for(TreeNode::ConstIterator iter = (*style).CBegin(); iter != (*style).CEnd(); ++iter)
- {
- if( OptionalString styleName = IsString( (*iter).second ) )
- {
- DALI_SCRIPT_VERBOSE("Style Applied '%s'\n", (*styleName).c_str());
- }
- }
-#endif
+ return CreateAnimation( animationName, replacement, Dali::Stage::GetCurrent().GetRootLayer() );
+}
- // a style may have other styles, which has other styles etc so we apply in reverse by convention.
- for(TreeNodeList::reverse_iterator iter = additionalStyles.rbegin(); iter != additionalStyles.rend(); ++iter)
- {
- ApplyProperties( root, *(*iter), handle, constant );
+BaseHandle Builder::Create( const std::string& templateName )
+{
+ Replacement replacement( mReplacementMap );
+ return Create( templateName, replacement );
+}
- ApplyStylesByActor( root, *(*iter), handle, constant );
- }
- }
+BaseHandle Builder::Create( const std::string& templateName, const Property::Map& map )
+{
+ Replacement replacement( map, mReplacementMap );
+ return Create( templateName, replacement );
+}
+
+BaseHandle Builder::CreateFromJson( const std::string& json )
+{
+ BaseHandle ret;
- // applying given node last
- ApplyProperties( root, node, handle, constant );
+ // merge in new template, hoping no one else has one named '@temp@'
+ std::string newTemplate =
+ std::string("{\"templates\":{\"@temp@\":") + \
+ json + \
+ std::string("}}");
- ApplyStylesByActor( root, node, handle, constant );
+ if( mParser.Parse(newTemplate) )
+ {
+ Replacement replacement( mReplacementMap );
+ ret = Create( "@temp@", replacement );
+ }
+ return ret;
}
-
-/*
- * Create a dali type from a node.
- * If parent given and an actor type was created then add it to the parent and
- * recursively add nodes children.
- */
-BaseHandle Builder::DoCreate( const TreeNode& root, const TreeNode& node,
- Actor parent, const Replacement& replacements )
+bool Builder::ApplyFromJson( Handle& handle, const std::string& json )
{
- BaseHandle baseHandle;
- TypeInfo typeInfo;
- const TreeNode* templateNode = NULL;
-
- if( OptionalString typeName = IsString(node, KEYNAME_TYPE) )
- {
- typeInfo = TypeRegistry::Get().GetTypeInfo( *typeName );
+ bool ret = false;
- if( !typeInfo )
- {
- // a template name is also allowed inplace of the type name
- OptionalChild templates = IsChild( root, KEYNAME_TEMPLATES);
-
- if( templates )
- {
- if( OptionalChild isTemplate = IsChild( *templates, *typeName ) )
- {
- templateNode = &(*isTemplate);
-
- if( OptionalString templateTypeName = IsString(*templateNode, KEYNAME_TYPE) )
- {
- typeInfo = TypeRegistry::Get().GetTypeInfo( *templateTypeName );
- }
- }
- }
- }
- }
+ // merge new style, hoping no one else has one named '@temp@'
+ std::string newStyle =
+ std::string("{\"styles\":{\"@temp@\":") + \
+ json + \
+ std::string("}}");
- if(!typeInfo)
+ if( mParser.Parse(newStyle) )
{
- DALI_SCRIPT_WARNING("Cannot create Dali type from node '%s'\n", node.GetName());
+ Replacement replacement( mReplacementMap );
+ ret = ApplyStyle( "@temp@", handle, replacement );
}
- else
- {
- baseHandle = typeInfo.CreateInstance();
- Handle handle = Handle::DownCast(baseHandle);
- Actor actor = Actor::DownCast(handle);
-
- if(handle)
- {
-
- DALI_SCRIPT_VERBOSE("Create:%s\n", typeInfo.GetName().c_str());
-
-#if defined(DEBUG_ENABLED)
- if(handle)
- {
- DALI_SCRIPT_VERBOSE(" Is Handle Object=%d\n", (long*)handle.GetObjectPtr());
- DALI_SCRIPT_VERBOSE(" Is Handle Property Count=%d\n", handle.GetPropertyCount());
- }
-
- if(actor)
- {
- DALI_SCRIPT_VERBOSE(" Is Actor id=%d\n", actor.GetId());
- }
-
- Toolkit::Control control = Toolkit::Control::DownCast(handle);
- if(control)
- {
- DALI_SCRIPT_VERBOSE(" Is Control id=%d\n", actor.GetId());
- }
-#endif // DEBUG_ENABLED
- if( templateNode )
- {
- ApplyProperties( root, *templateNode, handle, replacements );
+ return ret;
+}
- if( OptionalChild actors = IsChild( *templateNode, KEYNAME_ACTORS ) )
- {
- for( TreeConstIter iter = (*actors).CBegin(); iter != (*actors).CEnd(); ++iter )
- {
- DoCreate( root, (*iter).second, actor, replacements );
- }
- }
- }
+bool Builder::ApplyStyle( const std::string& styleName, Handle& handle )
+{
+ Replacement replacer( mReplacementMap );
+ return ApplyStyle( styleName, handle, replacer );
+}
- if( actor )
- {
- // add children of all the styles
- if( OptionalChild actors = IsChild( node, KEYNAME_ACTORS ) )
- {
- for( TreeConstIter iter = (*actors).CBegin(); iter != (*actors).CEnd(); ++iter )
- {
- DoCreate( root, (*iter).second, actor, replacements );
- }
- }
+bool Builder::LookupStyleName( const std::string& styleName )
+{
+ DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
- // apply style on top as they need the children to exist
- ApplyAllStyleProperties( root, node, actor, replacements );
+ OptionalChild styles = IsChild( *mParser.GetRoot(), KEYNAME_STYLES );
+ OptionalChild style = IsChildIgnoreCase( *styles, styleName );
- // then add to parent
- if( parent )
- {
- parent.Add( actor );
- }
- }
- else
- {
- ApplyProperties( root, node, handle, replacements );
- }
- }
- else
- {
- DALI_SCRIPT_WARNING("Cannot create handle from type '%s'\n", typeInfo.GetName().c_str());
- }
+ if( styles && style )
+ {
+ return true;
}
-
- return baseHandle;
+ return false;
}
-void Builder::SetupTask( RenderTask& task, const TreeNode& node, const Replacement& constant )
+const StylePtr Builder::GetStyle( const std::string& styleName )
{
- const Stage& stage = Stage::GetCurrent();
- Layer root = stage.GetRootLayer();
+ const StylePtr* style = mStyles.FindCaseInsensitiveC( styleName );
- if( OptionalString s = constant.IsString( IsChild(node, "sourceActor") ) )
+ if( style==NULL )
{
- Actor actor = root.FindChildByName(*s);
- if(actor)
- {
- task.SetSourceActor( actor );
- }
- else
- {
- DALI_SCRIPT_WARNING("Cannot find source actor on stage for render task called '%s'\n", (*s).c_str() );
- }
+ return StylePtr(NULL);
}
-
- if( OptionalString s = constant.IsString( IsChild(node, "cameraActor") ) )
+ else
{
- CameraActor actor = CameraActor::DownCast( root.FindChildByName(*s) );
- if(actor)
- {
- task.SetCameraActor( actor );
- }
- else
- {
- DALI_SCRIPT_WARNING("Cannot find camera actor on stage for render task called '%s'\n", (*s).c_str() );
- }
+ return *style;
}
+}
- if( OptionalString s = constant.IsString( IsChild(node, "targetFrameBuffer") ) )
- {
- FrameBufferImage fb = GetFrameBufferImage( *s, constant );
- if(fb)
- {
- task.SetTargetFrameBuffer( fb );
- }
- else
- {
- DALI_SCRIPT_WARNING("Cannot find target frame buffer '%s'\n", (*s).c_str() );
- }
- }
+void Builder::AddActors( Actor toActor )
+{
+ // 'stage' is the default/by convention section to add from
+ AddActors( "stage", toActor );
+}
- if( OptionalString s = constant.IsString( IsChild(node, "screenToFrameBufferFunction") ) )
+void Builder::AddActors( const std::string §ionName, Actor toActor )
+{
+ DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
+
+ Property::Map overrideMap;
+ Replacement replacements(overrideMap, mReplacementMap);
+
+ OptionalChild add = IsChild(*mParser.GetRoot(), sectionName);
+
+ if( add )
{
- if("DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION" == *s)
- {
- task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
- }
- else if("FULLSCREEN_FRAMEBUFFER_FUNCTION" == *s)
+ for( TreeNode::ConstIterator iter = (*add).CBegin(); iter != (*add).CEnd(); ++iter )
{
- task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
+ // empty actor adds directly to the stage
+ BaseHandle baseHandle = DoCreate( *mParser.GetRoot(), (*iter).second, Actor(), replacements );
+ Actor actor = Actor::DownCast(baseHandle);
+ if(actor)
+ {
+ toActor.Add( actor );
+ }
}
- else
+
+ // if were adding the 'stage' section then also check for a render task called stage
+ // to add automatically
+ if( "stage" == sectionName )
{
- DALI_SCRIPT_WARNING("todo");
+ if( OptionalChild renderTasks = IsChild(*mParser.GetRoot(), "renderTasks") )
+ {
+ if( OptionalChild tasks = IsChild(*renderTasks, "stage") )
+ {
+ CreateRenderTask( "stage" );
+ }
+ }
}
}
-
- // other setup is via the property system
- SetProperties( node, task, constant );
}
void Builder::CreateRenderTask( const std::string &name )
return ret;
}
+
bool Builder::IsPathConstrainer( const std::string& name )
{
size_t count( mPathConstrainerLut.size() );
mQuitSignal.Emit();
}
-void Builder::AddActors( Actor toActor )
+Builder::~Builder()
{
- // 'stage' is the default/by convention section to add from
- AddActors( "stage", toActor );
}
-void Builder::AddActors( const std::string §ionName, Actor toActor )
+void Builder::LoadConstants( const TreeNode& root, Property::Map& intoMap )
{
- DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
-
- Property::Map overrideMap;
- Replacement replacements(overrideMap, mReplacementMap);
-
- OptionalChild add = IsChild(*mParser.GetRoot(), sectionName);
+ Replacement replacer(intoMap);
- if( add )
+ if( OptionalChild constants = IsChild(root, "constants") )
{
- for( TreeNode::ConstIterator iter = (*add).CBegin(); iter != (*add).CEnd(); ++iter )
- {
- // empty actor adds directly to the stage
- BaseHandle baseHandle = DoCreate( *mParser.GetRoot(), (*iter).second, Actor(), replacements );
- Actor actor = Actor::DownCast(baseHandle);
- if(actor)
- {
- toActor.Add( actor );
- }
- }
-
- // if were adding the 'stage' section then also check for a render task called stage
- // to add automatically
- if( "stage" == sectionName )
+ for(TreeNode::ConstIterator iter = (*constants).CBegin();
+ iter != (*constants).CEnd(); ++iter)
{
- if( OptionalChild renderTasks = IsChild(*mParser.GetRoot(), "renderTasks") )
+ Dali::Property::Value property;
+ if( (*iter).second.GetName() )
{
- if( OptionalChild tasks = IsChild(*renderTasks, "stage") )
- {
- CreateRenderTask( "stage" );
- }
+#if defined(DEBUG_ENABLED)
+ DALI_SCRIPT_VERBOSE("Constant set from json '%s'\n", (*iter).second.GetName());
+#endif
+ DeterminePropertyFromNode( (*iter).second, property, replacer );
+ intoMap[ (*iter).second.GetName() ] = property;
}
}
}
-}
-
-Animation Builder::CreateAnimation( const std::string& animationName, const Replacement& replacement, Dali::Actor sourceActor )
-{
- DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
-
- Animation anim;
- if( OptionalChild animations = IsChild(*mParser.GetRoot(), "animations") )
+#if defined(DEBUG_ENABLED)
+ Property::Value* iter = intoMap.Find( "CONFIG_SCRIPT_LOG_LEVEL" );
+ if( iter && iter->GetType() == Property::STRING )
{
- if( OptionalChild animation = IsChild(*animations, animationName) )
+ std::string logLevel( iter->Get< std::string >() );
+ if( logLevel == "NoLogging" )
{
- anim = Dali::Toolkit::Internal::CreateAnimation( *animation, replacement, sourceActor, this );
+ gFilterScript->SetLogLevel( Integration::Log::NoLogging );
+ }
+ else if( logLevel == "Concise" )
+ {
+ gFilterScript->SetLogLevel( Integration::Log::Concise );
+ }
+ else if( logLevel == "General" )
+ {
+ gFilterScript->SetLogLevel( Integration::Log::General );
+ }
+ else if( logLevel == "Verbose" )
+ {
+ gFilterScript->SetLogLevel( Integration::Log::Verbose );
+ }
+ }
+#endif
+}
+
+Animation Builder::CreateAnimation( const std::string& animationName, const Replacement& replacement, Dali::Actor sourceActor )
+{
+ DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
+
+ Animation anim;
+
+ if( OptionalChild animations = IsChild(*mParser.GetRoot(), "animations") )
+ {
+ if( OptionalChild animation = IsChild(*animations, animationName) )
+ {
+ anim = Dali::Toolkit::Internal::CreateAnimation( *animation, replacement, sourceActor, this );
}
else
{
return anim;
}
-Animation Builder::CreateAnimation( const std::string& animationName, const Property::Map& map, Dali::Actor sourceActor )
+BaseHandle Builder::Create( const std::string& templateName, const Replacement& constant )
{
- Replacement replacement(map, mReplacementMap);
- return CreateAnimation( animationName, replacement, sourceActor);
-}
+ DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
-Animation Builder::CreateAnimation( const std::string& animationName, const Property::Map& map )
-{
- Replacement replacement(map, mReplacementMap);
- return CreateAnimation( animationName, replacement, Stage::GetCurrent().GetRootLayer() );
-}
+ BaseHandle baseHandle;
-Animation Builder::CreateAnimation( const std::string& animationName, Dali::Actor sourceActor )
-{
- Replacement replacement( mReplacementMap );
+ OptionalChild templates = IsChild(*mParser.GetRoot(), KEYNAME_TEMPLATES);
- return CreateAnimation( animationName, replacement, sourceActor );
-}
+ if( !templates )
+ {
+ DALI_SCRIPT_WARNING("No template section found to CreateFromTemplate\n");
+ }
+ else
+ {
+ OptionalChild childTemplate = IsChild(*templates, templateName);
+ if(!childTemplate)
+ {
+ DALI_SCRIPT_WARNING("Template '%s' does not exist in template section\n", templateName.c_str());
+ }
+ else
+ {
+ OptionalString type = constant.IsString( IsChild(*childTemplate, KEYNAME_TYPE) );
-Animation Builder::CreateAnimation( const std::string& animationName )
-{
- Replacement replacement( mReplacementMap );
+ if(!type)
+ {
+ DALI_SCRIPT_WARNING("Cannot create template '%s' as template section is missing 'type'\n", templateName.c_str());
+ }
+ else
+ {
+ baseHandle = DoCreate( *mParser.GetRoot(), *childTemplate, Actor(), constant );
+ }
+ }
+ }
- return CreateAnimation( animationName, replacement, Dali::Stage::GetCurrent().GetRootLayer() );
+ return baseHandle;
}
-bool Builder::ConvertChildValue( const TreeNode& mappingRoot, KeyStack& keyStack, Property::Value& child )
+/*
+ * Create a dali type from a node.
+ * If parent given and an actor type was created then add it to the parent and
+ * recursively add nodes children.
+ */
+BaseHandle Builder::DoCreate( const TreeNode& root, const TreeNode& node,
+ Actor parent, const Replacement& replacements )
{
- bool result = false;
+ BaseHandle baseHandle;
+ TypeInfo typeInfo;
+ const TreeNode* templateNode = NULL;
- switch( child.GetType() )
+ if( OptionalString typeName = IsString(node, KEYNAME_TYPE) )
{
- case Property::STRING:
+ typeInfo = TypeRegistry::Get().GetTypeInfo( *typeName );
+
+ if( !typeInfo )
{
- std::string value;
- if( child.Get( value ) )
+ // a template name is also allowed inplace of the type name
+ OptionalChild templates = IsChild( root, KEYNAME_TEMPLATES);
+
+ if( templates )
{
- std::string key;
- if( GetMappingKey( value, key ) )
+ if( OptionalChild isTemplate = IsChild( *templates, *typeName ) )
{
- // Check key for cycles:
- result=true;
- for( KeyStack::iterator iter = keyStack.begin() ; iter != keyStack.end(); ++iter )
- {
- if( key.compare(*iter) == 0 )
- {
- // key is already in stack; stop.
- DALI_LOG_WARNING("Detected cycle in stylesheet mapping table:%s\n", key.c_str());
- child = Property::Value("");
- result=false;
- break;
- }
- }
+ templateNode = &(*isTemplate);
- if( result )
+ if( OptionalString templateTypeName = IsString(*templateNode, KEYNAME_TYPE) )
{
- // The following call will overwrite the child with the value
- // from the mapping.
- RecursePropertyMap( mappingRoot, keyStack, key.c_str(), Property::NONE, child );
- result = true;
+ typeInfo = TypeRegistry::Get().GetTypeInfo( *templateTypeName );
}
}
}
- break;
}
+ }
- case Property::MAP:
+ if(!typeInfo)
+ {
+ DALI_SCRIPT_WARNING("Cannot create Dali type from node '%s'\n", node.GetName());
+ }
+ else
+ {
+ baseHandle = typeInfo.CreateInstance();
+ Handle handle = Handle::DownCast(baseHandle);
+ Actor actor = Actor::DownCast(handle);
+
+ if(handle)
{
- Property::Map* map = child.GetMap();
- if( map )
+
+ DALI_SCRIPT_VERBOSE("Create:%s\n", typeInfo.GetName().c_str());
+
+#if defined(DEBUG_ENABLED)
+ if(handle)
{
- for( Property::Map::SizeType i=0; i < map->Count(); ++i )
- {
- Property::Value& child = map->GetValue(i);
- ConvertChildValue(mappingRoot, keyStack, child);
- }
+ DALI_SCRIPT_VERBOSE(" Is Handle Object=%d\n", (long*)handle.GetObjectPtr());
+ DALI_SCRIPT_VERBOSE(" Is Handle Property Count=%d\n", handle.GetPropertyCount());
}
- break;
- }
- case Property::ARRAY:
- {
- Property::Array* array = child.GetArray();
- if( array )
+ if(actor)
{
- for( Property::Array::SizeType i=0; i < array->Count(); ++i )
- {
- Property::Value& child = array->GetElementAt(i);
- ConvertChildValue(mappingRoot, keyStack, child);
- }
+ DALI_SCRIPT_VERBOSE(" Is Actor id=%d\n", actor.GetId());
}
- break;
- }
-
- default:
- // Ignore other types.
- break;
- }
- return result;
-}
+ Toolkit::Control control = Toolkit::Control::DownCast(handle);
+ if(control)
+ {
+ DALI_SCRIPT_VERBOSE(" Is Control id=%d\n", actor.GetId());
+ }
+#endif // DEBUG_ENABLED
-bool Builder::RecursePropertyMap( const TreeNode& mappingRoot, KeyStack& keyStack, const char* theKey, Property::Type propertyType, Property::Value& value )
-{
- Replacement replacer( mReplacementMap );
- bool result = false;
+ if( templateNode )
+ {
+ ApplyProperties( root, *templateNode, handle, replacements );
- keyStack.push_back( theKey );
+ if( OptionalChild actors = IsChild( *templateNode, KEYNAME_ACTORS ) )
+ {
+ for( TreeConstIter iter = (*actors).CBegin(); iter != (*actors).CEnd(); ++iter )
+ {
+ DoCreate( root, (*iter).second, actor, replacements );
+ }
+ }
+ }
- for( TreeNode::ConstIterator iter = mappingRoot.CBegin(); iter != mappingRoot.CEnd(); ++iter )
- {
- std::string aKey( (*iter).first );
- if( aKey.compare( theKey ) == 0 )
- {
- if( propertyType == Property::NONE )
+ if( actor )
{
- DeterminePropertyFromNode( (*iter).second, value, replacer );
- result = true;
+ // add children of all the styles
+ if( OptionalChild actors = IsChild( node, KEYNAME_ACTORS ) )
+ {
+ for( TreeConstIter iter = (*actors).CBegin(); iter != (*actors).CEnd(); ++iter )
+ {
+ DoCreate( root, (*iter).second, actor, replacements );
+ }
+ }
+
+ // apply style on top as they need the children to exist
+ ApplyAllStyleProperties( root, node, actor, replacements );
+
+ // then add to parent
+ if( parent )
+ {
+ parent.Add( actor );
+ }
}
else
{
- result = DeterminePropertyFromNode( (*iter).second, propertyType, value, replacer );
- }
-
- if( result )
- {
- ConvertChildValue(mappingRoot, keyStack, value);
+ ApplyProperties( root, node, handle, replacements );
}
- break;
+ }
+ else
+ {
+ DALI_SCRIPT_WARNING("Cannot create handle from type '%s'\n", typeInfo.GetName().c_str());
}
}
- keyStack.pop_back();
-
- return result;
-}
-
-bool Builder::GetPropertyMap( const TreeNode& mappingRoot, const char* theKey, Property::Type propertyType, Property::Value& value )
-{
- KeyStack keyStack;
- return RecursePropertyMap( mappingRoot, keyStack, theKey, propertyType, value );
+ return baseHandle;
}
-
-void Builder::LoadFromString( std::string const& data, Dali::Toolkit::Builder::UIFormat format )
+void Builder::SetupTask( RenderTask& task, const TreeNode& node, const Replacement& constant )
{
- // parser to get constants and includes only
- Dali::Toolkit::JsonParser parser = Dali::Toolkit::JsonParser::New();
+ const Stage& stage = Stage::GetCurrent();
+ Layer root = stage.GetRootLayer();
- if( !parser.Parse( data ) )
+ if( OptionalString s = constant.IsString( IsChild(node, "sourceActor") ) )
{
- DALI_LOG_WARNING( "JSON Parse Error:%d:%d:'%s'\n",
- parser.GetErrorLineNumber(),
- parser.GetErrorColumn(),
- parser.GetErrorDescription().c_str() );
-
- DALI_ASSERT_ALWAYS(!"Cannot parse JSON");
+ Actor actor = root.FindChildByName(*s);
+ if(actor)
+ {
+ task.SetSourceActor( actor );
+ }
+ else
+ {
+ DALI_SCRIPT_WARNING("Cannot find source actor on stage for render task called '%s'\n", (*s).c_str() );
+ }
}
- else
- {
- // load constant map (allows the user to override the constants in the json after loading)
- LoadConstants( *parser.GetRoot(), mReplacementMap );
- // merge includes
- if( OptionalChild includes = IsChild(*parser.GetRoot(), KEYNAME_INCLUDES) )
+ if( OptionalString s = constant.IsString( IsChild(node, "cameraActor") ) )
+ {
+ CameraActor actor = CameraActor::DownCast( root.FindChildByName(*s) );
+ if(actor)
{
- Replacement replacer( mReplacementMap );
-
- for(TreeNode::ConstIterator iter = (*includes).CBegin(); iter != (*includes).CEnd(); ++iter)
- {
- OptionalString filename = replacer.IsString( (*iter).second );
-
- if( filename )
- {
-#if defined(DEBUG_ENABLED)
- DALI_SCRIPT_VERBOSE("Loading Include '%s'\n", (*filename).c_str());
-#endif
- LoadFromString( GetFileContents(*filename) );
- }
- }
+ task.SetCameraActor( actor );
}
-
- if( !mParser.Parse( data ) )
+ else
{
- DALI_LOG_WARNING( "JSON Parse Error:%d:%d:'%s'\n",
- mParser.GetErrorLineNumber(),
- mParser.GetErrorColumn(),
- mParser.GetErrorDescription().c_str() );
+ DALI_SCRIPT_WARNING("Cannot find camera actor on stage for render task called '%s'\n", (*s).c_str() );
+ }
+ }
- DALI_ASSERT_ALWAYS(!"Cannot parse JSON");
+ if( OptionalString s = constant.IsString( IsChild(node, "targetFrameBuffer") ) )
+ {
+ FrameBufferImage fb = GetFrameBufferImage( *s, constant );
+ if(fb)
+ {
+ task.SetTargetFrameBuffer( fb );
+ }
+ else
+ {
+ DALI_SCRIPT_WARNING("Cannot find target frame buffer '%s'\n", (*s).c_str() );
}
}
- DUMP_PARSE_TREE(parser); // This macro only writes out if DEBUG is enabled and the "DUMP_TREE" constant is defined in the stylesheet.
- DUMP_TEST_MAPPINGS(parser);
+ if( OptionalString s = constant.IsString( IsChild(node, "screenToFrameBufferFunction") ) )
+ {
+ if("DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION" == *s)
+ {
+ task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
+ }
+ else if("FULLSCREEN_FRAMEBUFFER_FUNCTION" == *s)
+ {
+ task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
+ }
+ else
+ {
+ DALI_SCRIPT_WARNING("todo");
+ }
+ }
- DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Cannot parse JSON");
+ // other setup is via the property system
+ SetProperties( node, task, constant );
}
-void Builder::AddConstants( const Property::Map& map )
+bool Builder::ApplyStyle( const std::string& styleName, Handle& handle, const Replacement& replacement )
{
- mReplacementMap.Merge( map );
-}
+ DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
-void Builder::AddConstant( const std::string& key, const Property::Value& value )
-{
- mReplacementMap[key] = value;
-}
+ OptionalChild styles = IsChild( *mParser.GetRoot(), KEYNAME_STYLES );
-const Property::Map& Builder::GetConstants() const
-{
- return mReplacementMap;
-}
+ std::string styleNameLower(styleName);
+ OptionalChild style = IsChildIgnoreCase( *styles, styleNameLower );
-const Property::Value& Builder::GetConstant( const std::string& key ) const
-{
- Property::Value* match = mReplacementMap.Find( key );
- if( match )
+ if( styles && style )
{
- return (*match);
+ ApplyAllStyleProperties( *mParser.GetRoot(), *style, handle, replacement );
+ return true;
}
else
{
- static Property::Value invalid;
- return invalid;
+ return false;
}
}
-void Builder::LoadConstants( const TreeNode& root, Property::Map& intoMap )
+void Builder::ApplyAllStyleProperties( const TreeNode& root, const TreeNode& node,
+ Dali::Handle& handle, const Replacement& constant )
{
- Replacement replacer(intoMap);
+ const char* styleName = node.GetName();
- if( OptionalChild constants = IsChild(root, "constants") )
+ StylePtr style = Style::New();
+
+ StylePtr* matchedStyle = NULL;
+ if( styleName )
{
- for(TreeNode::ConstIterator iter = (*constants).CBegin();
- iter != (*constants).CEnd(); ++iter)
+ matchedStyle = mStyles.FindCaseInsensitive( styleName );
+ if( ! matchedStyle )
{
- Dali::Property::Value property;
- if( (*iter).second.GetName() )
+ OptionalChild styleNodes = IsChild(root, KEYNAME_STYLES);
+ OptionalChild inheritFromNode = IsChild(node, KEYNAME_INHERIT);
+ if( !inheritFromNode )
+ {
+ inheritFromNode = IsChild( node, KEYNAME_STYLES );
+ }
+
+ if( styleNodes )
{
+ if( inheritFromNode )
+ {
+ TreeNodeList additionalStyleNodes;
+
+ CollectAllStyles( *styleNodes, *inheritFromNode, additionalStyleNodes );
+
#if defined(DEBUG_ENABLED)
- DALI_SCRIPT_VERBOSE("Constant set from json '%s'\n", (*iter).second.GetName());
+ for(TreeNode::ConstIterator iter = (*inheritFromNode).CBegin(); iter != (*inheritFromNode).CEnd(); ++iter)
+ {
+ if( OptionalString styleName = IsString( (*iter).second ) )
+ {
+ DALI_SCRIPT_VERBOSE("Style Applied '%s'\n", (*styleName).c_str());
+ }
+ }
#endif
- DeterminePropertyFromNode( (*iter).second, property, replacer );
- intoMap[ (*iter).second.GetName() ] = property;
+
+ // a style may have other styles, which has other styles etc so we apply in reverse by convention.
+ for(TreeNodeList::reverse_iterator iter = additionalStyleNodes.rbegin(); iter != additionalStyleNodes.rend(); ++iter)
+ {
+ RecordStyle( style, *(*iter), handle, constant );
+ ApplySignals( root, *(*iter), handle );
+ ApplyStylesByActor( root, *(*iter), handle, constant );
+ }
+ }
+
+ RecordStyle( style, node, handle, constant );
+ mStyles.Add( styleName, style ); // shallow copy
+ matchedStyle = &style;
}
}
}
-#if defined(DEBUG_ENABLED)
- Property::Value* iter = intoMap.Find( "CONFIG_SCRIPT_LOG_LEVEL" );
- if( iter && iter->GetType() == Property::STRING )
+ if( matchedStyle )
{
- std::string logLevel( iter->Get< std::string >() );
- if( logLevel == "NoLogging" )
+ StylePtr style( *matchedStyle );
+ style->ApplyVisualsAndPropertiesRecursively( handle ); // (recurses through states)
+ }
+ else // If there were no styles, instead set properties
+ {
+ SetProperties( node, handle, constant );
+ }
+ ApplySignals( root, node, handle );
+ ApplyStylesByActor( root, node, handle, constant );
+}
+
+void Builder::RecordStyle( StylePtr style,
+ const TreeNode& node,
+ Dali::Handle& handle,
+ const Replacement& replacements )
+{
+ // With repeated calls, accumulate inherited states, visuals and properties
+ // but override any with same name
+
+ for( TreeNode::ConstIterator iter = node.CBegin(); iter != node.CEnd(); ++iter )
+ {
+ const TreeNode::KeyNodePair& keyValue = *iter;
+ std::string key( keyValue.first );
+ if( key == KEYNAME_STATES )
{
- gFilterScript->SetLogLevel( Integration::Log::NoLogging );
+ const TreeNode& states = keyValue.second;
+ if( states.GetType() != TreeNode::OBJECT )
+ {
+ DALI_LOG_WARNING( "RecordStyle() Node \"%s\" is not a JSON object\n", key.c_str() );
+ continue;
+ }
+
+ for( TreeNode::ConstIterator iter = states.CBegin(); iter != states.CEnd(); ++iter )
+ {
+ const TreeNode& stateNode = (*iter).second;
+ const char* stateName = stateNode.GetName();
+ if( stateNode.GetType() != TreeNode::OBJECT )
+ {
+ DALI_LOG_WARNING( "RecordStyle() Node \"%s\" is not a JSON object\n", stateName );
+ continue;
+ }
+
+ StylePtr* stylePtr = style->subStates.FindCaseInsensitive( stateName );
+ if( stylePtr )
+ {
+ StylePtr style(*stylePtr);
+ RecordStyle( style, stateNode, handle, replacements );
+ }
+ else
+ {
+ StylePtr subState = Style::New();
+ RecordStyle( subState, stateNode, handle, replacements );
+ style->subStates.Add( stateName, subState );
+ }
+ }
}
- else if( logLevel == "Concise" )
+ else if( key == KEYNAME_VISUALS )
{
- gFilterScript->SetLogLevel( Integration::Log::Concise );
+ for( TreeNode::ConstIterator iter = keyValue.second.CBegin(); iter != keyValue.second.CEnd(); ++iter )
+ {
+ // Each key in this table should be a property name matching a visual.
+ const TreeNode::KeyNodePair& visual = *iter;
+ Dali::Property::Value property(Property::MAP);
+ if( DeterminePropertyFromNode( visual.second, Property::MAP, property, replacements ) )
+ {
+ Property::Map* mapPtr = style->visuals.FindCaseInsensitive( visual.first );
+ if( mapPtr )
+ {
+ // Override existing visuals
+ mapPtr->Clear();
+ mapPtr->Merge(*property.GetMap());
+ }
+ else
+ {
+ style->visuals.Add(visual.first, *property.GetMap());
+ }
+ }
+ }
}
- else if( logLevel == "General" )
+ else if( key == KEYNAME_ENTRY_TRANSITION )
{
- gFilterScript->SetLogLevel( Integration::Log::General );
+ Dali::Property::Value property(Property::MAP);
+ if( DeterminePropertyFromNode( keyValue.second, Property::MAP, property, replacements ) )
+ {
+ style->entryTransition = Toolkit::TransitionData::New( *property.GetMap() );
+ }
}
- else if( logLevel == "Verbose" )
+ else if( key == KEYNAME_EXIT_TRANSITION )
{
- gFilterScript->SetLogLevel( Integration::Log::Verbose );
+ Dali::Property::Value property(Property::MAP);
+ if( DeterminePropertyFromNode( keyValue.second, Property::MAP, property, replacements ) )
+ {
+ style->exitTransition = Toolkit::TransitionData::New( *property.GetMap() );
+ }
+ }
+ else if( key == KEYNAME_TRANSITIONS )
+ {
+ //@todo add new transitions to style.transitions
+ // override existing transitions. A transition matches on target & property name
+ const TreeNode& node = keyValue.second;
+ if( node.GetType() == TreeNode::ARRAY )
+ {
+ Dali::Property::Value property(Property::ARRAY);
+ if( DeterminePropertyFromNode( node, Property::ARRAY, property, replacements ) )
+ {
+ style->transitions = *property.GetArray();
+ }
+ }
+ else if( node.GetType() == TreeNode::OBJECT )
+ {
+ Dali::Property::Value property(Property::MAP);
+ if( DeterminePropertyFromNode( node, Property::MAP, property, replacements ) )
+ {
+ Property::Array propertyArray;
+ propertyArray.Add( property );
+ style->transitions = propertyArray;
+ }
+ }
+ else
+ {
+ DALI_LOG_WARNING( "RecordStyle() Node \"%s\" is not a JSON array or object\n", key.c_str() );
+ }
+ }
+ else if( key == KEYNAME_TYPE ||
+ key == KEYNAME_ACTORS ||
+ key == KEYNAME_SIGNALS ||
+ key == KEYNAME_STYLES ||
+ key == KEYNAME_MAPPINGS ||
+ key == KEYNAME_INHERIT )
+ {
+ continue;
+ }
+ else // It's a property
+ {
+ Property::Index index;
+ Property::Value value;
+ if( MapToTargetProperty( handle, key, keyValue.second, replacements, index, value ) )
+ {
+ Property::Value* existingValuePtr = style->properties.Find( index );
+ if( existingValuePtr != NULL )
+ {
+ *existingValuePtr = value; // Overwrite existing property.
+ }
+ else
+ {
+ style->properties.Add( index, value );
+ }
+ }
}
}
-#endif
+}
+// Set properties from node on handle.
+void Builder::ApplyProperties( const TreeNode& root, const TreeNode& node,
+ Dali::Handle& handle, const Replacement& constant )
+{
+ SetProperties( node, handle, constant );
+ ApplySignals( root, node, handle );
}
-bool Builder::ApplyStyle( const std::string& styleName, Handle& handle )
+void Builder::ApplySignals(const TreeNode& root, const TreeNode& node, Dali::Handle& handle )
{
- Replacement replacer( mReplacementMap );
- return ApplyStyle( styleName, handle, replacer );
+ Actor actor = Actor::DownCast(handle);
+ if( actor )
+ {
+ // add signals
+ SetupSignalAction( mSlotDelegate.GetConnectionTracker(), root, node, actor, this );
+ SetupPropertyNotification( mSlotDelegate.GetConnectionTracker(), root, node, actor, this );
+ }
}
-bool Builder::ApplyStyle( const std::string& styleName, Handle& handle, const Replacement& replacement )
+
+// Appling by style helper
+// use FindChildByName() to apply properties referenced in KEYNAME_ACTORS in the node
+void Builder::ApplyStylesByActor( const TreeNode& root, const TreeNode& node,
+ Dali::Handle& handle, const Replacement& constant )
{
- DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
+ if( Dali::Actor actor = Dali::Actor::DownCast( handle ) )
+ {
+ if( const TreeNode* actors = node.GetChild( KEYNAME_ACTORS ) )
+ {
+ // in a style the actor subtree properties referenced by actor name
+ for( TreeConstIter iter = actors->CBegin(); iter != actors->CEnd(); ++iter )
+ {
+ Dali::Actor foundActor;
- OptionalChild styles = IsChild( *mParser.GetRoot(), KEYNAME_STYLES );
+ if( (*iter).first )
+ {
+ foundActor = actor.FindChildByName( (*iter).first );
+ }
- std::string styleNameLower(styleName);
- OptionalChild style = IsChildIgnoreCase( *styles, styleNameLower );
+ if( !foundActor )
+ {
+ DALI_SCRIPT_VERBOSE("Cannot find actor in style application '%s'\n", (*iter).first);
+ }
+ else
+ {
+ DALI_SCRIPT_VERBOSE("Styles applied to actor '%s'\n", (*iter).first);
+ ApplyProperties( root, (*iter).second, foundActor, constant );
+ }
+ }
+ }
+ }
+}
- if( styles && style )
+/*
+ * Sets the handle properties found in the tree node
+ */
+void Builder::SetProperties( const TreeNode& node, Handle& handle, const Replacement& constant )
+{
+ if( handle )
{
- ApplyAllStyleProperties( *mParser.GetRoot(), *style, handle, replacement );
- return true;
+ for( TreeNode::ConstIterator iter = node.CBegin(); iter != node.CEnd(); ++iter )
+ {
+ const TreeNode::KeyNodePair& keyChild = *iter;
+
+ std::string key( keyChild.first );
+
+ // ignore special fields;
+ if( key == KEYNAME_TYPE ||
+ key == KEYNAME_ACTORS ||
+ key == KEYNAME_SIGNALS ||
+ key == KEYNAME_STYLES ||
+ key == KEYNAME_MAPPINGS ||
+ key == KEYNAME_INHERIT ||
+ key == KEYNAME_STATES ||
+ key == KEYNAME_VISUALS ||
+ key == KEYNAME_ENTRY_TRANSITION ||
+ key == KEYNAME_EXIT_TRANSITION ||
+ key == KEYNAME_TRANSITIONS )
+ {
+ continue;
+ }
+
+ Property::Index index;
+ Property::Value value;
+
+ bool mapped = MapToTargetProperty( handle, key, keyChild.second, constant, index, value );
+ if( mapped )
+ {
+ DALI_SCRIPT_VERBOSE("SetProperty '%s' Index=:%d Value Type=%d Value '%s'\n", key.c_str(), index, value.GetType(), PropertyValueToString(value).c_str() );
+
+ handle.SetProperty( index, value );
+ }
+
+ // Add custom properties
+ SetCustomProperties(node, handle, constant, PROPERTIES, Property::READ_WRITE);
+ SetCustomProperties(node, handle, constant, ANIMATABLE_PROPERTIES, Property::ANIMATABLE);
+
+ } // for property nodes
}
else
{
- return false;
+ DALI_SCRIPT_WARNING("Style applied to empty handle\n");
}
}
-BaseHandle Builder::Create( const std::string& templateName, const Property::Map& map )
+bool Builder::MapToTargetProperty(
+ Handle& propertyObject,
+ const std::string& key,
+ const TreeNode& node,
+ const Replacement& constant,
+ Property::Index& index,
+ Property::Value& value )
{
- Replacement replacement( map, mReplacementMap );
- return Create( templateName, replacement );
+ bool mapped = false;
+
+ index = propertyObject.GetPropertyIndex( key );
+ if( Property::INVALID_INDEX != index )
+ {
+ Property::Type type = propertyObject.GetPropertyType(index);
+
+ // if node.value is a mapping, get the property value from the "mappings" table
+ if( node.GetType() == TreeNode::STRING )
+ {
+ std::string mappingKey;
+ if( GetMappingKey( node.GetString(), mappingKey) )
+ {
+ OptionalChild mappingRoot = IsChild( mParser.GetRoot(), KEYNAME_MAPPINGS );
+ mapped = GetPropertyMap( *mappingRoot, mappingKey.c_str(), type, value );
+ }
+ }
+ if( ! mapped )
+ {
+ mapped = DeterminePropertyFromNode( node, type, value, constant );
+ if( ! mapped )
+ {
+ // Just determine the property from the node and if it's valid, let the property object handle it
+ DeterminePropertyFromNode( node, value, constant );
+ mapped = ( value.GetType() != Property::NONE );
+ }
+ }
+ }
+ else
+ {
+ DALI_LOG_ERROR("Key '%s' not found.\n", key.c_str());
+ }
+ return mapped;
}
-BaseHandle Builder::Create( const std::string& templateName, const Replacement& constant )
+bool Builder::GetPropertyMap( const TreeNode& mappingRoot, const char* theKey, Property::Type propertyType, Property::Value& value )
{
- DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
+ KeyStack keyStack;
+ return RecursePropertyMap( mappingRoot, keyStack, theKey, propertyType, value );
+}
- BaseHandle baseHandle;
+bool Builder::RecursePropertyMap( const TreeNode& mappingRoot, KeyStack& keyStack, const char* theKey, Property::Type propertyType, Property::Value& value )
+{
+ Replacement replacer( mReplacementMap );
+ bool result = false;
- OptionalChild templates = IsChild(*mParser.GetRoot(), KEYNAME_TEMPLATES);
+ keyStack.push_back( theKey );
- if( !templates )
- {
- DALI_SCRIPT_WARNING("No template section found to CreateFromTemplate\n");
- }
- else
+ for( TreeNode::ConstIterator iter = mappingRoot.CBegin(); iter != mappingRoot.CEnd(); ++iter )
{
- OptionalChild childTemplate = IsChild(*templates, templateName);
- if(!childTemplate)
- {
- DALI_SCRIPT_WARNING("Template '%s' does not exist in template section\n", templateName.c_str());
- }
- else
+ std::string aKey( (*iter).first );
+ if( aKey.compare( theKey ) == 0 )
{
- OptionalString type = constant.IsString( IsChild(*childTemplate, KEYNAME_TYPE) );
-
- if(!type)
+ if( propertyType == Property::NONE )
{
- DALI_SCRIPT_WARNING("Cannot create template '%s' as template section is missing 'type'\n", templateName.c_str());
+ DeterminePropertyFromNode( (*iter).second, value, replacer );
+ result = true;
}
else
{
- baseHandle = DoCreate( *mParser.GetRoot(), *childTemplate, Actor(), constant );
+ result = DeterminePropertyFromNode( (*iter).second, propertyType, value, replacer );
+ }
+
+ if( result )
+ {
+ ConvertChildValue(mappingRoot, keyStack, value);
}
+ break;
}
}
+ keyStack.pop_back();
- return baseHandle;
+ return result;
}
-BaseHandle Builder::CreateFromJson( const std::string& json )
+bool Builder::ConvertChildValue( const TreeNode& mappingRoot, KeyStack& keyStack, Property::Value& child )
{
- BaseHandle ret;
-
- // merge in new template, hoping no one else has one named '@temp@'
- std::string newTemplate =
- std::string("{\"templates\":{\"@temp@\":") + \
- json + \
- std::string("}}");
+ bool result = false;
- if( mParser.Parse(newTemplate) )
+ switch( child.GetType() )
{
- Replacement replacement( mReplacementMap );
- ret = Create( "@temp@", replacement );
- }
+ case Property::STRING:
+ {
+ std::string value;
+ if( child.Get( value ) )
+ {
+ std::string key;
+ if( GetMappingKey( value, key ) )
+ {
+ // Check key for cycles:
+ result=true;
+ for( KeyStack::iterator iter = keyStack.begin() ; iter != keyStack.end(); ++iter )
+ {
+ if( key.compare(*iter) == 0 )
+ {
+ // key is already in stack; stop.
+ DALI_LOG_WARNING("Detected cycle in stylesheet mapping table:%s\n", key.c_str());
+ child = Property::Value("");
+ result=false;
+ break;
+ }
+ }
- return ret;
-}
+ if( result )
+ {
+ // The following call will overwrite the child with the value
+ // from the mapping.
+ RecursePropertyMap( mappingRoot, keyStack, key.c_str(), Property::NONE, child );
+ result = true;
+ }
+ }
+ }
+ break;
+ }
-bool Builder::ApplyFromJson( Handle& handle, const std::string& json )
-{
- bool ret = false;
+ case Property::MAP:
+ {
+ Property::Map* map = child.GetMap();
+ if( map )
+ {
+ for( Property::Map::SizeType i=0; i < map->Count(); ++i )
+ {
+ Property::Value& child = map->GetValue(i);
+ ConvertChildValue(mappingRoot, keyStack, child);
+ }
+ }
+ break;
+ }
- // merge new style, hoping no one else has one named '@temp@'
- std::string newStyle =
- std::string("{\"styles\":{\"@temp@\":") + \
- json + \
- std::string("}}");
+ case Property::ARRAY:
+ {
+ Property::Array* array = child.GetArray();
+ if( array )
+ {
+ for( Property::Array::SizeType i=0; i < array->Count(); ++i )
+ {
+ Property::Value& child = array->GetElementAt(i);
+ ConvertChildValue(mappingRoot, keyStack, child);
+ }
+ }
+ break;
+ }
- if( mParser.Parse(newStyle) )
- {
- Replacement replacement( mReplacementMap );
- ret = ApplyStyle( "@temp@", handle, replacement );
+ default:
+ // Ignore other types.
+ break;
}
- return ret;
-}
-
-
-BaseHandle Builder::Create( const std::string& templateName )
-{
- Replacement replacement( mReplacementMap );
- return Create( templateName, replacement );
+ return result;
}
-Builder::Builder()
-: mSlotDelegate( this )
+void Builder::SetCustomProperties( const TreeNode& node, Handle& handle, const Replacement& constant,
+ const std::string& childName, Property::AccessMode accessMode )
{
- mParser = Dali::Toolkit::JsonParser::New();
-
- Property::Map defaultDirs;
- defaultDirs[ TOKEN_STRING(DALI_IMAGE_DIR) ] = DALI_IMAGE_DIR;
- defaultDirs[ TOKEN_STRING(DALI_SOUND_DIR) ] = DALI_SOUND_DIR;
- defaultDirs[ TOKEN_STRING(DALI_STYLE_DIR) ] = DALI_STYLE_DIR;
- defaultDirs[ TOKEN_STRING(DALI_STYLE_IMAGE_DIR) ] = DALI_STYLE_IMAGE_DIR;
+ // Add custom properties
+ if( OptionalChild customPropertiesChild = IsChild(node, childName) )
+ {
+ const TreeNode& customPropertiesNode = *customPropertiesChild;
+ const TreeConstIter endIter = customPropertiesNode.CEnd();
+ for( TreeConstIter iter = customPropertiesNode.CBegin(); endIter != iter; ++iter )
+ {
+ const TreeNode::KeyNodePair& keyChild = *iter;
+ std::string key( keyChild.first );
+ Property::Value value;
+ DeterminePropertyFromNode( keyChild.second, value, constant );
- AddConstants( defaultDirs );
+ // Register/Set property.
+ handle.RegisterProperty( key, value, accessMode );
+ }
+ }
}
-Builder::~Builder()
-{
-}
} // namespace Internal
#include <dali-toolkit/devel-api/builder/json-parser.h>
#include <dali-toolkit/devel-api/builder/builder.h>
#include <dali-toolkit/internal/builder/builder-declarations.h>
+#include <dali-toolkit/internal/builder/style.h>
// Warning messages usually displayed
#define DALI_SCRIPT_WARNING(format, args...) \
bool ApplyStyle( const std::string& styleName, Handle& handle );
/**
+ * Lookup the stylename in builder. If it's found in the parse tree,
+ * then return true.
+ * @param[in] styleName The style name to search for
+ * @return true if the stylename exists
+ */
+ bool LookupStyleName( const std::string& styleName );
+
+ /**
+ * Lookup the stylename in the recorded Styles - if it exists,
+ * performs a shallow copy to the passed in style and returns true.
+ * Otherwise it returns false.
+
+ * @param[in] styleName The stylename to search for
+ * @return A const pointer to the style object
+ */
+ const StylePtr GetStyle( const std::string& styleName );
+
+ /**
* @copydoc Toolkit::Builder::AddActors
*/
void AddActors( Actor toActor );
*/
void EmitQuitSignal();
+
protected:
virtual ~Builder();
private:
- // Undefined
- Builder(const Builder&);
- Builder& operator=(const Builder& rhs);
-
- void SetupTask( RenderTask& task, const Toolkit::TreeNode& node, const Replacement& replacement );
-
- void SetCustomProperties( const TreeNode& node, Handle& handle, const Replacement& constant, const std::string& childName, Property::AccessMode accessMode );
-
-private:
- Toolkit::JsonParser mParser;
-
- typedef std::map<const std::string, FrameBufferImage> ImageLut;
- ImageLut mFrameBufferImageLut;
-
- typedef std::map<const std::string, Path> PathLut;
- PathLut mPathLut;
-
- typedef struct{ std::string name; Dali::PathConstrainer pathConstrainer; } PathConstrainerEntry;
- typedef std::vector<PathConstrainerEntry> PathConstrainerLut;
- PathConstrainerLut mPathConstrainerLut;
-
+ typedef std::vector<const char*> KeyStack;
+ typedef std::vector< TreeNode::KeyNodePair > MappingsLut;
typedef struct{ std::string name; Dali::LinearConstrainer linearConstrainer; } LinearConstrainerEntry;
typedef std::vector<LinearConstrainerEntry> LinearConstrainerLut;
- LinearConstrainerLut mLinearConstrainerLut;
-
- SlotDelegate<Builder> mSlotDelegate;
-
- Property::Map mReplacementMap;
-
- typedef std::vector< TreeNode::KeyNodePair > MappingsLut;
- MappingsLut mCompleteMappings;
+ typedef struct{ std::string name; Dali::PathConstrainer pathConstrainer; } PathConstrainerEntry;
+ typedef std::vector<PathConstrainerEntry> PathConstrainerLut;
+ typedef std::map<const std::string, Path> PathLut;
+ typedef std::map<const std::string, FrameBufferImage> ImageLut;
- BaseHandle Create( const std::string& templateName, const Replacement& constant );
+private:
+ // Undefined
+ Builder(const Builder&);
- BaseHandle DoCreate( const TreeNode& root, const TreeNode& node, Actor parent, const Replacement& replacements );
+ // Undefined
+ Builder& operator=(const Builder& rhs);
void LoadConstants( const TreeNode& root, Property::Map& intoMap );
- void LoadIncludes( const std::string& data );
-
- bool ApplyStyle( const std::string& styleName, Handle& handle, const Replacement& replacement);
-
- Animation CreateAnimation( const std::string& animationName, const Replacement& replacement, Dali::Actor sourceActor );
-
- typedef std::vector<const char*> KeyStack;
+ Animation CreateAnimation( const std::string& animationName,
+ const Replacement& replacement,
+ Dali::Actor sourceActor );
+
+ BaseHandle Create( const std::string& templateName,
+ const Replacement& constant );
+
+ BaseHandle DoCreate( const TreeNode& root,
+ const TreeNode& node,
+ Actor parent,
+ const Replacement& replacements );
+
+ void SetupTask( RenderTask& task,
+ const Toolkit::TreeNode& node,
+ const Replacement& replacement );
+
+ bool ApplyStyle( const std::string& styleName,
+ Handle& handle,
+ const Replacement& replacement);
+
+ void ApplyAllStyleProperties( const TreeNode& root,
+ const TreeNode& node,
+ Dali::Handle& handle,
+ const Replacement& constant );
+
+ void RecordStyles( const char* styleName,
+ const TreeNode& node,
+ Dali::Handle& handle,
+ const Replacement& replacements );
+
+ void RecordStyle( StylePtr style,
+ const TreeNode& node,
+ Dali::Handle& handle,
+ const Replacement& replacements );
+
+ void ApplyProperties( const TreeNode& root,
+ const TreeNode& node,
+ Dali::Handle& handle,
+ const Replacement& constant );
+
+ void ApplySignals( const TreeNode& root,
+ const TreeNode& node,
+ Dali::Handle& handle );
+
+ void ApplyStylesByActor( const TreeNode& root,
+ const TreeNode& node,
+ Dali::Handle& handle,
+ const Replacement& constant );
+
+ void SetProperties( const TreeNode& node,
+ Handle& handle,
+ const Replacement& constant );
+
+ bool MapToTargetProperty( Handle& propertyObject,
+ const std::string& key,
+ const TreeNode& node,
+ const Replacement& constant,
+ Property::Index& index,
+ Property::Value& value );
/**
- * Tests if the value is a string delimited by <>. If it is, then it attempts to
- * change the value to the mapping from a matching key in the mappings table.
+ * Find the key in the mapping table, if it's present, then generate
+ * a property value for it (of the given type if available),
+ * recursing as necessary, and stopping if any cycles are detected.
+ *
* @param[in] mappingRoot The JSON node containing the mappings
- * @param[in,out] keyStack the stack of visited keys
+ * @param[in] theKey The key to search for
+ * @param[in] propertyType The property type if known, or NONE
* @param[in,out] value The string value to test and write back to.
- * @return true if the value was converted, false otherwise.
*/
- bool ConvertChildValue( const TreeNode& mappingRoot, KeyStack& keyStack, Property::Value& value );
+ bool GetPropertyMap( const TreeNode& mappingRoot,
+ const char* theKey,
+ Property::Type propertyType,
+ Property::Value& value );
+
+ void SetCustomProperties( const TreeNode& node,
+ Handle& handle,
+ const Replacement& constant,
+ const std::string& childName,
+ Property::AccessMode accessMode );
/**
- * Find the key in the mapping table, if it's present, then generate a property value for it (of the given type if available), recursing as necessary, and stopping if any cycles
- * are detected.
+ * Find the key in the mapping table, if it's present, then generate
+ * a property value for it (of the given type if available),
+ * recursing as necessary, and stopping if any cycles are detected.
+ *
* @param[in] mappingRoot The JSON node containing the mappings
* @param[in] theKey The key to search for
* @param[in,out] keyStack the stack of visited keys
* @param[in] propertyType The property type if known, or NONE
* @param[in,out] value The string value to test and write back to.
*/
- bool RecursePropertyMap( const TreeNode& mappingRoot, KeyStack& keyStack, const char* theKey, Property::Type propertyType, Property::Value& value );
+ bool RecursePropertyMap( const TreeNode& mappingRoot,
+ KeyStack& keyStack,
+ const char* theKey,
+ Property::Type propertyType,
+ Property::Value& value );
+
/**
- * Find the key in the mapping table, if it's present, then generate a property value for it (of the given type if available), recursing as necessary, and stopping if any cycles
- * are detected.
+ * Tests if the value is a string delimited by <>. If it is, then it attempts to
+ * change the value to the mapping from a matching key in the mappings table.
* @param[in] mappingRoot The JSON node containing the mappings
- * @param[in] theKey The key to search for
- * @param[in] propertyType The property type if known, or NONE
+ * @param[in,out] keyStack the stack of visited keys
* @param[in,out] value The string value to test and write back to.
+ * @return true if the value was converted, false otherwise.
*/
- bool GetPropertyMap( const TreeNode& mappingRoot, const char* theKey, Property::Type propertyType, Property::Value& value );
-
- void ApplyProperties( const TreeNode& root, const TreeNode& node,
- Dali::Handle& handle, const Replacement& constant );
-
- void ApplyStylesByActor( const TreeNode& root, const TreeNode& node,
- Dali::Handle& handle, const Replacement& constant );
-
- void ApplyAllStyleProperties( const TreeNode& root, const TreeNode& node,
- Dali::Handle& handle, const Replacement& constant );
-
- void SetProperties( const TreeNode& node, Handle& handle, const Replacement& constant );
+ bool ConvertChildValue( const TreeNode& mappingRoot,
+ KeyStack& keyStack,
+ Property::Value& value );
+private:
+ Toolkit::JsonParser mParser;
+ ImageLut mFrameBufferImageLut;
+ PathLut mPathLut;
+ PathConstrainerLut mPathConstrainerLut;
+ LinearConstrainerLut mLinearConstrainerLut;
+ SlotDelegate<Builder> mSlotDelegate;
+ Property::Map mReplacementMap;
+ MappingsLut mCompleteMappings;
+ Dictionary<StylePtr> mStyles; // State based styles
Toolkit::Builder::BuilderSignalType mQuitSignal;
};
#include <sstream>
#include <dali/public-api/object/property-array.h>
#include <dali/public-api/object/property-map.h>
-#include <dali/devel-api/adaptor-framework/color-controller.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/builder/builder-impl.h>
#include <dali-toolkit/internal/builder/builder-get-is.inl.h>
#include <dali-toolkit/internal/builder/replacement.h>
#include <dali-toolkit/internal/builder/builder-set-property.h>
+#include <dali-toolkit/internal/helpers/color-conversion.h>
namespace Dali
{
namespace Internal
{
-
-namespace
-{
-
-/**
- * Converts a HTML style 'color' hex string ("#FF0000" for bright red) to a Vector4.
- * The Vector4 alpha component will be set to 1.0f
- * @param hexString The HTML style hex string
- * @return a Vector4 containing the new color value
- */
-Vector4 HexStringToVector4( const char* s )
-{
- unsigned int value(0u);
- std::istringstream( s ) >> std::hex >> value;
- return Vector4( ((value >> 16 ) & 0xff ) / 255.0f,
- ((value >> 8 ) & 0xff ) / 255.0f,
- (value & 0xff ) / 255.0f,
- 1.0f );
-}
-
-} // anon namespace
-
-
/**
* 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
}
else if( OptionalString s = replacer.IsString(node) )
{
- if( (*s)[0] == '#' && 7 == (*s).size() )
- {
- value = HexStringToVector4( &(*s)[1] );
- done = true;
- }
- else if( Dali::ColorController::Get() )
- {
- Vector4 color;
- done = Dali::ColorController::Get().RetrieveColor( *s, color );
- value = color;
- }
+ Vector4 color;
+ done = ConvertStringToColor( *s, color );
+ value = color;
}
else if( TreeNode::OBJECT == node.GetType() )
{
--- /dev/null
+#ifndef DALI_TOOLKIT_INTERNAL_BUILDER_DICTIONARY_H
+#define DALI_TOOLKIT_INTERNAL_BUILDER_DICTIONARY_H
+
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dali/public-api/common/vector-wrapper.h>
+#include <algorithm>
+
+namespace Dali
+{
+extern bool CaseInsensitiveStringCompare( const std::string& a, const std::string& b );
+
+namespace Toolkit
+{
+namespace Internal
+{
+
+/**
+ * The Dictionary template class enables a means of storing key-value
+ * pairs where the keys are strings and the value can be a complex
+ * type.
+ *
+ * It enables lookup of keys via case-insensitive match.
+ */
+template<typename EntryType>
+class Dictionary
+{
+private:
+ /**
+ * Element is a key-value pair
+ */
+ struct Element
+ {
+ std::string key;
+ EntryType entry;
+ Element( const std::string&name, EntryType entry )
+ : key( name ),
+ entry( entry )
+ {
+ }
+ };
+ typedef std::vector<Element> Elements;
+ Elements container;
+
+public:
+ /**
+ * Only allow const iteration over the dictionary
+ */
+ typedef typename Elements::const_iterator iterator;
+
+
+ /**
+ * Constructor
+ */
+ Dictionary<EntryType>()
+ {
+ }
+
+ /**
+ * Add a key value pair to the dictionary.
+ * If the entry does not already exist, add it to the dictionary
+ * using a shallow copy
+ */
+ bool Add( const std::string& name, const EntryType& entry )
+ {
+ for( typename Elements::iterator iter = container.begin(); iter != container.end(); ++iter )
+ {
+ if( iter->key == name )
+ {
+ return false;
+ }
+ }
+ container.push_back( Element(name, entry) );
+ return true;
+ }
+
+ /**
+ * Add a key-value pair to the dictionary
+ * If the entry does not already exist, add it to the dictionary
+ * (shallow copy)
+ */
+ bool Add( const char* name, const EntryType& entry )
+ {
+ bool result=false;
+ if( name != NULL )
+ {
+ std::string theName(name);
+ result=Add(theName, entry);
+ }
+ return result;
+ }
+
+ /**
+ * Find the element in the dictionary pointed at by key, and
+ * return a pointer to it, or NULL.
+ */
+ EntryType* Find( const std::string& key ) const
+ {
+ EntryType* result=NULL;
+
+ if( ! key.empty() )
+ {
+ for( typename Elements::iterator iter = container.begin(); iter != container.end(); ++iter )
+ {
+ if( iter->key == key )
+ {
+ result = &(iter->entry);
+ break;
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Find the element in the dictionary pointed at by key, and
+ * return a pointer to it, or NULL
+ */
+ EntryType* Find( const char* key ) const
+ {
+ if( key != NULL )
+ {
+ std::string theKey(key);
+ return Find(theKey);
+ }
+ return NULL;
+ }
+
+ /**
+ * Find the element in the dictionary pointed at by key using a case
+ * insensitive search, and return a const pointer to it, or NULL
+ */
+ const EntryType* FindCaseInsensitiveC( const std::string& key ) const
+ {
+ if( ! key.empty() )
+ {
+ for( typename Elements::const_iterator iter = container.begin(); iter != container.end(); ++iter )
+ {
+ if( Dali::CaseInsensitiveStringCompare(iter->key, key ))
+ {
+ const EntryType* result = &(iter->entry);
+ return result;
+ }
+ }
+ }
+ return NULL;
+ }
+
+ /**
+ * Find the element in the dictionary pointed at by key using a case
+ * insensitive search, and return a non-const pointer to it, or NULL
+ */
+ EntryType* FindCaseInsensitive( const std::string& key ) const
+ {
+ EntryType* result = NULL;
+ if( ! key.empty() )
+ {
+ for( typename Elements::const_iterator iter = container.begin(); iter != container.end(); ++iter )
+ {
+ if( Dali::CaseInsensitiveStringCompare(iter->key, key ))
+ {
+ // Const cast because of const_iterator. const_iterator because, STL.
+ result = const_cast<EntryType*>(&(iter->entry));
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Find the element in the dictionary pointed at by key using a case
+ * insensitive search, and return a const pointer to it, or NULL
+ */
+ const EntryType* FindCaseInsensitiveC( const char* key ) const
+ {
+ if( key != NULL )
+ {
+ std::string theKey(key);
+ return FindCaseInsensitiveC( theKey );
+ }
+ return NULL;
+ }
+
+ /**
+ * Find the element in the dictionary pointed at by key using a case
+ * insensitive search, and return a non-const pointer to it, or NULL
+ */
+ EntryType* FindCaseInsensitive( const char* key ) const
+ {
+ if( key != NULL )
+ {
+ std::string theKey(key);
+ return FindCaseInsensitive( theKey );
+ }
+ return NULL;
+ }
+
+ /**
+ * Return an iterator pointing at the first entry in the dictionary
+ */
+ typename Elements::const_iterator Begin() const
+ {
+ return container.begin();
+ }
+
+ /**
+ * Return an iterator pointing past the last entry in the dictionary
+ */
+ typename Elements::const_iterator End() const
+ {
+ return container.end();
+ }
+};
+
+
+
+}//Internal
+}//Toolkit
+}//Dali
+
+#endif // DALI_TOOLKIT_INTERNAL_BUILDER_DICTIONARY_H
--- /dev/null
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dali/public-api/object/handle.h>
+#include <dali-toolkit/public-api/controls/control.h>
+#include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/internal/builder/style.h>
+
+namespace Dali
+{
+namespace Toolkit
+{
+namespace Internal
+{
+
+StylePtr Style::New()
+{
+ StylePtr stylePtr( new Style() );
+ return stylePtr;
+}
+
+void Style::ApplyVisualsAndPropertiesRecursively( Handle handle ) const
+{
+ ApplyVisuals( handle );
+ ApplyProperties( handle );
+
+ Toolkit::Control control = Toolkit::Control::DownCast(handle);
+ if( control )
+ {
+ Property::Value value = control.GetProperty(DevelControl::Property::STATE);
+ std::string stateName;
+ if( value.Get( stateName ) )
+ {
+ // Look up state in states table:
+ const StylePtr* stylePtr = subStates.FindCaseInsensitiveC( stateName );
+ if( stylePtr )
+ {
+ const StylePtr statePtr(*stylePtr);
+
+ // We have a state match.
+ statePtr->ApplyVisuals( handle );
+ statePtr->ApplyProperties( handle );
+
+ // Apply substate visuals
+ Property::Value value = control.GetProperty(DevelControl::Property::SUB_STATE);
+ std::string subStateName;
+ if( value.Get( subStateName ) && ! subStateName.empty() )
+ {
+ const StylePtr* stylePtr = statePtr->subStates.FindCaseInsensitiveC( subStateName );
+ if( stylePtr )
+ {
+ const StylePtr subStatePtr(*stylePtr);
+ // We have a sub-state match.
+ subStatePtr->ApplyVisuals( handle );
+ subStatePtr->ApplyProperties( handle );
+ }
+ }
+ }
+ }
+ }
+}
+
+void Style::ApplyVisuals( Handle handle ) const
+{
+ for( Dictionary<Property::Map>::iterator iter = visuals.Begin(); iter != visuals.End() ; ++iter )
+ {
+ const std::string& visualName = (*iter).key;
+ const Property::Map& map = (*iter).entry;
+ Dali::Property::Index index = handle.GetPropertyIndex( visualName );
+ if( index != Property::INVALID_INDEX )
+ {
+ const Property::Value value(const_cast<Property::Map&>(map));
+ handle.SetProperty( index, value );
+ }
+ }
+}
+
+void Style::ApplyProperties( Handle handle ) const
+{
+ for( Property::Map::SizeType i=0; i<properties.Count(); ++i )
+ {
+ KeyValuePair keyValue = properties.GetKeyValue( i );
+ if( keyValue.first.type == Property::Key::INDEX )
+ {
+ handle.SetProperty( keyValue.first.indexKey, keyValue.second );
+ }
+ }
+}
+
+Style::Style()
+{
+}
+
+Style::~Style()
+{
+}
+
+
+} // Internal
+} // Toolkit
+} // Dali
--- /dev/null
+#ifndef DALI_TOOLKIT_INTERNAL_BUILDER_STYLE_H
+#define DALI_TOOLKIT_INTERNAL_BUILDER_STYLE_H
+
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dali/public-api/object/ref-object.h>
+#include <dali-toolkit/devel-api/visual-factory/transition-data.h>
+#include <dali-toolkit/internal/builder/dictionary.h>
+
+namespace Dali
+{
+namespace Toolkit
+{
+namespace Internal
+{
+
+class Style;
+typedef IntrusivePtr<Style> StylePtr;
+
+/**
+ * This class encapsulates the style information for a given styled
+ * control. It is generated only when a control instance looks up
+ * it's style information for the first time, and then stored by
+ * Builder.
+ *
+ * It contains the visual, property and transition definitions for the
+ * main control and for each state and sub-state within the control.
+ *
+ * It has methods to enable the base control to apply visuals and
+ * properties per state.
+ */
+class Style : public RefObject
+{
+public:
+ static StylePtr New();
+
+public:
+ /**
+ * Apply the visuals and properties for the current state/substate
+ * of the handle to the control pointed at by handle. Recurses
+ * through sub-states.
+ *
+ * @param[in] handle The handle to apply the visuals to
+ */
+ void ApplyVisualsAndPropertiesRecursively( Handle handle ) const;
+
+
+private:
+ /**
+ * Apply the visuals of the style to the control pointed at by
+ * handle.
+ *
+ * @param[in] handle The handle to apply the visuals to
+ */
+ void ApplyVisuals( Handle handle ) const;
+
+ /**
+ * Apply the properties of the style to the control pointed at by
+ * handle.
+ *
+ * @param[in] handle The handle to apply the properties to
+ */
+ void ApplyProperties( Handle handle ) const;
+
+protected:
+ /**
+ * @brief Default constructor.
+ */
+ Style();
+
+ /**
+ * @brief virtual destructor.
+ */
+ virtual ~Style();
+
+private:
+ // Not implemented
+ DALI_INTERNAL Style( const Style& rhs );
+
+ // Not implemented
+ DALI_INTERNAL Style& operator=(const Style& rhs);
+
+public:
+ // Everything must be shallow-copiable.
+ Dictionary<StylePtr> subStates; // Each named style maps to a state.
+ Dictionary<Property::Map> visuals;
+ Property::Map properties;
+ Property::Array transitions;
+ Toolkit::TransitionData entryTransition;
+ Toolkit::TransitionData exitTransition;
+};
+
+} // Internal
+} // Toolkit
+} // Dali
+
+
+#endif //DALI_TOOLKIT_INTERNAL_BUILDER_STYLE_H
}
mIndicator = indicator;
- Toolkit::Control control = Toolkit::Control::DownCast( mIndicator );
- if( control )
- {
- control.SetStyleName( "ScrollBarIndicator" );
- }
-
mIndicatorFirstShow = true;
Self().Add( mIndicator );
#include <dali/public-api/events/touch-data.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
-#include <dali/public-api/images/resource-image.h>
+#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control-impl.h>
{
if( mPopup && ( filename.size() > 0 ) )
{
- Image image = ResourceImage::New( filename );
- mPopup.SetImage( image );
+ Property::Map map;
+ map[Toolkit::ImageVisual::Property::URL] = filename;
+ mPopup.SetProperty( Toolkit::ImageView::Property::IMAGE, map );
}
}
{
if( mPopupArrow && ( filename.size() > 0 ) )
{
- Image image = ResourceImage::New( filename );
- mPopupArrow.SetImage( image );
+ Property::Map map;
+ map[Toolkit::ImageVisual::Property::URL] = filename;
+ mPopupArrow.SetProperty( Toolkit::ImageView::Property::IMAGE, map );
}
}
#include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup-callback-interface.h>
#include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
+#include <dali-toolkit/internal/helpers/color-conversion.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
namespace Dali
{
namespace
{
-// todo Move this to adaptor??
+
#define GET_LOCALE_TEXT(string) dgettext("dali-toolkit", string)
const std::string TEXT_SELECTION_POPUP_BUTTON_STYLE_NAME( "TextSelectionPopupButton" );
DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupPressedImage", STRING, POPUP_PRESSED_IMAGE )
DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupFadeInDuration", FLOAT, POPUP_FADE_IN_DURATION )
DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupFadeOutDuration", FLOAT, POPUP_FADE_OUT_DURATION )
+DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "backgroundBorder", MAP, BACKGROUND_BORDER )
DALI_TYPE_REGISTRATION_END()
impl.mFadeOutDuration = value.Get < float >();
break;
}
+ case Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER:
+ {
+ Property::Map map = value.Get<Property::Map>();
+ impl.CreateBackgroundBorder( map );
+ break;
+ }
} // switch
} // TextSelectionPopup
}
value = impl.mFadeOutDuration;
break;
}
+ case Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER:
+ {
+ Property::Map map;
+ Toolkit::Visual::Base visual = impl.GetVisual( Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER );
+ if( visual )
+ {
+ visual.CreatePropertyMap( map );
+ }
+ value = map;
+ break;
+ }
} // switch
}
return value;
}
}
+void TextSelectionPopup::CreateBackgroundBorder( Property::Map& propertyMap )
+{
+ // Removes previous image if necessary
+ UnregisterVisual( Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER );
+
+ if( ! propertyMap.Empty() )
+ {
+ Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual( propertyMap );
+
+ if( visual )
+ {
+ RegisterVisual( Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER, visual );
+ visual.SetDepthIndex( DepthIndex::CONTENT );
+ }
+ }
+}
+
TextSelectionPopup::TextSelectionPopup( TextSelectionPopupCallbackInterface* callbackInterface )
: Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
mToolbar(),
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/controls/buttons/push-button.h>
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
#include <dali-toolkit/public-api/controls/table-view/table-view.h>
#include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup.h>
#include <dali-toolkit/devel-api/controls/text-controls/text-selection-toolbar.h>
// EXTERNAL INCLUDES
#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/object/property-map.h>
namespace Dali
{
void AddPopupOptionsToToolbar( bool showIcons, bool showCaptions );
/**
+ * Creates the background-border image
+ *
+ * @param[in] propertyMap The properties describing the background-border
+ */
+ void CreateBackgroundBorder( Property::Map& propertyMap );
+
+ /**
* Construct a new TextField.
*/
TextSelectionPopup( TextSelectionPopupCallbackInterface* callbackInterface );
{
if( ! mScrollBar )
{
+ Toolkit::ImageView indicator = Toolkit::ImageView::New();
+ indicator.SetParentOrigin( ParentOrigin::TOP_LEFT );
+ indicator.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+ indicator.SetStyleName( "TextSelectionScrollIndicator" );
+
mScrollBar = Toolkit::ScrollBar::New( Toolkit::ScrollBar::Horizontal );
mScrollBar.SetName( "Text popup scroll bar" );
+ mScrollBar.SetStyleName( "TextSelectionScrollBar" );
mScrollBar.SetParentOrigin( ParentOrigin::BOTTOM_LEFT );
mScrollBar.SetAnchorPoint( AnchorPoint::TOP_LEFT );
mScrollBar.SetPosition( mScrollBarPadding.x, -mScrollBarPadding.y );
mScrollBar.SetResizePolicy( Dali::ResizePolicy::FIT_TO_CHILDREN, Dali::Dimension::WIDTH );
mScrollBar.SetOrientation( Quaternion( Radian( 1.5f * Math::PI ), Vector3::ZAXIS ) );
+ mScrollBar.SetScrollIndicator( indicator );
mScrollBar.GetPanGestureDetector().DetachAll();
mScrollView.Add( mScrollBar );
}
$(toolkit_src_dir)/builder/builder-signals.cpp \
$(toolkit_src_dir)/builder/json-parser-state.cpp \
$(toolkit_src_dir)/builder/json-parser-impl.cpp \
+ $(toolkit_src_dir)/builder/style.cpp \
$(toolkit_src_dir)/builder/tree-node-manipulator.cpp \
$(toolkit_src_dir)/builder/replacement.cpp \
$(toolkit_src_dir)/visuals/visual-base-impl.cpp \
$(toolkit_src_dir)/visuals/gradient/linear-gradient.cpp \
$(toolkit_src_dir)/visuals/gradient/radial-gradient.cpp \
$(toolkit_src_dir)/visuals/gradient/gradient-visual.cpp \
- $(toolkit_src_dir)/visuals/image/batch-image-visual.cpp \
$(toolkit_src_dir)/visuals/image/image-visual.cpp \
$(toolkit_src_dir)/visuals/mesh/mesh-visual.cpp \
$(toolkit_src_dir)/visuals/npatch/npatch-visual.cpp \
\
$(toolkit_src_dir)/focus-manager/keyboard-focus-manager-impl.cpp \
$(toolkit_src_dir)/focus-manager/keyinput-focus-manager-impl.cpp \
+ $(toolkit_src_dir)/helpers/color-conversion.cpp \
$(toolkit_src_dir)/helpers/property-helper.cpp \
$(toolkit_src_dir)/filters/blur-two-pass-filter.cpp \
$(toolkit_src_dir)/filters/emboss-filter.cpp \
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
#include <dali-toolkit/public-api/accessibility-manager/accessibility-manager.h>
#include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
+#include <dali-toolkit/devel-api/controls/control-devel.h>
namespace Dali
{
mCurrentFocusActor( 0 ),
mFocusIndicatorActor(),
mFocusGroupLoopEnabled( false ),
- mIsKeyboardFocusEnabled( false ),
mIsFocusIndicatorEnabled( false ),
mIsWaitingKeyboardFocusChangeCommit( false ),
mFocusHistory(),
mSlotDelegate( this )
{
- OnPhysicalKeyboardStatusChanged(PhysicalKeyboard::Get());
-
+ // TODO: Get FocusIndicatorEnable constant from stylesheet to set mIsFocusIndicatorEnabled.
Toolkit::KeyInputFocusManager::Get().UnhandledKeyEventSignal().Connect(mSlotDelegate, &KeyboardFocusManager::OnKeyEvent);
Stage::GetCurrent().TouchSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
- PhysicalKeyboard::Get().StatusChangedSignal().Connect(mSlotDelegate, &KeyboardFocusManager::OnPhysicalKeyboardStatusChanged);
}
KeyboardFocusManager::~KeyboardFocusManager()
// Check whether the actor is in the stage and is keyboard focusable.
if( actor && actor.IsKeyboardFocusable() )
{
- mIsFocusIndicatorEnabled = true;
- // Draw the focus indicator upon the focused actor when PhysicalKeyboard is attached
- if( mIsKeyboardFocusEnabled )
+ if( mIsFocusIndicatorEnabled )
{
actor.Add( GetFocusIndicatorActor() );
}
// Send notification for the change of focus actor
+ Actor currentFocusedActor = GetCurrentFocusActor();
+
if( !mFocusChangedSignal.Empty() )
{
- mFocusChangedSignal.Emit(GetCurrentFocusActor(), actor);
+ mFocusChangedSignal.Emit(currentFocusedActor, actor);
+ }
+
+ Toolkit::Control currentlyFocusedControl = Toolkit::Control::DownCast(currentFocusedActor);
+ if( currentlyFocusedControl )
+ {
+ // Do we need it to remember if it was previously DISABLED?
+ currentlyFocusedControl.SetProperty(DevelControl::Property::STATE, DevelControl::NORMAL );
}
DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] Focus Changed\n", __FUNCTION__, __LINE__);
// Save the current focused actor
mCurrentFocusActor = actorID;
+ Toolkit::Control newlyFocusedControl = Toolkit::Control::DownCast(actor);
+ if( newlyFocusedControl )
+ {
+ newlyFocusedControl.SetProperty(DevelControl::Property::STATE, DevelControl::FOCUSED );
+ }
+
// Push Current Focused Actor to FocusHistory
mFocusHistory.PushBack( &actor.GetBaseObject() );
void KeyboardFocusManager::ClearFocus()
{
Actor actor = GetCurrentFocusActor();
- if(actor)
+ if( actor )
{
- if(mFocusIndicatorActor)
+ if( mFocusIndicatorActor )
{
- actor.Remove(mFocusIndicatorActor);
+ actor.Remove( mFocusIndicatorActor );
}
// Send notification for the change of focus actor
if( !mFocusChangedSignal.Empty() )
{
- mFocusChangedSignal.Emit(actor, Actor());
+ mFocusChangedSignal.Emit( actor, Actor() );
+ }
+
+ Toolkit::Control currentlyFocusedControl = Toolkit::Control::DownCast( actor );
+ if( currentlyFocusedControl )
+ {
+ currentlyFocusedControl.SetProperty( DevelControl::Property::STATE, DevelControl::NORMAL );
}
}
return mFocusIndicatorActor;
}
-void KeyboardFocusManager::OnPhysicalKeyboardStatusChanged(PhysicalKeyboard keyboard)
-{
- mIsKeyboardFocusEnabled = keyboard.IsAttached();
-
- if(mIsKeyboardFocusEnabled)
- {
- // Show indicator when keyboard focus turned on if there is focused actor.
- Actor actor = GetCurrentFocusActor();
- if(actor)
- {
- actor.Add( GetFocusIndicatorActor() );
- }
- mIsFocusIndicatorEnabled = true;
- }
- else
- {
- // Hide indicator when keyboard focus turned off
- Actor actor = GetCurrentFocusActor();
- if( actor && mFocusIndicatorActor )
- {
- actor.Remove( mFocusIndicatorActor );
- }
- mIsFocusIndicatorEnabled = false;
- }
-}
-
void KeyboardFocusManager::OnKeyEvent(const KeyEvent& event)
{
- if(!mIsKeyboardFocusEnabled)
- {
- return;
- }
-
AccessibilityAdaptor accessibilityAdaptor = AccessibilityAdaptor::Get();
bool isAccessibilityEnabled = accessibilityAdaptor.IsEnabled();
*/
// EXTERNAL INCLUDES
-#include <string>
-#include <dali/devel-api/adaptor-framework/physical-keyboard.h>
#include <dali/public-api/object/base-object.h>
// INTERNAL INCLUDES
*/
void OnTouch( const TouchData& touch );
- /**
- * Change the keyboard focus status when keyboard focus feature turned on or off.
- * @return Whether the status is changed or not.
- */
- void OnPhysicalKeyboardStatusChanged(PhysicalKeyboard keyboard);
-
private:
// Undefined
bool mFocusGroupLoopEnabled:1; ///< Whether the focus movement is looped within the same focus group
- bool mIsKeyboardFocusEnabled:1; ///< Whether keyboard focus feature turned on/off
-
bool mIsFocusIndicatorEnabled:1; ///< Whether indicator should be shown / hidden. It could be enabled when keyboard focus feature enabled and navigation keys or 'Tab' key pressed.
bool mIsWaitingKeyboardFocusChangeCommit:1; /// A flag to indicate PreFocusChangeSignal emitted but the proposed focus actor is not commited by the application yet.
--- /dev/null
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// CLASS HEADER
+#include <dali-toolkit/internal/helpers/color-conversion.h>
+
+// EXTERNAL INCLUDES
+#include <sstream>
+#include <dali/public-api/math/vector4.h>
+#include <dali/devel-api/adaptor-framework/color-controller.h>
+
+using Dali::Vector4;
+
+namespace
+{
+
+/**
+ * Converts a HTML style 'color' hex string ("#FF0000" for bright red) to a Vector4.
+ * The Vector4 alpha component will be set to 1.0f
+ * @param hexString The HTML style hex string
+ * @return a Vector4 containing the new color value
+ */
+Vector4 HexStringToVector4( const char* s )
+{
+ unsigned int value(0u);
+ std::istringstream( s ) >> std::hex >> value;
+ return Vector4( ((value >> 16 ) & 0xff ) / 255.0f,
+ ((value >> 8 ) & 0xff ) / 255.0f,
+ (value & 0xff ) / 255.0f,
+ 1.0f );
+}
+
+} // unnamed namespace
+
+namespace Dali
+{
+namespace Toolkit
+{
+namespace Internal
+{
+
+bool ConvertStringToColor( const std::string& colorString, Vector4& outColor )
+{
+ bool success( false );
+
+ if( ( '#' == colorString[0] ) &&
+ ( 7 == colorString.size() ) )
+ {
+ const char* cString = colorString.c_str();
+ outColor = HexStringToVector4( &cString[1] );
+ success = true;
+ }
+ else
+ {
+ Dali::ColorController controller = Dali::ColorController::Get();
+
+ if( controller )
+ {
+ success = controller.RetrieveColor( colorString, outColor );
+ }
+ }
+
+ return success;
+}
+
+bool ConvertPropertyToColor( const Property::Value& colorValue, Vector4& outColor )
+{
+ bool success( false );
+
+ if( Property::VECTOR4 == colorValue.GetType() )
+ {
+ success = colorValue.Get( outColor );
+ }
+ else if( Property::STRING == colorValue.GetType() )
+ {
+ std::string colorString;
+ if( colorValue.Get( colorString ) )
+ {
+ success = ConvertStringToColor( colorString, outColor );
+ }
+ }
+
+ return success;
+}
+
+} // Internal
+} // Toolkit
+} // Dali
--- /dev/null
+#ifndef DALI_TOOLKIT_INTERNAL_COLOR_CONVERSION_H
+#define DALI_TOOLKIT_INTERNAL_COLOR_CONVERSION_H
+
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// EXTERNAL INCLUDES
+#include <string>
+#include <dali/public-api/object/property.h>
+
+namespace Dali
+{
+
+class Vector4;
+
+namespace Toolkit
+{
+namespace Internal
+{
+
+/*
+ * @brief Convert the string representation of a color into a Vector4.
+ *
+ * The supported string formats are:
+ * 1) An HTML style 'color' hex string ("#FF0000" for bright red).
+ * 2) An ID referring to the color palette of the current theme e.g. "B018"
+ *
+ * @param[in] colorString The color in string format.
+ * @param[out] outColor The color if found.
+ * @return True if the conversion was successful.
+ */
+bool ConvertStringToColor( const std::string& colorString, Vector4& outColor );
+
+/*
+ * @brief Convert a variety of different color representations into a Vector4.
+ *
+ * @param[in] colorValue The color in Vector4 or string format.
+ * @param[out] outColor The color if found.
+ * @return True if the conversion was successful.
+ */
+bool ConvertPropertyToColor( const Property::Value& colorValue, Vector4& outColor );
+
+} // Internal
+} // Toolkit
+} // Dali
+
+
+#endif // DALI_TOOLKIT_INTERNAL_COLOR_CONVERSION_H
#include <dali/public-api/adaptor-framework/application.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/internal/builder/builder-impl.h>
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/styling/style-manager.h>
}
}
-void StyleManager::CollectQualifiers( StringList& qualifiersOut )
+static void CollectQualifiers( std::vector<std::string>& qualifiersOut )
{
// Append the relevant qualifier for orientation
int orientation = 0; // Get the orientation from the system
}
}
-void StyleManager::BuildQualifiedStyleName( const std::string& styleName, const StringList& qualifiers, std::string& qualifiedStyleOut )
+/**
+ * @brief Construct a qualified style name out of qualifiers
+ *
+ * A qualifed style name will be in the format: style-qualifier0-qualifier1-qualifierN
+ *
+ * @param[in] styleName The root name of the style
+ * @param[in] qualifiers List of qualifier names
+ * @param[out] qualifiedStyleOut The qualified style name
+ */
+static void BuildQualifiedStyleName(
+ const std::string& styleName,
+ const std::vector<std::string>& qualifiers,
+ std::string& qualifiedStyleOut )
{
qualifiedStyleOut.append( styleName );
- for( StringList::const_iterator it = qualifiers.begin(), itEnd = qualifiers.end(); it != itEnd; ++it )
+ for( std::vector<std::string>::const_iterator it = qualifiers.begin(),
+ itEnd = qualifiers.end(); it != itEnd; ++it )
{
const std::string& str = *it;
}
}
-void StyleManager::ApplyStyle( Toolkit::Builder builder, Toolkit::Control control )
+static bool GetStyleNameForControl( Toolkit::Builder builder, Toolkit::Control control, std::string& styleName)
{
- std::string styleName = control.GetStyleName();
+ styleName = control.GetStyleName();
if( styleName.empty() )
{
}
// Apply the style after choosing the correct actual style (e.g. landscape or portrait)
- StringList qualifiers;
+ std::vector<std::string> qualifiers;
CollectQualifiers( qualifiers );
- while( true )
+ bool found = 0;
+ std::string qualifiedStyleName;
+ do
{
- std::string qualifiedStyleName;
+ qualifiedStyleName.clear();
BuildQualifiedStyleName( styleName, qualifiers, qualifiedStyleName );
// Break if style found or we have tried the root style name (qualifiers is empty)
- if( builder.ApplyStyle( qualifiedStyleName, control ) || qualifiers.size() == 0 )
+ if( GetImpl(builder).LookupStyleName( qualifiedStyleName ) )
+ {
+ found = true;
+ break;
+ }
+ if( qualifiers.size() == 0 )
{
break;
}
-
// Remove the last qualifier in an attempt to find a style that is valid
qualifiers.pop_back();
+ } while (!found);
+
+ if(found)
+ {
+ styleName = qualifiedStyleName;
+ }
+ return found;
+}
+
+void StyleManager::ApplyStyle( Toolkit::Builder builder, Toolkit::Control control )
+{
+ std::string styleName = control.GetStyleName();
+ if( GetStyleNameForControl( builder, control, styleName ) )
+ {
+ builder.ApplyStyle( styleName, control );
}
if( mDefaultFontSize >= 0 )
}
}
+const StylePtr StyleManager::GetRecordedStyle( Toolkit::Control control )
+{
+ if( mThemeBuilder )
+ {
+ std::string styleName = control.GetStyleName();
+
+ if( GetStyleNameForControl( mThemeBuilder, control, styleName ) )
+ {
+ const StylePtr style = GetImpl(mThemeBuilder).GetStyle( styleName );
+ return style;
+ }
+ }
+ return StylePtr(NULL);
+}
+
Toolkit::Builder StyleManager::FindCachedBuilder( const std::string& key )
{
BuilderMap::iterator builderIt = mBuilderCache.find( key );
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/styling/style-manager.h>
#include <dali-toolkit/devel-api/builder/builder.h>
+#include <dali-toolkit/internal/builder/style.h>
namespace Dali
{
public: // Public API
-/**
+ /**
* @copydoc Toolkit::StyleManager::ApplyTheme
*/
void ApplyTheme( const std::string& themeFile );
*/
void ApplyStyle( Toolkit::Control control, const std::string& jsonFileName, const std::string& styleName );
+ /**
+ * Get the state/style information for the given control
+ * @param[in] control The control to get state information for
+ * @return The style information (or empty ptr if not found)
+ */
+ const StylePtr GetRecordedStyle( Toolkit::Control control );
+
public:
// SIGNALS
bool LoadJSON( Toolkit::Builder builder, const std::string& jsonFileName );
/**
- * @brief Collect qualifiers (e.g. Landscape, portrait etc) for a given style
- *
- * @param[in,out] qualifiersOut The list to populate with qualifiers
- */
- void CollectQualifiers( StringList& qualifiersOut );
-
- /**
- * @brief Construct a qualified style name out of qualifiers
- *
- * A qualifed style name will be in the format: style-qualifier0-qualifier1-qualifierN
- *
- * @param[in] styleName The root name of the style
- * @param[in] qualifiers List of qualifier names
- * @param[out] qualifiedStyleOut The qualified style name
- */
- void BuildQualifiedStyleName( const std::string& styleName, const StringList& qualifiers, std::string& qualifiedStyleOut );
-
- /**
* @brief Apply a style to the control using the given builder
*
* @param[in] builder The builder to apply the style from
const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
uniform lowp vec4 uColor;\n
uniform lowp vec4 borderColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
\n
void main()\n
{\n
- gl_FragColor = mixColor*borderColor*uColor;\n
+ gl_FragColor = vec4(mixColor, opacity)*borderColor*uColor;\n
}\n
);
const char* FRAGMENT_SHADER_ANTI_ALIASING = DALI_COMPOSE_SHADER(
uniform lowp vec4 uColor;\n
uniform lowp vec4 borderColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
uniform mediump float borderSize;\n
varying mediump float vAlpha;\n
\n
void main()\n
{\n
- gl_FragColor = mixColor*borderColor*uColor;\n
+ gl_FragColor = vec4(mixColor, opacity)*borderColor*uColor;\n
gl_FragColor.a *= smoothstep(0.0, 1.5, vAlpha)*smoothstep( borderSize+1.5, borderSize, vAlpha );\n
}\n
);
const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
\n
void main()\n
{\n
- gl_FragColor = mixColor*uColor;\n
+ gl_FragColor = vec4(mixColor, opacity)*uColor;\n
}\n
);
}
Vector4 color;
if( colorValue->Get( color ) )
{
- SetMixColor( color );
+ Property::Type type = colorValue->GetType();
+ if( type == Property::VECTOR4 )
+ {
+ SetMixColor( color );
+ }
+ else if( type == Property::VECTOR3 )
+ {
+ Vector3 color3(color);
+ SetMixColor( color3 );
+ }
}
else
{
// ColorVisual has it's own index key for mix color - use this instead
// of using the new base index to avoid changing existing applications
// String keys will get to this property.
- mImpl->mMixColorIndex = DevelHandle::RegisterProperty( mImpl->mRenderer, Toolkit::ColorVisual::Property::MIX_COLOR, MIX_COLOR, mImpl->mMixColor );
+ mImpl->mMixColorIndex = DevelHandle::RegisterProperty( mImpl->mRenderer, Toolkit::ColorVisual::Property::MIX_COLOR, MIX_COLOR, Vector3(mImpl->mMixColor) );
+
if( mImpl->mMixColor.a < 1.f )
{
mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
DALI_COMPOSE_SHADER(
uniform sampler2D sTexture;\n // sampler1D?
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
varying mediump vec2 vTexCoord;\n
\n
void main()\n
{\n
- gl_FragColor = texture2D( sTexture, vec2( vTexCoord.y, 0.5 ) ) * vec4(mixColor.rgb*mixColor.a, mixColor.a) * uColor;\n
+ gl_FragColor = texture2D( sTexture, vec2( vTexCoord.y, 0.5 ) ) * vec4(mixColor*opacity, opacity) * uColor;\n
}\n
),
DALI_COMPOSE_SHADER(
uniform sampler2D sTexture;\n // sampler1D?
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
varying mediump vec2 vTexCoord;\n
\n
void main()\n
{\n
- gl_FragColor = texture2D( sTexture, vec2( length(vTexCoord), 0.5 ) ) * vec4(mixColor.rgb*mixColor.a, mixColor.a) * uColor;\n
+ gl_FragColor = texture2D( sTexture, vec2( length(vTexCoord), 0.5 ) ) * vec4(mixColor*opacity, opacity) * uColor;\n
}\n
)
};
+++ /dev/null
-/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// CLASS HEADER
-#include "batch-image-visual.h"
-
-// EXTERNAL HEADER
-#include <cstring> // for strncasecmp
-#include <dali/public-api/images/resource-image.h>
-#include <dali/public-api/images/native-image.h>
-#include <dali/integration-api/debug.h>
-#include <dali/devel-api/adaptor-framework/bitmap-loader.h>
-#include <dali/devel-api/rendering/renderer-devel.h>
-#include <dali/public-api/images/pixel-data.h>
-#include <dali/public-api/rendering/texture.h>
-#include <dali/public-api/rendering/texture-set.h>
-#include <dali/public-api/rendering/texture-set.h>
-
-// INTERNAL HEADER
-#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
-#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
-#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
-#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
-#include <dali-toolkit/internal/visuals/visual-base-impl.h>
-#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
-#include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali-toolkit/internal/visuals/image-atlas-manager.h>
-
-namespace Dali
-{
-
-namespace Toolkit
-{
-
-namespace Internal
-{
-
-namespace
-{
-const char HTTP_URL[] = "http://";
-const char HTTPS_URL[] = "https://";
-
-// Properties:
-const char * const DESIRED_WIDTH( "desiredWidth" );
-const char * const DESIRED_HEIGHT( "desiredHeight" );
-
-const Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
-
-// The shader used for batched rendering. It uses interleaved data for
-// attributes. Limitation is that all batched renderers will share same set of uniforms.
-const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
- attribute mediump vec2 aPosition;\n
- attribute mediump vec2 aTexCoord;\n
- uniform mediump mat4 uMvpMatrix;\n
- varying mediump vec2 vTexCoord;\n
- \n
- void main()\n
- {\n
- vTexCoord = aTexCoord;\n
- gl_Position = uMvpMatrix * vec4( aPosition, 0.0, 1.0 );\n
- }\n
-);
-
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
- varying mediump vec2 vTexCoord;\n
- uniform sampler2D sTexture;\n
- uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
- uniform lowp float preMultipliedAlpha;\n
- lowp vec4 visualMixColor()\n
- {\n
- return vec4( mixColor.rgb * mix( 1.0, mixColor.a, preMultipliedAlpha ), mixColor.a );\n
- }\n
- \n
- void main()\n
- {\n
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * visualMixColor();
- }\n
-);
-
-} // unnamed namespace
-
-BatchImageVisualPtr BatchImageVisual::New( VisualFactoryCache& factoryCache, const std::string& url, const Property::Map& properties )
-{
- BatchImageVisualPtr visual = new BatchImageVisual( factoryCache );
- visual->mImageUrl = url;
- visual->SetProperties( properties );
-
- return visual;
-}
-
-BatchImageVisual::BatchImageVisual( VisualFactoryCache& factoryCache )
-: Visual::Base( factoryCache ),
- mImageUrl(""),
- mDesiredSize()
-{
-}
-
-BatchImageVisual::~BatchImageVisual()
-{
-}
-
-void BatchImageVisual::DoSetProperties( const Property::Map& propertyMap )
-{
- // url already passed in constructor
-
- for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
- {
- KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
- if( keyValue.first.type == Property::Key::INDEX )
- {
- DoSetProperty( keyValue.first.indexKey, keyValue.second );
- }
- else
- {
- if( keyValue.first == DESIRED_WIDTH )
- {
- DoSetProperty( Toolkit::ImageVisual::Property::DESIRED_WIDTH, keyValue.second );
- }
- else if( keyValue.first == DESIRED_HEIGHT )
- {
- DoSetProperty( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, keyValue.second );
- }
- }
- }
-}
-
-void BatchImageVisual::DoSetProperty( Property::Index index, const Property::Value& value )
-{
- switch( index )
- {
- case Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH:
- {
- int width;
- if( value.Get( width ) )
- {
- mDesiredSize.SetWidth( width );
- }
- else
- {
- DALI_LOG_ERROR("BatchImageVisual: width property has incorrect type\n");
- }
- break;
- }
- case Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT:
- {
- int height;
- if( value.Get( height ) )
- {
- mDesiredSize.SetHeight( height );
- }
- else
- {
- DALI_LOG_ERROR("BatchImageVisual: height property has incorrect type\n");
- }
- break;
- }
- }
-}
-
-void BatchImageVisual::GetNaturalSize( Vector2& naturalSize )
-{
- if( mDesiredSize.GetWidth() > 0 && mDesiredSize.GetHeight() > 0 )
- {
- naturalSize.x = mDesiredSize.GetWidth();
- naturalSize.y = mDesiredSize.GetHeight();
- return;
- }
- else if( !mImageUrl.empty() )
- {
- ImageDimensions dimentions = ResourceImage::GetImageSize( mImageUrl );
- naturalSize.x = dimentions.GetWidth();
- naturalSize.y = dimentions.GetHeight();
- return;
- }
-
- naturalSize = Vector2::ZERO;
-}
-
-void BatchImageVisual::InitializeRenderer( const std::string& imageUrl )
-{
- if( imageUrl.empty() )
- {
- return;
- }
-
- mImageUrl = imageUrl;
- mImpl->mRenderer.Reset();
- mAtlasRect = FULL_TEXTURE_RECT;
-
- if( !mImpl->mCustomShader &&
- ( strncasecmp( imageUrl.c_str(),HTTP_URL, sizeof( HTTP_URL ) -1 ) != 0 ) && // Ignore remote images
- ( strncasecmp( imageUrl.c_str(), HTTPS_URL, sizeof( HTTPS_URL ) -1 ) != 0 ) )
- {
- if( !mImpl->mRenderer )
- {
- TextureSet textureSet = mFactoryCache.GetAtlasManager()->Add(
- mAtlasRect,
- imageUrl,
- mDesiredSize );
-
- // If image doesn't fit the atlas, create new texture set with texture that
- // is used as whole.
- if( !textureSet )
- {
- BitmapLoader loader = BitmapLoader::New( imageUrl, mDesiredSize );
- loader.Load();
- Dali::PixelData pixelData = loader.GetPixelData();
- Texture texture = Texture::New( TextureType::TEXTURE_2D,
- pixelData.GetPixelFormat(),
- pixelData.GetWidth(),
- pixelData.GetHeight() );
- texture.Upload( pixelData );
- textureSet = TextureSet::New();
- textureSet.SetTexture( 0, texture );
- mAtlasRect = FULL_TEXTURE_RECT;
- }
-
- Geometry geometry = mFactoryCache.CreateBatchQuadGeometry( mAtlasRect );
- Shader shader( GetBatchShader( mFactoryCache ) );
- mImpl->mRenderer = Renderer::New( geometry, shader );
- mImpl->mRenderer.SetTextures( textureSet );
-
- // Turn batching on, to send message it must be on stage.
- mImpl->mRenderer.SetProperty( Dali::DevelRenderer::Property::BATCHING_ENABLED, true );
- }
- mImpl->mFlags |= Impl::IS_FROM_CACHE;
- }
-}
-
-void BatchImageVisual::DoSetOnStage( Actor& actor )
-{
- if( !mImageUrl.empty() )
- {
- InitializeRenderer( mImageUrl );
- }
- // Turn batching on, to send message it must be on stage
- mImpl->mRenderer.SetProperty( Dali::DevelRenderer::Property::BATCHING_ENABLED, true );
-
- actor.AddRenderer( mImpl->mRenderer );
-}
-
-void BatchImageVisual::DoSetOffStage( Actor& actor )
-{
- actor.RemoveRenderer( mImpl->mRenderer );
-
- // If we own the image then make sure we release it when we go off stage
- if( !mImageUrl.empty() )
- {
- CleanCache( mImageUrl );
- }
- else
- {
- mImpl->mRenderer.Reset();
- }
-}
-
-void BatchImageVisual::DoCreatePropertyMap( Property::Map& map ) const
-{
- map.Clear();
- map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::Visual::IMAGE );
-
- if( !mImageUrl.empty() )
- {
- map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl );
- map.Insert( Toolkit::ImageVisual::Property::BATCHING_ENABLED, true );
- map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth() );
- map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight() );
- }
-}
-
-Shader BatchImageVisual::GetBatchShader( VisualFactoryCache& factoryCache )
-{
- Shader shader = factoryCache.GetShader( VisualFactoryCache::BATCH_IMAGE_SHADER );
- if( !shader )
- {
- shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
- factoryCache.SaveShader( VisualFactoryCache::BATCH_IMAGE_SHADER, shader );
- }
- return shader;
-}
-
-void BatchImageVisual::CleanCache(const std::string& url)
-{
- TextureSet textureSet = mImpl->mRenderer.GetTextures();
- mImpl->mRenderer.Reset();
- if( mFactoryCache.CleanRendererCache( url ) )
- {
- mFactoryCache.GetAtlasManager()->Remove( textureSet, mAtlasRect );
- }
-}
-
-void BatchImageVisual::OnSetTransform()
-{
- if( mImpl->mRenderer )
- {
- //Register transform properties
- mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
- }
-}
-
-} // namespace Internal
-
-} // namespace Toolkit
-
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_TOOLKIT_INTERNAL_BATCH_IMAGE_VISUAL_H
-#define DALI_TOOLKIT_INTERNAL_BATCH_IMAGE_VISUAL_H
-
-/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// EXTERNAL INCLUDES
-#include <dali/public-api/common/intrusive-ptr.h>
-
-// INTERNAL HEADER
-#include <dali-toolkit/internal/visuals/visual-base-impl.h>
-#include <dali-toolkit/internal/visuals/image-atlas-manager.h>
-
-namespace Dali
-{
-namespace Toolkit
-{
-namespace Internal
-{
-
-class BatchImageVisual;
-typedef IntrusivePtr< BatchImageVisual > BatchImageVisualPtr;
-
-class BatchImageVisual: public Visual::Base, public ConnectionTracker
-{
-public:
-
- /**
- * @brief Create a new batch-image visual.
- *
- * @param[in] factoryCache A pointer pointing to the VisualFactoryCache object
- * @param[in] url The URL of the image to use
- * @param[in] properties A Property::Map containing settings for this visual
- * @return A smart-pointer to the newly allocated visual.
- */
- static BatchImageVisualPtr New( VisualFactoryCache& factoryCache, const std::string& url, const Property::Map& properties = Property::Map() );
-
-public: // from Visual
-
- /**
- * @copydoc Visual::Base::GetNaturalSize
- */
- virtual void GetNaturalSize( Vector2& naturalSize );
-
- /**
- * @copydoc Visual::Base::CreatePropertyMap
- */
- virtual void DoCreatePropertyMap( Property::Map& map ) const;
-
-protected:
-
- /**
- * @brief Constructor.
- *
- * @param[in] factoryCache The VisualFactoryCache object
- */
- BatchImageVisual( VisualFactoryCache& factoryCache );
-
- /**
- * @brief A reference counted object may only be deleted by calling Unreference().
- */
- ~BatchImageVisual();
-
- /**
- * @copydoc Visua::Base::DoSetProperties
- */
- virtual void DoSetProperties( const Property::Map& propertyMap );
-
- /**
- * @copydoc Visual::Base::DoSetOnStage
- */
- virtual void DoSetOnStage( Actor& actor );
-
- /**
- * @copydoc Visual::Base::DoSetOffStage
- */
- virtual void DoSetOffStage( Actor& actor );
-
- /**
- * @copydoc Visual::Base::OnSetTransform
- */
- virtual void OnSetTransform();
-
-private:
-
- /**
- * Get the batch image rendering shader.
- * @param[in] factoryCache A pointer pointing to the VisualFactoryCache object
- */
- static Shader GetBatchShader( VisualFactoryCache& factoryCache );
-
- /**
- * @brief Initializes the Dali::Renderer from an image url string
- *
- * @param[in] imageUrl The image url string to intialize this ImageVisual from
- */
- void InitializeRenderer( const std::string& imageUrl );
-
- /**
- * Clean the Visual from cache, and remove the image from atlas if it is not used anymore
- */
- void CleanCache( const std::string& url );
-
- /**
- * Helper method to set individual values by index key.
- * @param[in] index The index key of the value
- * @param[in] value The value
- */
- void DoSetProperty( Property::Index index, const Property::Value& value );
-
-private:
-
- Vector4 mAtlasRect;
- std::string mImageUrl;
- Dali::ImageDimensions mDesiredSize;
-};
-
-} // namespace Internal
-
-} // namespace Toolkit
-
-} // namespace Dali
-
-#endif // DALI_TOOLKIT_INTERNAL_BATCH_IMAGE_VISUAL_H
const char * const IMAGE_DESIRED_WIDTH( "desiredWidth" );
const char * const IMAGE_DESIRED_HEIGHT( "desiredHeight" );
const char * const SYNCHRONOUS_LOADING( "synchronousLoading" );
-const char * const BATCHING_ENABLED( "batchingEnabled" );
// fitting modes
DALI_ENUM_TO_STRING_TABLE_BEGIN( FITTING_MODE )
varying mediump vec2 vTexCoord;\n
uniform sampler2D sTexture;\n
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
uniform lowp float preMultipliedAlpha;\n
\n
lowp vec4 visualMixColor()\n
{\n
- return vec4( mixColor.rgb * mix( 1.0, mixColor.a, preMultipliedAlpha ), mixColor.a );\n
+ return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
}\n
void main()\n
{\n
uniform sampler2D sTexture;\n
uniform mediump vec4 uAtlasRect;\n
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
uniform lowp float preMultipliedAlpha;\n
\n
lowp vec4 visualMixColor()\n
{\n
- return vec4( mixColor.rgb * mix( 1.0, mixColor.a, preMultipliedAlpha ), mixColor.a );\n
+ return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
}\n
\n
void main()\n
// WrapMode -- 0: CLAMP; 1: REPEAT; 2: REFLECT;
uniform lowp vec2 wrapMode;\n
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
uniform lowp float preMultipliedAlpha;\n
\n
mediump float wrapCoordinate( mediump vec2 range, mediump float coordinate, lowp float wrap )\n
\n
lowp vec4 visualMixColor()\n
{\n
- return vec4( mixColor.rgb * mix( 1.0, mixColor.a, preMultipliedAlpha ), mixColor.a );\n
+ return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
}\n
\n
void main()\n
precision mediump float;\n
varying mediump vec3 vIllumination;\n
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
uniform lowp float preMultipliedAlpha;\n
lowp vec4 visualMixColor()\n
{\n
- return vec4( mixColor.rgb * mix( 1.0, mixColor.a, preMultipliedAlpha ), mixColor.a );\n
+ return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
}\n
void main()\n
{\n
varying mediump float vSpecular;\n
uniform sampler2D sDiffuse;\n
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
uniform lowp float preMultipliedAlpha;\n
lowp vec4 visualMixColor()\n
{\n
- return vec4( mixColor.rgb * mix( 1.0, mixColor.a, preMultipliedAlpha ), mixColor.a );\n
+ return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
}\n
void main()\n
{\n
uniform sampler2D sNormal;\n
uniform sampler2D sGloss;\n
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
uniform lowp float preMultipliedAlpha;\n
lowp vec4 visualMixColor()\n
{\n
- return vec4( mixColor.rgb * mix( 1.0, mixColor.a, preMultipliedAlpha ), mixColor.a );\n
+ return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
}\n
void main()\n
{\n
varying mediump vec2 vTexCoord;\n
uniform sampler2D sTexture;\n
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
uniform lowp float preMultipliedAlpha;\n
lowp vec4 visualMixColor()\n
{\n
- return vec4( mixColor.rgb * mix( 1.0, mixColor.a, preMultipliedAlpha ), mixColor.a );\n
+ return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
}\n
void main()\n
{\n
precision mediump float;\n
varying mediump vec3 vIllumination;\n
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
-
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
void main()\n
{\n
- vec4 baseColor = mixColor * uColor;\n
+ vec4 baseColor = vec4(mixColor, opacity) * uColor;\n
gl_FragColor = vec4( vIllumination.rgb * baseColor.rgb, baseColor.a );\n
}\n
);
Vector4 color;
if( colorValue->Get( color ) )
{
- SetMixColor( color );
+ Property::Type type = colorValue->GetType();
+ if( type == Property::VECTOR4 )
+ {
+ SetMixColor( color );
+ }
+ else if( type == Property::VECTOR3 )
+ {
+ Vector3 color3(color);
+ SetMixColor( color3 );
+ }
}
}
// Register transform properties
mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
- mImpl->mMixColorIndex = DevelHandle::RegisterProperty( mImpl->mRenderer, Toolkit::PrimitiveVisual::Property::MIX_COLOR, MIX_COLOR, mImpl->mMixColor );
+ mImpl->mMixColorIndex = DevelHandle::RegisterProperty( mImpl->mRenderer, Toolkit::PrimitiveVisual::Property::MIX_COLOR, MIX_COLOR, Vector3(mImpl->mMixColor) );
}
void PrimitiveVisual::UpdateShaderUniforms()
uniform sampler2D sTexture;\n
uniform mediump vec4 uAtlasRect;\n
uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
\n
void main()\n
{\n
mediump vec2 texCoord = clamp( mix( uAtlasRect.xy, uAtlasRect.zw, vTexCoord ), uAtlasRect.xy, uAtlasRect.zw );\n
- gl_FragColor = texture2D( sTexture, texCoord ) * uColor * mixColor;\n
+ gl_FragColor = texture2D( sTexture, texCoord ) * uColor * vec4( mixColor, opacity );\n
}\n
);
* | underline | STRING |
* | shadow | STRING |
* | outline | STRING |
- * | batchingEnabled | BOOLEAN |
*
*/
class TextVisual : public Visual::Base
mControlSize( Vector2::ZERO ),
mDepthIndex( 0.0f ),
mMixColorIndex( Property::INVALID_INDEX ),
+ mOpacityIndex( Property::INVALID_INDEX ),
mFlags( 0 )
{
}
Size mControlSize;
float mDepthIndex;
Property::Index mMixColorIndex;
+ Property::Index mOpacityIndex;
int mFlags;
};
#include <dali/integration-api/debug.h>
//INTERNAL HEARDER
+#include <dali-toolkit/public-api/visuals/color-visual-properties.h>
+#include <dali-toolkit/public-api/visuals/primitive-visual-properties.h>
#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
{
matchKey = Property::Key( DevelVisual::Property::MIX_COLOR );
}
+ else if( matchKey == OPACITY )
+ {
+ matchKey = Property::Key( DevelVisual::Property::OPACITY );
+ }
}
switch( matchKey.indexKey )
Vector4 mixColor;
if( value.Get( mixColor ) )
{
- SetMixColor( mixColor );
+ if( value.GetType() == Property::VECTOR4 )
+ {
+ SetMixColor( mixColor );
+ }
+ else
+ {
+ Vector3 mixColor3(mixColor);
+ SetMixColor( mixColor3 );
+ }
+ }
+ break;
+ }
+ case DevelVisual::Property::OPACITY:
+ {
+ float opacity;
+ if( value.Get( opacity ) )
+ {
+ mImpl->mMixColor.a = opacity;
+ SetMixColor( mImpl->mMixColor );
}
break;
}
{
DoSetOffStage( actor );
mImpl->mMixColorIndex = Property::INVALID_INDEX;
+ mImpl->mOpacityIndex = Property::INVALID_INDEX;
mImpl->mFlags &= ~Impl::IS_ON_STAGE;
}
}
// Note, Color and Primitive will also insert their own mix color into the map
// which is ok, because they have a different key value range.
- map.Insert( DevelVisual::Property::MIX_COLOR, GetMixColor() );
+ map.Insert( DevelVisual::Property::MIX_COLOR, mImpl->mMixColor ); // vec4
+ map.Insert( DevelVisual::Property::OPACITY, mImpl->mMixColor.a );
}
void Visual::Base::EnablePreMultipliedAlpha( bool preMultipled )
mImpl->mRenderer,
Toolkit::DevelVisual::Property::MIX_COLOR,
MIX_COLOR,
- mImpl->mMixColor );
+ Vector3(mImpl->mMixColor) );
+ }
- if( mImpl->mMixColor.a < 1.f )
- {
- mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
- }
+ if( mImpl->mMixColor.a < 1.f )
+ {
+ mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
+ }
- float preMultipliedAlpha = 0.0f;
- if( IsPreMultipliedAlphaEnabled() )
- {
- preMultipliedAlpha = 1.0f;
- }
- mImpl->mRenderer.RegisterProperty( "preMultipliedAlpha", preMultipliedAlpha );
+ if( mImpl->mOpacityIndex == Property::INVALID_INDEX )
+ {
+ mImpl->mOpacityIndex = DevelHandle::RegisterProperty(
+ mImpl->mRenderer,
+ Toolkit::DevelVisual::Property::OPACITY,
+ OPACITY,
+ mImpl->mMixColor.a );
}
+
+ float preMultipliedAlpha = 0.0f;
+ if( IsPreMultipliedAlphaEnabled() )
+ {
+ preMultipliedAlpha = 1.0f;
+ }
+ mImpl->mRenderer.RegisterProperty( "preMultipliedAlpha", preMultipliedAlpha );
}
void Visual::Base::SetMixColor( const Vector4& color )
if( mImpl->mRenderer )
{
- mImpl->mRenderer.SetProperty( mImpl->mMixColorIndex, color );
+ mImpl->mRenderer.SetProperty( mImpl->mMixColorIndex, Vector3(color) );
+ mImpl->mRenderer.SetProperty( mImpl->mOpacityIndex, color.a );
if( color.a < 1.f )
{
mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
}
}
+void Visual::Base::SetMixColor( const Vector3& color )
+{
+ mImpl->mMixColor.r = color.r;
+ mImpl->mMixColor.g = color.g;
+ mImpl->mMixColor.b = color.b;
+
+ if( mImpl->mRenderer )
+ {
+ mImpl->mRenderer.SetProperty( mImpl->mMixColorIndex, color );
+ }
+}
+
const Vector4& Visual::Base::GetMixColor() const
{
return mImpl->mMixColor;
return mImpl->mRenderer;
}
-
Property::Index Visual::Base::GetPropertyIndex( Property::Key key )
{
Property::Index index = DevelHandle::GetPropertyIndex( mImpl->mRenderer, key );
void Visual::Base::SetupTransition(
Dali::Animation& transition,
Internal::TransitionData::Animator& animator,
- Property::Index index )
+ Property::Index index,
+ Property::Value& initialValue,
+ Property::Value& targetValue )
{
if( index != Property::INVALID_INDEX )
{
{
if( animator.animate == false )
{
- mImpl->mRenderer.SetProperty( index, animator.targetValue );
+ mImpl->mRenderer.SetProperty( index, targetValue );
}
else
{
if( animator.initialValue.GetType() != Property::NONE )
{
- mImpl->mRenderer.SetProperty( index, animator.initialValue );
+ mImpl->mRenderer.SetProperty( index, initialValue );
}
if( ! transition )
}
transition.AnimateTo( Property( mImpl->mRenderer, index ),
- animator.targetValue,
+ targetValue,
animator.alphaFunction,
TimePeriod( animator.timePeriodDelay,
animator.timePeriodDuration ) );
}
#endif
- Property::Index index = Property::INVALID_INDEX;
-
- bool isMixColor = false;
- bool isMixColorOpaque = true;
+ Property::Map map;
+ DoCreatePropertyMap( map );
+ Property::Value* valuePtr = map.Find( Toolkit::DevelVisual::Property::TYPE );
+ int visualType;
+ valuePtr->Get(visualType);
- // Get the property index
if( animator.propertyKey == Toolkit::DevelVisual::Property::MIX_COLOR ||
- animator.propertyKey == MIX_COLOR )
+ animator.propertyKey == MIX_COLOR ||
+ ( visualType == Toolkit::Visual::COLOR &&
+ animator.propertyKey == ColorVisual::Property::MIX_COLOR ) ||
+ ( visualType == Toolkit::Visual::PRIMITIVE &&
+ animator.propertyKey == PrimitiveVisual::Property::MIX_COLOR ) )
{
- isMixColor = true;
- index = mImpl->mMixColorIndex;
-
- Vector4 initialColor;
- if( animator.initialValue.Get(initialColor) ) // if there is an initial color, test it
- {
- isMixColorOpaque = initialColor.a >= 1.0f;
- }
- else
- {
- isMixColorOpaque = mImpl->mMixColor.a >= 1.0f; // otherwise, test the current color
- }
+ AnimateMixColorProperty( transition, animator );
+ }
+ else if(animator.propertyKey == Toolkit::DevelVisual::Property::OPACITY ||
+ animator.propertyKey == OPACITY )
+ {
+ AnimateOpacityProperty( transition, animator );
}
else if( mImpl->mRenderer )
{
- index = GetPropertyIndex( animator.propertyKey );
+ AnimateRendererProperty(transition, animator);
}
+}
- // Set target value into data store
- if( animator.targetValue.GetType() != Property::NONE )
+void Visual::Base::AnimateOpacityProperty(
+ Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator )
+{
+ Property::Index index = mImpl->mOpacityIndex;
+
+ bool isOpaque = mImpl->mMixColor.a >= 1.0f;
+
+ if( index != Property::INVALID_INDEX )
{
- if( isMixColor )
+ float initialOpacity;
+ if( animator.initialValue.Get( initialOpacity ) )
+ {
+ isOpaque = (initialOpacity >= 1.0f);
+ }
+
+ float targetOpacity;
+ if( animator.targetValue.Get( targetOpacity ) )
{
- animator.targetValue.Get( mImpl->mMixColor );
+ mImpl->mMixColor.a = targetOpacity;
}
- else
+
+ SetupTransition( transition, animator, index, animator.initialValue, animator.targetValue );
+ SetupBlendMode( transition, isOpaque, animator.animate );
+ }
+}
+
+void Visual::Base::AnimateRendererProperty(
+ Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator )
+{
+ Property::Index index = GetPropertyIndex( animator.propertyKey );
+ if( index != Property::INVALID_INDEX )
+ {
+ if( animator.targetValue.GetType() != Property::NONE )
{
- // Note: there may be several of these calls if more than one
- // transform property is animated.
+ // Try writing target value into transform property map
+ // if it's not a valid key, then it won't alter mTransform
Property::Map map;
if( animator.propertyKey.type == Property::Key::INDEX )
{
mImpl->mTransform.UpdatePropertyMap( map );
}
+
+ SetupTransition( transition, animator, index, animator.initialValue, animator.targetValue );
}
+}
+
+void Visual::Base::AnimateMixColorProperty(
+ Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator )
+{
+ Property::Index index = mImpl->mMixColorIndex;
+ bool animateOpacity = false;
+ bool isOpaque = true;
+
+ Property::Value initialOpacity;
+ Property::Value targetOpacity;
+ Property::Value initialMixColor;
+ Property::Value targetMixColor;
if( index != Property::INVALID_INDEX )
{
- SetupTransition( transition, animator, index );
+ Vector4 initialColor;
+ if( animator.initialValue.Get(initialColor) )
+ {
+ if( animator.initialValue.GetType() == Property::VECTOR4 )
+ {
+ // if there is an initial color specifying alpha, test it
+ isOpaque = initialColor.a >= 1.0f;
+ initialOpacity = initialColor.a;
+ }
+ initialMixColor = Vector3( initialColor );
+ }
- // For mix color, ensure the blend mode is on if the initial or final values are not opaque,
- // and that it is turned off after the animation ends if the final value is opaque
- if( isMixColor && (!isMixColorOpaque || mImpl->mMixColor.a < 1.0f) )
+ // Set target value into data store
+ if( animator.targetValue.GetType() != Property::NONE )
{
- mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
+ Vector4 mixColor;
+ animator.targetValue.Get(mixColor);
+ if( animator.targetValue.GetType() == Property::VECTOR4 )
+ {
+ mImpl->mMixColor.a = mixColor.a;
+ targetOpacity = mixColor.a;
+ animateOpacity = true;
+ }
- if( animator.animate == true && mImpl->mMixColor.a >= 1.0f )
+ mImpl->mMixColor.r = mixColor.r;
+ mImpl->mMixColor.g = mixColor.g;
+ mImpl->mMixColor.b = mixColor.b;
+ targetMixColor = Vector3(mixColor);
+ }
+
+ SetupTransition( transition, animator, index, initialMixColor, targetMixColor );
+ if( animateOpacity )
+ {
+ SetupTransition( transition, animator, mImpl->mOpacityIndex, initialOpacity, targetOpacity );
+ SetupBlendMode( transition, isOpaque, animator.animate );
+ }
+ }
+}
+
+void Visual::Base::SetupBlendMode( Animation& transition, bool isInitialOpaque, bool animating )
+{
+ // Ensure the blend mode is turned on if we are animating opacity, and
+ // turned off after the animation ends if the final value is opaque
+ if( ! isInitialOpaque || mImpl->mMixColor.a < 1.0f )
+ {
+ mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
+
+ if( animating == true && mImpl->mMixColor.a >= 1.0f )
+ {
+ // When it becomes opaque, set the blend mode back to automatically
+ if( ! mImpl->mBlendSlotDelegate )
{
- // When it becomes opaque, set the blend mode back to automatically
- if( ! mImpl->mBlendSlotDelegate )
- {
- mImpl->mBlendSlotDelegate = new SlotDelegate<Visual::Base>(this);
- }
- transition.FinishedSignal().Connect( *(mImpl->mBlendSlotDelegate),
- &Visual::Base::OnMixColorFinished );
+ mImpl->mBlendSlotDelegate = new SlotDelegate<Visual::Base>(this);
}
+ transition.FinishedSignal().Connect( *(mImpl->mBlendSlotDelegate),
+ &Visual::Base::OnMixColorFinished );
}
}
}
Renderer GetRenderer();
/**
- * Sets the mix color of the visual.
+ * Sets the mix color ( including opacity ) of the visual.
* @param[in] mixColor The new mix color
*/
void SetMixColor( const Vector4& color );
/**
+ * Sets the mix color of the visual.
+ * @param[in] mixColor The new mix color
+ */
+ void SetMixColor( const Vector3& color );
+
+ /**
* Gets the mix color of the visual.
* @return The mix color
*/
* @param[in] transition The transition to use or set up.
* @param[in] animator The animation data to use
* @param[in] index The property index on the renderer to animate
+ * @param[in] initialValue The optional initial value
+ * @param[in] targetValue The target value to use
*/
void SetupTransition( Dali::Animation& transition,
Internal::TransitionData::Animator& animator,
- Property::Index index );
+ Property::Index index,
+ Property::Value& initialValue,
+ Property::Value& targetValue );
+
+ /**
+ * Animate the opacity property - Special handling to
+ * ensure that the blend mode is set to ON whilst animating,
+ * and set back to AUTO if it's opaque at the end of the
+ * animation.
+ *
+ * @param[in] transition The transition to use or set up.
+ * @param[in] animator The animation data to use
+ */
+ void AnimateOpacityProperty( Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator );
+
+ /**
+ * Animate the renderer property - no special handling
+ *
+ * @param[in] transition The transition to use or set up.
+ * @param[in] animator The animation data to use
+ */
+ void AnimateRendererProperty( Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator );
+
+ /**
+ * Animate the mix color property.
+ *
+ * If the animator is a vec3, then it only animates the color
+ * channels without animating the opacity. If it's a vec4, then it
+ * runs 2 animators, one for the the vec3 mixColor, and one for the
+ * opacity. (They are separate uniforms in the shader )
+ *
+ * @param[in] transition The transition to use or set up.
+ * @param[in] animator The animation data to use
+ */
+ void AnimateMixColorProperty( Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator );
+
+ /**
+ * Set up the right blend mode if the opacity is being animated.
+ * Also ensure that when the animation finishes, the blend mode is
+ * set to the appropriate value. It also uses the target value as
+ * set into mMixColor.
+ *
+ * @param[in] transition The transition to listen to
+ * @param[in] isInitialOpaque Whether the initial value is opaque
+ * @param[in] animating If the transition animates the value.
+ */
+ void SetupBlendMode( Dali::Animation& transition,
+ bool isInitialOpaque, bool animating );
/**
* When a mix color animation has finished, ensure the blend mode is set back
return geometry;
}
-Geometry VisualFactoryCache::CreateBatchQuadGeometry( Vector4 texCoords )
-{
- const float halfWidth = 0.5f;
- const float halfHeight = 0.5f;
- struct QuadVertex {
- QuadVertex( const Vector2& vertexPosition, const Vector2& vertexTexCoords )
- : position( vertexPosition ),
- texCoords( vertexTexCoords )
- {}
- Vector2 position;
- Vector2 texCoords;
- };
-
- // special case, when texture takes whole space
- if( texCoords == Vector4::ZERO )
- {
- texCoords = Vector4(0.0f, 0.0f, 1.0f, 1.0f);
- }
-
- QuadVertex quadVertexData[6] =
- {
- QuadVertex( Vector2(-halfWidth, -halfHeight ), Vector2(texCoords.x, texCoords.y) ),
- QuadVertex( Vector2( halfWidth, -halfHeight ), Vector2(texCoords.z, texCoords.y) ),
- QuadVertex( Vector2(-halfWidth, halfHeight ), Vector2(texCoords.x, texCoords.w) ),
- QuadVertex( Vector2( halfWidth, -halfHeight ), Vector2(texCoords.z, texCoords.y) ),
- QuadVertex( Vector2(-halfWidth, halfHeight ), Vector2(texCoords.x, texCoords.w) ),
- QuadVertex( Vector2( halfWidth, halfHeight ), Vector2(texCoords.z, texCoords.w) ),
- };
-
- Property::Map vertexFormat;
- vertexFormat[ "aPosition" ] = Property::VECTOR2;
- vertexFormat[ "aTexCoord" ] = Property::VECTOR2;
- PropertyBuffer vertexBuffer = PropertyBuffer::New( vertexFormat );
- vertexBuffer.SetData( quadVertexData, 6 );
-
- // create geometry as normal, single quad
- Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexBuffer );
- geometry.SetType( Geometry::TRIANGLES );
-
- return geometry;
-}
-
Image VisualFactoryCache::GetBrokenVisualImage()
{
return ResourceImage::New( BROKEN_VISUAL_IMAGE_URL );
GRADIENT_SHADER_RADIAL_USER_SPACE,
GRADIENT_SHADER_RADIAL_BOUNDING_BOX,
IMAGE_SHADER,
- BATCH_IMAGE_SHADER,
IMAGE_SHADER_ATLAS_DEFAULT_WRAP,
IMAGE_SHADER_ATLAS_CUSTOM_WRAP,
NINE_PATCH_SHADER,
static Geometry CreateGridGeometry( Uint16Pair gridSize );
/**
- * Create the batchable geometry
- * @param[in] texCoords The texture atlas rect coordinates
- * @return The created batchable geometry
- */
- static Geometry CreateBatchQuadGeometry( Vector4 texCoords );
-
- /**
* @brief Returns an image to be used when a visual has failed to correctly render
* @return The broken image handle.
*/
#include <dali-toolkit/internal/visuals/border/border-visual.h>
#include <dali-toolkit/internal/visuals/color/color-visual.h>
#include <dali-toolkit/internal/visuals/gradient/gradient-visual.h>
-#include <dali-toolkit/internal/visuals/image/batch-image-visual.h>
#include <dali-toolkit/internal/visuals/image/image-visual.h>
#include <dali-toolkit/internal/visuals/mesh/mesh-visual.h>
#include <dali-toolkit/internal/visuals/npatch/npatch-visual.h>
namespace
{
-const char * const BATCHING_ENABLED( "batchingEnabled" );
BaseHandle Create()
{
BaseHandle handle = Toolkit::VisualFactory::Get();
}
else // Regular image
{
- bool batchingEnabled( false );
- Property::Value* batchingEnabledValue = propertyMap.Find( Toolkit::ImageVisual::Property::BATCHING_ENABLED, BATCHING_ENABLED );
- if( batchingEnabledValue )
- {
- batchingEnabledValue->Get( batchingEnabled );
- }
-
- if( batchingEnabled )
- {
- visualPtr = BatchImageVisual::New( *( mFactoryCache.Get() ), imageUrl, propertyMap );
- }
- else
- {
- visualPtr = ImageVisual::New( *( mFactoryCache.Get() ), imageUrl, propertyMap );
- }
+ visualPtr = ImageVisual::New( *( mFactoryCache.Get() ), imageUrl, propertyMap );
}
}
// Mix color
const char * const MIX_COLOR( "mixColor" );
+const char * const OPACITY( "opacity" );
// Image visual
const char * const IMAGE_URL_NAME( "url" );
// Mix color
extern const char * const MIX_COLOR;
+extern const char * const OPACITY;
// Image visual
extern const char * const IMAGE_URL_NAME;
);
const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(\n
-uniform lowp vec4 uColor;\n
-uniform lowp vec4 mixColor;\n
+ uniform lowp vec4 uColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
\n
void main()\n
{\n
- gl_FragColor = uColor*mixColor;\n
+ gl_FragColor = uColor * vec4( mixColor, opacity );\n
}\n
);
namespace Dali
{
+extern bool CaseInsensitiveStringCompare( const std::string& a, const std::string& b );
namespace Toolkit
{
return connected;
}
+const Scripting::StringEnum ControlStateTable[] = {
+ { "NORMAL", Toolkit::DevelControl::NORMAL },
+ { "FOCUSED", Toolkit::DevelControl::FOCUSED },
+ { "DISABLED", Toolkit::DevelControl::DISABLED },
+}; const unsigned int ControlStateTableCount = sizeof( ControlStateTable ) / sizeof( ControlStateTable[0] );
+
// Setup signals and actions using the type-registry.
DALI_TYPE_REGISTRATION_BEGIN( Control, CustomActor, Create );
// Construction & Destruction
Impl(Control& controlImpl)
: mControlImpl( controlImpl ),
+ mState( Toolkit::DevelControl::NORMAL ),
+ mSubState(""),
mStyleName(""),
mBackgroundColor(Color::TRANSPARENT),
mStartingPinchScale( NULL ),
break;
}
+ case Toolkit::DevelControl::Property::STATE:
+ {
+ Toolkit::DevelControl::State state( controlImpl.mImpl->mState );
+
+ if( Scripting::GetEnumerationProperty< Toolkit::DevelControl::State >( value, ControlStateTable, ControlStateTableCount, state ) )
+ {
+ controlImpl.mImpl->SetState( state );
+ }
+ }
+ break;
+
+ case Toolkit::DevelControl::Property::SUB_STATE:
+ {
+ std::string subState;
+ if( value.Get( subState ) )
+ {
+ controlImpl.mImpl->SetSubState( subState );
+ }
+ }
+ break;
+
case Toolkit::Control::Property::BACKGROUND_COLOR:
{
DALI_LOG_WARNING( "BACKGROUND_COLOR property is deprecated. Use BACKGROUND property instead\n" );
break;
}
+ case Toolkit::DevelControl::Property::STATE:
+ {
+ value = Scripting::GetEnumerationName< Toolkit::DevelControl::State >( controlImpl.mImpl->mState, ControlStateTable, ControlStateTableCount );
+ break;
+ }
+
case Toolkit::Control::Property::BACKGROUND_COLOR:
{
DALI_LOG_WARNING( "BACKGROUND_COLOR property is deprecated. Use BACKGROUND property instead\n" );
return value;
}
+ void SetState( DevelControl::State state )
+ {
+ if( mState != state )
+ {
+ // If mState was Disabled, and new state is Focused, should probably
+ // store that fact, e.g. in another property that FocusManager can access.
+ mState = state;
+
+ // Trigger state change and transitions
+ // Apply new style, if stylemanager is available
+ Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
+ if( styleManager )
+ {
+ const StylePtr stylePtr = GetImpl( styleManager ).GetRecordedStyle( Toolkit::Control( mControlImpl.GetOwner() ) );
+ if( stylePtr )
+ {
+ for( int i=mVisuals.Count()-1; i >= 0; i-- )
+ {
+ mControlImpl.UnregisterVisual( mVisuals[i]->index );
+ }
+
+ Dali::CustomActor handle( mControlImpl.GetOwner() );
+ stylePtr->ApplyVisualsAndPropertiesRecursively( handle );
+ }
+ }
+ }
+ }
+
+ void SetSubState( const std::string& state )
+ {
+ if( mSubState != state )
+ {
+ mSubState = state;
+ // Trigger transitions
+
+ }
+ }
+
// Data
Control& mControlImpl;
+ DevelControl::State mState;
+ std::string mSubState;
+
RegisteredVisualContainer mVisuals; // Stores visuals needed by the control, non trivial type so std::vector used.
std::string mStyleName;
Vector4 mBackgroundColor; ///< The color of the background visual
static const PropertyRegistration PROPERTY_4;
static const PropertyRegistration PROPERTY_5;
static const PropertyRegistration PROPERTY_6;
+ static const PropertyRegistration PROPERTY_7;
+ static const PropertyRegistration PROPERTY_8;
};
// Properties registered without macro to use specific member variables.
const PropertyRegistration Control::Impl::PROPERTY_4( typeRegistration, "keyInputFocus", Toolkit::Control::Property::KEY_INPUT_FOCUS, Property::BOOLEAN, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
const PropertyRegistration Control::Impl::PROPERTY_5( typeRegistration, "background", Toolkit::Control::Property::BACKGROUND, Property::MAP, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
const PropertyRegistration Control::Impl::PROPERTY_6( typeRegistration, "tooltip", Toolkit::DevelControl::Property::TOOLTIP, Property::MAP, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_7( typeRegistration, "state", Toolkit::DevelControl::Property::STATE, Property::STRING, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_8( typeRegistration, "subState", Toolkit::DevelControl::Property::SUB_STATE, Property::STRING, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
Toolkit::Control Control::New()
{
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 2;
-const unsigned int TOOLKIT_MICRO_VERSION = 26;
+const unsigned int TOOLKIT_MICRO_VERSION = 27;
const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
* @{
*/
+/**
+ * @brief BorderVisual is to render a solid color as an internal border to the control's quad.
+ * @SINCE_1_1.45
+ */
namespace BorderVisual
{
+/**
+ * @brief BorderVisual Property
+ * @SINCE_1_1.45
+ */
namespace Property
{
+/**
+ * @brief BorderVisual Property
+ * @SINCE_1_1.45
+ */
enum
{
/**
* @{
*/
+/**
+ * @brief ColorVisual is to render a solid color to the control's quad.
+ * @SINCE_1_1.45
+ */
namespace ColorVisual
{
+/**
+ * @brief ColorVisual Property
+ * @SINCE_1_1.45
+ */
namespace Property
{
+/**
+ * @brief ColorVisual Property
+ * @SINCE_1_1.45
+ */
enum
{
/**
* @{
*/
+/**
+ * @brief GradientVisual is to render a smooth transition of colors to the control's quad.
+ * @SINCE_1_1.45
+ */
namespace GradientVisual
{
+/**
+ * @brief GradientVisual Property
+ * @SINCE_1_1.45
+ */
namespace Property
{
+/**
+ * @brief GradientVisual Property
+ * @SINCE_1_1.45
+ */
enum
{
/**
} // namespace Property
+/**
+ * @brief The type of coordinate system for certain attributes of the points in a gradient.
+ *
+ * This applies to the:
+ * - Start (x1, y1) and End (x2 and y2) points of a line if using a linear gradient.
+ * - Center point (cx, cy) and radius (r) of a circle if using a radial gradient.
+ * @SINCE_1_1.45
+ */
namespace Units
{
* This applies to the:
* - Start (x1, y1) and End (x2 and y2) points of a line if using a linear gradient.
* - Center point (cx, cy) and radius (r) of a circle if using a radial gradient.
+ * @SINCE_1_1.45
*/
enum Type
{
} // namespace Units
+/**
+ * @brief Policies that define what happens if the gradient starts or ends inside the bounds of the target rectangle.
+ * @SINCE_1_1.45
+ */
namespace SpreadMethod
{
/**
* @brief Policies that define what happens if the gradient starts or ends inside the bounds of the target rectangle.
+ * @SINCE_1_1.45
*/
enum Type
{
* @{
*/
+/**
+ * @brief ImageVisual is to render an image into the control's quad.
+ * @SINCE_1_1.45
+ */
namespace ImageVisual
{
+/**
+ * @brief ImageVisual Property
+ * @SINCE_1_1.45
+ */
namespace Property
{
+/**
+ * @brief ImageVisual Property
+ * @SINCE_1_1.45
+ */
enum
{
/**
BORDER_ONLY,
/**
- * @brief This enables Image visuals to automatically be converted to Batch-Image visuals.
- * @details Name "batchingEnabled", type Property::BOOLEAN.
- * @SINCE_1_2.0
- * @note Optional. If not specified, the default is false.
- * @note For Image visuals only. Not to be used with NPatch or SVG images.
- */
- BATCHING_ENABLED,
-
- /**
* @brief The image area to be displayed.
* @details Name "pixelArea", type Property::VECTOR4.
* It is a rectangular area.
* @{
*/
+/**
+ * @brief MeshVisual is to render a mesh using a .obj file, optionally with textures provided by a mtl file.
+ * @SINCE_1_1.45
+ */
namespace MeshVisual
{
+/**
+ * @brief MeshVisual Property
+ * @SINCE_1_1.45
+ */
namespace Property
{
+/**
+ * @brief MeshVisual Property
+ * @SINCE_1_1.45
+ */
enum
{
/**
} // namespace Property
+/**
+ * @brief The shading mode used by MeshVisual.
+ * @SINCE_1_1.45
+ */
namespace ShadingMode
{
+/**
+ * @brief The shading mode used by MeshVisual.
+ * @SINCE_1_1.45
+ */
enum Value
{
TEXTURELESS_WITH_DIFFUSE_LIGHTING, ///< *Simplest*. One color that is lit by ambient and diffuse lighting. @SINCE_1_1.45
* @{
*/
+/**
+ * @brief PrimitiveVisual is to render a simple 3D shape, such as a cube or sphere.
+ * @SINCE_1_1.45
+ */
namespace PrimitiveVisual
{
+/**
+ * @brief PrimitiveVisual Property
+ * @SINCE_1_1.45
+ */
namespace Property
{
+/**
+ * @brief PrimitiveVisual Property
+ * @SINCE_1_1.45
+ */
enum
{
/**
} // namespace Property
+/**
+ * @brief The primitive shape to render as a PrimitiveVisual.
+ * @SINCE_1_1.45
+ */
namespace Shape
{
/**
- * @brief The primitive shape to render.
+ * @brief The primitive shape to render as a PrimitiveVisual.
+ * @SINCE_1_1.45
*/
enum Type
{
* @{
*/
+/**
+ * @brief All the visual types
+ * @SINCE_1_1.45
+ */
namespace Visual
{
WIREFRAME ///< Renders a simple wire-frame outlining a quad. @SINCE_1_2_2
};
+/**
+ * @brief Visual Property
+ * @SINCE_1_1.45
+ */
namespace Property
{
+/**
+ * @brief Visual Property
+ * @SINCE_1_1.45
+ */
enum
{
/**
} // namespace Property
+/**
+ * @brief Shader for Visuals
+ * @SINCE_1_1.45
+ */
namespace Shader
{
+/**
+ * @brief Shader Property
+ * @SINCE_1_1.45
+ */
namespace Property
{
+/**
+ * @brief The type of Shader
+ * @SINCE_1_1.45
+ */
enum
{
/**
"popupPressedColor":[0.24,0.72,0.8,0.11],
"background": {
"rendererType": "image",
- "url": "{DALI_IMAGE_DIR}selection-popup-bg.9.png"
+ "url": "{DALI_IMAGE_DIR}selection-popup-background.9.png"
+ },
+ "backgroundBorder": {
+ "visualType": "IMAGE",
+ "url": "{DALI_IMAGE_DIR}selection-popup-border.9.png",
+ "mixColor":[0.24,0.72,0.8,1.0]
},
"popupFadeInDuration":0.25,
"popupFadeOutDuration":0.25
"overshootSize":[1920.0,130.0]
}
},
+ "TextSelectionScrollBar":
+ {
+ "indicatorShowDuration":0.25,
+ "indicatorHideDuration":0.25
+ },
+ "TextSelectionScrollIndicator":
+ {
+ "image":
+ {
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}text_selection_scroll_indicator.9.png"
+ },
+ "color":[0.0,0.72,0.9,0.7]
+ },
"ScrollView":
{
"overshootEffectColor":"B018",
"popupPressedColor":[0.24,0.72,0.8,0.11],
"background": {
"visualType": "IMAGE",
- "url": "{DALI_IMAGE_DIR}selection-popup-bg.9.png"
+ "url": "{DALI_IMAGE_DIR}selection-popup-background.9.png"
+ },
+ "backgroundBorder": {
+ "visualType": "IMAGE",
+ "url": "{DALI_IMAGE_DIR}selection-popup-border.9.png",
+ "mixColor":[0.24,0.72,0.8,1.0]
},
"popupFadeInDuration":0.25,
"popupFadeOutDuration":0.25
"overshootSize":[480.0,42.0]
}
},
+ "TextSelectionScrollBar":
+ {
+ "indicatorShowDuration":0.25,
+ "indicatorHideDuration":0.25
+ },
+ "TextSelectionScrollIndicator":
+ {
+ "image":
+ {
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}text_selection_scroll_indicator.9.png" // designed for HD resolution
+ },
+ "color":[0.0,0.72,0.9,0.7],
+ "scale":[0.625,1.0,1.0] // Note: This reduces height for WVGA resolution
+ },
"ScrollView":
{
"overshootEffectColor":"B018",
"ScrollBar":
{
"indicatorShowDuration":0.25,
- "indicatorHideDuration":0.25,
- "color":[0.0,0.72,0.9,0.7]
+ "indicatorHideDuration":0.25
+ },
+ "ScrollBarIndicator":
+ {
+ "image":
+ {
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}popup_scroll.9.png"
+ }
},
"TextEditor":
{
"popupPressedColor":[0.24,0.72,0.8,0.11],
"background": {
"visualType": "IMAGE",
- "url": "{DALI_IMAGE_DIR}selection-popup-bg.9.png"
+ "url": "{DALI_IMAGE_DIR}selection-popup-background.9.png"
+ },
+ "backgroundBorder": {
+ "visualType": "IMAGE",
+ "url": "{DALI_IMAGE_DIR}selection-popup-border.9.png",
+ "mixColor":[0.24,0.72,0.8,1.0]
},
"popupFadeInDuration":0.25,
"popupFadeOutDuration":0.25
"overshootSize":[720.0,130.0]
}
},
+ "TextSelectionScrollBar":
+ {
+ "indicatorShowDuration":0.25,
+ "indicatorHideDuration":0.25
+ },
+ "TextSelectionScrollIndicator":
+ {
+ "image":
+ {
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}text_selection_scroll_indicator.9.png"
+ },
+ "color":[0.0,0.72,0.9,0.7]
+ },
"ScrollView":
{
"overshootEffectColor":"B018",
// C++
label.SetProperty( TextLabel::Property::FONT_FAMILY, "FreeSerif" );
-label.SetProperty( TextLabel::Property::FONT_STYLE, "{\"weight\":\"bold\",\"slant\":\"italic\"}" );
+label.SetProperty( TextLabel::Property::FONT_STYLE,
+ Property::Map().Add( "weight", "bold" )
+ .Add( "slant", "italic" ) );
label.SetProperty( TextLabel::Property::POINT_SIZE, 12.0f );
~~~
// JavaScript
label.fontFamily = "FreeSerif";
-label.fontStyle = "{\"weight\":\"bold\",\"slant\":\"italic\"}";
+label.fontStyle = {
+ "weight" : "bold",
+ "slant" : "italic"
+ };
label.pointSize = 12;
~~~
"textlabel":
{
"fontFamily":"FreeSerif",
- "fontStyle":"{\"weight\":\"bold\",\"slant\":\"italic\"}",
+ "fontStyle":
+ {
+ "weight":"bold",
+ "slant":"italic"
+ },
"pointSize":8
}
}
"textlabel":
{
"fontFamily":"FreeSerif",
- "fontStyle":"{\"weight\":\"bold\",\"slant\":\"italic\"}",
+ "fontStyle":
+ {
+ "weight":"bold",
+ "slant":"italic"
+ },
},
"textlabelFontSize0":
"customLabel":
{
"fontFamily":"TimesNewRoman",
- "fontStyle":"{\"weight\":\"regular\",\"slant\":\"regular\"}",
+ "fontStyle":
+ {
+ "weight":"regular",
+ "slant":"regular"
+ },
},
"customLabelFontSize0":
{
Name: dali-addon
Summary: DALi module for Node.JS
-Version: 1.2.26
+Version: 1.2.27
Release: 1
Group: Development/Libraries
License: Apache License, Version 2.0
Name: dali-toolkit
Summary: The OpenGLES Canvas Core Library Toolkit
-Version: 1.2.26
+Version: 1.2.27
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-2-Clause and MIT
#need libtzplatform-config for directory if tizen version is 3.x
-%if "%{tizen_version_major}" == "3"
+%if 0%{?tizen_version_major} >= 3
BuildRequires: pkgconfig(libtzplatform-config)
%endif
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
%include <dali/public-api/math/random.h>
%include <dali/public-api/math/angle-axis.h>
%include <dali/public-api/math/viewport.h>
+%include <dali/public-api/math/math-utils.h>
%include <dali/public-api/object/property-index-ranges.h>
%include <dali/public-api/object/property.h>
%template(StringValuePair) std::pair<std::string, Dali::Property::Value>;
%template(TouchPointContainer) std::vector<Dali::TouchPoint>;
-%template(RectDouble) Dali::Rect<double>;
-%template(RectInteger) Dali::Rect<int>;
-%template(RectUnsignedInteger) Dali::Rect<unsigned int>;
-%template(RectFloat) Dali::Rect<float>;
+%template(Rectangle) Dali::Rect<int>;
+%template(PaddingType) Dali::Rect<float>;
%template(VectorInteger) Dali::Vector<int>;
%template(VectorFloat) Dali::Vector<float>;
%template(VectorUnsignedChar) Dali::Vector<unsigned char>;
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
%}
%enddef
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_VIDEOVIEWSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~VideoViewSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_VIDEOVIEWSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_VideoViewSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_APPLICATIONSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~ApplicationSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_APPLICATIONSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_ApplicationSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_APPLICATIONCONTROLSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~ApplicationControlSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_APPLICATIONCONTROLSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_ApplicationControlSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_IMAGESIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~ImageSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_IMAGESIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_ImageSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RESOURCESIMAGESIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~ResourceImageSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RESOURCESIMAGESIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_ResourceImageSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RECTINT( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~RectInteger() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RECTINT( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_RectInteger(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RECTDOUBLE( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~RectDouble() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RECTDOUBLE( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_RectDouble(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RECTFLOAT( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~RectFloat() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RECTFLOAT( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_RectFloat(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RECTUNSIGNEDINT( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~RectUnsignedInteger() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RECTUNSIGNEDINT( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_RectUnsignedInteger(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_STRINGVALUEPAIR( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~StringValuePair() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_STRINGVALUEPAIR( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_StringValuePair(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_TOUCHCONTAINER( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~TouchPointContainer() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_TOUCHCONTAINER( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_TouchPointContainer(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_BOOLSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~BoolSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_BOOLSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_BoolSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ACCESSIBILITYACTIONSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~AccessibilityActionSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ACCESSIBILITYACTIONSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_AccessibilityActionSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ACCESSIBILITYACTIONSCROLLSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~AccessibilityActionScrollSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ACCESSIBILITYACTIONSCROLLSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_AccessibilityActionScrollSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ACCESSIBILITYFOCUSSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~AccessibilityFocusOvershotSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ACCESSIBILITYFOCUSSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_AccessibilityFocusOvershotSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_VECTORINT( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~VectorInteger() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_VECTORINT( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_VectorInteger(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_VECTORFLOAT( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~VectorFloat() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_VECTORFLOAT( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_VectorFloat(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_VECTORUNSIGNEDCHAR( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~VectorUnsignedChar() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_VECTORUNSIGNEDCHAR( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_VectorUnsignedChar(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_VECTORUINT16PAIR( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~VectorUint16Pair() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_VECTORUINT16PAIR( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_VectorUint16Pair(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_TIMERSIGNALTYPE( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~TimerSignalType() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_TIMERSIGNALTYPE( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_TimerSignalType(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ACTOR( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~ActorSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ACTOR( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_ActorSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ANIMATIONSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~AnimationSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ANIMATIONSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_AnimationSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_BUTTON( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~ButtonSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_BUTTON( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_ButtonSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_PAGETURNSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~PageTurnSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_PAGETURNSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_PageTurnSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_PAGEVIEWSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~PagePanSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_PAGEVIEWSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_PagePanSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_PANGESTURESIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~PanGestureDetectedSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_PANGESTURESIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_PanGestureDetectedSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_PINCHGESTURESIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~PinchGestureDetectedSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_PINCHGESTURESIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_PinchGestureDetectedSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENDERTASKSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~RenderTaskSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENDERTASKSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_RenderTaskSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_SCROLLABLESIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~ScrollableSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_SCROLLABLESIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_ScrollableSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_SCROLLVIEWSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~ScrollViewSnapStartedSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_SCROLLVIEWSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_ScrollViewSnapStartedSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_SLIDERVALUECHANGEDSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~SliderValueChangedSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_SLIDERVALUECHANGEDSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_SliderValueChangedSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_SLIDERMARKCHANGEDSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~SliderMarkReachedSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_SLIDERMARKCHANGEDSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_SliderMarkReachedSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_STAGESIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~StageWheelSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_STAGESIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_StageWheelSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_STYLECHANGEDSIGNAL( NameSpace, ClassName )
-%typemap(csfinalize) NameSpace::ClassName %{
- ~StyleChangedSignal() {
- DisposeQueue.Instance.Add(this);
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_STYLECHANGEDSIGNAL( NameSpace, ClassName )
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock(this) {
- if (swigCPtr.Handle != global::System.IntPtr.Zero) {
- if (swigCMemOwn) {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_StyleChangedSignal(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-%}
-%enddef
-
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_TAPGESTURESIGNAL( NameSpace, ClassName )
+%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_STRINGVALUEPAIR( NameSpace, ClassName )
%typemap(csfinalize) NameSpace::ClassName %{
- ~TapGestureDetectedSignal() {
+ ~StringValuePair() {
DisposeQueue.Instance.Add(this);
}
%}
%enddef
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_TAPGESTURESIGNAL( NameSpace, ClassName )
+%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_STRINGVALUEPAIR( NameSpace, ClassName )
%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
if (!Stage.IsInstalled()) {
DisposeQueue.Instance.Add(this);
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
- NDalicPINVOKE.delete_TapGestureDetectedSignal(swigCPtr);
+ NDalicPINVOKE.delete_StringValuePair(swigCPtr);
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
%}
%enddef
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_TEXTFIELDSIGNAL( NameSpace, ClassName )
+%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_BOOLSIGNAL( NameSpace, ClassName )
%typemap(csfinalize) NameSpace::ClassName %{
- ~TextFieldSignal() {
+ ~BoolSignal() {
DisposeQueue.Instance.Add(this);
}
%}
%enddef
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_TEXTFIELDSIGNAL( NameSpace, ClassName )
+%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_BOOLSIGNAL( NameSpace, ClassName )
%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
if (!Stage.IsInstalled()) {
DisposeQueue.Instance.Add(this);
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
- NDalicPINVOKE.delete_TextFieldSignal(swigCPtr);
+ NDalicPINVOKE.delete_BoolSignal(swigCPtr);
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
%}
%enddef
-%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_TEXTEDITORSIGNAL( NameSpace, ClassName )
+%define DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_TIMERSIGNALTYPE( NameSpace, ClassName )
%typemap(csfinalize) NameSpace::ClassName %{
- ~TextEditorSignal() {
+ ~TimerSignalType() {
DisposeQueue.Instance.Add(this);
}
%}
%enddef
-%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_TEXTEDITORSIGNAL( NameSpace, ClassName )
+%define DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_TIMERSIGNALTYPE( NameSpace, ClassName )
%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") NameSpace::ClassName %{{
if (!Stage.IsInstalled()) {
DisposeQueue.Instance.Add(this);
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
- NDalicPINVOKE.delete_TextEditorSignal(swigCPtr);
+ NDalicPINVOKE.delete_TimerSignalType(swigCPtr);
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION( Dali::Toolkit, VisualFactory );
DALI_CREATE_CUSTOM_DISPOSE_DERIVED_FUNCTION( Dali::Toolkit, VisualFactory );
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_APPLICATIONSIGNAL( Dali, Signal<void(Dali::Application&)>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_APPLICATIONSIGNAL( Dali, Signal<void(Dali::Application&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_APPLICATIONCONTROLSIGNAL( Dali, Signal<void(Dali::Application&, void*)>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_APPLICATIONCONTROLSIGNAL( Dali, Signal<void(Dali::Application&, void*)>);
-
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_VIDEOVIEWSIGNAL( Dali, Signal<void(Dali::Toolkit::VideoView&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_VIDEOVIEWSIGNAL( Dali, Signal<void(Dali::Toolkit::VideoView&)>);
-
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_IMAGESIGNAL( Dali, Signal<void(Dali::Image)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_IMAGESIGNAL( Dali, Signal<void(Dali::Image)>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RESOURCESIMAGESIGNAL( Dali, Signal<void(Dali::ResourceImage)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RESOURCESIMAGESIGNAL( Dali, Signal<void(Dali::ResourceImage)>);
-
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RECTINT( Dali, Rect<int>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RECTINT( Dali, Rect<int>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RECTDOUBLE( Dali, Rect<double>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RECTDOUBLE( Dali, Rect<double>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RECTFLOAT( Dali, Rect<float>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RECTFLOAT( Dali, Rect<float>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RECTUNSIGNEDINT( Dali, Rect<unsigned int>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RECTUNSIGNEDINT( Dali, Rect<unsigned int>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_TOUCHCONTAINER( std, vector<Dali::TouchPoint>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_TOUCHCONTAINER( std, vector<Dali::TouchPoint>);
-
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_VECTORINT( Dali, Vector<int>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_VECTORINT( Dali, Vector<int>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_VECTORFLOAT( Dali, Vector<float>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_VECTORFLOAT( Dali, Vector<float>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_VECTORUNSIGNEDCHAR( Dali, Vector<unsigned char>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_VECTORUNSIGNEDCHAR( Dali, Vector<unsigned char>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_VECTORUINT16PAIR( Dali, Vector<Dali::Uint16Pair>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_VECTORUINT16PAIR( Dali, Vector<Dali::Uint16Pair>);
-
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ACCESSIBILITYACTIONSIGNAL( Dali, Signal<bool(Dali::Toolkit::AccessibilityManager&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ACCESSIBILITYACTIONSIGNAL( Dali, Signal<bool(Dali::Toolkit::AccessibilityManager&)>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ACCESSIBILITYACTIONSCROLLSIGNAL( Dali, Signal<bool(Dali::Toolkit::AccessibilityManager&, const Dali::TouchEvent&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ACCESSIBILITYACTIONSCROLLSIGNAL( Dali, Signal<bool(Dali::Toolkit::AccessibilityManager&, const Dali::TouchEvent&)>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ACCESSIBILITYFOCUSSIGNAL( Dali, Signal<void(Dali::Actor, Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ACCESSIBILITYFOCUSSIGNAL( Dali, Signal<void(Dali::Actor, Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)>);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Application&)>, ApplicationSignal);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Application&)>, ApplicationSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Application&, void*)>, ApplicationControlSignal);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Application&, void*)>, ApplicationControlSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::VideoView&)>, VideoViewSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::VideoView&)>, VideoViewSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Image)>, ImageSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Image)>, ImageSignal);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::ResourceImage)>, ResourceImageSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::ResourceImage)>, ResourceImageSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Rect<int>, Rectangle);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Rect<int>, Rectangle);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Rect<float>, PaddingType);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Rect<float>, PaddingType);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( std, vector<Dali::TouchPoint>, TouchPointContainer);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( std, vector<Dali::TouchPoint>, TouchPointContainer);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Vector<int>, VectorInteger);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Vector<int>, VectorInteger);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Vector<float>, VectorFloat);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Vector<float>, VectorFloat);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Vector<unsigned char>, VectorUnsignedChar);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Vector<unsigned char>, VectorUnsignedChar);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Vector<Dali::Uint16Pair>, VectorUint16Pair);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Vector<Dali::Uint16Pair>, VectorUint16Pair);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::AccessibilityManager&)>, AccessibilityActionSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::AccessibilityManager&)>, AccessibilityActionSignal);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::AccessibilityManager&, const Dali::TouchEvent&)>, AccessibilityActionScrollSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::AccessibilityManager&, const Dali::TouchEvent&)>, AccessibilityActionScrollSignal);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Actor, Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)>, AccessibilityFocusOvershotSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Actor, Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)>, AccessibilityFocusOvershotSignal);
//DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_STRINGVALUEPAIR( Dali, pair<std::string, Dali::Property::Value>);
//DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_STRINGVALUEPAIR( Dali, pair<std::string, Dali::Property::Value>);
//DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_BOOLSIGNAL( Dali, Signal<bool()>);
//DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_TIMERSIGNALTYPE( Dali, Signal<bool()>);
//DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_TIMERSIGNALTYPE( Dali, Signal<bool()>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ACTOR( Dali, Signal<void (Dali::Actor)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ACTOR( Dali, Signal<void (Dali::Actor)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void (Dali::Actor)>, ActorSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void (Dali::Actor)>, ActorSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Animation&)>, AnimationSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Animation&)>, AnimationSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::Button)>, ButtonSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::Button)>, ButtonSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::PageTurnView, unsigned int, bool)>, PageTurnSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::PageTurnView, unsigned int, bool)>, PageTurnSignal);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::PageTurnView)>, PagePanSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::PageTurnView)>, PagePanSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void (Dali::Actor, const Dali::PanGesture&)>, PanGestureDetectedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void (Dali::Actor, const Dali::PanGesture&)>, PanGestureDetectedSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void (Dali::Actor, const Dali::PinchGesture&)>, PinchGestureDetectedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void (Dali::Actor, const Dali::PinchGesture&)>, PinchGestureDetectedSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::RenderTask&)>, RenderTaskSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::RenderTask&)>, RenderTaskSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal< void(const Dali::Vector2&)>, ScrollableSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal< void(const Dali::Vector2&)>, ScrollableSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal< void(const Dali::Toolkit::ScrollView::SnapEvent&)>, ScrollViewSnapStartedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal< void(const Dali::Toolkit::ScrollView::SnapEvent&)>, ScrollViewSnapStartedSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::Slider, float)>, SliderValueChangedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::Slider, float)>, SliderValueChangedSignal);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::Slider, int)>, SliderMarkReachedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::Slider, int)>, SliderMarkReachedSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void (const Dali::WheelEvent&)>, StageWheelSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void (const Dali::WheelEvent&)>, StageWheelSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::StyleManager, Dali::StyleChange::Type)>, StyleChangedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::StyleManager, Dali::StyleChange::Type)>,StyleChangedSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void (Dali::Actor, const Dali::TapGesture&)>, TapGestureDetectedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void (Dali::Actor, const Dali::TapGesture&)>, TapGestureDetectedSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::TextEditor)>, TextEditorSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::TextEditor)>, TextEditorSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::TextField)>, TextFieldSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::TextField)>, TextFieldSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( std, vector<Dali::Actor>, ActorContainer);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( std, vector<Dali::Actor>, ActorContainer);
+
+//DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ITEM( std, pair<unsigned int, Dali::Actor));
+//DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ITEM( std, pair<unsigned int, Dali::Actor>);
+
+//DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ITEMCONTAINER( std, vector<std::pair<unsigned int, Dali::Actor>>);
+//DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ITEMCONTAINER( std, vector<std::pair<unsigned int, Dali::Actor>>);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( std, vector<unsigned int>, ItemIdContainer);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( std, vector<unsigned int>, ItemIdContainer);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Actor, Dali::Actor)>, FocusChangedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Actor, Dali::Actor)>, FocusChangedSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Actor, bool)>, FocusGroupChangedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Actor, bool)>, FocusGroupChangedSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void (Dali::Toolkit::GaussianBlurView)>, GaussianBlurViewSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void (Dali::Toolkit::GaussianBlurView)>, GaussianBlurViewSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::Control, const Dali::KeyEvent&)>, ControlKeySignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<bool(Dali::Toolkit::Control, const Dali::KeyEvent&)>, ControlKeySignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void (const Dali::KeyEvent&)>, KeyEventSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void (const Dali::KeyEvent&)>, KeyEventSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::Control)>, KeyInputFocusSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::Toolkit::Control)>, KeyInputFocusSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, IntrusivePtr<Dali::Toolkit::Ruler>, RulerPtr);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, IntrusivePtr<Dali::Toolkit::Ruler>, RulerPtr);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void()>, VoidSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void()>, VoidSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(float)>, FloatSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(float)>, FloatSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(const Dali::RefObject*)>, ObjectDestroyedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(const Dali::RefObject*)>, ObjectDestroyedSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::BaseHandle)>, ObjectCreatedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::BaseHandle)>, ObjectCreatedSignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void(Dali::PropertyNotification&)>, PropertyNotifySignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void(Dali::PropertyNotification&)>, PropertyNotifySignal);
+
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void (Dali::Actor, const Dali::LongPressGesture&)>, LongPressGestureDetectedSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void (Dali::Actor, const Dali::LongPressGesture&)>, LongPressGestureDetectedSignal);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_ANIMATIONSIGNAL( Dali, Signal<void(Dali::Animation&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_ANIMATIONSIGNAL( Dali, Signal<void(Dali::Animation&)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<bool (Dali::Actor, const Dali::HoverEvent&)>, ActorHoverSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<bool (Dali::Actor, const Dali::HoverEvent&)>, ActorHoverSignal);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_BUTTON( Dali, Signal<bool(Dali::Toolkit::Button)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_BUTTON( Dali, Signal<bool(Dali::Toolkit::Button)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<bool (Dali::Actor, const Dali::TouchData&)>, ActorTouchDataSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<bool (Dali::Actor, const Dali::TouchData&)>, ActorTouchDataSignal);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_PAGETURNSIGNAL( Dali, Signal<void(Dali::Toolkit::PageTurnView, unsigned int, bool)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_PAGETURNSIGNAL( Dali, Signal<void(Dali::Toolkit::PageTurnView, unsigned int, bool)>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_PAGEVIEWSIGNAL( Dali, Signal<void(Dali::Toolkit::PageTurnView)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_PAGEVIEWSIGNAL( Dali, Signal<void(Dali::Toolkit::PageTurnView)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<bool (Dali::Actor, const Dali::WheelEvent&)>, ActorWheelSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<bool (Dali::Actor, const Dali::WheelEvent&)>, ActorWheelSignal);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_PANGESTURESIGNAL( Dali, Signal<void (Dali::Actor, const Dali::PanGesture&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_PANGESTURESIGNAL( Dali, Signal<void (Dali::Actor, const Dali::PanGesture&)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, Signal<void (const Dali::TouchData&)>, TouchSignal);
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, Signal<void (const Dali::TouchData&)>, TouchSignal);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_PINCHGESTURESIGNAL( Dali, Signal<void (Dali::Actor, const Dali::PinchGesture&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_PINCHGESTURESIGNAL( Dali, Signal<void (Dali::Actor, const Dali::PinchGesture&)>);
+//DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENAME( Dali, (std::pair< Dali::Radian, Dali::Radian >), AngleThresholdPair);
+//DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENAME( Dali, (std::pair< Dali::Radian, Dali::Radian >), AngleThresholdPair);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_RENDERTASKSIGNAL( Dali, Signal<void(Dali::RenderTask&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_RENDERTASKSIGNAL( Dali, Signal<void(Dali::RenderTask&)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION( Dali, ApplicationExtensions );
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION( Dali, ApplicationExtensions );
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_SCROLLABLESIGNAL( Dali, Signal< void(const Dali::Vector2&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_SCROLLABLESIGNAL( Dali, Signal< void(const Dali::Vector2&)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION( Dali, SlotObserver );
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION( Dali, SlotObserver );
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_SCROLLVIEWSIGNAL( Dali, Signal< void(const Dali::Toolkit::ScrollView::SnapEvent&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_SCROLLVIEWSIGNAL( Dali, Signal< void(const Dali::Toolkit::ScrollView::SnapEvent&)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION( Dali, SignalObserver );
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION( Dali, SignalObserver );
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_SLIDERVALUECHANGEDSIGNAL( Dali, Signal<bool(Dali::Toolkit::Slider, float)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_SLIDERVALUECHANGEDSIGNAL( Dali, Signal<bool(Dali::Toolkit::Slider, float)>);
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_SLIDERMARKCHANGEDSIGNAL( Dali, Signal<bool(Dali::Toolkit::Slider, int)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_SLIDERMARKCHANGEDSIGNAL( Dali, Signal<bool(Dali::Toolkit::Slider, int)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION( Dali, AnimatablePropertyComponentRegistration );
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION( Dali, AnimatablePropertyComponentRegistration );
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_STAGESIGNAL( Dali, Signal<void (const Dali::WheelEvent&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_STAGESIGNAL( Dali, Signal<void (const Dali::WheelEvent&)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION( Dali, AnimatablePropertyRegistration );
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION( Dali, AnimatablePropertyRegistration );
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_STYLECHANGEDSIGNAL( Dali, Signal<void(Dali::Toolkit::StyleManager, Dali::StyleChange::Type)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_STYLECHANGEDSIGNAL( Dali, Signal<void(Dali::Toolkit::StyleManager, Dali::StyleChange::Type)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION( Dali::Toolkit, AsyncImageLoader );
+DALI_CREATE_CUSTOM_DISPOSE_DERIVED_FUNCTION( Dali::Toolkit, AsyncImageLoader );
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_TAPGESTURESIGNAL( Dali, Signal<void (Dali::Actor, const Dali::TapGesture&)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_TAPGESTURESIGNAL( Dali, Signal<void (Dali::Actor, const Dali::TapGesture&)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION( Dali, ChildPropertyRegistration );
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION( Dali, ChildPropertyRegistration );
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_TEXTEDITORSIGNAL( Dali, Signal<void(Dali::Toolkit::TextEditor)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_TEXTEDITORSIGNAL( Dali, Signal<void(Dali::Toolkit::TextEditor)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION( Dali::Toolkit, ClampState2D );
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION( Dali::Toolkit, ClampState2D );
-DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION_TEXTFIELDSIGNAL( Dali, Signal<void(Dali::Toolkit::TextField)>);
-DALI_CREATE_CUSTOM_DISPOSE_FUNCTION_TEXTFIELDSIGNAL( Dali, Signal<void(Dali::Toolkit::TextField)>);
+DALI_CREATE_CUSTOM_DESTRUCTOR_FUNCTION( Dali, DaliException );
+DALI_CREATE_CUSTOM_DISPOSE_FUNCTION( Dali, DaliException );
%rename(ExceedPolicyType) Dali::Toolkit::TextField::ExceedPolicy;
%rename(ToolkitPropertyRange) Dali::Toolkit::PropertyRanges;
%rename(TooltipPositionType) Dali::Toolkit::Tooltip::Position::Type;
+%rename(DirectionType) Dali::Toolkit::Direction::Type;
+%rename(AlignType) Dali::Toolkit::Align::Type;
%rename(VisualType) Dali::Toolkit::Visual::Type;
%rename(VisualTransformPropertyType) Dali::Toolkit::DevelVisual::Transform::Property::Type;
%rename(VISUAL_SHADER_VERTEX) Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
%csconstvalue("1 << 5") REQUIRES_KEYBOARD_NAVIGATION_SUPPORT;
%csconstvalue("1 << 6") DISABLE_STYLE_CHANGE_SIGNALS;
+%typemap(csclassmodifiers) Dali::Toolkit::Alignment "internal class"
+
typedef unsigned int ItemId;
typedef std::vector<ItemId> ItemIdContainer;
typedef std::pair<ItemId, Actor> Item;
%include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
%include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
+%include <dali-toolkit/devel-api/align-enums.h>
+
%include <dali-toolkit/devel-api/visual-factory/visual-base.h>
%include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
%include events/pangesture-event.i
%include events/propertynotification-event.i
%include events/longpressgesture-event.i
-%include events/rectinteger.i
+%include events/rectangle.i
+%include events/padding.i
%include events/resourceimage-event.i
%include events/scrollable-event.i
%include events/scrollbar-event.i
%}
%typemap(cscode) Dali::Actor::Property %{
- public static readonly int BATCH_PARENT = NDalicManualPINVOKE.Actor_Property_BATCH_PARENT_get();
public static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
-%}
-
-%typemap(cscode) Dali::Renderer::Property %{
- public static readonly int BATCHING_ENABLED = NDalicManualPINVOKE.Renderer_Property_BATCHING_ENABLED_get();
-%}
-
-%typemap(cscode) Dali::Renderer %{
- public bool BatchingEnabled
- {
- get
- {
- bool temp = false;
- GetProperty( Renderer.Property.BATCHING_ENABLED).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Renderer.Property.BATCHING_ENABLED, new Dali.Property.Value( value ) );
- }
- }
+ public static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
%}
%typemap(cscode) Dali::Toolkit::Control::Property %{
public static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();
+ public static readonly int STATE = NDalicManualPINVOKE.View_Property_STATE_get();
+ public static readonly int SUB_STATE = NDalicManualPINVOKE.View_Property_SUB_STATE_get();
%}
%typemap(cscode) Dali::Toolkit::ItemView::Property %{
return (IntPtr)swigCPtr;
}
+ public Position CurrentPosition
+ {
+ get
+ {
+ return GetCurrentPosition();
+ }
+ }
+
+ public Size3D CurrentSize
+ {
+ get
+ {
+ return GetCurrentSize();
+ }
+ }
+
public Actor Parent
{
get
{
return IsVisible();
}
- }
+ }
- public float Opacity
- {
- set
+ public float Opacity
+ {
+ get
{
- SetOpacity(value);
+ float temp = 0;
+ GetProperty( Actor.Property.OPACITY ).Get( ref temp );
+ return temp;
}
- get
+ set
{
- return GetCurrentOpacity();
+ SetProperty( Actor.Property.OPACITY, new Dali.Property.Value( value ) );
}
- }
+ }
public bool StateFocusEnable
{
}
}
- public bool BatchParent
- {
- get
- {
- bool temp = false;
- GetProperty( Actor.Property.BATCH_PARENT).Get( ref temp );
- return temp;
- }
- set
- {
- SetProperty( Actor.Property.BATCH_PARENT, new Dali.Property.Value( value ) );
- }
- }
-
public int SiblingOrder
{
get
{
int temp = 0;
- GetProperty( Actor.Property.SIBLING_ORDER).Get( ref temp );
+ GetProperty( Actor.Property.SIBLING_ORDER ).Get( ref temp );
return temp;
}
set
--- /dev/null
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+%csmethodmodifiers Dali::Rect<float>::x "private";
+%csmethodmodifiers Dali::Rect<float>::y "private";
+%csmethodmodifiers Dali::Rect<float>::left "private";
+%csmethodmodifiers Dali::Rect<float>::right "private";
+%csmethodmodifiers Dali::Rect<float>::width "private";
+%csmethodmodifiers Dali::Rect<float>::bottom "private";
+%csmethodmodifiers Dali::Rect<float>::height "private";
+%csmethodmodifiers Dali::Rect<float>::top "private";
+%ignore Dali::Rect<float>::IsEmpty;
+%ignore Dali::Rect<float>::Left;
+%ignore Dali::Rect<float>::Right;
+%ignore Dali::Rect<float>::Top;
+%ignore Dali::Rect<float>::Bottom;
+%ignore Dali::Rect<float>::Area;
+%ignore Dali::Rect<float>::Intersects;
+%ignore Dali::Rect<float>::Contains;
+
+%define DALI_PADDINGTYPE_PROPERTY_PARAM(NameSpace,ClassName)
+ %typemap(cscode) NameSpace::ClassName %{
+ public static bool operator ==(PaddingType a, PaddingType b)
+ {
+ // If both are null, or both are same instance, return true.
+ if (System.Object.ReferenceEquals(a, b))
+ {
+ return true;
+ }
+
+ // If one is null, but not both, return false.
+ if (((object)a == null) || ((object)b == null))
+ {
+ return false;
+ }
+
+ // Return true if the fields match:
+ return ( System.Math.Abs( a.Left - b.Left ) < NDalic.GetRangedEpsilon(a.Left, b.Left) )&&
+ ( System.Math.Abs( a.Right - b.Right ) < NDalic.GetRangedEpsilon(a.Right, b.Right) )&&
+ ( System.Math.Abs( a.Bottom - b.Bottom ) < NDalic.GetRangedEpsilon(a.Bottom, b.Bottom) )&&
+ ( System.Math.Abs( a.Top - b.Top ) < NDalic.GetRangedEpsilon(a.Top, b.Top) );
+ }
+
+ public static bool operator !=(PaddingType a, PaddingType b)
+ {
+ return !(a == b);
+ }
+
+ ///< The Left value
+ public float Left
+ {
+ set
+ {
+ left = value;
+ }
+ get
+ {
+ return left;
+ }
+ }
+
+ ///< The Right value
+ public float Right
+ {
+ set
+ {
+ right = value;
+ }
+ get
+ {
+ return right;
+ }
+ }
+
+ ///< The Bottom value
+ public float Bottom
+ {
+ set
+ {
+ bottom = value;
+ }
+ get
+ {
+ return bottom;
+ }
+ }
+
+ ///< The Top value
+ public float Top
+ {
+ set
+ {
+ top = value;
+ }
+ get
+ {
+ return top;
+ }
+ }
+
+%}
+
+%enddef
+
+namespace Dali
+{
+ DALI_PADDINGTYPE_PROPERTY_PARAM( Dali, Rect<float>);
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+%csmethodmodifiers Dali::Rect<int>::x "private";
+%csmethodmodifiers Dali::Rect<int>::y "private";
+%csmethodmodifiers Dali::Rect<int>::left "private";
+%csmethodmodifiers Dali::Rect<int>::right "private";
+%csmethodmodifiers Dali::Rect<int>::width "private";
+%csmethodmodifiers Dali::Rect<int>::bottom "private";
+%csmethodmodifiers Dali::Rect<int>::height "private";
+%csmethodmodifiers Dali::Rect<int>::top "private";
+
+%define DALI_RECTANGLE_PROPERTY_PARAM(NameSpace,ClassName)
+ %typemap(cscode) NameSpace::ClassName %{
+ public static bool operator ==(Rectangle a, Rectangle b)
+ {
+ // If both are null, or both are same instance, return true.
+ if (System.Object.ReferenceEquals(a, b))
+ {
+ return true;
+ }
+
+ // If one is null, but not both, return false.
+ if (((object)a == null) || ((object)b == null))
+ {
+ return false;
+ }
+
+ // Return true if the fields match:
+ return a.X == b.X && a.Y == b.Y && a.Width == b.Width && a.Height == b.Height;
+ }
+
+ public static bool operator !=(Rectangle a, Rectangle b)
+ {
+ return !(a == b);
+ }
+
+ ///< X position of the rectangle
+ public int X
+ {
+ set
+ {
+ x = value;
+ }
+ get
+ {
+ return x;
+ }
+ }
+
+ ///< Y position of the rectangle
+ public int Y
+ {
+ set
+ {
+ y = value;
+ }
+ get
+ {
+ return y;
+ }
+ }
+
+ ///< Width of the rectangle
+ public int Width
+ {
+ set
+ {
+ width = value;
+ }
+ get
+ {
+ return width;
+ }
+ }
+
+ ///< Height of the rectangle
+ public int Height
+ {
+ set
+ {
+ height = value;
+ }
+ get
+ {
+ return height;
+ }
+ }
+%}
+
+%enddef
+
+namespace Dali
+{
+ DALI_RECTANGLE_PROPERTY_PARAM( Dali, Rect<int>);
+}
+++ /dev/null
-/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-%define DALI_RECTINTEGER_PROPERTY_PARAM(NameSpace,ClassName)
- %typemap(cscode) NameSpace::ClassName %{
-
- public int X {
- set {
- NDalicPINVOKE.RectInteger_x_set(swigCPtr, value);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
- get {
- int ret = NDalicPINVOKE.RectInteger_x_get(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
- }
-
- public int Y {
- set {
- NDalicPINVOKE.RectInteger_y_set(swigCPtr, value);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
- get {
- int ret = NDalicPINVOKE.RectInteger_y_get(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
- }
-
- public int W {
- set {
- NDalicPINVOKE.RectInteger_width_set(swigCPtr, value);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
- get {
- int ret = NDalicPINVOKE.RectInteger_width_get(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
- }
-
- public int H {
- set {
- NDalicPINVOKE.RectInteger_height_set(swigCPtr, value);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
- get {
- int ret = NDalicPINVOKE.RectInteger_height_get(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
- }
-
-%}
-
-%enddef
-
-namespace Dali
-{
- DALI_RECTINTEGER_PROPERTY_PARAM( Dali, Rect<int>);
-}
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
text.MultiLine = true;
text.SetResizePolicy(ResizePolicyType.FILL_TO_PARENT, DimensionType.WIDTH);
text.SetResizePolicy(ResizePolicyType.DIMENSION_DEPENDENCY, DimensionType.HEIGHT);
- text.SetPadding(new RectFloat(10.0f, 10.0f, 20.0f, 0.0f));
+ text.SetPadding(new PaddingType(10.0f, 10.0f, 20.0f, 0.0f));
_popup.SetContent(text);
_popup.SetKeyboardFocusable(true);
_popup.SetDisplayState(Popup.DisplayStateType.HIDDEN);
private int _myRating;
private bool _myDragEnabled;
- public StarRating() : base(ViewWrapperImpl.CustomViewBehaviour.VIEW_BEHAVIOUR_DEFAULT)
+ // Called by DALi Builder if it finds a StarRating control in a JSON file
+ static CustomView CreateInstance()
+ {
+ return new StarRating();
+ }
+
+ // static constructor registers the control type (only runs once)
+ static StarRating()
+ {
+ // ViewRegistry registers control type with DALi type registery
+ // also uses introspection to find any properties that need to be registered with type registry
+ ViewRegistry.Instance.Register(CreateInstance, typeof(StarRating) );
+ }
+
+ public StarRating() : base(typeof(StarRating).Name, ViewWrapperImpl.CustomViewBehaviour.VIEW_BEHAVIOUR_DEFAULT)
{
}
[STAThread]
static void Main(string[] args)
{
+ System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor (typeof(MyCSharpExample.StarRating).TypeHandle);
+
Example example = new Example(Application.NewApplication());
example.MainLoop ();
}
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
namespace MyCSharpExample
{
- class Example
- {
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
- delegate void CallbackDelegate(IntPtr appPtr); // void, void delgate
-
- private Dali.Application _application;
-
- public Example(Dali.Application application)
- {
- _application = application;
- Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
-
- _application.Initialized += Initialize;
- Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
- }
-
- public void Initialize(object source, NUIApplicationInitEventArgs e)
- {
-
- OperatorTests();
-
- Handle handle = new Handle();
- int myPropertyIndex = handle.RegisterProperty("myProperty", new Property.Value(10.0f), Property.AccessMode.READ_WRITE);
- float myProperty = 0.0f;
- handle.GetProperty(myPropertyIndex).Get(ref myProperty);
- Console.WriteLine( "myProperty value: " + myProperty );
-
- int myPropertyIndex2 = handle.RegisterProperty("myProperty2", new Property.Value(new Size(5.0f, 5.0f)), Property.AccessMode.READ_WRITE);
- Size myProperty2 = new Size(0.0f, 0.0f);
- handle.GetProperty(myPropertyIndex2).Get(myProperty2);
- Console.WriteLine( "myProperty2 value: " + myProperty2.W + ", " + myProperty2.H );
-
- Actor actor = new Actor();
- actor.Size = new Position(200.0f, 200.0f, 0.0f);
- actor.Name = "MyActor";
- actor.Color = new Color(1.0f, 0.0f, 1.0f, 0.8f);
- Console.WriteLine("Actor id: {0}", actor.GetId());
- Console.WriteLine("Actor size: " + actor.Size.X + ", " + actor.Size.Y);
- Console.WriteLine("Actor name: " + actor.Name);
-
- Stage stage = Stage.GetCurrent();
- stage.BackgroundColor = Color.White;
-
- Size stageSize = stage.Size;
- Console.WriteLine("Stage size: " + stageSize.W + ", " + stageSize.H);
- stage.Add(actor);
-
- TextLabel text = new TextLabel("Hello Mono World");
- text.ParentOrigin = NDalic.ParentOriginCenter;
- text.AnchorPoint = NDalic.AnchorPointCenter;
- text.HorizontalAlignment = "CENTER";
- stage.Add(text);
-
- Console.WriteLine( "Text label text: " + text.Text );
-
- Console.WriteLine( "Text label point size: " + text.PointSize );
- text.PointSize = 32.0f;
- Console.WriteLine( "Text label new point size: " + text.PointSize );
-
- using (RectInteger ri = new RectInteger(02,05,20,30))
- {
- Console.WriteLine( " Created " + ri );
- Console.WriteLine( " IsEmpty() = " + ri.IsEmpty() );
- Console.WriteLine( " Left = " + ri.Left() );
- Console.WriteLine( " Right = " + ri.Right() );
- Console.WriteLine( " Top = " + ri.Top() );
- Console.WriteLine( " Bottom = " + ri.Bottom() );
- Console.WriteLine( " Area = " + ri.Area() );
- }
- Console.WriteLine( " *************************" );
- using (RectInteger ri2 = new RectInteger(02,05,20,30))
- {
- Console.WriteLine( " Created " + ri2 );
- ri2.Set(1,1,40,40);
- Console.WriteLine( " IsEmpty() = " + ri2.IsEmpty() );
- Console.WriteLine( " Left = " + ri2.Left() );
- Console.WriteLine( " Right = " + ri2.Right() );
- Console.WriteLine( " Top = " + ri2.Top() );
- Console.WriteLine( " Bottom = " + ri2.Bottom() );
- Console.WriteLine( " Area = " + ri2.Area() );
- }
- Console.WriteLine( " *************************" );
- using (RectDouble rd = new RectDouble(02,05,20.5,30.5))
- {
- Console.WriteLine( " Created " + rd );
- Console.WriteLine( " IsEmpty() = " + rd.IsEmpty() );
- Console.WriteLine( " Left = " + rd.Left() );
- Console.WriteLine( " Right = " + rd.Right() );
- Console.WriteLine( " Top = " + rd.Top() );
- Console.WriteLine( " Bottom = " + rd.Bottom() );
- Console.WriteLine( " Area = " + rd.Area() );
- }
- Console.WriteLine( " *************************" );
- RectDouble rd2 = new RectDouble();
- rd2.x = 10;
- rd2.y = 10;
- rd2.width = 20;
- rd2.height = 20;
- Console.WriteLine( " Created " + rd2 );
- Console.WriteLine( " IsEmpty() = " + rd2.IsEmpty() );
- Console.WriteLine( " Left = " + rd2.Left() );
- Console.WriteLine( " Right = " + rd2.Right() );
- Console.WriteLine( " Top = " + rd2.Top() );
- Console.WriteLine( " Bottom = " + rd2.Bottom() );
- Console.WriteLine( " Area = " + rd2.Area() );
-
- Console.WriteLine( " *************************" );
- Size Size = new Size(100, 50);
- Console.WriteLine( " Created " + Size );
- Console.WriteLine( " Size x = " + Size.W + ", y = " + Size.H );
- Size += new Size(20, 20);
- Console.WriteLine( " Size x = " + Size.W + ", y = " + Size.H );
- Size.W += 10;
- Size.H += 10;
- Console.WriteLine( " Size width = " + Size.W + ", height = " + Size.H );
-
- Console.WriteLine( " *************************" );
- Position Position = new Position(20, 100, 50);
- Console.WriteLine( " Created " + Position );
- Console.WriteLine( " Position x = " + Position.X + ", y = " + Position.Y + ", z = " + Position.Z );
- Position += new Position(20, 20, 20);
- Console.WriteLine( " Position x = " + Position.X + ", y = " + Position.Y + ", z = " + Position.Z );
- Position.X += 10;
- Position.Y += 10;
- Position.Z += 10;
- Console.WriteLine( " Position width = " + Position.X + ", height = " + Position.Y + ", depth = " + Position.Z );
- Position parentOrigin = new Dali.Position(NDalic.ParentOriginBottomRight);
- Console.WriteLine( " parentOrigin x = " + parentOrigin.X + ", y = " + parentOrigin.Y + ", z = " + parentOrigin.Z );
-
- Console.WriteLine( " *************************" );
- Color color = new Color(20, 100, 50, 200);
- Console.WriteLine( " Created " + color );
- Console.WriteLine( " Color R = " + color.R + ", G = " + color.G + ", B = " + color.B + ", A = " + color.A );
- color += new Color(20, 20, 20, 20);
- Console.WriteLine( " Color R = " + color.R + ", G = " + color.G + ", B = " + color.B + ", A = " + color.A );
- color.R += 10;
- color.G += 10;
- color.B += 10;
- color.A += 10;
- Console.WriteLine( " Color r = " + color.R + ", g = " + color.G + ", b = " + color.B + ", a = " + color.A );
- }
-
-
- public void OperatorTests()
- {
- Actor actor = new Actor();
- Actor differentActor = new Actor();
- Actor actorSame = actor;
- Actor nullActor = null;
-
- // test the true operator
- if ( actor )
- {
- Console.WriteLine ("BaseHandle Operator true (actor) : test passed ");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator true (actor): test failed ");
- }
-
- Actor parent = actor.GetParent ();
-
- if ( parent )
- {
- Console.WriteLine ("Handle with Empty body :failed ");
- }
- else
- {
- Console.WriteLine ("Valid with Empty body :passed ");
- }
-
- actor.Add( differentActor );
- // here we test two different C# objects, which on the native side have the same body/ ref-object
- if ( actor == differentActor.GetParent() )
- {
- Console.WriteLine ("actor == differentActor.GetParent() :passed ");
- }
- else
- {
- Console.WriteLine ("actor == differentActor.GetParent() :failed ");
- }
-
- if ( differentActor == differentActor.GetParent() )
- {
- Console.WriteLine ("differentActor == differentActor.GetParent() :failed ");
- }
- else
- {
- Console.WriteLine ("differentActor == differentActor.GetParent() :passed ");
- }
-
-
- if ( nullActor )
- {
- Console.WriteLine ("BaseHandle Operator true (nullActor) : test failed ");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator true (nullActor): test passed ");
- }
-
- // ! operator
- if ( !actor )
- {
- Console.WriteLine ("BaseHandle Operator !(actor) : test failed ");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator !(actor): test passed ");
- }
-
- if ( !nullActor )
- {
- Console.WriteLine ("BaseHandle Operator !(nullActor) : test passed ");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator !(nullActor): test failed ");
- }
-
- // Note: operator false only used inside & operator
- // test equality operator ==
- if ( actor == actorSame )
- {
- Console.WriteLine ("BaseHandle Operator (actor == actorSame) : test passed");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator (actor == actorSame) : test failed");
+ class Example
+ {
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ delegate void CallbackDelegate(IntPtr appPtr); // void, void delgate
+
+ private Dali.Application _application;
+
+ public Example(Dali.Application application)
+ {
+ _application = application;
+ Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
+
+ _application.Initialized += Initialize;
+ Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
+ }
+
+ public void Initialize(object source, NUIApplicationInitEventArgs e)
+ {
+ OperatorTests();
+
+ CustomViewPropertyTest();
+
+ Handle handle = new Handle();
+ int myPropertyIndex = handle.RegisterProperty("myProperty", new Property.Value(10.0f), Property.AccessMode.READ_WRITE);
+ float myProperty = 0.0f;
+ handle.GetProperty(myPropertyIndex).Get(ref myProperty);
+ Console.WriteLine( "myProperty value: " + myProperty );
+
+ int myPropertyIndex2 = handle.RegisterProperty("myProperty2", new Property.Value(new Size(5.0f, 5.0f)), Property.AccessMode.READ_WRITE);
+ Size myProperty2 = new Size(0.0f, 0.0f);
+ handle.GetProperty(myPropertyIndex2).Get(myProperty2);
+ Console.WriteLine( "myProperty2 value: " + myProperty2.W + ", " + myProperty2.H );
+
+ Actor actor = new Actor();
+ actor.Size = new Position(200.0f, 200.0f, 0.0f);
+ actor.Name = "MyActor";
+ actor.Color = new Color(1.0f, 0.0f, 1.0f, 0.8f);
+ Console.WriteLine("Actor id: {0}", actor.GetId());
+ Console.WriteLine("Actor size: " + actor.Size.X + ", " + actor.Size.Y);
+ Console.WriteLine("Actor name: " + actor.Name);
+
+ Stage stage = Stage.GetCurrent();
+ stage.BackgroundColor = Color.White;
+ Size stageSize = stage.Size;
+ Console.WriteLine("Stage size: " + stageSize.W + ", " + stageSize.H);
+ stage.Add(actor);
+
+ TextLabel text = new TextLabel("Hello Mono World");
+ text.ParentOrigin = NDalic.ParentOriginCenter;
+ text.AnchorPoint = NDalic.AnchorPointCenter;
+ text.HorizontalAlignment = "CENTER";
+ stage.Add(text);
+
+ Console.WriteLine( "Text label text: " + text.Text );
+
+ Console.WriteLine( "Text label point size: " + text.PointSize );
+ text.PointSize = 32.0f;
+ Console.WriteLine( "Text label new point size: " + text.PointSize );
+
+ RectanglePaddingClassTest();
+
+ Console.WriteLine( " *************************" );
+ Size Size = new Size(100, 50);
+ Console.WriteLine( " Created " + Size );
+ Console.WriteLine( " Size x = " + Size.W + ", y = " + Size.H );
+ Size += new Size(20, 20);
+ Console.WriteLine( " Size x = " + Size.W + ", y = " + Size.H );
+ Size.W += 10;
+ Size.H += 10;
+ Console.WriteLine( " Size width = " + Size.W + ", height = " + Size.H );
+
+ Console.WriteLine( " *************************" );
+ Position Position = new Position(20, 100, 50);
+ Console.WriteLine( " Created " + Position );
+ Console.WriteLine( " Position x = " + Position.X + ", y = " + Position.Y + ", z = " + Position.Z );
+ Position += new Position(20, 20, 20);
+ Console.WriteLine( " Position x = " + Position.X + ", y = " + Position.Y + ", z = " + Position.Z );
+ Position.X += 10;
+ Position.Y += 10;
+ Position.Z += 10;
+ Console.WriteLine( " Position width = " + Position.X + ", height = " + Position.Y + ", depth = " + Position.Z );
+ Position parentOrigin = new Dali.Position(NDalic.ParentOriginBottomRight);
+ Console.WriteLine( " parentOrigin x = " + parentOrigin.X + ", y = " + parentOrigin.Y + ", z = " + parentOrigin.Z );
+
+ Console.WriteLine( " *************************" );
+ Color color = new Color(20, 100, 50, 200);
+ Console.WriteLine( " Created " + color );
+ Console.WriteLine( " Color R = " + color.R + ", G = " + color.G + ", B = " + color.B + ", A = " + color.A );
+ color += new Color(20, 20, 20, 20);
+ Console.WriteLine( " Color R = " + color.R + ", G = " + color.G + ", B = " + color.B + ", A = " + color.A );
+ color.R += 10;
+ color.G += 10;
+ color.B += 10;
+ color.A += 10;
+ Console.WriteLine( " Color r = " + color.R + ", g = " + color.G + ", b = " + color.B + ", a = " + color.A );
+ }
+
+ public void RectanglePaddingClassTest()
+ {
+ using (Rectangle r1 = new Rectangle(2, 5, 20, 30))
+ {
+ Console.WriteLine( " Created " + r1 );
+ Console.WriteLine( " IsEmpty() = " + r1.IsEmpty() );
+ Console.WriteLine( " Left = " + r1.Left() );
+ Console.WriteLine( " Right = " + r1.Right() );
+ Console.WriteLine( " Top = " + r1.Top() );
+ Console.WriteLine( " Bottom = " + r1.Bottom() );
+ Console.WriteLine( " Area = " + r1.Area() );
+ }
+
+ Console.WriteLine( " *************************" );
+
+ using (Rectangle r2 = new Rectangle(2, 5, 20, 30))
+ {
+ Console.WriteLine( " Created " + r2 );
+ r2.Set(1,1,40,40);
+ Console.WriteLine( " IsEmpty() = " + r2.IsEmpty() );
+ Console.WriteLine( " Left = " + r2.Left() );
+ Console.WriteLine( " Right = " + r2.Right() );
+ Console.WriteLine( " Top = " + r2.Top() );
+ Console.WriteLine( " Bottom = " + r2.Bottom() );
+ Console.WriteLine( " Area = " + r2.Area() );
+ }
+
+ Console.WriteLine( " *************************" );
+
+ Rectangle r3 = new Rectangle(10, 10, 20, 20);
+ Rectangle r4 = new Rectangle(10, 10, 20, 20);
+
+ if (r3 == r4)
+ {
+ Console.WriteLine("r3 == r4");
+ }
+ else
+ {
+ Console.WriteLine("r3 != r4");
+ }
+
+ r4 = new Rectangle(12, 10, 20, 20);
+
+ if (r3 == r4)
+ {
+ Console.WriteLine("r3 == r4");
+ }
+ else
+ {
+ Console.WriteLine("r3 != r4");
+ }
+
+ PaddingType p1 = new PaddingType(10.5f, 10.7f, 20.8f, 20.8f);
+ PaddingType p2 = new PaddingType(10.5f, 10.7f, 20.8f, 20.8f);
+
+ if (p1 == p2)
+ {
+ Console.WriteLine("p1 == p2");
+ }
+ else
+ {
+ Console.WriteLine("p1 != p2");
+ }
+
+ p2 = new PaddingType(12.0f, 10.7f, 20.2f, 20.0f);
+
+ if (p1 == p2)
+ {
+ Console.WriteLine("p1 == p2");
+ }
+ else
+ {
+ Console.WriteLine("p1 != p2");
+ }
+ }
+
+ public void OperatorTests()
+ {
+ Actor actor = new Actor();
+ Actor differentActor = new Actor();
+ Actor actorSame = actor;
+ Actor nullActor = null;
+
+ // test the true operator
+ if ( actor )
+ {
+ Console.WriteLine ("BaseHandle Operator true (actor) : test passed ");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator true (actor): test failed ");
+ }
+
+ Actor parent = actor.GetParent ();
+
+ if ( parent )
+ {
+ Console.WriteLine ("Handle with Empty body :failed ");
+ }
+ else
+ {
+ Console.WriteLine ("Valid with Empty body :passed ");
+ }
+
+ actor.Add( differentActor );
+
+ // here we test two different C# objects, which on the native side have the same body/ ref-object
+ if ( actor == differentActor.GetParent() )
+ {
+ Console.WriteLine ("actor == differentActor.GetParent() :passed ");
+ }
+ else
+ {
+ Console.WriteLine ("actor == differentActor.GetParent() :failed ");
+ }
+
+ if ( differentActor == differentActor.GetParent() )
+ {
+ Console.WriteLine ("differentActor == differentActor.GetParent() :failed ");
+ }
+ else
+ {
+ Console.WriteLine ("differentActor == differentActor.GetParent() :passed ");
+ }
+
+ if ( nullActor )
+ {
+ Console.WriteLine ("BaseHandle Operator true (nullActor) : test failed ");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator true (nullActor): test passed ");
+ }
+
+ // ! operator
+ if ( !actor )
+ {
+ Console.WriteLine ("BaseHandle Operator !(actor) : test failed ");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator !(actor): test passed ");
+ }
+
+ if ( !nullActor )
+ {
+ Console.WriteLine ("BaseHandle Operator !(nullActor) : test passed ");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator !(nullActor): test failed ");
+ }
+
+ // Note: operator false only used inside & operator
+ // test equality operator ==
+ if ( actor == actorSame )
+ {
+ Console.WriteLine ("BaseHandle Operator (actor == actorSame) : test passed");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator (actor == actorSame) : test failed");
+ }
+
+ if ( actor == differentActor )
+ {
+ Console.WriteLine ("BaseHandle Operator (actor == differentActor) : test failed");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator (actor == differentActor) : test passed");
+ }
+
+ if ( actor == nullActor )
+ {
+ Console.WriteLine ("BaseHandle Operator (actor == nullActor) : test failed");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator (actor == nullActor) : test passed");
+ }
+
+ if ( nullActor == nullActor )
+ {
+ Console.WriteLine ("BaseHandle Operator (nullActor == nullActor) : test passed");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator (nullActor == nullActor) : test failed");
+ }
+
+ // test || operator
+ if ( actor || actorSame )
+ {
+ Console.WriteLine ("BaseHandle Operator (actor || actorSame) : test passed");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator (actor || actorSame) : test failed");
+ }
+
+ if ( actor || nullActor )
+ {
+ Console.WriteLine ("BaseHandle Operator (actor || nullActor) : test passed");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator (actor || nullActor) : test failed");
+ }
+
+ if ( nullActor || nullActor )
+ {
+ Console.WriteLine ("BaseHandle Operator (nullActor || nullActor) : test failed");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator (nullActor || nullActor) : test passed");
+ }
+
+ // test && operator
+ if ( actor && actorSame )
+ {
+ Console.WriteLine ("BaseHandle Operator (actor && actorSame) : test passed");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator (actor && actorSame) : test failed");
+ }
+
+ if ( actor && nullActor )
+ {
+ Console.WriteLine ("BaseHandle Operator (actor && nullActor) : test failed");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator (actor && nullActor) : test passed");
+ }
+
+ if ( nullActor && nullActor )
+ {
+ Console.WriteLine ("BaseHandle Operator (nullActor && nullActor) : test failed");
+ }
+ else
+ {
+ Console.WriteLine ("BaseHandle Operator (nullActor && nullActor) : test passed");
+ }
+ }
+
+ public void CustomViewPropertyTest()
+ {
+ // Create a Spin control
+ Spin spin = new Spin();
+
+ // Background property
+ Property.Map background = new Property.Map();
+ background.Add( Dali.Constants.Visual.Property.Type, new Property.Value((int)Dali.Constants.Visual.Type.Color) )
+ .Add( Dali.Constants.ColorVisualProperty.MixColor, new Property.Value(Color.Red) );
+ spin.Background = background;
+
+ background = spin.Background;
+ Vector4 backgroundColor = new Vector4();
+ background.Find(Dali.Constants.ColorVisualProperty.MixColor).Get(backgroundColor);
+ if( backgroundColor == Color.Red )
+ {
+ Console.WriteLine ("Custom View Background property : test passed");
+ }
+ else
+ {
+ Console.WriteLine ("Custom View Background property : test failed");
+ }
+
+ // BackgroundColor property
+ spin.BackgroundColor = Color.Yellow;
+ if(spin.BackgroundColor == Color.Yellow)
+ {
+ Console.WriteLine ("Custom View BackgroundColor property : test passed");
+ }
+ else
+ {
+ Console.WriteLine ("Custom View BackgroundColor property : test failed");
+ }
+
+ // StyleName property
+ spin.StyleName = "MyCustomStyle";
+ if(spin.StyleName == "MyCustomStyle")
+ {
+ Console.WriteLine ("Custom View StyleName property : test passed");
+ }
+ else
+ {
+ Console.WriteLine ("Custom View StyleName property : test failed");
+ }
+ }
+
+ public void MainLoop()
+ {
+ _application.MainLoop ();
+ }
+
+ /// <summary>
+ /// The main entry point for the application.
+ /// </summary>
+ [STAThread]
+ static void Main(string[] args)
+ {
+ Console.WriteLine ("Hello Mono World");
+
+ Example example = new Example(Application.NewApplication());
+ example.MainLoop ();
+ }
}
-
- if ( actor == differentActor )
- {
- Console.WriteLine ("BaseHandle Operator (actor == differentActor) : test failed");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator (actor == differentActor) : test passed");
- }
-
- if ( actor == nullActor )
- {
- Console.WriteLine ("BaseHandle Operator (actor == nullActor) : test failed");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator (actor == nullActor) : test passed");
- }
-
- if ( nullActor == nullActor )
- {
- Console.WriteLine ("BaseHandle Operator (nullActor == nullActor) : test passed");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator (nullActor == nullActor) : test failed");
- }
-
- // test || operator
- if ( actor || actorSame )
- {
- Console.WriteLine ("BaseHandle Operator (actor || actorSame) : test passed");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator (actor || actorSame) : test failed");
- }
-
- if ( actor || nullActor )
- {
- Console.WriteLine ("BaseHandle Operator (actor || nullActor) : test passed");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator (actor || nullActor) : test failed");
- }
-
- if ( nullActor || nullActor )
- {
- Console.WriteLine ("BaseHandle Operator (nullActor || nullActor) : test failed");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator (nullActor || nullActor) : test passed");
- }
-
-
- // test && operator
- if ( actor && actorSame )
- {
- Console.WriteLine ("BaseHandle Operator (actor && actorSame) : test passed");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator (actor && actorSame) : test failed");
- }
-
- if ( actor && nullActor )
- {
- Console.WriteLine ("BaseHandle Operator (actor && nullActor) : test failed");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator (actor && nullActor) : test passed");
- }
-
- if ( nullActor && nullActor )
- {
- Console.WriteLine ("BaseHandle Operator (nullActor && nullActor) : test failed");
- }
- else
- {
- Console.WriteLine ("BaseHandle Operator (nullActor && nullActor) : test passed");
- }
-
- }
-
- public void MainLoop()
- {
- _application.MainLoop ();
- }
-
- /// <summary>
- /// The main entry point for the application.
- /// </summary>
- [STAThread]
- static void Main(string[] args)
- {
- Console.WriteLine ("Hello Mono World");
-
- Example example = new Example(Application.NewApplication());
- example.MainLoop ();
- }
- }
}
extern "C" {
#endif
-SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_BATCH_PARENT_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SIBLING_ORDER_get() {
int jresult ;
int result;
- result = (int)Dali::DevelActor::Property::BATCH_PARENT;
+ result = (int)Dali::DevelActor::Property::SIBLING_ORDER;
jresult = (int)result;
return jresult;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SIBLING_ORDER_get() {
+SWIGEXPORT float SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
int jresult ;
int result;
- result = (int)Dali::DevelActor::Property::SIBLING_ORDER;
+ result = (float)Dali::DevelActor::Property::OPACITY;
jresult = (int)result;
return jresult;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_Renderer_Property_BATCHING_ENABLED_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_TOOLTIP_get() {
int jresult ;
int result;
- result = (int)Dali::DevelRenderer::Property::BATCHING_ENABLED;
+ result = (int)Dali::Toolkit::DevelControl::Property::TOOLTIP;
jresult = (int)result;
return jresult;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_TOOLTIP_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_STATE_get() {
int jresult ;
int result;
- result = (int)Dali::Toolkit::DevelControl::Property::TOOLTIP;
+ result = (int)Dali::Toolkit::DevelControl::Property::STATE;
+ jresult = (int)result;
+ return jresult;
+}
+
+SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_SUB_STATE_get() {
+ int jresult ;
+ int result;
+
+ result = (int)Dali::Toolkit::DevelControl::Property::SUB_STATE;
jresult = (int)result;
return jresult;
}
}
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_New(void * jarg1) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_New(char * jarg1, void * jarg2) {
void * jresult ;
- Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ;
+ std::string arg1 ;
+ Dali::Toolkit::Internal::ControlWrapper *arg2 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ;
Dali::Toolkit::ControlWrapper result;
- arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1;
+ if (!jarg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+ return 0;
+ }
+ (&arg1)->assign(jarg1);
+ arg2 = (Dali::Toolkit::Internal::ControlWrapper *)jarg2;
{
try {
- result = Dali::Toolkit::Internal::ControlWrapper::New(arg1);
+ result = Dali::Toolkit::Internal::ControlWrapper::New(arg1,arg2);
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
}
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapper_New(void * jarg1) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapper_New(char * jarg1, void * jarg2) {
void * jresult ;
- Dali::Toolkit::Internal::ControlWrapper *arg1 = 0 ;
+ std::string arg1 ;
+ Dali::Toolkit::Internal::ControlWrapper *arg2 = 0 ;
Dali::Toolkit::ControlWrapper result;
- arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1;
- if (!arg1) {
+ if (!jarg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
+ return 0;
+ }
+ (&arg1)->assign(jarg1);
+ arg2 = (Dali::Toolkit::Internal::ControlWrapper *)jarg2;
+ if (!arg2) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::ControlWrapper & type is null", 0);
return 0;
}
{
try {
- result = Dali::Toolkit::ControlWrapper::New(*arg1);
+ result = Dali::Toolkit::ControlWrapper::New(arg1,*arg2);
} catch (std::out_of_range& e) {
{
SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
{
public class CustomView : ViewWrapper
{
- public CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour) : base(new ViewWrapperImpl(behaviour))
+ public CustomView(string typeName, ViewWrapperImpl.CustomViewBehaviour behaviour) : base(typeName, new ViewWrapperImpl(behaviour))
{
// Registering CustomView virtual functions to viewWrapperImpl delegates.
viewWrapperImpl.OnStageConnection = new ViewWrapperImpl.OnStageConnectionDelegate(OnStageConnection);
*/
using System;
-namespace Dali
+namespace Dali
{
namespace Constants
{
-
- public enum TextureType
+ public enum TextureType
{
Texture2D = Dali.TextureType.TEXTURE_2D, ///< One 2D image @SINCE_1_1.43
TextureCube = Dali.TextureType.TEXTURE_CUBE ///< Six 2D images arranged in a cube-shape @SINCE_1_1.43
}
- public enum ViewMode
+ public enum ViewMode
{
Mono = Dali.ViewMode.MONO, ///< Monoscopic (single camera). This is the default @SINCE_1_0.0
StereoHorizontal = Dali.ViewMode.STEREO_HORIZONTAL, ///< Stereoscopic. Frame buffer is split horizontally with the left and right camera views in their respective sides. @SINCE_1_0.0
public static readonly Dali.Vector3 Zero = Dali.Vector3.ZERO;
}
+ public struct Direction
+ {
+ public enum Type
+ {
+ LeftToRight = Dali.DirectionType.LEFT_TO_RIGHT,
+ RightToLeft = Dali.DirectionType.RIGHT_TO_LEFT
+ }
+ }
+
+ public struct Align
+ {
+ public enum Type
+ {
+ TopBegin = Dali.AlignType.TOP_BEGIN,
+ TopCenter = Dali.AlignType.TOP_CENTER,
+ TopEnd = Dali.AlignType.TOP_END,
+ CenterBegin = Dali.AlignType.CENTER_BEGIN,
+ Center = Dali.AlignType.CENTER,
+ CenterEnd = Dali.AlignType.CENTER_END,
+ BottomBegin = Dali.AlignType.BOTTOM_BEGIN,
+ BottomCenter = Dali.AlignType.BOTTOM_CENTER,
+ BottomEnd = Dali.AlignType.BOTTOM_END
+ }
+ }
+
public struct Visual
{
public enum Type
public static readonly int Shader = NDalic.VISUAL_PROPERTY_SHADER;
public static readonly int Transform = NDalic.VISUAL_PROPERTY_TRANSFORM;
public static readonly int PremultipliedAlpha = NDalic.VISUAL_PROPERTY_PREMULTIPLIED_ALPHA;
- public static readonly int MixCOlor = NDalic.VISUAL_PROPERTY_MIX_COLOR;
+ public static readonly int MixColor = NDalic.VISUAL_PROPERTY_MIX_COLOR;
}
public struct ShaderProperty
public static readonly int DesiredHeight = NDalic.IMAGE_VISUAL_DESIRED_HEIGHT;
public static readonly int SynchronousLoading = NDalic.IMAGE_VISUAL_SYNCHRONOUS_LOADING;
public static readonly int BorderOnly = NDalic.IMAGE_VISUAL_BORDER_ONLY;
- public static readonly int BatchingEnabled = NDalic.IMAGE_VISUAL_BATCHING_ENABLED;
public static readonly int PixelArea = NDalic.IMAGE_VISUAL_PIXEL_AREA;
public static readonly int WrapModeU = NDalic.IMAGE_VISUAL_WRAP_MODE_U;
public static readonly int WrapModeV = NDalic.IMAGE_VISUAL_WRAP_MODE_V;
public static readonly int BelowVisual = NDalic.TOOLTIP_TAIL_BELOW_VISUAL;
}
}
-
} // namespace Constants
} // namesapce Dali
public static extern global::System.IntPtr new_ViewWrapperImpl(int jarg1);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapperImpl_New")]
- public static extern global::System.IntPtr ViewWrapperImpl_New(global::System.Runtime.InteropServices.HandleRef jarg1);
+ public static extern global::System.IntPtr ViewWrapperImpl_New(string jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_delete_ViewWrapperImpl")]
public static extern void delete_ViewWrapperImpl(global::System.Runtime.InteropServices.HandleRef jarg1);
public static extern global::System.IntPtr GetControlWrapperImpl__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapper_New")]
- public static extern global::System.IntPtr ViewWrapper_New(global::System.Runtime.InteropServices.HandleRef jarg1);
+ public static extern global::System.IntPtr ViewWrapper_New(string jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_new_ViewWrapper__SWIG_0")]
public static extern global::System.IntPtr new_ViewWrapper__SWIG_0();
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_MakeCallback")]
public static extern global::System.IntPtr MakeCallback(global::System.Runtime.InteropServices.HandleRef jarg1);
- [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Actor_Property_BATCH_PARENT_get")]
- public static extern int Actor_Property_BATCH_PARENT_get();
-
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Actor_Property_SIBLING_ORDER_get")]
public static extern int Actor_Property_SIBLING_ORDER_get();
- [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Renderer_Property_BATCHING_ENABLED_get")]
- public static extern int Renderer_Property_BATCHING_ENABLED_get();
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Actor_Property_OPACITY_get")]
+ public static extern int Actor_Property_OPACITY_get();
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_View_Property_TOOLTIP_get")]
public static extern int View_Property_TOOLTIP_get();
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_View_Property_STATE_get")]
+ public static extern int View_Property_STATE_get();
+
+ [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_View_Property_SUB_STATE_get")]
+ public static extern int View_Property_SUB_STATE_get();
+
[global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_ItemView_Property_LAYOUT_get")]
public static extern int ItemView_Property_LAYOUT_get();
///
/// static Spin()
/// {
- /// ViewRegistry.Instance.RegisterControl("Spin", CreateInstance, typeof(Spin) );
+ /// ViewRegistry.Instance.Register(CreateInstance, typeof(Spin) );
/// }
///
/// The control should also provide a CreateInstance function, which gets passed to the ViewRegistry
/// {
/// ViewRegistry registers control type with DALi type registery
/// also uses introspection to find any properties that need to be registered with type registry
- /// ViewRegistry.Instance.Register("Spin", CreateInstance, typeof(Spin) );
+ /// ViewRegistry.Instance.Register(CreateInstance, typeof(Spin) );
/// }
///
/// </summary>
- public void Register(string viewName, Func< CustomView > createFunction, System.Type viewType )
+ public void Register(Func< CustomView > createFunction, System.Type viewType )
{
// add the mapping between the view name and it's create function
- _constructorMap.Add (viewName, createFunction);
+ _constructorMap.Add (viewType.Name, createFunction);
// Call into DALi C++ to register the control with the type registry
- TypeRegistration.RegisterControl( viewName, _createCallback );
+ TypeRegistration.RegisterControl( viewType.Name, _createCallback );
// Cycle through each property in the class
foreach (System.Reflection.PropertyInfo propertyInfo in viewType.GetProperties())
ScriptableProperty scriptableProp = attr as ScriptableProperty;
// we get the start property index, based on the type and it's heirachy, e.g. DateView (70,000)-> Spin (60,000) -> View (50,000)
- int propertyIndex = _propertyRangeManager.GetPropertyIndex( viewName, viewType, scriptableProp.type );
+ int propertyIndex = _propertyRangeManager.GetPropertyIndex( viewType.Name, viewType, scriptableProp.type );
// get the enum for the property type... E.g. registering a string property returns Dali.PropertyType.String
Dali.Property.Type propertyType = GetDaliPropertyType( propertyInfo.PropertyType.Name );
// Example RegisterProperty("spin","maxValue", 50001, FLOAT, set, get );
// Native call to register the property
- TypeRegistration.RegisterProperty (viewName, propertyInfo.Name , propertyIndex, propertyType, _setPropertyCallback, _getPropertyCallback);
+ TypeRegistration.RegisterProperty (viewType.Name, propertyInfo.Name , propertyIndex, propertyType, _setPropertyCallback, _getPropertyCallback);
}
}
// Console.WriteLine ("property name = " + propertyInfo.Name);
}
}
- public ViewWrapper (ViewWrapperImpl implementation) : this (NDalicManualPINVOKE.ViewWrapper_New(ViewWrapperImpl.getCPtr(implementation)), true)
+ public ViewWrapper (string typeName, ViewWrapperImpl implementation) : this (NDalicManualPINVOKE.ViewWrapper_New(typeName, ViewWrapperImpl.getCPtr(implementation)), true)
{
viewWrapperImpl = implementation;
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
DirectorConnect();
}
- public static ViewWrapper New(ViewWrapperImpl viewWrapper)
+ public static ViewWrapper New(string typeName, ViewWrapperImpl viewWrapper)
{
- ViewWrapper ret = new ViewWrapper(NDalicManualPINVOKE.ViewWrapperImpl_New(ViewWrapperImpl.getCPtr(viewWrapper)), true);
+ ViewWrapper ret = new ViewWrapper(NDalicManualPINVOKE.ViewWrapperImpl_New(typeName, ViewWrapperImpl.getCPtr(viewWrapper)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
["VECTOR4", "Vector4", "", "Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);"],
["MATRIX3", "Matrix3", "", "Matrix3 temp = new Matrix3();"],
["MATRIX", "Matrix", "", "Matrix temp = new Matrix();" ],
- ["RECTANGLE", "RectInteger", "", "RectInteger temp = new RectInteger(0,0,0,0);"],
+ ["RECTANGLE", "Rectangle", "", "Rectangle temp = new Rectangle(0,0,0,0);"],
["ROTATION", "Quaternion", "", "Quaternion temp = new Quaternion();"],
["STRING", "string", "out", "string temp;"],
["ARRAY", "Dali.Property.Array", "", "Dali.Property.Array temp = new Dali.Property.Array();"],
{
// ViewRegistry registers control type with DALi type registery
// also uses introspection to find any properties that need to be registered with type registry
- ViewRegistry.Instance.Register("Spin", CreateInstance, typeof(Spin) );
+ ViewRegistry.Instance.Register(CreateInstance, typeof(Spin) );
}
- public Spin() : base(ViewWrapperImpl.CustomViewBehaviour.REQUIRES_KEYBOARD_NAVIGATION_SUPPORT | ViewWrapperImpl.CustomViewBehaviour.DISABLE_STYLE_CHANGE_SIGNALS)
+
+ public Spin() : base(typeof(Spin).Name, ViewWrapperImpl.CustomViewBehaviour.REQUIRES_KEYBOARD_NAVIGATION_SUPPORT | ViewWrapperImpl.CustomViewBehaviour.DISABLE_STYLE_CHANGE_SIGNALS)
{
}
projects / platform / core / uifw / dali-toolkit.git / commitdiff
