From: Adeel Kazmi Date: Tue, 26 Apr 2016 15:53:27 +0000 (-0700) Subject: Merge "Changed signal order for StyleManager" into devel/master X-Git-Tag: dali_1.1.32~10 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=commitdiff_plain;h=0297bd30ec1f17d6087f9b876e58ef0c510e9585;hp=a3cf9d0565a515064de2feb99b8b8cc33be9d521 Merge "Changed signal order for StyleManager" into devel/master --- diff --git a/automated-tests/src/dali-toolkit-styling/CMakeLists.txt b/automated-tests/src/dali-toolkit-styling/CMakeLists.txt new file mode 100644 index 0000000..92653f1 --- /dev/null +++ b/automated-tests/src/dali-toolkit-styling/CMakeLists.txt @@ -0,0 +1,83 @@ +SET(PKG_NAME "dali-toolkit-styling") + +SET(EXEC_NAME "tct-${PKG_NAME}-core") +SET(RPM_NAME "core-${PKG_NAME}-tests") + +SET(CAPI_LIB "dali-toolkit-styling") + +# List of test case sources (Only these get parsed for test cases) +SET(TC_SOURCES + utc-Dali-StyleManager.cpp +) + +# Append list of test harness files (Won't get parsed for test cases) +LIST(APPEND TC_SOURCES + ../dali-toolkit/dali-toolkit-test-utils/test-harness.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-application.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-bitmap-loader.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-color-controller.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-event-thread-callback.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-environment-variable.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-feedback-player.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-file-loader.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-imf-manager.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-physical-keyboard.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-sound-player.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-text-abstraction.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-timer.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-tts-player.cpp + ../dali-toolkit/dali-toolkit-test-utils/toolkit-virtual-keyboard.cpp + ../dali-toolkit/dali-toolkit-test-utils/dummy-control.cpp + ../dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-animation-data.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-button.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-application.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-gesture-manager.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-render-controller.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-trace-call-stack.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-native-image.cpp +) + + +PKG_CHECK_MODULES(${CAPI_LIB} REQUIRED + dali-core + dali-toolkit +) + +PKG_CHECK_MODULES(DALI_ADAPTOR REQUIRED + dali-adaptor +) + +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -ggdb --coverage -Wall -Werror") + +ADD_DEFINITIONS(-DTEST_RESOURCE_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/../../resources\" ) + +FOREACH(directory ${${CAPI_LIB}_LIBRARY_DIRS}) + SET(CMAKE_CXX_LINK_FLAGS "${CMAKE_CXX_LINK_FLAGS} -L${directory}") +ENDFOREACH(directory ${CAPI_LIB_LIBRARY_DIRS}) + +INCLUDE_DIRECTORIES( + ../../../ + ${${CAPI_LIB}_INCLUDE_DIRS} + ${DALI_ADAPTOR_INCLUDE_DIRS} + ../dali-toolkit/dali-toolkit-test-utils +) + +ADD_EXECUTABLE(${EXEC_NAME} ${EXEC_NAME}.cpp ${TC_SOURCES}) +TARGET_LINK_LIBRARIES(${EXEC_NAME} + ${${CAPI_LIB}_LIBRARIES} + -lpthread -ldl +) + +INSTALL(PROGRAMS ${EXEC_NAME} + DESTINATION ${BIN_DIR}/${EXEC_NAME} +) diff --git a/automated-tests/src/dali-toolkit-styling/tct-dali-toolkit-styling-core.cpp b/automated-tests/src/dali-toolkit-styling/tct-dali-toolkit-styling-core.cpp new file mode 100644 index 0000000..6e99684 --- /dev/null +++ b/automated-tests/src/dali-toolkit-styling/tct-dali-toolkit-styling-core.cpp @@ -0,0 +1,51 @@ +#include +#include +#include +#include +#include "tct-dali-toolkit-styling-core.h" + +int main(int argc, char * const argv[]) +{ + int result = TestHarness::EXIT_STATUS_BAD_ARGUMENT; + + const char* optString = "rs"; + bool optRerunFailed(true); + bool optRunSerially(false); + + int nextOpt = 0; + do + { + nextOpt = getopt( argc, argv, optString ); + switch(nextOpt) + { + case 'r': + optRerunFailed = true; + break; + case 's': + optRunSerially = true; + break; + case '?': + TestHarness::Usage(argv[0]); + exit(TestHarness::EXIT_STATUS_BAD_ARGUMENT); + break; + } + } while( nextOpt != -1 ); + + if( optind == argc ) // no testcase name in argument list + { + if( optRunSerially ) + { + result = TestHarness::RunAll( argv[0], tc_array ); + } + else + { + result = TestHarness::RunAllInParallel( argv[0], tc_array, optRerunFailed ); + } + } + else + { + // optind is index of next argument - interpret as testcase name + result = TestHarness::FindAndRunTestCase(tc_array, argv[optind]); + } + return result; +} diff --git a/automated-tests/src/dali-toolkit-styling/utc-Dali-StyleManager.cpp b/automated-tests/src/dali-toolkit-styling/utc-Dali-StyleManager.cpp new file mode 100644 index 0000000..e463e2f --- /dev/null +++ b/automated-tests/src/dali-toolkit-styling/utc-Dali-StyleManager.cpp @@ -0,0 +1,420 @@ +/* + * Copyright (c) 2014 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace Dali; +using namespace Dali::Toolkit; + +namespace +{ +const char* defaultTheme = +"{\n" +" \"styles\":\n" +" {\n" +" \"textlabel\":\n" +" {\n" +" \"pointSize\":18\n" +" },\n" +"\n" +" \"textlabelFontSize0\":\n" +" {\n" +" \"pointSize\":8\n" +" },\n" +" \"textlabelFontSize1\":\n" +" {\n" +" \"pointSize\":10\n" +" },\n" +" \"textlabelFontSize2\":\n" +" {\n" +" \"pointSize\":15\n" +" },\n" +" \"textlabelFontSize3\":\n" +" {\n" +" \"pointSize\":19\n" +" },\n" +" \"textlabelFontSize4\":\n" +" {\n" +" \"pointSize\":25\n" +" },\n" +"\n" +" \"textfield\":\n" +" {\n" +" \"pointSize\":18,\n" +" \"primaryCursorColor\":[0.0,0.72,0.9,1.0],\n" +" \"secondaryCursorColor\":[0.0,0.72,0.9,1.0],\n" +" \"cursorWidth\":3,\n" +" \"selectionHighlightColor\":[0.75,0.96,1.0,1.0],\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" +"\n" +" \"textfieldFontSize0\":\n" +" {\n" +" \"pointSize\":10\n" +" },\n" +" \"textfieldFontSize1\":\n" +" {\n" +" \"pointSize\":10\n" +" },\n" +" \"textfieldFontSize2\":\n" +" {\n" +" \"pointSize\":10\n" +" },\n" +" \"textfieldFontSize3\":\n" +" {\n" +" \"pointSize\":10\n" +" },\n" +" \"textfieldFontSize4\":\n" +" {\n" +" \"pointSize\":10\n" +" },\n" +" \"textselectionpopup\":\n" +" {\n" +" \"popupMaxSize\":[656,72],\n" +" \"optionDividerSize\":[2,0],\n" +" \"popupDividerColor\":[0.23,0.72,0.8,0.11],\n" +" \"popupIconColor\":[1.0,1.0,1.0,1.0],\n" +" \"popupPressedColor\":[0.24,0.72,0.8,0.11],\n" +" \"background\": {\n" +" \"rendererType\": \"nPatch\",\n" +" \"imageUrl\": \"{DALI_IMAGE_DIR}selection-popup-bg.9.png\"\n" +" },\n" +" \"popupFadeInDuration\":0.25,\n" +" \"popupFadeOutDuration\":0.25\n" +" },\n" +" \"textselectionpopupbutton\":\n" +" {\n" +" \"label\":\n" +" {\n" +" \"pointSize\":8,\n" +" \"fontStyle\":\"{\\\\""weight\\\\"":\\\\""light\\\\""}\"\n" +" }\n" +" },\n" +" \"textselectiontoolbar\":\n" +" {\n" +" \"enableOvershoot\":true,\n" +" \"scrollView\":\n" +" {\n" +" \"overshootAnimationSpeed\":360.0,\n" +" \"overshootSize\":[720.0,130.0]\n" +" }\n" +" },\n" +" \"scrollview\":\n" +" {\n" +" \"overshootEffectColor\":\"B018\",\n" +" \"overshootAnimationSpeed\":360.0,\n" +" \"overshootSize\":[720.0,130.0]\n" +" },\n" +" \"itemview\":\n" +" {\n" +" \"overshootEffectColor\":\"B018\",\n" +" \"overshootAnimationSpeed\":360.0,\n" +" \"overshootSize\":[720.0,130.0]\n" +" },\n" +" \"texteditor\":\n" +" {\n" +" \"pointSize\":18,\n" +" \"primaryCursorColor\":[0.0,0.72,0.9,1.0],\n" +" \"secondaryCursorColor\":[0.0,0.72,0.9,1.0],\n" +" \"cursorWidth\":3,\n" +" \"selectionHighlightColor\":[0.75,0.96,1.0,1.0],\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" +" }\n" +"}\n"; + +} // anonymous namespace + + + +void dali_style_manager_startup(void) +{ + test_return_value = TET_UNDEF; +} + +void dali_style_manager_cleanup(void) +{ + test_return_value = TET_PASS; +} + +int UtcDaliStyleManagerGet(void) +{ + ToolkitTestApplication application; + + tet_infoline(" UtcDaliStyleManagerGet"); + + // Register Type + TypeInfo type; + type = TypeRegistry::Get().GetTypeInfo( "StyleManager" ); + DALI_TEST_CHECK( type ); + BaseHandle handle = type.CreateInstance(); + DALI_TEST_CHECK( handle ); + + StyleManager manager; + + manager = StyleManager::Get(); + DALI_TEST_CHECK(manager); + + StyleManager newManager = StyleManager::Get(); + DALI_TEST_CHECK(newManager); + + // Check that focus manager is a singleton + DALI_TEST_CHECK(manager == newManager); + END_TEST; +} + +int UtcDaliStyleManagerSetOrientationValue(void) +{ + ToolkitTestApplication application; + + tet_infoline( " UtcDaliStyleManagerSetOrientationValue" ); + + StyleManager manager = StyleManager::Get(); + + int orientation1 = 0; + manager.SetOrientationValue( orientation1 ); + DALI_TEST_CHECK( manager.GetOrientationValue() == orientation1 ); + + int orientation2 = 180; + manager.SetOrientationValue( orientation2 ); + DALI_TEST_CHECK( manager.GetOrientationValue() == orientation2 ); + + END_TEST; +} + +int UtcDaliStyleManagerSetOrientation(void) +{ + ToolkitTestApplication application; + + tet_infoline( " UtcDaliStyleManagerSetOrientation" ); + + StyleManager manager = StyleManager::Get(); + + Orientation orientation; + + manager.SetOrientation( orientation ); + + DALI_TEST_CHECK( manager.GetOrientation() == orientation ); + + END_TEST; +} + +int UtcDaliStyleManagerSetStyleConstant(void) +{ + ToolkitTestApplication application; + + tet_infoline( " UtcDaliStyleManagerSetStyleConstant" ); + + StyleManager manager = StyleManager::Get(); + + std::string key( "key" ); + Property::Value value( 100 ); + + manager.SetStyleConstant( key, value ); + + Property::Value returnedValue; + manager.GetStyleConstant( key, returnedValue ); + + DALI_TEST_CHECK( value.Get() == returnedValue.Get() ); + + std::string key2( "key2" ); + Property::Value returnedValue2; + DALI_TEST_CHECK( !manager.GetStyleConstant( key2, returnedValue2 ) ); + + END_TEST; +} + +namespace +{ +class StyleChangedSignalChecker : public ConnectionTracker +{ +public: + StyleChangedSignalChecker() + : signalCount(0) + { + } + + void OnStyleChanged(StyleManager styleManager, StyleChange::Type type) + { + signalCount++; + } + + void Reset() + { + signalCount =0; + } + +public: + int signalCount; +}; + +} // anonymous namespace + +int UtcDaliStyleManagerPropertyOverride(void) +{ + ToolkitTestApplication application; + + tet_infoline( "Testing StyleManager property overrides" ); + + const char* json1 = + "{\n" + " \"styles\":\n" + " {\n" + " \"testbutton\":\n" + " {\n" + " \"backgroundColor\":[1.0,1.0,0.0,1.0],\n" + " \"foregroundColor\":[0.0,0.0,1.0,1.0]\n" + " }\n" + " }\n" + "}\n"; + + const char* json2 = + "{\n" + " \"styles\":\n" + " {\n" + " \"testbutton\":\n" + " {\n" + " \"backgroundColor\":[1.0,0.0,0.0,1.0],\n" + " \"foregroundColor\":[0.0,1.0,1.0,1.0]\n" + " }\n" + " }\n" + "}\n"; + + // Add 2 buttons to test how many times the signal is sent + Test::TestButton testButton = Test::TestButton::New(); + Test::TestButton testButton2 = Test::TestButton::New(); + Stage::GetCurrent().Add( testButton ); + Stage::GetCurrent().Add( testButton2 ); + StyleChangedSignalChecker styleChangedSignalHandler; + StyleChangedSignalChecker styleChangedSignalHandler2; + StyleManager styleManager = StyleManager::Get(); + + styleManager.StyleChangedSignal().Connect(&styleChangedSignalHandler, &StyleChangedSignalChecker::OnStyleChanged); + + // Render and notify + application.SendNotification(); + application.Render(); + + tet_infoline("Apply the style"); + + Test::StyleMonitor::SetThemeFileOutput(json1); + std::string themeFile("ThemeOne"); + StyleManager::Get().RequestThemeChange(themeFile); + + Property::Value bgColor( testButton.GetProperty(Test::TestButton::Property::BACKGROUND_COLOR) ); + Property::Value fgColor( testButton.GetProperty(Test::TestButton::Property::FOREGROUND_COLOR) ); + + DALI_TEST_EQUALS( bgColor, Property::Value(Color::YELLOW), 0.001, TEST_LOCATION ); + DALI_TEST_EQUALS( fgColor, Property::Value(Color::BLUE), 0.001, TEST_LOCATION ); + + tet_infoline("Testing that the signal handler is called only once"); + DALI_TEST_EQUALS( styleChangedSignalHandler.signalCount, 1, TEST_LOCATION ); + + tet_infoline("Override the background property"); + testButton.SetProperty( Test::TestButton::Property::BACKGROUND_COLOR, Color::GREEN ); + bgColor = testButton.GetProperty(Test::TestButton::Property::BACKGROUND_COLOR); + fgColor = testButton.GetProperty(Test::TestButton::Property::FOREGROUND_COLOR); + DALI_TEST_EQUALS( bgColor, Property::Value(Color::GREEN), 0.001, TEST_LOCATION ); + DALI_TEST_EQUALS( fgColor, Property::Value(Color::BLUE), 0.001, TEST_LOCATION ); + + // Render and notify + application.SendNotification(); + application.Render(); + + tet_infoline("Apply the style again"); + + styleChangedSignalHandler.signalCount = 0; + StyleManager::Get().RequestThemeChange(themeFile); + + bgColor = testButton.GetProperty(Test::TestButton::Property::BACKGROUND_COLOR); + fgColor = testButton.GetProperty(Test::TestButton::Property::FOREGROUND_COLOR); + + tet_infoline("Check that the property is changed"); + DALI_TEST_EQUALS( bgColor, Property::Value(Color::YELLOW), 0.001, TEST_LOCATION ); + DALI_TEST_EQUALS( fgColor, Property::Value(Color::BLUE), 0.001, TEST_LOCATION ); + tet_infoline("Testing that the signal handler is called only once"); + DALI_TEST_EQUALS( styleChangedSignalHandler.signalCount, 1, TEST_LOCATION ); + + tet_infoline( "Load a different stylesheet"); + + tet_infoline("Apply the new style"); + Test::StyleMonitor::SetThemeFileOutput(json2); + + styleChangedSignalHandler.signalCount = 0; + std::string themeFile2("ThemeTwo"); + StyleManager::Get().RequestThemeChange(themeFile2); + + bgColor = testButton.GetProperty(Test::TestButton::Property::BACKGROUND_COLOR); + fgColor = testButton.GetProperty(Test::TestButton::Property::FOREGROUND_COLOR); + + tet_infoline("Check that the properties change, but the signal gets sent only once"); + DALI_TEST_EQUALS( bgColor, Property::Value(Color::RED), 0.001, TEST_LOCATION ); + DALI_TEST_EQUALS( fgColor, Property::Value(Color::CYAN), 0.001, TEST_LOCATION ); + DALI_TEST_EQUALS( styleChangedSignalHandler.signalCount, 1, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliStyleManagerFontSizeChange(void) +{ + tet_infoline("Test that the StyleChange signal is fired when the font size is altered" ); + Test::StyleMonitor::SetThemeFileOutput(defaultTheme); + + ToolkitTestApplication application; + + std::string labelStr("Label"); + Toolkit::TextLabel label = Toolkit::TextLabel::New(labelStr); + Stage::GetCurrent().Add( label ); + + Toolkit::TextLabel label2 = Toolkit::TextLabel::New(labelStr); + Stage::GetCurrent().Add( label2 ); + + StyleChangedSignalChecker styleChangedSignalHandler; + StyleMonitor styleMonitor = StyleMonitor::Get(); + StyleManager styleManager = StyleManager::Get(); + + styleManager.StyleChangedSignal().Connect(&styleChangedSignalHandler, &StyleChangedSignalChecker::OnStyleChanged); + + Test::StyleMonitor::SetDefaultFontFamily("Times New Roman"); + + styleMonitor.StyleChangeSignal().Emit( styleMonitor, StyleChange::DEFAULT_FONT_CHANGE); + + tet_infoline("Test that the StyleChanged signal is received only once"); + + DALI_TEST_EQUALS( styleChangedSignalHandler.signalCount, 1, TEST_LOCATION ); + + // Check that the label's font style has been altered + Property::Value family = label.GetProperty(TextLabel::Property::FONT_FAMILY); + std::string familyStr; + family.Get( familyStr ); + + DALI_TEST_EQUALS( familyStr, "Times New Roman", TEST_LOCATION); + + END_TEST; +} diff --git a/automated-tests/src/dali-toolkit/CMakeLists.txt b/automated-tests/src/dali-toolkit/CMakeLists.txt index 15ffd4c..4d63fee 100644 --- a/automated-tests/src/dali-toolkit/CMakeLists.txt +++ b/automated-tests/src/dali-toolkit/CMakeLists.txt @@ -45,7 +45,6 @@ SET(TC_SOURCES utc-Dali-PushButton.cpp utc-Dali-RadioButton.cpp utc-Dali-ScrollViewEffect.cpp - utc-Dali-StyleManager.cpp utc-Dali-SuperBlurView.cpp utc-Dali-Toolkit.cpp utc-Dali-Model3dView.cpp diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp index 0a90c8e..467bb52 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp @@ -233,12 +233,27 @@ void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* lo DALI_TEST_EQUALS(str1.c_str(), str2, location); } -/** - * Test whether two strings are equal. - * @param[in] str1 The first string - * @param[in] str2 The second string - * @param[in] location The TEST_LOCATION macro should be used here - */ +void DALI_TEST_EQUALS( Property::Value& str1, const char* str2, const char* location) +{ + bool result = false; + + if( str1.GetType() == Property::STRING ) + { + std::string string; + str1.Get(string); + result = !string.compare(str2); + } + + if( result ) + { + tet_result(TET_PASS); + } + else + { + tet_result(TET_FAIL); + } +} + void DALI_TEST_EQUALS( const char* str1, const std::string &str2, const char* location) { DALI_TEST_EQUALS(str1, str2.c_str(), location); diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.h index baeaa6a..5e10efe 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.h +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.h @@ -153,6 +153,82 @@ inline bool CompareType(Degree q1, Degree q2, float epsilon) return CompareType(q1.degree, q2.degree, epsilon); } +template <> +inline bool CompareType(Property::Value q1, Property::Value q2, float epsilon) +{ + Property::Type type = q1.GetType(); + if( type != q2.GetType() ) + { + return false; + } + + switch(type) + { + case Property::BOOLEAN: + { + bool a, b; + q1.Get(a); + q2.Get(b); + return a == b; + break; + } + case Property::INTEGER: + { + int a, b; + q1.Get(a); + q2.Get(b); + return a == b; + break; + } + case Property::FLOAT: + { + float a, b; + q1.Get(a); + q2.Get(b); + return CompareType(a, b, epsilon); + break; + } + case Property::VECTOR2: + { + Vector2 a, b; + q1.Get(a); + q2.Get(b); + return CompareType(a, b, epsilon); + break; + } + case Property::VECTOR3: + { + Vector3 a, b; + q1.Get(a); + q2.Get(b); + return CompareType(a, b, epsilon); + break; + } + case Property::RECTANGLE: + case Property::VECTOR4: + { + Vector4 a, b; + q1.Get(a); + q2.Get(b); + return CompareType(a, b, epsilon); + break; + } + case Property::ROTATION: + { + Quaternion a, b; + q1.Get(a); + q2.Get(b); + return CompareType(a, b, epsilon); + break; + } + default: + return false; + } + + return false; +} + + bool operator==(TimePeriod a, TimePeriod b); std::ostream& operator<<( std::ostream& ostream, TimePeriod value ); std::ostream& operator<<( std::ostream& ostream, Radian angle ); @@ -316,6 +392,14 @@ inline void DALI_TEST_EQUALS( const std::string &str1, const * @param[in] str2 The second string * @param[in] location The TEST_LOCATION macro should be used here */ +void DALI_TEST_EQUALS( Property::Value& str1, const char* str2, const char* location); + +/** + * Test whether two strings are equal. + * @param[in] str1 The first string + * @param[in] str2 The second string + * @param[in] location The TEST_LOCATION macro should be used here + */ void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* location); /** diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-button.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-button.cpp index cbecb9b..a83f3e3 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-button.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-button.cpp @@ -72,6 +72,7 @@ void TestButton::SetProperty( BaseObject* object, Property::Index index, const P if ( button ) { + TestButton& buttonImpl = GetImpl(button); switch ( index ) { case Test::TestButton::Property::PRESS_TRANSITION: @@ -79,19 +80,28 @@ void TestButton::SetProperty( BaseObject* object, Property::Index index, const P if( value.GetType() == Property::MAP ) { Property::Map* valueMap = value.GetMap(); - TestButton& buttonImpl = GetImpl(button); buttonImpl.mPressTransitionData.Clear(); NewAnimation( *valueMap, buttonImpl.mPressTransitionData ); } else if( value.GetType() == Property::ARRAY ) { Property::Array* valueArray = value.GetArray(); - TestButton& buttonImpl = GetImpl(button); buttonImpl.mPressTransitionData.Clear(); NewAnimation( *valueArray, buttonImpl.mPressTransitionData ); } break; } + case Test::TestButton::Property::BACKGROUND_COLOR: + { + buttonImpl.mBackgroundColor = value.Get(); + break; + } + + case Test::TestButton::Property::FOREGROUND_COLOR: + { + buttonImpl.mForegroundColor = value.Get(); + break; + } } } } @@ -100,6 +110,8 @@ Property::Value TestButton::GetProperty( BaseObject* object, Property::Index pro { Test::TestButton button = Test::TestButton::DownCast( Dali::BaseHandle( object ) ); + Property::Value value; + if ( button ) { TestButton& buttonImpl = GetImpl(button); @@ -108,22 +120,26 @@ Property::Value TestButton::GetProperty( BaseObject* object, Property::Index pro case Test::TestButton::Property::PRESS_TRANSITION: { return ConvertAnimationMap(buttonImpl.mPressTransitionData); - break; } case Test::TestButton::Property::RELEASE_TRANSITION: { return ConvertAnimationMap(buttonImpl.mReleaseTransitionData); - break; } case Test::TestButton::Property::DISABLED_TRANSITION: { return ConvertAnimationMap(buttonImpl.mDisabledTransitionData); - break; } case Test::TestButton::Property::ENABLED_TRANSITION: { return ConvertAnimationMap(buttonImpl.mEnabledTransitionData); - break; + } + case Test::TestButton::Property::BACKGROUND_COLOR: + { + return Property::Value(buttonImpl.mBackgroundColor); + } + case Test::TestButton::Property::FOREGROUND_COLOR: + { + return Property::Value(buttonImpl.mForegroundColor); } } } @@ -142,6 +158,8 @@ DALI_PROPERTY_REGISTRATION( Test, TestButton, "pressTransition", ARRAY, PRESS_TR DALI_PROPERTY_REGISTRATION( Test, TestButton, "releaseTransition", ARRAY, RELEASE_TRANSITION) DALI_PROPERTY_REGISTRATION( Test, TestButton, "disabledTransition", ARRAY, DISABLED_TRANSITION ) DALI_PROPERTY_REGISTRATION( Test, TestButton, "enabledTransition", ARRAY, ENABLED_TRANSITION ) +DALI_PROPERTY_REGISTRATION( Test, TestButton, "backgroundColor", VECTOR4, BACKGROUND_COLOR ) +DALI_PROPERTY_REGISTRATION( Test, TestButton, "foregroundColor", VECTOR4, FOREGROUND_COLOR ) DALI_TYPE_REGISTRATION_END() diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-button.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-button.h index 5dd5ac3..c9a29e4 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-button.h +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-button.h @@ -42,7 +42,9 @@ public: PRESS_TRANSITION = PROPERTY_START_INDEX, RELEASE_TRANSITION, DISABLED_TRANSITION, - ENABLED_TRANSITION + ENABLED_TRANSITION, + BACKGROUND_COLOR, + FOREGROUND_COLOR }; }; TestButton(); @@ -79,6 +81,8 @@ public: Test::TestAnimationData mReleaseTransitionData; Test::TestAnimationData mDisabledTransitionData; Test::TestAnimationData mEnabledTransitionData; + Dali::Vector4 mBackgroundColor; + Dali::Vector4 mForegroundColor; }; inline TestButton& GetImpl( Test::TestButton& handle ) diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp index a69b323..5820806 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp @@ -394,6 +394,12 @@ static Internal::Adaptor::AccessibilityAdaptor& GetImplementation(Dali::Accessib return static_cast(handle); } +static const Internal::Adaptor::AccessibilityAdaptor& GetImplementation(const Dali::AccessibilityAdaptor& adaptor) +{ + const BaseObject& handle = adaptor.GetBaseObject(); + return static_cast(handle); +} + } // namespace Adaptor } // namespace Internal @@ -422,7 +428,7 @@ void AccessibilityAdaptor::MockSetReadPosition( Vector2& position ) // Methods: -Vector2 AccessibilityAdaptor::GetReadPosition() +Vector2 AccessibilityAdaptor::GetReadPosition() const { return Internal::Adaptor::GetImplementation(*this).GetReadPosition(); } diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.h index 900f374..2975c33 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.h +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.h @@ -56,7 +56,7 @@ public: // Getters static AccessibilityAdaptor Get(); - Vector2 GetReadPosition(); + Vector2 GetReadPosition() const; bool IsEnabled() const; void SetActionHandler(AccessibilityActionHandler& handler); void SetGestureHandler(AccessibilityGestureHandler& handler); diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-bitmap-loader.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-bitmap-loader.cpp new file mode 100644 index 0000000..00c1204 --- /dev/null +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-bitmap-loader.cpp @@ -0,0 +1,135 @@ +/* + * 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. + */ + +#include +#include +#include + +using namespace Dali; + +namespace Dali +{ +class Adaptor; + +namespace Internal +{ + +class BitmapLoader : public BaseObject +{ +public: + static IntrusivePtr New( const std::string& url, + ImageDimensions size, + FittingMode::Type fittingMode, + SamplingMode::Type samplingMode, + bool orientationCorrection) + { + IntrusivePtr internal = new BitmapLoader( url, size, fittingMode, samplingMode, orientationCorrection ); + return internal; + } + + BitmapLoader(const std::string& url, + ImageDimensions size, + FittingMode::Type fittingMode, + SamplingMode::Type samplingMode, + bool orientationCorrection) + : mSize(size), + mPixelData(), + mUrl(url) + { + } + + ~BitmapLoader(){} + + void Load() + { + size_t bufferSize = mSize.GetWidth() * mSize.GetHeight() * 4; + unsigned char* buffer = static_cast(malloc(bufferSize)); + memset(buffer, 0, bufferSize); + + mPixelData = PixelData::New( buffer, mSize.GetWidth(), mSize.GetHeight(), Pixel::RGBA8888, PixelData::FREE); + } + + PixelDataPtr GetPixelData() const + { + return mPixelData; + } + + const std::string& GetUrl() const + { + return mUrl; + } + + bool IsLoaded() + { + return mPixelData ? true : false; + } + + ImageDimensions mSize; + PixelDataPtr mPixelData; + const std::string mUrl; +}; + +} // internal + +inline Internal::BitmapLoader& GetImplementation(Dali::BitmapLoader& handle) +{ + DALI_ASSERT_ALWAYS( handle && "handle is empty" ); + BaseObject& object = handle.GetBaseObject(); + return static_cast(object); +} + +inline const Internal::BitmapLoader& GetImplementation(const Dali::BitmapLoader& handle) +{ + DALI_ASSERT_ALWAYS( handle && "handle is empty" ); + const BaseObject& object = handle.GetBaseObject(); + return static_cast(object); +} + +Dali::BitmapLoader Dali::BitmapLoader::New(std::string const&url, Dali::Uint16Pair size, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode, bool orientationCorrection) +{ + IntrusivePtr internal = Internal::BitmapLoader::New(url, size, fittingMode, samplingMode, orientationCorrection); + return BitmapLoader( internal.Get() ); +} + +Dali::BitmapLoader::BitmapLoader(Dali::BitmapLoader const& handle) +:BaseHandle(handle) +{ +} +Dali::BitmapLoader::BitmapLoader(Internal::BitmapLoader* internal) +:BaseHandle(internal) +{ +} +Dali::BitmapLoader::~BitmapLoader() +{ +} +void Dali::BitmapLoader::Load() +{ + GetImplementation(*this).Load(); +} +PixelDataPtr Dali::BitmapLoader::GetPixelData() const +{ + return GetImplementation(*this).GetPixelData(); +} +std::string Dali::BitmapLoader::GetUrl() const +{ + return GetImplementation(*this).GetUrl(); +} +bool Dali::BitmapLoader::IsLoaded() +{ + return GetImplementation(*this).IsLoaded(); +} + +} // Dali diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-color-controller.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-color-controller.cpp new file mode 100644 index 0000000..f24bc44 --- /dev/null +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-color-controller.cpp @@ -0,0 +1,91 @@ +/* + * 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. + */ + +#include + +#include + +using namespace Dali; + +namespace Dali +{ +namespace Internal +{ +namespace Adaptor +{ + +class ColorController : public BaseObject +{ +public: + ColorController(){} + static Dali::ColorController Get() + { + return Dali::ColorController( new ColorController() ); + } + + bool RetrieveColor( const std::string& colorCode, Vector4& colorValue ) + { + return false; + } + + bool RetrieveColor( const std::string& colorCode , + Vector4& textColor, + Vector4& textOutlineColor, + Vector4& textShadowColor) + { + return false; + } +protected: + virtual ~ColorController(){} +}; + +} // Adaptor +} // Internal + +inline Internal::Adaptor::ColorController& GetImplementation(Dali::ColorController& controller) +{ + DALI_ASSERT_ALWAYS(controller && "ColorController handle is empty"); + BaseObject& handle = controller.GetBaseObject(); + return static_cast(handle); +} + +inline const Internal::Adaptor::ColorController& GetImplementation(const Dali::ColorController& controller) +{ + DALI_ASSERT_ALWAYS(controller && "ColorController handle is empty"); + const BaseObject& handle = controller.GetBaseObject(); + return static_cast(handle); +} + +ColorController ColorController::Get() +{ + return Internal::Adaptor::ColorController::Get(); +} + +ColorController::ColorController(Internal::Adaptor::ColorController* internal) +: BaseHandle(internal) +{ +} + +ColorController::~ColorController() +{ +} + +bool ColorController::RetrieveColor( const std::string& colorCode, Vector4& colorValue ) +{ + return GetImplementation(*this).RetrieveColor( colorCode, colorValue ); +} + +} // Dali diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-feedback-player.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-feedback-player.cpp new file mode 100644 index 0000000..999249a --- /dev/null +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-feedback-player.cpp @@ -0,0 +1,180 @@ +/* + * 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. + */ + +#include +#include +#include + +using namespace Dali; + +namespace Dali +{ +class Adaptor; + +namespace Internal +{ +namespace Adaptor +{ + +class FeedbackPlayer : public Dali::BaseObject +{ +public: + static Dali::FeedbackPlayer New() + { + Dali::FeedbackPlayer player = Dali::FeedbackPlayer( new FeedbackPlayer() ); + return player; + } + + static Dali::FeedbackPlayer Get() + { + Dali::FeedbackPlayer player; + Dali::SingletonService service( Dali::SingletonService::Get() ); + if( service ) + { + // Check whether the singleton is already created + Dali::BaseHandle handle = service.GetSingleton( typeid( Dali::FeedbackPlayer ) ); + if( handle ) + { + player = Dali::FeedbackPlayer( dynamic_cast< FeedbackPlayer* >( handle.GetObjectPtr() ) ); + } + else + { + player = Dali::FeedbackPlayer( New() ); + service.Register( typeid( player ), player ); + } + } + return player; + } + void PlayMonotone(unsigned int duration) + { + } + + void PlayFile( const std::string& filePath ) + { + } + + void Stop() + { + } + + int PlaySound( const std::string& fileName ) + { + return 0; + } + + void StopSound( int handle ) + { + } + + void PlayFeedbackPattern( int type, int pattern ) + { + } + + bool LoadFile(const std::string& filename, std::string& data) + { + return true; + } + +private: + FeedbackPlayer() + { + } + + virtual ~FeedbackPlayer() + { + } + + FeedbackPlayer(const FeedbackPlayer&) + { + } + + FeedbackPlayer& operator=(FeedbackPlayer&) + { + return *this; + } +}; + +} // Adaptor +} // Internal + +inline Internal::Adaptor::FeedbackPlayer& GetImplementation(Dali::FeedbackPlayer& player) +{ + DALI_ASSERT_ALWAYS( player && "FeedbackPlayer handle is empty" ); + BaseObject& handle = player.GetBaseObject(); + return static_cast(handle); +} + +inline const Internal::Adaptor::FeedbackPlayer& GetImplementation(const Dali::FeedbackPlayer& player) +{ + DALI_ASSERT_ALWAYS( player && "FeedbackPlayer handle is empty" ); + const BaseObject& handle = player.GetBaseObject(); + return static_cast(handle); +} + +FeedbackPlayer::FeedbackPlayer() +{ +} + +FeedbackPlayer FeedbackPlayer::Get() +{ + return Internal::Adaptor::FeedbackPlayer::Get(); +} + +FeedbackPlayer::~FeedbackPlayer() +{ +} + +void FeedbackPlayer::PlayMonotone(unsigned int duration) +{ + GetImplementation(*this).PlayMonotone(duration); +} + +void FeedbackPlayer::PlayFile(const std::string filePath) +{ + GetImplementation(*this).PlayFile(filePath); +} + +void FeedbackPlayer::Stop() +{ + GetImplementation(*this).Stop(); +} + +int FeedbackPlayer::PlaySound( const std::string& fileName ) +{ + return GetImplementation(*this).PlaySound(fileName); +} + +void FeedbackPlayer::StopSound( int handle ) +{ + GetImplementation(*this).StopSound(handle); +} + +void FeedbackPlayer::PlayFeedbackPattern( int type, int pattern ) +{ + GetImplementation(*this).PlayFeedbackPattern(type, pattern); +} + +bool FeedbackPlayer::LoadFile(const std::string& filename, std::string& data) +{ + return GetImplementation(*this).LoadFile(filename, data); +} + +FeedbackPlayer::FeedbackPlayer( Internal::Adaptor::FeedbackPlayer* player ) +: BaseHandle( player ) +{ +} + +} // Dali diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-file-loader.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-file-loader.cpp new file mode 100644 index 0000000..5cc6ad1 --- /dev/null +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-file-loader.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2015 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 +#include +#include +#include + +namespace Dali +{ + +namespace FileLoader +{ + +int ReadFile( + const std::string& filename, + Dali::Vector & memblock, + FileLoader::FileType fileType) +{ + return 0; +} + +int ReadFile( + const std::string& filename, + std::streampos& fileSize, + Dali::Vector & memblock, + FileLoader::FileType fileType) +{ + return 0; +} + +std::streampos GetFileSize(const std::string& filename) +{ + return 0; +} + +} +} diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.cpp index 30dd65f..b1b5660 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.cpp @@ -15,130 +15,145 @@ * */ -#include "toolkit-orientation.h" +#include #include #include #include -namespace Dali -{ +using namespace Dali; -namespace +namespace Dali { -ToolkitOrientation* gToolkitOrientation(NULL); -} // unnamed namespace +class Adaptor; namespace Internal { - namespace Adaptor { +class Window; + + +struct RotationEvent +{ + int angle; ///< one of 0, 90, 180, 270 + int winResize; ///< true if the window should be resized + int width; ///< new window width + int height; ///< new window height +}; /** - * Stub for the Orientation + * The RotationObserver can be overridden in order to listen to rotation events. */ -class Orientation : public BaseObject +class RotationObserver { -public: // Creation & Destruction +public: + virtual void OnRotationPrepare( const RotationEvent& rotation ) = 0; + virtual void OnRotationRequest( ) = 0; - Orientation(); - Orientation(ToolkitOrientation *orientation); - ~Orientation(); +protected: + RotationObserver(){} + virtual ~RotationObserver(){} +}; -public: // Setters & Getters +class Orientation : public BaseObject, public RotationObserver +{ +public: + typedef Dali::Orientation::OrientationSignalType OrientationSignalType; - void SetDegrees( int degrees ) + static Orientation* New(Window* window) + { + Orientation* orientation = new Orientation(window); + return orientation; + } + Orientation(Window* window) { - mOrientation = degrees; } - int GetDegrees() const; - float GetRadians() const; - -public: // Signals - - Dali::Orientation::OrientationSignalType& ChangedSignal(); - - void EmitChangedSignal() +protected: + virtual ~Orientation() + { + } +public: + void SetAdaptor(Dali::Adaptor& adaptor) + { + } + int GetDegrees() const + { + return 0; + } + float GetRadians() const + { + return 0.0f; + } + OrientationSignalType& ChangedSignal() { - mChangedSignal.Emit(Dali::Orientation(this)); + return mChangedSignal; } + virtual void OnRotationPrepare( const RotationEvent& rotation ) + { + }; + virtual void OnRotationRequest( ) + { + }; private: - - Dali::Orientation::OrientationSignalType mChangedSignal; - - ToolkitOrientation* mToolkitOrientation; - - int mOrientation; + Orientation(const Orientation&); + Orientation& operator=(Orientation&); + OrientationSignalType mChangedSignal; }; -Orientation::Orientation() -: mToolkitOrientation(NULL), - mOrientation(0) -{ -} +} // Adaptor namespace +} // Internal namespace -Orientation::Orientation(ToolkitOrientation *orientation) -: mToolkitOrientation(orientation), - mOrientation(0) +inline Internal::Adaptor::Orientation& GetImplementation (Dali::Orientation& orientation) { + DALI_ASSERT_ALWAYS(orientation && "Orientation handle is empty"); + BaseObject& handle = orientation.GetBaseObject(); + return static_cast(handle); } - -Orientation::~Orientation() +inline const Internal::Adaptor::Orientation& GetImplementation(const Dali::Orientation& orientation) { + DALI_ASSERT_ALWAYS(orientation && "Orientation handle is empty"); + const BaseObject& handle = orientation.GetBaseObject(); + return static_cast(handle); } -int Orientation::GetDegrees() const +Orientation::Orientation() { - mToolkitOrientation->mFunctionsCalled.GetDegrees = true; - return mOrientation; } - -float Orientation::GetRadians() const +Orientation::~Orientation() { - mToolkitOrientation->mFunctionsCalled.GetRadians = true; - return Math::PI * (float)mOrientation / 180.0f; } - -Dali::Orientation::OrientationSignalType& Orientation::ChangedSignal() +Orientation::Orientation(const Orientation& handle) +: BaseHandle(handle) { - mToolkitOrientation->mFunctionsCalled.ChangedSignal = true; - return mChangedSignal; } -} // namespace Adaptor - -} // namespace Internal - -//////////////////////////////////////////////////////////////////////////////////////////////////// - -ToolkitOrientation::ToolkitOrientation() -: mOrientationStub(new Internal::Adaptor::Orientation(this)), - mOrientation( mOrientationStub ) +Orientation& Orientation::operator=(const Orientation& rhs) { - gToolkitOrientation = this; + BaseHandle::operator=(rhs); + return *this; } -ToolkitOrientation::~ToolkitOrientation() +int Orientation::GetDegrees() const { - gToolkitOrientation = NULL; + return GetImplementation(*this).GetDegrees(); } -Orientation ToolkitOrientation::GetHandle() +float Orientation::GetRadians() const { - return mOrientation; + return GetImplementation(*this).GetRadians(); } -void ToolkitOrientation::SetDegrees( int degrees ) +Orientation::OrientationSignalType& Orientation::ChangedSignal() { - mOrientationStub->SetDegrees( degrees ); + return GetImplementation(*this).ChangedSignal(); } -void ToolkitOrientation::EmitChangedSignal() +Orientation::Orientation( Internal::Adaptor::Orientation* orientation ) +: BaseHandle(orientation) { - mOrientationStub->EmitChangedSignal(); } -} // namespace Dali +} // Dali diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.h deleted file mode 100644 index 007f70f..0000000 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.h +++ /dev/null @@ -1,128 +0,0 @@ -#ifndef __DALI_TOOLKIT_TOOLKIT_ORIENTATION_H__ -#define __DALI_TOOLKIT_TOOLKIT_ORIENTATION_H__ - -/* - * Copyright (c) 2014 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 -#include - -namespace Dali -{ - -namespace Internal -{ -namespace Adaptor -{ -class Orientation; -} -} - -/** - * This creates a stubbed Orientation so that internal Toolkit Adaptor calls work. - * Furthermore, it provides an interface to see if certain methods were invoked. - */ -class ToolkitOrientation -{ -public: // Construction & Destruction - - ToolkitOrientation(); - ~ToolkitOrientation(); - -public: // Getters - - Orientation GetHandle(); - -public: // Setters - - void SetDegrees( int degrees ); - -public: // Signal Emissions - - void EmitChangedSignal(); - -public: // TEST FUNCTIONS - - // Enumeration of Adaptor methods - enum TestFuncEnum - { - GetDegrees, - GetRadians, - ChangedSignal, - }; - - void Reset() - { - mFunctionsCalled.Reset(); - } - - bool WasCalled(TestFuncEnum func) - { - switch(func) - { - case GetDegrees: return mFunctionsCalled.GetDegrees; - case GetRadians: return mFunctionsCalled.GetRadians; - case ChangedSignal: return mFunctionsCalled.ChangedSignal; - } - return false; - } - - void ResetCallStatistics(TestFuncEnum func) - { - switch(func) - { - case GetDegrees: mFunctionsCalled.GetDegrees = false; break; - case GetRadians: mFunctionsCalled.GetRadians = false; break; - case ChangedSignal: mFunctionsCalled.ChangedSignal = false; break; - } - } - -private: - - struct TestFunctions - { - TestFunctions() - : GetDegrees(false), - GetRadians(false), - ChangedSignal(false) - { - } - - void Reset() - { - GetDegrees = false; - GetRadians = false; - ChangedSignal = false; - } - - bool GetDegrees; - bool GetRadians; - bool ChangedSignal; - }; - - TestFunctions mFunctionsCalled; - - // The stub - Internal::Adaptor::Orientation* mOrientationStub; - friend class Internal::Adaptor::Orientation; - Orientation mOrientation; // Hold a handle ourselves. -}; - -} // namespace Dali - -#endif // __DALI_TOOLKIT_TOOLKIT_ORIENTATION_H__ diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.cpp index 8ac2d0f..d8efd70 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * 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. @@ -15,7 +15,7 @@ * */ -#include "toolkit-singleton-service.h" +#include #include #include @@ -31,108 +31,125 @@ namespace Internal namespace Adaptor { -/** - * Stub for the SingletonService - */ -class SingletonService : public Dali::BaseObject +namespace { -public: - static Dali::SingletonService New(); - static Dali::SingletonService Get(); - void Register( const std::type_info& info, BaseHandle singleton ); - void UnregisterAll(); - BaseHandle GetSingleton( const std::type_info& info ) const; - -private: - SingletonService(); - virtual ~SingletonService(); +Dali::IntrusivePtr gSingletonService; +} // unnamed namespace - // Undefined - SingletonService( const SingletonService& ); - SingletonService& operator=( SingletonService& ); -private: - - typedef std::pair SingletonPair; - typedef std::map SingletonContainer; - typedef SingletonContainer::const_iterator SingletonConstIter; - - SingletonContainer mSingletonContainer; ///< The container to look up singleton by its type name +class SingletonService : public Dali::BaseObject +{ +public: - static Dali::SingletonService mToolkitSingletonService; -}; + /** + * Create a SingletonService. + * This should only be called once by the Application class. + * @return A newly created SingletonService. + */ + static Dali::SingletonService New() + { + DALI_ASSERT_ALWAYS( 0 && "SingletonService New method used"); + gSingletonService = Dali::IntrusivePtr( new SingletonService() ); + return Dali::SingletonService( gSingletonService.Get() ); + } -Dali::SingletonService SingletonService::mToolkitSingletonService; + /** + * @copydoc Dali::SingletonService::Get() + */ + static Dali::SingletonService Get() + { + Dali::SingletonService singletonService; + if ( !gSingletonService ) + { + gSingletonService = Dali::IntrusivePtr( new SingletonService() ); + } + return Dali::SingletonService( gSingletonService.Get() ); + } -Dali::SingletonService SingletonService::New() -{ - return Get(); -} + /** + * @copydoc Dali::SingletonService::Register() + */ + void Register( const std::type_info& info, BaseHandle singleton ) + { + if( singleton ) + { + mSingletonContainer.insert( SingletonPair( info.name(), singleton ) ); + } + } -Dali::SingletonService SingletonService::Get() -{ - if( ! mToolkitSingletonService ) + /** + * @copydoc Dali::SingletonService::UnregisterAll() + */ + void UnregisterAll() { - mToolkitSingletonService = Dali::SingletonService( new Dali::Internal::Adaptor::SingletonService ); + mSingletonContainer.clear(); } - return mToolkitSingletonService; -} -void SingletonService::Register( const std::type_info& info, BaseHandle singleton ) -{ - if( singleton ) + /** + * @copydoc Dali::SingletonService::GetSingleton() + */ + BaseHandle GetSingleton( const std::type_info& info ) const { - mSingletonContainer.insert( SingletonPair( info.name(), singleton ) ); + BaseHandle object; + + SingletonConstIter iter = mSingletonContainer.find(info.name()); + if( iter != mSingletonContainer.end() ) + { + object = ( *iter ).second; + } + return object; } -} -void SingletonService::UnregisterAll() -{ - mSingletonContainer.clear(); -} +private: -BaseHandle SingletonService::GetSingleton( const std::type_info& info ) const -{ - BaseHandle object; + /** + * Private Constructor + * @see SingletonService::New() + */ + SingletonService() + : mSingletonContainer() + { + // Can only have one instance of SingletonService + DALI_ASSERT_ALWAYS( !gSingletonService && "Only one instance of SingletonService is allowed"); + gSingletonService = this; + } - SingletonConstIter iter = mSingletonContainer.find(info.name()); - if( iter != mSingletonContainer.end() ) + /** + * Virtual Destructor + */ + virtual ~SingletonService() { - object = ( *iter ).second; + gSingletonService = 0; } - return object; -} + // Undefined + SingletonService( const SingletonService& ); + SingletonService& operator=( SingletonService& ); -SingletonService::SingletonService() -: mSingletonContainer() -{ -} +private: + typedef std::pair SingletonPair; + typedef std::map SingletonContainer; + typedef SingletonContainer::const_iterator SingletonConstIter; -SingletonService::~SingletonService() -{ -} + SingletonContainer mSingletonContainer; ///< The container to look up singleton by its type name +}; } // namespace Adaptor } // namespace Internal //////////////////////////////////////////////////////////////////////////////////////////////////// -Internal::Adaptor::SingletonService& GetImplementation(Dali::SingletonService& player) +inline Internal::Adaptor::SingletonService& GetImplementation(Dali::SingletonService& player) { DALI_ASSERT_ALWAYS( player && "SingletonService handle is empty" ); - BaseObject& handle = player.GetBaseObject(); - return static_cast(handle); } -const Internal::Adaptor::SingletonService& GetImplementation(const Dali::SingletonService& player) +inline const Internal::Adaptor::SingletonService& GetImplementation(const Dali::SingletonService& player) { DALI_ASSERT_ALWAYS( player && "SingletonService handle is empty" ); - const BaseObject& handle = player.GetBaseObject(); - return static_cast(handle); } diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.h deleted file mode 100644 index 68e4ecc..0000000 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.h +++ /dev/null @@ -1,57 +0,0 @@ -#ifndef __DALI_TOOLKIT_TOOLKIT_SINGLETON_SERVICE_H__ -#define __DALI_TOOLKIT_TOOLKIT_SINGLETON_SERVICE_H__ - -/* - * Copyright (c) 2014 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 - -#define __DALI_SINGELTON_SERVICE_H__ -#include -#include - -// INTERNAL INCLUDES - -namespace Dali -{ - -namespace Internal DALI_INTERNAL -{ -namespace Adaptor -{ -class SingletonService; -} -} - -class SingletonService : public BaseHandle -{ -public: - SingletonService(); - static Dali::SingletonService New(); - static SingletonService Get(); - ~SingletonService(); - void Register( const std::type_info& info, BaseHandle singleton ); - void UnregisterAll(); - BaseHandle GetSingleton( const std::type_info& info ) const; - -public: // Not intended for application developers - SingletonService( Internal::Adaptor::SingletonService* singletonService ); -}; - -} // namespace Dali - -#endif // __DALI_TOOLKIT_TOOLKIT_SINGLETON_SERVICE_H__ diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-sound-player.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-sound-player.cpp new file mode 100644 index 0000000..8eefcfa --- /dev/null +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-sound-player.cpp @@ -0,0 +1,127 @@ +/* + * 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. + */ + +#include +#include +#include + +using namespace Dali; + +namespace Dali +{ +class Adaptor; + +namespace Internal +{ +namespace Adaptor +{ + + +class SoundPlayer : public Dali::BaseObject +{ +public: + static Dali::SoundPlayer New() + { + Dali::SoundPlayer player = Dali::SoundPlayer( new SoundPlayer() ); + return player; + } + + static Dali::SoundPlayer Get() + { + Dali::SoundPlayer player; + + Dali::SingletonService service( Dali::SingletonService::Get() ); + if ( service ) + { + // Check whether the singleton is already created + Dali::BaseHandle handle = service.GetSingleton( typeid( Dali::SoundPlayer ) ); + if ( handle ) + { + // If so, downcast the handle + player = Dali::SoundPlayer( dynamic_cast< SoundPlayer* >( handle.GetObjectPtr() ) ); + } + else + { + player = Dali::SoundPlayer( New() ); + service.Register( typeid( player ), player ); + } + } + return player; + } + + int PlaySound(const std::string fileName) + { + return 0; + } + + void Stop(int handle) + { + } + +private: + SoundPlayer() + { + } + + virtual ~SoundPlayer() + { + } + + SoundPlayer(const SoundPlayer&); + SoundPlayer& operator=(SoundPlayer&); +}; + +} // Adaptor namespace +} // Internal namespace + +inline Internal::Adaptor::SoundPlayer& GetImplementation(Dali::SoundPlayer& player) +{ + DALI_ASSERT_ALWAYS( player && "SoundPlayer handle is empty" ); + BaseObject& handle = player.GetBaseObject(); + return static_cast(handle); +} + +inline const Internal::Adaptor::SoundPlayer& GetImplementation(const Dali::SoundPlayer& player) +{ + DALI_ASSERT_ALWAYS( player && "SoundPlayer handle is empty" ); + const BaseObject& handle = player.GetBaseObject(); + return static_cast(handle); +} + +SoundPlayer SoundPlayer::Get() +{ + return Internal::Adaptor::SoundPlayer::Get(); +} + +SoundPlayer::SoundPlayer() +{ +} + +SoundPlayer::SoundPlayer(Internal::Adaptor::SoundPlayer*player) +:BaseHandle(player) +{ +} + +SoundPlayer::~SoundPlayer() +{ +} + +int SoundPlayer::PlaySound(const std::string fileName) +{ + return GetImplementation(*this).PlaySound(fileName); +} + +} // Dali diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.cpp index 65750c1..ba0469d 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.cpp @@ -23,8 +23,31 @@ namespace Dali { +const std::string Dali::StyleMonitor::DEFAULT_FONT_FAMILY("DefaultFont"); +const std::string Dali::StyleMonitor::DEFAULT_FONT_STYLE("Regular"); +const float Dali::StyleMonitor::DEFAULT_FONT_SIZE(1.0f); +} +namespace +{ +const char* DEFAULT_THEME= + "{\"styles\":{\n" + " \"textlabel\":\n" + " {\n" + " \"fontStyle\":\"Regular\",\n" + " \"pointSize\":18\n" + " }\n" + " }\n" + "}\n"; + +std::string gTheme; +std::string gFontFamily = Dali::StyleMonitor::DEFAULT_FONT_FAMILY; +std::string gFontStyle = Dali::StyleMonitor::DEFAULT_FONT_STYLE; +float gFontSize = Dali::StyleMonitor::DEFAULT_FONT_SIZE; +} +namespace Dali +{ namespace Internal { namespace Adaptor @@ -41,9 +64,11 @@ public: // Creation & Destruction public: // Style Information std::string GetDefaultFontFamily() const; + std::string GetDefaultFontStyle() const; float GetDefaultFontSize() const; const std::string& GetTheme() const; void SetTheme(std::string theme); + bool LoadThemeFile( const std::string& filename, std::string& output ); public: // Signals Dali::StyleMonitor::StyleChangeSignalType& StyleChangeSignal(); @@ -57,6 +82,8 @@ private: Dali::StyleMonitor::StyleChangeSignalType mStyleChangeSignal; static Dali::StyleMonitor mToolkitStyleMonitor; std::string mTheme; + + std::string mOutput; //<<< Test output. Use SetThemeFileOutput in a testharness to use it. }; Dali::StyleMonitor StyleMonitor::mToolkitStyleMonitor; @@ -81,12 +108,18 @@ StyleMonitor::~StyleMonitor() std::string StyleMonitor::GetDefaultFontFamily() const { - return Dali::StyleMonitor::DEFAULT_FONT_FAMILY; + return gFontFamily; +} + +std::string StyleMonitor::GetDefaultFontStyle() const +{ + return gFontStyle; } float StyleMonitor::GetDefaultFontSize() const { - return Dali::StyleMonitor::DEFAULT_FONT_SIZE; + return gFontSize; + } const std::string& StyleMonitor::GetTheme() const @@ -100,6 +133,19 @@ void StyleMonitor::SetTheme(std::string path) EmitStyleChangeSignal( StyleChange::THEME_CHANGE ); } +bool StyleMonitor::LoadThemeFile( const std::string& filename, std::string& output ) +{ + if( !gTheme.empty() ) + { + output = gTheme; + } + else + { + output = DEFAULT_THEME; + } + return true; +} + Dali::StyleMonitor::StyleChangeSignalType& StyleMonitor::StyleChangeSignal() { return mStyleChangeSignal; @@ -121,9 +167,6 @@ const Internal::Adaptor::StyleMonitor& GetImplementation(const Dali::StyleMonito return static_cast(object); } -const std::string Dali::StyleMonitor::DEFAULT_FONT_FAMILY("DefaultFont"); -const float Dali::StyleMonitor::DEFAULT_FONT_SIZE(1.0f); - StyleMonitor::StyleMonitor() { } @@ -147,6 +190,11 @@ std::string StyleMonitor::GetDefaultFontFamily() const return GetImplementation(*this).GetDefaultFontFamily(); } +std::string StyleMonitor::GetDefaultFontStyle() const +{ + return GetImplementation(*this).GetDefaultFontStyle(); +} + float StyleMonitor::GetDefaultFontSize() const { return GetImplementation(*this).GetDefaultFontSize(); @@ -172,6 +220,11 @@ void StyleMonitor::EmitStyleChangeSignal(StyleChange::Type styleChange) GetImplementation(*this).EmitStyleChangeSignal(styleChange); } +bool StyleMonitor::LoadThemeFile( const std::string& filename, std::string& output ) +{ + return GetImplementation(*this).LoadThemeFile(filename, output); +} + StyleMonitor& StyleMonitor::operator=(const StyleMonitor& monitor) { if( *this != monitor ) @@ -187,3 +240,31 @@ StyleMonitor::StyleMonitor(Internal::Adaptor::StyleMonitor* internal) } } // namespace Dali + +namespace Test +{ +namespace StyleMonitor +{ + +void SetThemeFileOutput( const std::string& output ) +{ + gTheme = output; +} + +void SetDefaultFontFamily(const std::string& family) +{ + gFontFamily = family; +} + +void SetDefaultFontStyle(const std::string& style) +{ + gFontStyle = style; +} + +void SetDefaultFontSize( float size ) +{ + gFontSize = size; +} + +} // StyleMonitor +} // Test diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.h index 8aa55e5..9bdb67c 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.h +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.h @@ -43,6 +43,7 @@ class StyleMonitor : public BaseHandle public: // Typedefs typedef Signal< void (StyleMonitor, StyleChange::Type) > StyleChangeSignalType; static const std::string DEFAULT_FONT_FAMILY; + static const std::string DEFAULT_FONT_STYLE; static const float DEFAULT_FONT_SIZE; public: // Creation & Destruction @@ -54,9 +55,11 @@ public: // Creation & Destruction public: // Style Information std::string GetDefaultFontFamily() const; + std::string GetDefaultFontStyle() const; float GetDefaultFontSize() const; const std::string& GetTheme() const; void SetTheme(std::string themeFilePath); + bool LoadThemeFile( const std::string& filename, std::string& output ); public: // Signals StyleChangeSignalType& StyleChangeSignal(); @@ -72,4 +75,16 @@ public: } // namespace Dali +namespace Test +{ +namespace StyleMonitor +{ +void SetThemeFileOutput( const std::string& output ); +void SetDefaultFontFamily(const std::string& family); +void SetDefaultFontStyle(const std::string& style); +void SetDefaultFontSize( float size ); + +} +} + #endif // __DALI_TOOLKIT_TOOLKIT_STYLE_MONITOR_H__ diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-test-application.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-test-application.h index 40280a0..384c22b 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-test-application.h +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-test-application.h @@ -22,8 +22,6 @@ #include #include -#include "toolkit-orientation.h" - namespace Dali { diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-text-abstraction.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-text-abstraction.cpp new file mode 100644 index 0000000..cd0c19d --- /dev/null +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-text-abstraction.cpp @@ -0,0 +1,553 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace Dali; + +namespace Dali +{ +class Adaptor; + +namespace TextAbstraction +{ +namespace Internal +{ + +class BidirectionalSupport : public BaseObject +{ +public: + BidirectionalSupport() + { + } + + ~BidirectionalSupport() + { + } + + static TextAbstraction::BidirectionalSupport Get() + { + TextAbstraction::BidirectionalSupport bidirectionalSupportHandle; + + Dali::SingletonService service( Dali::SingletonService::Get() ); + if( service ) + { + // Check whether the singleton is already created + BaseHandle handle = service.GetSingleton( typeid( TextAbstraction::BidirectionalSupport ) ); + if(handle) + { + // If so, downcast the handle + BidirectionalSupport* impl = dynamic_cast< Internal::BidirectionalSupport* >( handle.GetObjectPtr() ); + bidirectionalSupportHandle = TextAbstraction::BidirectionalSupport( impl ); + } + else // create and register the object + { + bidirectionalSupportHandle = TextAbstraction::BidirectionalSupport( new BidirectionalSupport ); + service.Register( typeid( bidirectionalSupportHandle ), bidirectionalSupportHandle ); + } + } + return bidirectionalSupportHandle; + } + BidiInfoIndex CreateInfo( const Character* const paragraph, Length numberOfCharacters ){return 0;} + + void DestroyInfo( BidiInfoIndex bidiInfoIndex ) + { + } + + void Reorder( BidiInfoIndex bidiInfoIndex,CharacterIndex firstCharacterIndex,Length numberOfCharacters,CharacterIndex* visualToLogicalMap ) + { + } + + bool GetMirroredText( Character* text,CharacterDirection* directions,Length numberOfCharacters ) + { + return true; + } + + bool GetParagraphDirection( BidiInfoIndex bidiInfoIndex ) const + { + return true; + } + + void GetCharactersDirection( BidiInfoIndex bidiInfoIndex, CharacterDirection* directions, Length numberOfCharacters ) + { + } +}; // class BidirectionalSupport + + +class FontClient : public BaseObject +{ +public: + FontClient() + : mDpiHorizontal( 0 ), + mDpiVertical( 0 ) + { + } + + ~FontClient(){} + + static Dali::TextAbstraction::FontClient Get() + { + Dali::TextAbstraction::FontClient fontClientHandle; + + Dali::SingletonService service( SingletonService::Get() ); + if ( service ) + { + // Check whether the singleton is already created + Dali::BaseHandle handle = service.GetSingleton( typeid( Dali::TextAbstraction::FontClient ) ); + if(handle) + { + // If so, downcast the handle + FontClient* impl = dynamic_cast< Dali::TextAbstraction::Internal::FontClient* >( handle.GetObjectPtr() ); + fontClientHandle = Dali::TextAbstraction::FontClient( impl ); + } + else // create and register the object + { + fontClientHandle = Dali::TextAbstraction::FontClient( new FontClient ); + service.Register( typeid( fontClientHandle ), fontClientHandle ); + } + } + + return fontClientHandle; + } + + void SetDpi( unsigned int horizontalDpi, unsigned int verticalDpi ){} + void GetDpi( unsigned int& horizontalDpi, unsigned int& verticalDpi ){horizontalDpi=verticalDpi=96;} + + void ResetSystemDefaults(){} + void GetDefaultFonts( FontList& defaultFonts ){} + void GetDefaultPlatformFontDescription( FontDescription& fontDescription ){} + void GetSystemFonts( FontList& systemFonts ){} + void GetDescription( FontId id, FontDescription& fontDescription ){} + PointSize26Dot6 GetPointSize( FontId id ){return 9;} + FontId FindDefaultFont( Character charcode, PointSize26Dot6 pointSize, bool preferColor ){return 0;} + FontId FindFallbackFont( FontId preferredFont, Character charcode, PointSize26Dot6 pointSize, bool preferColor ){return 0;} + FontId GetFontId( const FontPath& path, PointSize26Dot6 pointSize, FaceIndex faceIndex ){return 0;} + FontId GetFontId( const FontDescription& fontDescription,PointSize26Dot6 pointSize, FaceIndex faceIndex ){return 0;} + bool IsScalable( const FontPath& path ){return true;} + bool IsScalable( const FontDescription& fontDescription ){return true;} + void GetFixedSizes( const FontPath& path, Dali::Vector< PointSize26Dot6>& sizes ){} + void GetFixedSizes( const FontDescription& fontDescription, Dali::Vector< PointSize26Dot6 >& sizes ){} + void GetFontMetrics( FontId fontId, FontMetrics& metrics, int desiredFixedSize ){} + GlyphIndex GetGlyphIndex( FontId fontId, Character charcode ){return 0;} + bool GetGlyphMetrics( GlyphInfo* array, uint32_t size, bool horizontal, int desiredFixedSize ){return true;} + BufferImage CreateBitmap( FontId fontId, GlyphIndex glyphIndex ){return BufferImage();} + void CreateVectorBlob( FontId fontId, GlyphIndex glyphIndex, VectorBlob*& blob, + unsigned int& blobLength, unsigned int& nominalWidth, unsigned int& nominalHeight ) + { + blobLength = 0; + } + const GlyphInfo& GetEllipsisGlyph( PointSize26Dot6 pointSize ){return mGlyphInfo;} +private: + unsigned int mDpiHorizontal; + unsigned int mDpiVertical; + GlyphInfo mGlyphInfo; +}; // class FontClient + + +class Shaping : public BaseObject +{ +public: + Shaping() : mText(NULL) + {} + + ~Shaping() + { + delete [] mText; + } + + static Dali::TextAbstraction::Shaping Get() + { + Dali::TextAbstraction::Shaping shapingHandle; + + Dali::SingletonService service( SingletonService::Get() ); + if ( service ) + { + // Check whether the singleton is already created + Dali::BaseHandle handle = service.GetSingleton( typeid( Dali::TextAbstraction::Shaping ) ); + if(handle) + { + // If so, downcast the handle + Shaping* impl = dynamic_cast< Dali::TextAbstraction::Internal::Shaping* >( handle.GetObjectPtr() ); + shapingHandle = Dali::TextAbstraction::Shaping( impl ); + } + else // create and register the object + { + shapingHandle = Dali::TextAbstraction::Shaping( new Shaping ); + service.Register( typeid( shapingHandle ), shapingHandle ); + } + } + return shapingHandle; + } + + void GetGlyphs(GlyphInfo* glyphStore, unsigned int*mappingTable) + { + // Return store & mapping table (0, 1, 2, 3... N-1)) + if( glyphStore ) + { + memcpy( glyphStore, mText, mNumChars ); + } + for( unsigned int i=0; i(object); +} + +inline static const TextAbstraction::Internal::BidirectionalSupport& GetImplementation( const TextAbstraction::BidirectionalSupport& bidirectionalSupport ) +{ + DALI_ASSERT_ALWAYS( bidirectionalSupport && "bidirectional support handle is empty" ); + const BaseObject& object = bidirectionalSupport.GetBaseObject(); + return static_cast(object); +} + +inline static TextAbstraction::Internal::FontClient& GetImplementation(TextAbstraction::FontClient& fontClient) +{ + DALI_ASSERT_ALWAYS( fontClient && "fontClient handle is empty" ); + BaseObject& handle = fontClient.GetBaseObject(); + return static_cast(handle); +} + +inline static const TextAbstraction::Internal::FontClient& GetImplementation(const TextAbstraction::FontClient& fontClient) +{ + DALI_ASSERT_ALWAYS( fontClient && "fontClient handle is empty" ); + const BaseObject& handle = fontClient.GetBaseObject(); + return static_cast(handle); +} + +inline static TextAbstraction::Internal::Shaping& GetImplementation(TextAbstraction::Shaping& shaping) +{ + DALI_ASSERT_ALWAYS( shaping && "shaping handle is empty" ); + BaseObject& handle = shaping.GetBaseObject(); + return static_cast(handle); +} + +inline static const TextAbstraction::Internal::Shaping& GetImplementation(const TextAbstraction::Shaping& shaping) +{ + DALI_ASSERT_ALWAYS( shaping && "shaping handle is empty" ); + const BaseObject& handle = shaping.GetBaseObject(); + return static_cast(handle); +} + + +//////////////////////////////////////////////////////////////////////////////// +/******************************************************************************/ + +namespace TextAbstraction +{ +const PointSize26Dot6 FontClient::DEFAULT_POINT_SIZE = 768u; // 12*64 + +BidirectionalSupport::BidirectionalSupport() +{ +} + +BidirectionalSupport::~BidirectionalSupport() +{ +} + +BidirectionalSupport::BidirectionalSupport( Internal::BidirectionalSupport* implementation ) +: BaseHandle( implementation ) +{ +} + +BidirectionalSupport BidirectionalSupport::Get() +{ + return Internal::BidirectionalSupport::Get(); +} + +BidiInfoIndex BidirectionalSupport::CreateInfo( const Character* const paragraph, + Length numberOfCharacters ) +{ + return GetImplementation( *this ).CreateInfo( paragraph, numberOfCharacters ); +} + +void BidirectionalSupport::DestroyInfo( BidiInfoIndex bidiInfoIndex ) +{ + GetImplementation( *this ).DestroyInfo( bidiInfoIndex ); +} + +void BidirectionalSupport::Reorder( BidiInfoIndex bidiInfoIndex, + CharacterIndex firstCharacterIndex, + Length numberOfCharacters, + CharacterIndex* visualToLogicalMap ) +{ + GetImplementation( *this ).Reorder( bidiInfoIndex, firstCharacterIndex, numberOfCharacters, visualToLogicalMap ); +} + +bool BidirectionalSupport::GetMirroredText( Character* text, + CharacterDirection* directions, + Length numberOfCharacters ) +{ + return GetImplementation( *this ).GetMirroredText( text, directions, numberOfCharacters ); +} + +bool BidirectionalSupport::GetParagraphDirection( BidiInfoIndex bidiInfoIndex ) const +{ + return GetImplementation( *this ).GetParagraphDirection( bidiInfoIndex ); +} + +void BidirectionalSupport::GetCharactersDirection( BidiInfoIndex bidiInfoIndex, + CharacterDirection* directions, + Length numberOfCharacters ) +{ + GetImplementation( *this ).GetCharactersDirection( bidiInfoIndex, directions, numberOfCharacters ); +} + + +FontClient FontClient::Get() +{ + return Internal::FontClient::Get(); +} + +FontClient::FontClient() +{ +} + +FontClient::~FontClient() +{ +} + +FontClient::FontClient( const FontClient& handle ) +: BaseHandle( handle ) +{ +} + +FontClient& FontClient::operator=( const FontClient& handle ) +{ + BaseHandle::operator=( handle ); + return *this; +} + +void FontClient::SetDpi( unsigned int horizontalDpi, unsigned int verticalDpi ) +{ + GetImplementation(*this).SetDpi( horizontalDpi, verticalDpi ); +} + +void FontClient::GetDpi( unsigned int& horizontalDpi, unsigned int& verticalDpi ) +{ + GetImplementation(*this).GetDpi( horizontalDpi, verticalDpi ); +} + +void FontClient::ResetSystemDefaults() +{ + GetImplementation(*this).ResetSystemDefaults(); +} + +void FontClient::GetDefaultFonts( FontList& defaultFonts ) +{ + GetImplementation(*this).GetDefaultFonts( defaultFonts ); +} + +void FontClient::GetDefaultPlatformFontDescription( FontDescription& fontDescription ) +{ + GetImplementation(*this).GetDefaultPlatformFontDescription( fontDescription ); +} + +void FontClient::GetSystemFonts( FontList& systemFonts ) +{ + GetImplementation(*this).GetSystemFonts( systemFonts ); +} + +void FontClient::GetDescription( FontId id, FontDescription& fontDescription ) +{ + GetImplementation(*this).GetDescription( id, fontDescription ); +} + +PointSize26Dot6 FontClient::GetPointSize( FontId id ) +{ + return GetImplementation(*this).GetPointSize( id ); +} + +FontId FontClient::FindDefaultFont( Character charcode, PointSize26Dot6 pointSize, bool preferColor ) +{ + return GetImplementation(*this).FindDefaultFont( charcode, pointSize, preferColor ); +} + +FontId FontClient::FindFallbackFont( FontId preferredFont, Character charcode, PointSize26Dot6 pointSize, bool preferColor ) +{ + return GetImplementation(*this).FindFallbackFont( preferredFont, charcode, pointSize, preferColor ); +} + +FontId FontClient::GetFontId( const FontPath& path, PointSize26Dot6 pointSize, FaceIndex faceIndex ) +{ + return GetImplementation(*this).GetFontId( path, pointSize, faceIndex ); +} + +FontId FontClient::GetFontId( const FontDescription& fontDescription, + PointSize26Dot6 pointSize, + FaceIndex faceIndex ) +{ + return GetImplementation(*this).GetFontId( fontDescription, + pointSize, + faceIndex ); +} + +bool FontClient::IsScalable( const FontPath& path ) +{ + return GetImplementation(*this).IsScalable( path ); +} + +bool FontClient::IsScalable( const FontDescription& fontDescription ) +{ + return GetImplementation(*this).IsScalable( fontDescription ); +} + +void FontClient::GetFixedSizes( const FontPath& path, Dali::Vector< PointSize26Dot6>& sizes ) +{ + GetImplementation(*this).GetFixedSizes( path, sizes ); +} + +void FontClient::GetFixedSizes( const FontDescription& fontDescription, + Dali::Vector< PointSize26Dot6 >& sizes ) +{ + GetImplementation(*this).GetFixedSizes( fontDescription, sizes ); +} + +void FontClient::GetFontMetrics( FontId fontId, FontMetrics& metrics, int desiredFixedSize ) +{ + GetImplementation(*this).GetFontMetrics( fontId, metrics, desiredFixedSize ); +} + +GlyphIndex FontClient::GetGlyphIndex( FontId fontId, Character charcode ) +{ + return GetImplementation(*this).GetGlyphIndex( fontId, charcode ); +} + +bool FontClient::GetGlyphMetrics( GlyphInfo* array, uint32_t size, GlyphType type, bool horizontal, int desiredFixedSize ) +{ + return GetImplementation(*this).GetGlyphMetrics( array, size, horizontal, desiredFixedSize ); +} + +BufferImage FontClient::CreateBitmap( FontId fontId, GlyphIndex glyphIndex ) +{ + return GetImplementation(*this).CreateBitmap( fontId, glyphIndex ); +} + + +void FontClient::CreateVectorBlob( FontId fontId, + GlyphIndex glyphIndex, + VectorBlob*& blob, + unsigned int& blobLength, + unsigned int& nominalWidth, + unsigned int& nominalHeight ) +{ + GetImplementation(*this).CreateVectorBlob( fontId, glyphIndex, blob, blobLength, nominalWidth, nominalHeight ); +} + +const GlyphInfo& FontClient::GetEllipsisGlyph( PointSize26Dot6 pointSize ) +{ + return GetImplementation(*this).GetEllipsisGlyph( pointSize ); +} + +FontClient::FontClient( Internal::FontClient* internal ) +: BaseHandle( internal ) +{ +} + +FontMetrics::FontMetrics() +: ascender( 0.f ), + descender( 0.f ), + height( 0.f ), + underlinePosition( 0.f ), + underlineThickness( 0.f ) +{ +} + +GlyphInfo::GlyphInfo() +{ +} + +Script GetCharacterScript(unsigned int x) +{ + return LATIN; +} +bool HasLigatureMustBreak(Script x){return false;} +bool IsCommonScript(unsigned int character){ return false;} +bool IsNewParagraph(unsigned int character){return false;} +bool IsRightToLeftScript(Script){return false;} +bool IsWhiteSpace(unsigned int character) +{ + return character < 0x21; +} + +Segmentation Segmentation::Get(){ return Segmentation();} +Segmentation::Segmentation(){} +Segmentation::~Segmentation(){} +void Segmentation::GetLineBreakPositions(unsigned int const*, unsigned int, char*){} +void Segmentation::GetWordBreakPositions(unsigned int const*, unsigned int, char*){} + +Shaping Shaping::Get() +{ + return TextAbstraction::Internal::Shaping::Get(); +} + +Shaping::Shaping() +{ +} + +Shaping::Shaping( Internal::Shaping* internal ) +: BaseHandle( internal ) +{ +} + +Shaping::~Shaping() +{ +} + +void Shaping::GetGlyphs(GlyphInfo* glyphStore, unsigned int*mappingTable) +{ + // Return store & mapping table (0, 1, 2, 3... N-1)) + GetImplementation(*this).GetGlyphs(glyphStore, mappingTable); +} + +Length Shaping::Shape(unsigned int const* text, unsigned int numChars, unsigned int fontId, Script script) +{ + return GetImplementation(*this).Shape( text, numChars, fontId, script ); +} + +} // TextAbstraction +} // Dali diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-virtual-keyboard.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-virtual-keyboard.cpp new file mode 100644 index 0000000..e3f3ce5 --- /dev/null +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-virtual-keyboard.cpp @@ -0,0 +1,67 @@ +/* + * 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. + */ + +#include +#include + +using namespace Dali; + +namespace Dali +{ +class Adaptor; + +namespace Internal +{ +namespace Adaptor +{ + +namespace VirtualKeyboard +{ +Dali::VirtualKeyboard::StatusSignalType gKeyboardStatusSignal; +} + +} // Adaptor +} // Internal + + +bool IsKey( const Dali::KeyEvent& keyEvent, Dali::KEY daliKey) +{ + return true; +} + +namespace VirtualKeyboard +{ + +void ApplySettings( Dali::Property::Map const& ) +{ +} + +bool IsVisible() +{ + return false; +} + +void Show() +{ +} + +StatusSignalType& StatusChangedSignal() +{ + return Internal::Adaptor::VirtualKeyboard::gKeyboardStatusSignal; +} + +} // VirtualKeyboard +} // Dali diff --git a/automated-tests/src/dali-toolkit/utc-Dali-ControlRenderer.cpp b/automated-tests/src/dali-toolkit/utc-Dali-ControlRenderer.cpp index 810079f..55fa608 100644 --- a/automated-tests/src/dali-toolkit/utc-Dali-ControlRenderer.cpp +++ b/automated-tests/src/dali-toolkit/utc-Dali-ControlRenderer.cpp @@ -321,7 +321,7 @@ int UtcDaliControlRendererGetPropertyMap2(void) DALI_TEST_CHECK( typeValue ); DALI_TEST_CHECK( typeValue->Get() == "border" ); - colorValue = resultMap.Find( "borderColor", Property::VECTOR4 ); + colorValue = resultMap.Find( "borderColor", Property::VECTOR4 ); DALI_TEST_CHECK( colorValue ); DALI_TEST_CHECK( colorValue->Get() == Color::CYAN ); diff --git a/automated-tests/src/dali-toolkit/utc-Dali-StyleManager.cpp b/automated-tests/src/dali-toolkit/utc-Dali-StyleManager.cpp deleted file mode 100644 index 98a4d0b..0000000 --- a/automated-tests/src/dali-toolkit/utc-Dali-StyleManager.cpp +++ /dev/null @@ -1,123 +0,0 @@ -/* - * Copyright (c) 2014 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 -#include -#include -#include -#include -#include - - -using namespace Dali; -using namespace Dali::Toolkit; - -void dali_style_manager_startup(void) -{ - test_return_value = TET_UNDEF; -} - -void dali_style_manager_cleanup(void) -{ - test_return_value = TET_PASS; -} - -int UtcDaliStyleManagerGet(void) -{ - ToolkitTestApplication application; - - tet_infoline(" UtcDaliStyleManagerGet"); - - // Register Type - TypeInfo type; - type = TypeRegistry::Get().GetTypeInfo( "StyleManager" ); - DALI_TEST_CHECK( type ); - BaseHandle handle = type.CreateInstance(); - DALI_TEST_CHECK( handle ); - - StyleManager manager; - - manager = StyleManager::Get(); - DALI_TEST_CHECK(manager); - - StyleManager newManager = StyleManager::Get(); - DALI_TEST_CHECK(newManager); - - // Check that focus manager is a singleton - DALI_TEST_CHECK(manager == newManager); - END_TEST; -} - -int UtcDaliStyleManagerSetOrientationValue(void) -{ - ToolkitTestApplication application; - - tet_infoline( " UtcDaliStyleManagerSetOrientationValue" ); - - StyleManager manager = StyleManager::Get(); - - int orientation1 = 0; - manager.SetOrientationValue( orientation1 ); - DALI_TEST_CHECK( manager.GetOrientationValue() == orientation1 ); - - int orientation2 = 180; - manager.SetOrientationValue( orientation2 ); - DALI_TEST_CHECK( manager.GetOrientationValue() == orientation2 ); - - END_TEST; -} - -int UtcDaliStyleManagerSetOrientation(void) -{ - ToolkitTestApplication application; - - tet_infoline( " UtcDaliStyleManagerSetOrientation" ); - - StyleManager manager = StyleManager::Get(); - - Orientation orientation; - - manager.SetOrientation( orientation ); - - DALI_TEST_CHECK( manager.GetOrientation() == orientation ); - - END_TEST; -} - -int UtcDaliStyleManagerSetStyleConstant(void) -{ - ToolkitTestApplication application; - - tet_infoline( " UtcDaliStyleManagerSetStyleConstant" ); - - StyleManager manager = StyleManager::Get(); - - std::string key( "key" ); - Property::Value value( 100 ); - - manager.SetStyleConstant( key, value ); - - Property::Value returnedValue; - manager.GetStyleConstant( key, returnedValue ); - - DALI_TEST_CHECK( value.Get() == returnedValue.Get() ); - - std::string key2( "key2" ); - Property::Value returnedValue2; - DALI_TEST_CHECK( !manager.GetStyleConstant( key2, returnedValue2 ) ); - - END_TEST; -} diff --git a/dali-toolkit/devel-api/styling/style-manager.cpp b/dali-toolkit/devel-api/styling/style-manager.cpp index 19e2f1f..01be6ba 100644 --- a/dali-toolkit/devel-api/styling/style-manager.cpp +++ b/dali-toolkit/devel-api/styling/style-manager.cpp @@ -88,9 +88,9 @@ StyleManager::StyleManager( Internal::StyleManager *impl ) { } -StyleManager::StyleChangeSignalType& StyleManager::StyleChangeSignal() +StyleManager::StyleChangedSignalType& StyleManager::StyleChangedSignal() { - return GetImpl( *this ).StyleChangeSignal(); + return GetImpl( *this ).StyleChangedSignal(); } void StyleManager::RequestThemeChange( const std::string& themeFile ) @@ -106,4 +106,3 @@ void StyleManager::RequestDefaultTheme() } // namespace Toolkit } // namespace Dali - diff --git a/dali-toolkit/devel-api/styling/style-manager.h b/dali-toolkit/devel-api/styling/style-manager.h index 8c9f3b5..2d790a4 100644 --- a/dali-toolkit/devel-api/styling/style-manager.h +++ b/dali-toolkit/devel-api/styling/style-manager.h @@ -43,28 +43,17 @@ class StyleManager; * * The default theme is automatically loaded and applied. * - * If the application wants to customize the theme, RequestThemeChange needs to be called. - * Also, the default orientation is Portrait, if the application wants to adapt to the orientation change, call SetOrientation or SetOrienationValue. - * @code - * const char* CUSTOM_THEME = DALI_SCRIPT_DIR "tizen-dark-theme.json"; - * - * void OnInit(Application& app) - * { - * Toolkit::StyleManager::Get().RequestThemeChange( CUSTOM_THEME ); - * Toolkit::StyleManager::Get().SetOrientation( ... ); - * ... - * } - * @endcode - * - * Internal::Control can be configured to register for the signals that are required from StyleManager, - * such as theme change. + * If the application wants to customize the theme, RequestThemeChange + * needs to be called. Internal::Control can be configured to + * register for the signals that are required from StyleManager, such + * as theme change. */ class DALI_IMPORT_API StyleManager : public BaseHandle { public: // Signals - typedef Signal< void ( StyleManager, StyleChange::Type ) > StyleChangeSignalType; + typedef Signal< void ( StyleManager, StyleChange::Type ) > StyleChangedSignalType; /** * @brief Create a StyleManager handle; this can be initialised with StyleManager::Get() @@ -171,14 +160,16 @@ public: public: // Signals /** - * @brief This signal is emitted whenever the style (e.g. theme/font change) is changed on device + * @brief This signal is emitted after the style (e.g. theme/font change) has changed + * and the controls have been informed. + * * A callback of the following type may be connected: * @code * void YourCallbackName( StyleManager styleManager, StyleChange change ); * @endcode * @return The signal to connect to. */ - StyleChangeSignalType& StyleChangeSignal(); + StyleChangedSignalType& StyleChangedSignal(); public: diff --git a/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp b/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp index f0c3fc6..8301a08 100644 --- a/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp +++ b/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp @@ -802,34 +802,34 @@ void TextEditor::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange: { DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnStyleChange\n"); - switch ( change ) - { - case StyleChange::DEFAULT_FONT_CHANGE: - { - DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnStyleChange DEFAULT_FONT_CHANGE\n"); - std::string newFont = styleManager.GetDefaultFontFamily(); - // Property system did not set the font so should update it. - mController->UpdateAfterFontChange( newFont ); - break; - } - - case StyleChange::DEFAULT_FONT_SIZE_CHANGE: - { - DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor::OnStyleChange StyleChange::DEFAULT_FONT_SIZE_CHANGE (%f)\n", mController->GetDefaultPointSize() ); - - if ( (mController->GetDefaultPointSize() <= 0.0f) ) // If DefaultPointSize not set by Property system it will be 0.0f - { - // Property system did not set the PointSize so should update it. - // todo instruct text-controller to update model - } - break; - } - case StyleChange::THEME_CHANGE: - { - GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) ); - break; - } - } + switch ( change ) + { + case StyleChange::DEFAULT_FONT_CHANGE: + { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnStyleChange DEFAULT_FONT_CHANGE\n"); + std::string newFont = styleManager.GetDefaultFontFamily(); + // Property system did not set the font so should update it. + mController->UpdateAfterFontChange( newFont ); + break; + } + + case StyleChange::DEFAULT_FONT_SIZE_CHANGE: + { + DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor::OnStyleChange StyleChange::DEFAULT_FONT_SIZE_CHANGE (%f)\n", mController->GetDefaultPointSize() ); + + if ( (mController->GetDefaultPointSize() <= 0.0f) ) // If DefaultPointSize not set by Property system it will be 0.0f + { + // Property system did not set the PointSize so should update it. + // todo instruct text-controller to update model + } + break; + } + case StyleChange::THEME_CHANGE: + { + GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) ); + break; + } + } } Vector3 TextEditor::GetNaturalSize() diff --git a/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp b/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp index 082e7e5..ef00fc3 100644 --- a/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp +++ b/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp @@ -1024,34 +1024,34 @@ void TextField::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange:: { DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextField::OnStyleChange\n"); - switch ( change ) - { - case StyleChange::DEFAULT_FONT_CHANGE: - { - DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextField::OnStyleChange DEFAULT_FONT_CHANGE\n"); - std::string newFont = styleManager.GetDefaultFontFamily(); - // Property system did not set the font so should update it. - mController->UpdateAfterFontChange( newFont ); - break; - } - - case StyleChange::DEFAULT_FONT_SIZE_CHANGE: - { - DALI_LOG_INFO( gLogFilter, Debug::General, "TextField::OnStyleChange StyleChange::DEFAULT_FONT_SIZE_CHANGE (%f)\n", mController->GetDefaultPointSize() ); - - if ( (mController->GetDefaultPointSize() <= 0.0f) ) // If DefaultPointSize not set by Property system it will be 0.0f - { - // Property system did not set the PointSize so should update it. - // todo instruct text-controller to update model - } - break; - } - case StyleChange::THEME_CHANGE: - { - GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) ); - break; - } - } + switch ( change ) + { + case StyleChange::DEFAULT_FONT_CHANGE: + { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextField::OnStyleChange DEFAULT_FONT_CHANGE\n"); + std::string newFont = styleManager.GetDefaultFontFamily(); + // Property system did not set the font so should update it. + mController->UpdateAfterFontChange( newFont ); + break; + } + + case StyleChange::DEFAULT_FONT_SIZE_CHANGE: + { + DALI_LOG_INFO( gLogFilter, Debug::General, "TextField::OnStyleChange StyleChange::DEFAULT_FONT_SIZE_CHANGE (%f)\n", mController->GetDefaultPointSize() ); + + if ( (mController->GetDefaultPointSize() <= 0.0f) ) // If DefaultPointSize not set by Property system it will be 0.0f + { + // Property system did not set the PointSize so should update it. + // todo instruct text-controller to update model + } + break; + } + case StyleChange::THEME_CHANGE: + { + GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) ); + break; + } + } } Vector3 TextField::GetNaturalSize() diff --git a/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp b/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp index 9d3fd45..cc633b1 100644 --- a/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp +++ b/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp @@ -486,7 +486,6 @@ void TextLabel::OnInitialize() void TextLabel::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange::Type change ) { - DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextLabel::OnStyleChange\n"); switch ( change ) diff --git a/dali-toolkit/internal/styling/style-manager-impl.cpp b/dali-toolkit/internal/styling/style-manager-impl.cpp index 85aa069..f9569b9 100644 --- a/dali-toolkit/internal/styling/style-manager-impl.cpp +++ b/dali-toolkit/internal/styling/style-manager-impl.cpp @@ -248,9 +248,14 @@ void StyleManager::ApplyStyle( Toolkit::Control control, const std::string& json } } -Toolkit::StyleManager::StyleChangeSignalType& StyleManager::StyleChangeSignal() +Toolkit::StyleManager::StyleChangedSignalType& StyleManager::StyleChangedSignal() { - return mStyleChangeSignal; + return mStyleChangedSignal; +} + +Toolkit::StyleManager::StyleChangedSignalType& StyleManager::ControlStyleChangeSignal() +{ + return mControlStyleChangeSignal; } void StyleManager::SetTheme( const std::string& themeFile ) @@ -275,7 +280,7 @@ void StyleManager::SetTheme( const std::string& themeFile ) mFeedbackStyle->StyleChanged( mThemeFile, StyleChange::THEME_CHANGE ); } - mStyleChangeSignal.Emit( Toolkit::StyleManager::Get(), StyleChange::THEME_CHANGE ); + EmitStyleChangeSignals(StyleChange::THEME_CHANGE); } else { @@ -447,10 +452,21 @@ void StyleManager::StyleMonitorChange( StyleMonitor styleMonitor, StyleChange::T break; } } + EmitStyleChangeSignals( styleChange ); +} - mStyleChangeSignal.Emit( Toolkit::StyleManager::Get(), styleChange ); +void StyleManager::EmitStyleChangeSignals( StyleChange::Type styleChange ) +{ + Toolkit::StyleManager styleManager = StyleManager::Get(); + + // Update Controls first + mControlStyleChangeSignal.Emit( styleManager, styleChange ); + + // Inform application last + mStyleChangedSignal.Emit( styleManager, styleChange ); } + } // namespace Internal } // namespace Toolkit diff --git a/dali-toolkit/internal/styling/style-manager-impl.h b/dali-toolkit/internal/styling/style-manager-impl.h index 294e601..283cf96 100644 --- a/dali-toolkit/internal/styling/style-manager-impl.h +++ b/dali-toolkit/internal/styling/style-manager-impl.h @@ -136,8 +136,16 @@ public: /** * @copydoc Toolkit::StyleManager::StyleChangeSignal + * This signal is sent after all the controls have been updated + * due to style change */ - Toolkit::StyleManager::StyleChangeSignalType& StyleChangeSignal(); + Toolkit::StyleManager::StyleChangedSignalType& StyleChangedSignal(); + + /** + * This signal is sent to the controls following a style change. + * It should not be exposed in the public API + */ + Toolkit::StyleManager::StyleChangedSignalType& ControlStyleChangeSignal(); private: typedef std::vector StringList; @@ -232,6 +240,12 @@ private: */ void StyleMonitorChange( StyleMonitor styleMonitor, StyleChange::Type styleChange ); + /** + * Emit signals to controls first, app second + */ + void EmitStyleChangeSignals( StyleChange::Type styleChange ); + + // Undefined StyleManager(const StyleManager&); @@ -260,7 +274,8 @@ private: Toolkit::Internal::FeedbackStyle* mFeedbackStyle; ///< Feedback style // Signals - Toolkit::StyleManager::StyleChangeSignalType mStyleChangeSignal; ///< Emitted when the style( theme/font ) changes + Toolkit::StyleManager::StyleChangedSignalType mControlStyleChangeSignal; ///< Emitted when the style( theme/font ) changes for the controls to style themselves + Toolkit::StyleManager::StyleChangedSignalType mStyleChangedSignal; ///< Emitted after the controls have been styled }; } // namespace Internal diff --git a/dali-toolkit/public-api/controls/control-impl.cpp b/dali-toolkit/public-api/controls/control-impl.cpp index 841e3d3..2019553 100644 --- a/dali-toolkit/public-api/controls/control-impl.cpp +++ b/dali-toolkit/public-api/controls/control-impl.cpp @@ -674,12 +674,12 @@ Toolkit::Control::KeyEventSignalType& Control::KeyEventSignal() return mImpl->mKeyEventSignal; } -Toolkit::Control::KeyInputFocusSignalType& Control:: KeyInputFocusGainedSignal() +Toolkit::Control::KeyInputFocusSignalType& Control::KeyInputFocusGainedSignal() { return mImpl->mKeyInputFocusGainedSignal; } -Toolkit::Control::KeyInputFocusSignalType& Control:: KeyInputFocusLostSignal() +Toolkit::Control::KeyInputFocusSignalType& Control::KeyInputFocusLostSignal() { return mImpl->mKeyInputFocusLostSignal; } @@ -720,15 +720,18 @@ void Control::Initialize() if( mImpl->mFlags & REQUIRES_STYLE_CHANGE_SIGNALS ) { - Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get(); + Toolkit::StyleManager styleManager = StyleManager::Get(); + // if stylemanager is available if( styleManager ) { + StyleManager& styleManagerImpl = GetImpl( styleManager ); + // Register for style changes - styleManager.StyleChangeSignal().Connect( this, &Control::OnStyleChange ); + styleManagerImpl.ControlStyleChangeSignal().Connect( this, &Control::OnStyleChange ); // Apply the current style - GetImpl( styleManager ).ApplyThemeStyleAtInit( Toolkit::Control( GetOwner() ) ); + styleManagerImpl.ApplyThemeStyleAtInit( Toolkit::Control( GetOwner() ) ); } }