* Currently the resources folder is harcoded in compile time.
This works on devices where applications are always installed
in specific folders but doesn't work in other platforms like
MS Windows where the user can install the application in any
folder.
* An option has been added to the CMakeLists.txt file. By default
the resource folder is hardcoded. This behaviour can be disabled
by setting the option -DUSE_DEFAULT_RESOURCE_DIR=OFF and setting
environment variables in installation time for DALI_IMAGE_DIR,
DALI_SOUND_DIR, DALI_STYLE_DIR, DALI_STYLE_IMAGE_DIR and
DALI_DATA_READ_ONLY_DIR.
Change-Id: I3eea313da150f577e25171f2d5fb4791209f5181
Signed-off-by: Victor Cebollada <v.cebollada@samsung.com>
utc-Dali-ColorConversion.cpp
utc-Dali-Control-internal.cpp
utc-Dali-DebugRendering.cpp
+ utc-Dali-FeedbackStyle.cpp
utc-Dali-ItemView-internal.cpp
utc-Dali-LogicalModel.cpp
utc-Dali-PropertyHelper.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.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-input-method-context.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-input-method-options.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-lifecycle-controller.cpp
--- /dev/null
+/*
+ * Copyright (c) 2020 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 <iostream>
+#include <stdlib.h>
+
+#include <dali-toolkit/internal/feedback/feedback-style.h>
+#include <dali-toolkit-test-suite-utils.h>
+#include <dali-toolkit/dali-toolkit.h>
+#include <dali/devel-api/adaptor-framework/feedback-player.h>
+
+using namespace Dali;
+using namespace Toolkit;
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+namespace Adaptor
+{
+
+/**
+ * @brief Sets the return value of the FeedbackPlayer::LoadFile() method of the stub implementation.
+ *
+ * Used to improve the line coverage.
+ *
+ * @param[in] feedbackPlayer The FeedbackPlayer singleton.
+ * @param[in] returnValue The desired return value for the FeedbackPlayer::LoadFile() method. Either true or false.
+ */
+void SetLoadFileReturnValue( Dali::FeedbackPlayer feedbackPlayer, bool returnValue );
+
+}
+
+}
+
+}
+
+int UtcDaliFeedbackStyle(void)
+{
+ // Not too much to test. Just to improve coverage.
+
+ ToolkitTestApplication application;
+ tet_infoline(" UtcDaliFeedbackStyle");
+
+ try
+ {
+ Toolkit::Internal::FeedbackStyle feedbackStyle;
+
+ Dali::FeedbackPlayer feedbackPlayer = Dali::FeedbackPlayer::Get();
+ Dali::Internal::Adaptor::SetLoadFileReturnValue(feedbackPlayer, false);
+
+ Toolkit::Internal::FeedbackStyle feedbackStyle2;
+
+ Dali::Internal::Adaptor::SetLoadFileReturnValue(feedbackPlayer, true);
+ }
+ catch(...)
+ {
+ tet_result(TET_FAIL);
+ }
+
+ tet_result(TET_PASS);
+ END_TEST;
+}
bool LoadFile(const std::string& filename, std::string& data)
{
- return true;
+ return mLoadFileReturn;
+ }
+
+ void SetLoadFileReturnValue(bool value)
+ {
+ mLoadFileReturn = value;
}
private:
FeedbackPlayer()
+ : mLoadFileReturn{true}
{
}
{
return *this;
}
+
+ bool mLoadFileReturn;
};
} // Adaptor
{
}
+namespace Internal
+{
+namespace Adaptor
+{
+
+void SetLoadFileReturnValue(Dali::FeedbackPlayer feedbackPlayer, bool returnValue)
+{
+ GetImplementation(feedbackPlayer).SetLoadFileReturnValue( returnValue );
+}
+
+} // Adaptor
+} // Internal
+
} // Dali
Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
accAdaptor.HandleActionEnableEvent();
+ accAdaptor.HandleActionNextEvent(true);
Actor first = Actor::New();
Stage::GetCurrent().Add(first);
OPTION(ENABLE_LINK_TEST "Enable the link test" ON)
OPTION(INSTALL_DOXYGEN_DOC "Install doxygen doc" ON)
OPTION(CONFIGURE_AUTOMATED_TESTS "Configure automated tests" ON)
+OPTION(USE_DEFAULT_RESOURCE_DIR "Whether to use the default resource folders. Otherwise set environment variables for DALI_IMAGE_DIR, DALI_SOUND_DIR, DALI_STYLE_DIR, DALI_STYLE_IMAGE_DIR and DALI_DATA_READ_ONLY_DIR" ON)
IF( ENABLE_PKG_CONFIGURE )
FIND_PACKAGE( PkgConfig REQUIRED )
IF( SET_VCPKG_INSTALL_PREFIX )
ADD_DEFINITIONS( "-DBUILDING_DALI_TOOLKIT" )
- ADD_DEFINITIONS( -DDALI_IMAGE_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/images/\"
- -DDALI_SOUND_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/sounds/\"
- -DDALI_STYLE_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/styles/\"
- -DDALI_STYLE_IMAGE_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/styles/images/\"
- -DDALI_DATA_READ_ONLY_DIR=\"${VCPKG_INSTALLED_DIR}/share/\" )
+ IF( USE_DEFAULT_RESOURCE_DIR )
+ ADD_DEFINITIONS( -DDALI_IMAGE_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/images/\"
+ -DDALI_SOUND_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/sounds/\"
+ -DDALI_STYLE_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/styles/\"
+ -DDALI_STYLE_IMAGE_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/styles/images/\"
+ -DDALI_DATA_READ_ONLY_DIR=\"${VCPKG_INSTALLED_DIR}/share/\" )
+ ENDIF()
ELSE()
ADD_DEFINITIONS(-DPIC -DSTDC_HEADERS)
- ADD_DEFINITIONS(-DDALI_IMAGE_DIR=\"${dataReadOnlyDir}/toolkit/images/\"
- -DDALI_SOUND_DIR=\"${dataReadOnlyDir}/toolkit/sounds/\"
- -DDALI_STYLE_DIR=\"${dataReadOnlyDir}/toolkit/styles/\"
- -DDALI_STYLE_IMAGE_DIR=\"${dataReadOnlyDir}/toolkit/styles/images/\"
- -DDALI_DATA_READ_ONLY_DIR=\"${dataReadOnlyDir}\" )
+ IF( USE_DEFAULT_RESOURCE_DIR )
+ ADD_DEFINITIONS( -DDALI_IMAGE_DIR=\"${dataReadOnlyDir}/toolkit/images/\"
+ -DDALI_SOUND_DIR=\"${dataReadOnlyDir}/toolkit/sounds/\"
+ -DDALI_STYLE_DIR=\"${dataReadOnlyDir}/toolkit/styles/\"
+ -DDALI_STYLE_IMAGE_DIR=\"${dataReadOnlyDir}/toolkit/styles/images/\"
+ -DDALI_DATA_READ_ONLY_DIR=\"${dataReadOnlyDir}\" )
+ ENDIF()
IF("${ARCH}" STREQUAL "arm")
ADD_DEFINITIONS("-DTARGET")
ENDIF( NOT ${ENABLE_EXPORTALL} )
ENDIF()
+IF( NOT USE_DEFAULT_RESOURCE_DIR )
+ ADD_DEFINITIONS( -DDALI_IMAGE_DIR=0
+ -DDALI_SOUND_DIR=0
+ -DDALI_STYLE_DIR=0
+ -DDALI_STYLE_IMAGE_DIR=0
+ -DDALI_DATA_READ_ONLY_DIR=0 )
+ENDIF()
+
IF( ENABLE_TRACE )
ADD_DEFINITIONS("-DTRACE_ENABLED")
ENDIF()
--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/environment-variable.h>
+
+namespace
+{
+
+#define TOKEN_STRING(x) #x
+
+} // unnamed namespace
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+const std::string AssetManager::GetDaliImagePath()
+{
+ return (nullptr == DALI_IMAGE_DIR) ? EnvironmentVariable::GetEnvironmentVariable(TOKEN_STRING(DALI_IMAGE_DIR)) : DALI_IMAGE_DIR;
+}
+
+const std::string AssetManager::GetDaliSoundPath()
+{
+ return (nullptr == DALI_SOUND_DIR) ? EnvironmentVariable::GetEnvironmentVariable(TOKEN_STRING(DALI_SOUND_DIR)) : DALI_SOUND_DIR;
+}
+
+const std::string AssetManager::GetDaliStylePath()
+{
+ return (nullptr == DALI_STYLE_DIR) ? EnvironmentVariable::GetEnvironmentVariable(TOKEN_STRING(DALI_STYLE_DIR)) : DALI_STYLE_DIR;
+}
+
+const std::string AssetManager::GetDaliStyleImagePath()
+{
+ return (nullptr == DALI_STYLE_IMAGE_DIR) ? EnvironmentVariable::GetEnvironmentVariable(TOKEN_STRING(DALI_STYLE_IMAGE_DIR)) : DALI_STYLE_IMAGE_DIR;
+}
+
+const std::string AssetManager::GetDaliDataReadOnlyPath()
+{
+ return (nullptr == DALI_DATA_READ_ONLY_DIR) ? EnvironmentVariable::GetEnvironmentVariable(TOKEN_STRING(DALI_DATA_READ_ONLY_DIR)) : DALI_DATA_READ_ONLY_DIR;
+}
+
+} // Toolkit
+
+} // Dali
--- /dev/null
+#ifndef DALI_TOOLKIT_ASSET_MANAGER_DEVEL_H
+#define DALI_TOOLKIT_ASSET_MANAGER_DEVEL_H
+
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <string>
+
+// INTERNAL INCLUDES
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+class AssetManager
+{
+public:
+ static const std::string GetDaliImagePath();
+ static const std::string GetDaliSoundPath();
+ static const std::string GetDaliStylePath();
+ static const std::string GetDaliStyleImagePath();
+ static const std::string GetDaliDataReadOnlyPath();
+};
+
+} // Toolkit
+
+} // Dali
+
+
+#endif // DALI_TOOLKIT_ASSET_MANAGER_DEVEL_H
+
# Add local source files here
SET( devel_api_src_files
+ ${devel_api_src_dir}/asset-manager/asset-manager.cpp
${devel_api_src_dir}/builder/base64-encoding.cpp
${devel_api_src_dir}/builder/builder.cpp
${devel_api_src_dir}/builder/json-parser.cpp
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
const char* const ACTOR_FOCUSABLE("focusable");
const char* const IS_FOCUS_GROUP("isFocusGroup");
-const char* FOCUS_BORDER_IMAGE_PATH = DALI_IMAGE_DIR "B16-8_TTS_focus.9.png";
+const char* FOCUS_BORDER_IMAGE_FILE_NAME = "B16-8_TTS_focus.9.png";
-const char* FOCUS_SOUND_FILE = DALI_SOUND_DIR "Focus.ogg";
-const char* FOCUS_CHAIN_END_SOUND_FILE = DALI_SOUND_DIR "End_of_List.ogg";
+const char* FOCUS_SOUND_FILE_NAME = "Focus.ogg";
+const char* FOCUS_CHAIN_END_SOUND_FILE_NAME = "End_of_List.ogg";
/**
* The function to be used in the hit-test algorithm to check whether the actor is hittable.
mFocusIndicatorActor(),
mPreviousPosition( 0.0f, 0.0f ),
mRecursiveFocusMoveCounter(0),
+ mFocusSoundFilePath(),
+ mFocusChainEndSoundFilePath(),
mIsWrapped(false),
mIsFocusWithinGroup(false),
mIsEndcapFeedbackEnabled(false),
mIsAccessibilityTtsEnabled(false),
mTtsCreated(false),
mIsFocusIndicatorEnabled(false),
- mContinuousPlayMode(false)
+ mContinuousPlayMode(false),
+ mIsFocusSoundFilePathSet(false),
+ mIsFocusChainEndSoundFilePathSet(false)
{
}
Dali::SoundPlayer soundPlayer = Dali::SoundPlayer::Get();
if(soundPlayer)
{
- soundPlayer.PlaySound(FOCUS_SOUND_FILE);
+ if (!mIsFocusSoundFilePathSet)
+ {
+ const std::string soundDirPath = AssetManager::GetDaliSoundPath();
+ mFocusSoundFilePath = soundDirPath + FOCUS_SOUND_FILE_NAME;
+ mIsFocusSoundFilePathSet = true;
+ }
+ soundPlayer.PlaySound(mFocusSoundFilePath);
}
// Play the accessibility attributes with the TTS player.
if( ! mFocusIndicatorActor )
{
// Create the default if it hasn't been set and one that's shared by all the keyboard focusable actors
- mFocusIndicatorActor = Toolkit::ImageView::New( FOCUS_BORDER_IMAGE_PATH );
+ const std::string imageDirPath = AssetManager::GetDaliImagePath();
+ const std::string focusBorderImagePath = imageDirPath + FOCUS_BORDER_IMAGE_FILE_NAME;
+
+ mFocusIndicatorActor = Toolkit::ImageView::New(focusBorderImagePath);
mFocusIndicatorActor.SetParentOrigin( ParentOrigin::CENTER );
mFocusIndicatorActor.SetZ( 1.0f );
Dali::SoundPlayer soundPlayer = Dali::SoundPlayer::Get();
if(soundPlayer)
{
- soundPlayer.PlaySound(FOCUS_CHAIN_END_SOUND_FILE);
+ if (!mIsFocusChainEndSoundFilePathSet)
+ {
+ const std::string soundDirPath = AssetManager::GetDaliSoundPath();
+ mFocusChainEndSoundFilePath = soundDirPath + FOCUS_CHAIN_END_SOUND_FILE_NAME;
+ mIsFocusChainEndSoundFilePathSet = true;
+ }
+ soundPlayer.PlaySound(mFocusChainEndSoundFilePath);
}
mIsEndcapFeedbackPlayed = true;
Actor mFocusIndicatorActor; ///< The focus indicator actor shared by all the focusable actors for highlight
Vector2 mPreviousPosition; ///< The previous pan position; useful for calculating velocity for Gesture::Finished events
unsigned int mRecursiveFocusMoveCounter; ///< The counter to count the number of recursive focus movement attempted before the focus movement is successful.
+ std::string mFocusSoundFilePath; ///< The path of the focus sound file
+ std::string mFocusChainEndSoundFilePath; ///< The path of the focus chain end sound file
bool mIsWrapped:1; ///< Whether the focus movement is wrapped around or not
bool mIsFocusWithinGroup:1; ///< Whether the focus movement is limited to the current focus group or not
bool mTtsCreated:1; ///< Whether the TTS Player has been accessed
bool mIsFocusIndicatorEnabled:1; ///< Whether indicator should be shown / hidden. It could be enabled when TTS enabled or 'Tab' key operated.
bool mContinuousPlayMode:1; ///< Keeps track of whether or not we are in continuous play mode
+ bool mIsFocusSoundFilePathSet:1; ///< Whether the path of the focus sound file has been set
+ bool mIsFocusChainEndSoundFilePathSet:1; ///< Whether the path of the focus chain end sound file has been set
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
#include <dali-toolkit/devel-api/builder/json-parser.h>
#include <dali-toolkit/internal/builder/builder-declarations.h>
mParser = Dali::Toolkit::JsonParser::New();
Property::Map defaultDirs;
- defaultDirs[ TOKEN_STRING(DALI_IMAGE_DIR) ] = DALI_IMAGE_DIR;
- defaultDirs[ TOKEN_STRING(DALI_SOUND_DIR) ] = DALI_SOUND_DIR;
- defaultDirs[ TOKEN_STRING(DALI_STYLE_DIR) ] = DALI_STYLE_DIR;
- defaultDirs[ TOKEN_STRING(DALI_STYLE_IMAGE_DIR) ] = DALI_STYLE_IMAGE_DIR;
+ defaultDirs[TOKEN_STRING(DALI_IMAGE_DIR)] = AssetManager::GetDaliImagePath();
+ defaultDirs[TOKEN_STRING(DALI_SOUND_DIR)] = AssetManager::GetDaliSoundPath();
+ defaultDirs[TOKEN_STRING(DALI_STYLE_DIR)] = AssetManager::GetDaliStylePath();
+ defaultDirs[TOKEN_STRING(DALI_STYLE_IMAGE_DIR)] = AssetManager::GetDaliStyleImagePath();
AddConstants( defaultDirs );
}
#include <dali/public-api/size-negotiation/relayout-container.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
#include <dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
}; const unsigned int ContextualModeTableCount = sizeof( ContextualModeTable ) / sizeof( ContextualModeTable[0] );
// Popup defaults.
-const Vector3 DEFAULT_POPUP_PARENT_RELATIVE_SIZE( 0.75f, 1.0f, 1.0f ); ///< Default size percentage of parent.
-const float DEFAULT_POPUP_ANIMATION_DURATION = 0.6f; ///< Duration of hide/show animations.
-const float POPUP_OUT_MARGIN_WIDTH = 16.f; ///< Space between the screen edge and the popup edge in the horizontal dimension.
-const float POPUP_OUT_MARGIN_HEIGHT = 36.f; ///< Space between the screen edge and the popup edge in the vertical dimension.
-const Vector3 DEFAULT_TAIL_POSITION( 0.5f, 1.0f, 0.0f ); ///< Position the tail will be displayed when enabled without setting the position.
+const Vector3 DEFAULT_POPUP_PARENT_RELATIVE_SIZE( 0.75f, 1.0f, 1.0f ); ///< Default size percentage of parent.
+const float DEFAULT_POPUP_ANIMATION_DURATION = 0.6f; ///< Duration of hide/show animations.
+const float POPUP_OUT_MARGIN_WIDTH = 16.f; ///< Space between the screen edge and the popup edge in the horizontal dimension.
+const float POPUP_OUT_MARGIN_HEIGHT = 36.f; ///< Space between the screen edge and the popup edge in the vertical dimension.
+const Vector3 DEFAULT_TAIL_POSITION( 0.5f, 1.0f, 0.0f ); ///< Position the tail will be displayed when enabled without setting the position.
// Contextual defaults.
-const Vector2 DEFAULT_CONTEXTUAL_ADJACENCY_MARGIN( 10.0f, 10.0f ); ///< How close the Popup will be to it's contextual parent.
-const Vector2 DEFAULT_CONTEXTUAL_STAGE_BORDER( 15.0f, 15.0f ); ///< How close the Popup can be to the stage edges.
+const Vector2 DEFAULT_CONTEXTUAL_ADJACENCY_MARGIN( 10.0f, 10.0f ); ///< How close the Popup will be to it's contextual parent.
+const Vector2 DEFAULT_CONTEXTUAL_STAGE_BORDER( 15.0f, 15.0f ); ///< How close the Popup can be to the stage edges.
// Popup style defaults.
-const char* DEFAULT_BACKGROUND_IMAGE_PATH = DALI_IMAGE_DIR "00_popup_bg.9.png"; ///< Background image.
-const char* DEFAULT_TAIL_UP_IMAGE_PATH = DALI_IMAGE_DIR "popup_tail_up.png"; ///< Tail up image.
-const char* DEFAULT_TAIL_DOWN_IMAGE_PATH = DALI_IMAGE_DIR "popup_tail_down.png"; ///< Tail down image.
-const char* DEFAULT_TAIL_LEFT_IMAGE_PATH = DALI_IMAGE_DIR "popup_tail_left.png"; ///< Tail left image.
-const char* DEFAULT_TAIL_RIGHT_IMAGE_PATH = DALI_IMAGE_DIR "popup_tail_right.png"; ///< Tail right image.
-
-const Vector4 DEFAULT_BACKING_COLOR( 0.0f, 0.0f, 0.0f, 0.5f ); ///< Color of the dimmed backing.
-const Rect<int> DEFAULT_BACKGROUND_BORDER( 17, 17, 13, 13 ); ///< Default border of the background.
-const Rect<float> DEFAULT_TITLE_PADDING( 20.0f, 20.0f, 20.0f, 20.0f ); ///< Title padding used on popups with content and/or controls (from Tizen GUI UX).
-const Rect<float> DEFAULT_TITLE_ONLY_PADDING( 8.0f, 8.0f, 8.0f, 8.0f ); ///< Title padding used on popups with a title only (like toast popups).
-const Vector3 FOOTER_SIZE( 620.0f, 96.0f,0.0f ); ///< Default size of the bottom control area.
-const float DEFAULT_RELATIVE_PARENT_WIDTH = 0.75f; ///< If width is not fixed, relative size to parent is used by default.
+const char* DEFAULT_BACKGROUND_IMAGE_FILE_NAME = "00_popup_bg.9.png"; ///< Background image.
+const char* DEFAULT_TAIL_UP_IMAGE_FILE_NAME = "popup_tail_up.png"; ///< Tail up image.
+const char* DEFAULT_TAIL_DOWN_IMAGE_FILE_NAME = "popup_tail_down.png"; ///< Tail down image.
+const char* DEFAULT_TAIL_LEFT_IMAGE_FILE_NAME = "popup_tail_left.png"; ///< Tail left image.
+const char* DEFAULT_TAIL_RIGHT_IMAGE_FILE_NAME = "popup_tail_right.png"; ///< Tail right image.
+
+const Vector4 DEFAULT_BACKING_COLOR( 0.0f, 0.0f, 0.0f, 0.5f ); ///< Color of the dimmed backing.
+const Rect<int> DEFAULT_BACKGROUND_BORDER( 17, 17, 13, 13 ); ///< Default border of the background.
+const Rect<float> DEFAULT_TITLE_PADDING( 20.0f, 20.0f, 20.0f, 20.0f ); ///< Title padding used on popups with content and/or controls (from Tizen GUI UX).
+const Rect<float> DEFAULT_TITLE_ONLY_PADDING( 8.0f, 8.0f, 8.0f, 8.0f ); ///< Title padding used on popups with a title only (like toast popups).
+const Vector3 FOOTER_SIZE( 620.0f, 96.0f,0.0f ); ///< Default size of the bottom control area.
+const float DEFAULT_RELATIVE_PARENT_WIDTH = 0.75f; ///< If width is not fixed, relative size to parent is used by default.
} // Unnamed namespace
mPopupBackgroundImage(),
mBackgroundBorder( DEFAULT_BACKGROUND_BORDER ),
mMargin(),
- mTailUpImage( DEFAULT_TAIL_UP_IMAGE_PATH ),
- mTailDownImage( DEFAULT_TAIL_DOWN_IMAGE_PATH ),
- mTailLeftImage( DEFAULT_TAIL_LEFT_IMAGE_PATH ),
- mTailRightImage( DEFAULT_TAIL_RIGHT_IMAGE_PATH )
+ mTailUpImage(),
+ mTailDownImage(),
+ mTailLeftImage(),
+ mTailRightImage()
{
SetKeyboardNavigationSupport( true );
+
+ const std::string imageDirPath = AssetManager::GetDaliImagePath();
+ mTailUpImage = imageDirPath + DEFAULT_TAIL_UP_IMAGE_FILE_NAME;
+ mTailDownImage = imageDirPath + DEFAULT_TAIL_DOWN_IMAGE_FILE_NAME;
+ mTailLeftImage = imageDirPath + DEFAULT_TAIL_LEFT_IMAGE_FILE_NAME;
+ mTailRightImage = imageDirPath + DEFAULT_TAIL_RIGHT_IMAGE_FILE_NAME;
}
void Popup::OnInitialize()
mPopupLayout = Toolkit::TableView::New( 3, 1 );
// Adds the default background image.
- SetPopupBackgroundImage( Toolkit::ImageView::New( DEFAULT_BACKGROUND_IMAGE_PATH ) );
+ const std::string imageDirPath = AssetManager::GetDaliImagePath();
+ SetPopupBackgroundImage( Toolkit::ImageView::New( imageDirPath + DEFAULT_BACKGROUND_IMAGE_FILE_NAME ) );
mPopupLayout.SetName( "popupLayoutTable" );
mPopupLayout.SetParentOrigin( ParentOrigin::CENTER );
// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>
+// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
+
namespace Dali
{
namespace
{
+const char* const IMAGE_BRDF_FILE_NAME = "brdfLUT.png";
+
// glTF file extension
const std::string GLTF_EXT( ".gltf" );
mLightType = Toolkit::Scene3dView::LightType::IMAGE_BASED_LIGHT;
// BRDF texture
- std::string imageBrdfUrl = DALI_IMAGE_DIR "brdfLUT.png";
+ const std::string imageDirPath = AssetManager::GetDaliImagePath();
+ const std::string imageBrdfUrl = imageDirPath + IMAGE_BRDF_FILE_NAME;
mBRDFTexture = LoadTexture( imageBrdfUrl.c_str(), true );
if( !mBRDFTexture )
{
#include <dali/devel-api/object/property-helper-devel.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
#include <dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h>
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
namespace
{
-const char* DEFAULT_INDICATOR_IMAGE_PATH = DALI_IMAGE_DIR "popup_scroll.9.png";
+const char* DEFAULT_INDICATOR_IMAGE_FILE_NAME = "popup_scroll.9.png";
const float DEFAULT_SLIDER_DEPTH(1.0f);
const float DEFAULT_INDICATOR_SHOW_DURATION(0.5f);
const float DEFAULT_INDICATOR_HIDE_DURATION(0.5f);
void ScrollBar::CreateDefaultIndicatorActor()
{
- Toolkit::ImageView indicator = Toolkit::ImageView::New( DEFAULT_INDICATOR_IMAGE_PATH );
+ const std::string imageDirPath = AssetManager::GetDaliImagePath();
+ Toolkit::ImageView indicator = Toolkit::ImageView::New( imageDirPath + DEFAULT_INDICATOR_IMAGE_FILE_NAME );
indicator.SetParentOrigin( ParentOrigin::TOP_LEFT );
indicator.SetAnchorPoint( AnchorPoint::TOP_LEFT );
indicator.SetStyleName( "ScrollBarIndicator" );
#include <dali/public-api/events/touch-data.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
-#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
+#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT;
const float POPUP_TEXT_PADDING = 10.0f;
-const char* SKINNED_TRACK_VISUAL = DALI_IMAGE_DIR "slider-skin.9.png";
-const char* SKINNED_HANDLE_VISUAL = DALI_IMAGE_DIR "slider-skin-handle.png";
-const char* SKINNED_PROGRESS_VISUAL = DALI_IMAGE_DIR "slider-skin-progress.9.png";
-const char* SKINNED_POPUP_VISUAL = DALI_IMAGE_DIR "slider-popup.9.png";
-const char* SKINNED_POPUP_ARROW_VISUAL = DALI_IMAGE_DIR "slider-popup-arrow.png";
+const char* SKINNED_TRACK_VISUAL_FILE_NAME = "slider-skin.9.png";
+const char* SKINNED_HANDLE_VISUAL_FILE_NAME = "slider-skin-handle.png";
+const char* SKINNED_PROGRESS_VISUAL_FILE_NAME = "slider-skin-progress.9.png";
+const char* SKINNED_POPUP_VISUAL_FILE_NAME = "slider-popup.9.png";
+const char* SKINNED_POPUP_ARROW_VISUAL_FILE_NAME = "slider-popup-arrow.png";
const Vector2 DEFAULT_HIT_REGION( DEFAULT_WIDTH, DEFAULT_HIT_HEIGHT );
const Vector2 DEFAULT_TRACK_REGION( DEFAULT_WIDTH, DEFAULT_HEIGHT );
SetTrackRegion( DEFAULT_TRACK_REGION );
SetHandleSize( DEFAULT_HANDLE_SIZE );
- SetTrackVisual( SKINNED_TRACK_VISUAL );
- SetHandleVisual( SKINNED_HANDLE_VISUAL );
- SetProgressVisual( SKINNED_PROGRESS_VISUAL );
- SetPopupVisual( SKINNED_POPUP_VISUAL );
- SetPopupArrowVisual( SKINNED_POPUP_ARROW_VISUAL );
+ const std::string imageDirPath = AssetManager::GetDaliImagePath();
+ SetTrackVisual( imageDirPath + SKINNED_TRACK_VISUAL_FILE_NAME );
+ SetHandleVisual( imageDirPath + SKINNED_HANDLE_VISUAL_FILE_NAME );
+ SetProgressVisual( imageDirPath + SKINNED_PROGRESS_VISUAL_FILE_NAME );
+ SetPopupVisual( imageDirPath + SKINNED_POPUP_VISUAL_FILE_NAME );
+ SetPopupArrowVisual( imageDirPath + SKINNED_POPUP_ARROW_VISUAL_FILE_NAME );
SetShowPopup( DEFAULT_SHOW_POPUP );
SetShowValue( DEFAULT_SHOW_VALUE );
#include <dali/devel-api/adaptor-framework/style-monitor.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
#include <dali-toolkit/devel-api/builder/json-parser.h>
#include <dali-toolkit/internal/feedback/feedback-ids.h>
-using std::string;
-
namespace // unnamed namespace
{
Debug::Filter* gLogFilter = Debug::Filter::New(Debug::General, false, "LOG_FEEDBACK");
#endif
-const char* DEFAULT_FEEDBACK_THEME_PATH = DALI_STYLE_DIR"default-feedback-theme.json";
+const char* DEFAULT_FEEDBACK_THEME_FILE_NAME = "default-feedback-theme.json";
// Sets bool and string if the node has a child "name"
void GetIfString(const Dali::Toolkit::TreeNode& node, const std::string& name, bool& exists, std::string& str)
bool mHasHapticFeedbackInfo;
bool mHasSoundFeedbackInfo;
- string mSignalName;
- string mHapticFeedbackPattern;
- string mSoundFeedbackPattern;
- string mHapticFeedbackFile;
- string mSoundFeedbackFile;
+ std::string mSignalName;
+ std::string mHapticFeedbackPattern;
+ std::string mSoundFeedbackPattern;
+ std::string mHapticFeedbackFile;
+ std::string mSoundFeedbackFile;
};
typedef std::vector<SignalFeedbackInfo> SignalFeedbackInfoContainer;
{
}
- string mTypeName;
+ std::string mTypeName;
SignalFeedbackInfoContainer mSignalFeedbackInfoList;
};
{
mFeedback = Dali::FeedbackPlayer::Get();
- string defaultTheme;
+ const std::string styleDirPath = AssetManager::GetDaliStylePath();
+ const std::string defaultThemeFilePath = styleDirPath + DEFAULT_FEEDBACK_THEME_FILE_NAME;
+
+ std::string defaultTheme;
- if( mFeedback && mFeedback.LoadFile( DEFAULT_FEEDBACK_THEME_PATH, defaultTheme ) )
+ if( mFeedback && mFeedback.LoadFile( defaultThemeFilePath, defaultTheme ) )
{
LoadTheme( defaultTheme );
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "ResourceLoader::LoadTheme(%s) - loaded %d bytes\n",
- DEFAULT_FEEDBACK_THEME_PATH, defaultTheme.size() );
+ defaultThemeFilePath.c_str(), defaultTheme.size() );
}
else
{
- DALI_LOG_ERROR("ResourceLoader::LoadTheme(%s) - failed to load\n", DEFAULT_FEEDBACK_THEME_PATH);
+ DALI_LOG_ERROR("ResourceLoader::LoadTheme(%s) - failed to load\n", defaultThemeFilePath.c_str());
}
}
struct PlayFeedbackFromSignal
{
- PlayFeedbackFromSignal( FeedbackStyle& controller, const string& typeName, const string& signalName )
+ PlayFeedbackFromSignal( FeedbackStyle& controller, const std::string& typeName, const std::string& signalName )
: mController( controller ),
mTypeName( typeName ),
mSignalName( signalName )
}
FeedbackStyle& mController;
- string mTypeName;
- string mSignalName;
+ std::string mTypeName;
+ std::string mSignalName;
};
void FeedbackStyle::ObjectCreated( BaseHandle handle )
{
- std::string typeName = handle.GetTypeName();
-
if( handle )
{
- string type = handle.GetTypeName();
+ const std::string& type = handle.GetTypeName();
const FeedbackStyleInfo styleInfo = GetStyleInfo( type );
}
}
-const FeedbackStyleInfo& FeedbackStyle::GetStyleInfo( const string& type ) const
+const FeedbackStyleInfo& FeedbackStyle::GetStyleInfo( const std::string& type ) const
{
- std::map<const string, FeedbackStyleInfo>::const_iterator iter( mStyleInfoLut.find( type ) );
+ std::map<const std::string, FeedbackStyleInfo>::const_iterator iter( mStyleInfoLut.find( type ) );
if( iter != mStyleInfoLut.end() )
{
return iter->second;
{
if( styleChange == StyleChange::THEME_CHANGE )
{
- string userDefinedTheme;
+ std::string userDefinedTheme;
if( mFeedback && mFeedback.LoadFile( userDefinedThemePath, userDefinedTheme ) )
{
{
DALI_LOG_ERROR("FeedbackStyle::StyleChanged() User defined theme failed to load! \n");
+ const std::string styleDirPath = AssetManager::GetDaliStylePath();
+ const std::string defaultThemeFilePath = styleDirPath + DEFAULT_FEEDBACK_THEME_FILE_NAME;
+
//If there is any problem is using the user defined theme, then fall back to default theme
- if( !LoadTheme( DEFAULT_FEEDBACK_THEME_PATH ) )
+ if( !LoadTheme( defaultThemeFilePath ) )
{
//If the default theme fails, Then No luck!
DALI_LOG_ERROR("FeedbackStyle::StyleChanged() Default theme failed to load! \n");
}
}
-bool FeedbackStyle::LoadTheme( const string& data )
+bool FeedbackStyle::LoadTheme( const std::string& data )
{
bool result = false;
return result;
}
-void FeedbackStyle::LoadFromString( const string& data )
+void FeedbackStyle::LoadFromString( const std::string& data )
{
Toolkit::JsonParser parser = Toolkit::JsonParser::New();
const Toolkit::TreeNode* root = NULL;
}
}
-void FeedbackStyle::PlayFeedback(const string& type, const string& signalName)
+void FeedbackStyle::PlayFeedback(const std::string& type, const std::string& signalName)
{
const FeedbackStyleInfo styleInfo = GetStyleInfo(type);
SignalFeedbackInfoConstIter iter;
}
}
-FeedbackPattern FeedbackStyle::GetFeedbackPattern( const string &pattern )
+FeedbackPattern FeedbackStyle::GetFeedbackPattern( const std::string &pattern )
{
if( 0 == mFeedbackPatternLut.size() )
{
mFeedbackPatternLut["FEEDBACK_PATTERN_SLIDER_SWEEP"] = Dali::FEEDBACK_PATTERN_SLIDER_SWEEP;
}
- std::map<const string, FeedbackPattern>::const_iterator iter( mFeedbackPatternLut.find( pattern ) );
+ std::map<const std::string, FeedbackPattern>::const_iterator iter( mFeedbackPatternLut.find( pattern ) );
if( iter != mFeedbackPatternLut.end() )
{
#include <dali/integration-api/adaptor-framework/scene-holder.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
const char* const IS_FOCUS_GROUP_PROPERTY_NAME = "isKeyboardFocusGroup"; // This property will be replaced by a flag in Control.
-const char* const FOCUS_BORDER_IMAGE_PATH = DALI_IMAGE_DIR "keyboard_focus.9.png";
+const char* const FOCUS_BORDER_IMAGE_FILE_NAME = "keyboard_focus.9.png";
BaseHandle Create()
{
if( ! mFocusIndicatorActor )
{
// Create the default if it hasn't been set and one that's shared by all the keyboard focusable actors
- mFocusIndicatorActor = Toolkit::ImageView::New( FOCUS_BORDER_IMAGE_PATH );
+ const std::string imageDirPath = AssetManager::GetDaliImagePath();
+ mFocusIndicatorActor = Toolkit::ImageView::New( imageDirPath + FOCUS_BORDER_IMAGE_FILE_NAME );
// Apply size constraint to the focus indicator
mFocusIndicatorActor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
#include <dali/public-api/adaptor-framework/application.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
#include <dali-toolkit/internal/builder/builder-impl.h>
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
const char* PORTRAIT_QUALIFIER = "portrait";
const char* FONT_SIZE_QUALIFIER = "fontsize";
-const char* DEFAULT_THEME = DALI_STYLE_DIR "dali-toolkit-default-theme.json";
+const char* DEFAULT_THEME_FILE_NAME = "dali-toolkit-default-theme.json";
const char* PACKAGE_PATH_KEY = "PACKAGE_PATH";
const char* APPLICATION_RESOURCE_PATH_KEY = "APPLICATION_RESOURCE_PATH";
-const char* DEFAULT_PACKAGE_PATH = DALI_DATA_READ_ONLY_DIR "/toolkit/";
+const char* DEFAULT_TOOLKIT_PACKAGE_PATH = "/toolkit/";
#if defined(DEBUG_ENABLED)
Debug::Filter* gLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_STYLE");
StyleManager::StyleManager()
: mDefaultFontSize( -1 ),
mDefaultFontFamily(""),
- mFeedbackStyle( NULL )
+ mDefaultThemeFilePath(),
+ mFeedbackStyle( nullptr )
{
// Add theme builder constants
- mThemeBuilderConstants[ PACKAGE_PATH_KEY ] = DEFAULT_PACKAGE_PATH;
+ const std::string dataReadOnlyDir = AssetManager::GetDaliDataReadOnlyPath();
+ mThemeBuilderConstants[ PACKAGE_PATH_KEY ] = dataReadOnlyDir + DEFAULT_TOOLKIT_PACKAGE_PATH;
mThemeBuilderConstants[ APPLICATION_RESOURCE_PATH_KEY ] = Application::GetResourcePath();
mStyleMonitor = StyleMonitor::Get();
mDefaultFontSize = mStyleMonitor.GetDefaultFontSize();
}
+ // Set the full path for the default style theme.
+ const std::string styleDirPath = AssetManager::GetDaliStylePath();
+ mDefaultThemeFilePath = styleDirPath + DEFAULT_THEME_FILE_NAME;
+
// Sound & haptic style
mFeedbackStyle = new FeedbackStyle();
}
void StyleManager::ApplyDefaultTheme()
{
- SetTheme( DEFAULT_THEME );
+ SetTheme(mDefaultThemeFilePath);
}
const std::string& StyleManager::GetDefaultFontFamily() const
{
loading = true;
mThemeBuilder = CreateBuilder( mThemeBuilderConstants );
- themeLoaded = LoadJSON( mThemeBuilder, DEFAULT_THEME ); // Sets themeLoaded to true if theme exists
+ themeLoaded = LoadJSON( mThemeBuilder, mDefaultThemeFilePath ); // Sets themeLoaded to true if theme exists
}
- if( themeFile.compare(DEFAULT_THEME) != 0 )
+ if( themeFile.compare(mDefaultThemeFilePath) != 0 )
{
// The theme is different to the default: Merge it
loading = true;
mThemeBuilder = CreateBuilder( mThemeBuilderConstants );
// Load default theme because this is first try to load stylesheet.
- themeLoaded = LoadJSON( mThemeBuilder, DEFAULT_THEME );
- mThemeFile = DEFAULT_THEME;
+ themeLoaded = LoadJSON( mThemeBuilder, mDefaultThemeFilePath );
+ mThemeFile = mDefaultThemeFilePath;
if( themeLoaded )
{
int mDefaultFontSize; ///< Logical size, not a point-size
std::string mDefaultFontFamily;
+ std::string mDefaultThemeFilePath; ///< The full path of the default theme file
std::string mThemeFile; ///< The full path of the current theme file
Property::Map mThemeBuilderConstants; ///< Contants to give the theme builder
#include <dali-toolkit/internal/visuals/svg/svg-visual.h>
#include <dali-toolkit/internal/visuals/image-atlas-manager.h>
-
-namespace
-{
-const char * const BROKEN_VISUAL_IMAGE_URL( DALI_IMAGE_DIR "broken.png");
-}
-
namespace Dali
{
#include <dali/devel-api/scripting/scripting.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
#include <dali-toolkit/public-api/visuals/text-visual-properties.h>
DALI_TYPE_REGISTRATION_BEGIN_CREATE( Toolkit::VisualFactory, Dali::BaseHandle, Create, true )
DALI_TYPE_REGISTRATION_END()
-const char * const BROKEN_IMAGE_URL( DALI_IMAGE_DIR "broken.png" ); ///< URL For the broken image
+const char* const BROKEN_IMAGE_FILE_NAME = "broken.png"; ///< The file name of the broken image.
} // namespace
{
if( type == StyleChange::THEME_CHANGE )
{
- std::string brokenImageUrl(BROKEN_IMAGE_URL);
+ const std::string imageDirPath = AssetManager::GetDaliImagePath();
+ std::string brokenImageUrl = imageDirPath + BROKEN_IMAGE_FILE_NAME;
Property::Map config = Toolkit::DevelStyleManager::GetConfigurations( styleManager );
config["brokenImageUrl"].Get( brokenImageUrl );
{
mFactoryCache = std::unique_ptr<VisualFactoryCache>( new VisualFactoryCache( mPreMultiplyOnLoad ) );
- std::string brokenImageUrl(BROKEN_IMAGE_URL);
+ const std::string imageDirPath = AssetManager::GetDaliImagePath();
+ std::string brokenImageUrl = imageDirPath + BROKEN_IMAGE_FILE_NAME;
+
Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
if( styleManager )
{