utc-Dali-Text-ViewModel.cpp
utc-Dali-DebugRendering.cpp
utc-Dali-ItemView-internal.cpp
+ utc-Dali-PropertyHelper.cpp
)
# Append list of test harness files (Won't get parsed for test cases)
--- /dev/null
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali-toolkit-test-suite-utils.h>
+#include <dali-toolkit/internal/helpers/property-helper.h>
+
+using namespace Dali;
+using namespace Dali::Toolkit;
+
+void dali_property_helper_startup(void)
+{
+ test_return_value = TET_UNDEF;
+}
+
+void dali_property_helper_cleanup(void)
+{
+ test_return_value = TET_PASS;
+}
+
+int UtcDaliPropertyHelperGetStringFromPropertyWithString(void)
+{
+ tet_infoline( "Test to check if a simple string is parsed correctly" );
+
+ const std::string inputString = "Hello World";
+ Property::Value value( inputString );
+
+ std::string output;
+ DALI_TEST_CHECK( Toolkit::Internal::GetStringFromProperty( value, output ) );
+ DALI_TEST_EQUALS( output, inputString, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliPropertyHelperGetStringFromPropertyWithEmptyValue(void)
+{
+ tet_infoline( "Test to ensure if an empty value returns false" );
+
+ std::string output;
+ DALI_TEST_CHECK( ! Toolkit::Internal::GetStringFromProperty( Property::Value(), output ) );
+
+ END_TEST;
+}
+
+int UtcDaliPropertyHelperGetStringFromPropertyWithStringArray(void)
+{
+ tet_infoline( "Test to check if a string array is parsed correctly and adds new line characters too" );
+
+ Property::Value value( Property::Array().Add( "Hello World" )
+ .Add( "The Quick Brown Fox" )
+ .Add( "Jumps over the lazy dog" ) );
+
+ std::string output;
+ DALI_TEST_CHECK( Toolkit::Internal::GetStringFromProperty( value, output ) );
+ DALI_TEST_CHECK( output.find( "Hello World\n" ) != std::string::npos );
+ DALI_TEST_CHECK( output.find( "The Quick Brown Fox\n" ) != std::string::npos );
+ DALI_TEST_CHECK( output.find( "Jumps over the lazy dog\n" ) != std::string::npos );
+
+ END_TEST;
+}
+
+int UtcDaliPropertyHelperGetStringFromPropertyWithEmptyArray(void)
+{
+ tet_infoline( "Test to check if an empty array returns false" );
+
+ Property::Array array;
+
+ std::string output;
+ DALI_TEST_CHECK( ! Toolkit::Internal::GetStringFromProperty( Property::Value( array ), output ) );
+
+ END_TEST;
+}
+
+int UtcDaliPropertyHelperGetStringFromPropertyWithMultipleTypesInArray(void)
+{
+ tet_infoline( "Test to ensure an array with multiple types returns false" );
+
+ Property::Value value( Property::Array().Add( "Hello World" )
+ .Add( "The Quick Brown Fox" )
+ .Add( 1 )
+ .Add( "Jumps" )
+ .Add( 25 )
+ .Add( "Over" ) );
+
+ std::string output;
+ DALI_TEST_CHECK( ! Toolkit::Internal::GetStringFromProperty( value, output ) );
+ DALI_TEST_CHECK( output.empty() );
+
+ END_TEST;
+}
#include <dali-toolkit-test-suite-utils.h>
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
+#include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
+#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
+#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
using namespace Dali;
using namespace Dali::Toolkit;
namespace
{
-
+static const char* trackImage = TEST_RESOURCE_DIR "/progress-bar-skin-track-progress.png";
+static const char* progressImage = TEST_RESOURCE_DIR "/progress-bar-skin-progress-progress.png";
+static const char* secondaryProgressImage = TEST_RESOURCE_DIR "/progress-bar-skin-secondary-progress.png";
+static const char* indeterminateImage = TEST_RESOURCE_DIR "/progress-bar-skin-indeterminate.png";
static bool gObjectCreatedCallBackCalled;
static void TestCallback(BaseHandle handle)
static bool gProgressBarValueChangedCallBackCalled = false;
-static void OnProgressBarValueChanged( ProgressBar progressBar, float value )
+static void OnProgressBarValueChanged( ProgressBar progressBar, float value, float secondaryValue )
{
gProgressBarValueChangedCallBackCalled = true;
}
progressBar.SetAnchorPoint(ParentOrigin::TOP_LEFT);
progressBar.SetSize( Vector2( Stage::GetCurrent().GetSize().x, 20.0f ) );
progressBar.SetPosition( 0.0f, 0.0f );
-
progressBar.ValueChangedSignal().Connect( &OnProgressBarValueChanged );
+
progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 0.2f);
application.SendNotification();
application.Render();
- //gProgressBarValueChangedCallBackCalled = false;
+ DALI_TEST_CHECK(gProgressBarValueChangedCallBackCalled);
+
+ //Check Secondary progress value can make signal
+ gProgressBarValueChangedCallBackCalled = false;
+ progressBar.SetProperty(ProgressBar::Property::SECONDARY_PROGRESS_VALUE, 0.2f);
+
+ application.SendNotification();
+ application.Render();
DALI_TEST_CHECK(gProgressBarValueChangedCallBackCalled);
END_TEST;
progressBar.SetAnchorPoint(ParentOrigin::TOP_LEFT);
progressBar.SetSize( Vector2( Stage::GetCurrent().GetSize().x, 20.0f ) );
progressBar.SetPosition( 0.0f, 0.0f );
-
+ progressBar.ValueChangedSignal().Connect( &OnProgressBarValueChanged );
Stage::GetCurrent().Add(progressBar);
application.SendNotification();
application.Render();
- float val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.0f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 0.2f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.2f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 0.8f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.8f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 0.4f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.4f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 0.0f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.0f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 1.0f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 1.0f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, -1.0f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 1.0f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 0.9f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.9f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 1.1f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.9f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 2.0f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.9f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 0.0f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.0f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 0.9f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.9f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 0.09f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.09f, TEST_LOCATION);
-
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 0.1f);
- val = progressBar.GetProperty<float>(ProgressBar::Property::PROGRESS_VALUE);
- DALI_TEST_EQUALS(val, 0.1f, TEST_LOCATION);
-
- {
- Property::Map map;
- map["rendererType"] = "image";
- map["size"] = Vector2(200, 200);
- map["url"] = "track2.png";
- progressBar.SetProperty(ProgressBar::Property::TRACK_VISUAL, map);
- map["url"] = "progress2.png";
- progressBar.SetProperty(ProgressBar::Property::PROGRESS_VISUAL, map);
-
- Property::Value value = progressBar.GetProperty(ProgressBar::Property::TRACK_VISUAL);
- Property::Map* resultMap = value.GetMap();
- DALI_TEST_CHECK( resultMap );
- Property::Value* url = resultMap->Find("url");
- DALI_TEST_CHECK( url ) ;
- DALI_TEST_EQUALS( *url, "track2.png", TEST_LOCATION );
-
- value = progressBar.GetProperty(ProgressBar::Property::PROGRESS_VISUAL);
- resultMap = value.GetMap();
- DALI_TEST_CHECK( resultMap );
- url = resultMap->Find("url");
- DALI_TEST_CHECK( url ) ;
- DALI_TEST_EQUALS( *url, "progress2.png", TEST_LOCATION );
-
- }
-
+ Property::Map map;
+ map["visualType"] = "IMAGE";
+ map[Toolkit::ImageVisual::Property::URL] = trackImage;
+ progressBar.SetProperty(ProgressBar::Property::TRACK_VISUAL, map);
+
+ Property::Value value = progressBar.GetProperty(ProgressBar::Property::TRACK_VISUAL);
+ Property::Map* resultMap = value.GetMap();
+ DALI_TEST_CHECK( resultMap );
+ Property::Value* urlValue = resultMap->Find( Toolkit::ImageVisual::Property::URL );
+ std::string urlString;
+ urlValue->Get( urlString );
+ DALI_TEST_CHECK( !urlString.empty() ) ;
+ DALI_TEST_EQUALS( urlString, trackImage, TEST_LOCATION );
+
+ Property::Map colorMap;
+ colorMap["visualType"] = "COLOR";
+ colorMap[Toolkit::ColorVisual::Property::MIX_COLOR] = Color::RED;
+ progressBar.SetProperty(ProgressBar::Property::TRACK_VISUAL, colorMap);
+
+ value = progressBar.GetProperty(ProgressBar::Property::TRACK_VISUAL);
+ resultMap = value.GetMap();
+ DALI_TEST_CHECK( resultMap );
+ Property::Value* colorValue = resultMap->Find( Toolkit::ColorVisual::Property::MIX_COLOR );
+ Vector4 color = Color::TRANSPARENT;
+ colorValue->Get( color );
+ DALI_TEST_CHECK( color != Color::TRANSPARENT );
+ DALI_TEST_EQUALS( color, Color::RED, TEST_LOCATION );
+
+ map[Toolkit::ImageVisual::Property::URL] = progressImage;
+ progressBar.SetProperty(ProgressBar::Property::PROGRESS_VISUAL, map);
+
+ value = progressBar.GetProperty(ProgressBar::Property::PROGRESS_VISUAL);
+ resultMap = value.GetMap();
+ DALI_TEST_CHECK( resultMap );
+ urlValue = resultMap->Find( Toolkit::ImageVisual::Property::URL );
+ urlValue->Get( urlString );
+ DALI_TEST_CHECK( !urlString.empty() ) ;
+ DALI_TEST_EQUALS( urlString, progressImage, TEST_LOCATION );
+
+ progressBar.SetProperty(ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, secondaryProgressImage);
+
+ value = progressBar.GetProperty(ProgressBar::Property::SECONDARY_PROGRESS_VISUAL);
+ resultMap = value.GetMap();
+ DALI_TEST_CHECK( resultMap );
+ urlValue = resultMap->Find( Toolkit::ImageVisual::Property::URL );
+ urlValue->Get( urlString );
+ DALI_TEST_CHECK( !urlString.empty() ) ;
+ DALI_TEST_EQUALS( urlString, secondaryProgressImage, TEST_LOCATION );
+
+ map[Toolkit::ImageVisual::Property::URL] = secondaryProgressImage;
+ progressBar.SetProperty(ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, map);
+
+ value = progressBar.GetProperty(ProgressBar::Property::SECONDARY_PROGRESS_VISUAL);
+ resultMap = value.GetMap();
+ DALI_TEST_CHECK( resultMap );
+ urlValue = resultMap->Find( Toolkit::ImageVisual::Property::URL );
+ urlValue->Get( urlString );
+ DALI_TEST_CHECK( !urlString.empty() ) ;
+ DALI_TEST_EQUALS( urlString, secondaryProgressImage, TEST_LOCATION );
+
+ map[Toolkit::ImageVisual::Property::URL] = indeterminateImage;
+ progressBar.SetProperty(ProgressBar::Property::INDETERMINATE_VISUAL, map);
+
+ value = progressBar.GetProperty(ProgressBar::Property::INDETERMINATE_VISUAL);
+ resultMap = value.GetMap();
+ DALI_TEST_CHECK( resultMap );
+ urlValue = resultMap->Find( Toolkit::ImageVisual::Property::URL );
+ urlValue->Get( urlString );
+ DALI_TEST_CHECK( !urlString.empty() ) ;
+ DALI_TEST_EQUALS( urlString, indeterminateImage, TEST_LOCATION );
+
+ progressBar.SetProperty(ProgressBar::Property::LABEL_VISUAL, "test1");
+
+ value = progressBar.GetProperty(ProgressBar::Property::LABEL_VISUAL);
+ resultMap = value.GetMap();
+ DALI_TEST_CHECK( resultMap );
+ Property::Value* textValue = resultMap->Find(Toolkit::TextVisual::Property::TEXT);
+
+ std::string textString;
+ textValue->Get( textString );
+ DALI_TEST_CHECK( !textString.empty() );
+ DALI_TEST_EQUALS( textString, std::string( "test1" ), TEST_LOCATION );
+
+ Property::Map textVisualMap2;
+ textVisualMap2.Insert( Toolkit::Visual::Property::TYPE, Toolkit::DevelVisual::TEXT );
+ textVisualMap2.Insert( Toolkit::TextVisual::Property::TEXT, "test2" );
+ textVisualMap2.Insert( Toolkit::TextVisual::Property::POINT_SIZE, 12.0f );
+ progressBar.SetProperty(ProgressBar::Property::LABEL_VISUAL, textVisualMap2);
+
+ value = progressBar.GetProperty(ProgressBar::Property::LABEL_VISUAL);
+ resultMap = value.GetMap();
+ DALI_TEST_CHECK( resultMap );
+ textValue = resultMap->Find(Toolkit::TextVisual::Property::TEXT);
+
+ textValue->Get( textString );
+ DALI_TEST_CHECK( !textString.empty() );
+ DALI_TEST_EQUALS( textString, std::string( "test2" ), TEST_LOCATION );
+
+ progressBar.SetProperty(ProgressBar::Property::LABEL_VISUAL, "test3");
+
+ value = progressBar.GetProperty(ProgressBar::Property::LABEL_VISUAL);
+ resultMap = value.GetMap();
+ DALI_TEST_CHECK( resultMap );
+ textValue = resultMap->Find(Toolkit::TextVisual::Property::TEXT);
+
+ std::string textString2;
+ textValue->Get( textString2 );
+ DALI_TEST_CHECK( !textString2.empty() );
+ DALI_TEST_EQUALS( textString2, std::string( "test3" ), TEST_LOCATION );
+
+ Property::Map transitionMap;
+ transitionMap["target"] = "indeterminateVisual";
+ transitionMap["property"] = "offset";
+ transitionMap["initialValue"] = Vector2( 0.0f, 0.0f );
+ transitionMap["targetValue"] = Vector2( 10.0f, 0.0f );
+ transitionMap["animator"] = Property::Map().Add("alphaFunction", "EASE_IN_OUT_BACK")
+ .Add("timePeriod", Property::Map().Add("delay", 0.5f).Add("duration", 1.0f));
+ Property::Array array;
+ array.PushBack( transitionMap );
+ progressBar.SetProperty(ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION, array);
+
+ Property::Map transitionMap2;
+ transitionMap2["target"] = "indeterminateVisual";
+ transitionMap2["property"] = "offset";
+ transitionMap2["initialValue"] = Vector2( 0.0f, 0.0f );
+ transitionMap2["targetValue"] = Vector2( 15.0f, 0.0f );
+ transitionMap2["animator"] = Property::Map().Add("alphaFunction", "EASE_IN_OUT_BACK")
+ .Add("timePeriod", Property::Map().Add("delay", 0.5f).Add("duration", 1.0f));
+ progressBar.SetProperty(ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION, transitionMap2);
END_TEST;
}
progressBar.SetAnchorPoint(ParentOrigin::TOP_LEFT);
progressBar.SetSize( Vector2( Stage::GetCurrent().GetSize().x, 20.0f ) );
progressBar.SetPosition( 0.0f, 0.0f );
+ progressBar.ValueChangedSignal().Connect( &OnProgressBarValueChanged );
Stage::GetCurrent().Add(progressBar);
application.SendNotification();
DALI_TEST_EQUALS(val, 0.0f, TEST_LOCATION);
// test to download a file of 100k in chunks
- float lowerBound = 0, upperBound = 100, progressValue = 0, chunkValue = 0;
+ float lowerBound = 0, upperBound = 100, progressValue = 0, secondaryProgressValue = 0, chunkValue = 0;
while( chunkValue <= upperBound )
{
chunkValue = chunkValue + 100;
}
+ val = progressBar.GetProperty<float>(ProgressBar::Property::SECONDARY_PROGRESS_VALUE);
+ DALI_TEST_EQUALS(val, 0.0f, TEST_LOCATION);
+
+ // test to download a file of 100k in chunks
+ lowerBound = 0, upperBound = 100, secondaryProgressValue = 0, chunkValue = 0;
+
+ while( chunkValue <= upperBound )
+ {
+ secondaryProgressValue = (chunkValue - lowerBound ) / ( upperBound - lowerBound );
+ progressBar.SetProperty(ProgressBar::Property::SECONDARY_PROGRESS_VALUE, secondaryProgressValue);
+ val = progressBar.GetProperty<float>(ProgressBar::Property::SECONDARY_PROGRESS_VALUE);
+ DALI_TEST_EQUALS(val, secondaryProgressValue, TEST_LOCATION);
+ chunkValue = chunkValue + 10;
+ }
+
+ // test to download a file of 1000k in chunks
+ lowerBound = 0, upperBound = 1000, secondaryProgressValue = 0, chunkValue = 0;
+
+ while( chunkValue <= upperBound )
+ {
+ secondaryProgressValue = (chunkValue - lowerBound ) / ( upperBound - lowerBound );
+ progressBar.SetProperty(ProgressBar::Property::SECONDARY_PROGRESS_VALUE, secondaryProgressValue);
+ val = progressBar.GetProperty<float>(ProgressBar::Property::SECONDARY_PROGRESS_VALUE);
+ DALI_TEST_EQUALS(val, secondaryProgressValue, TEST_LOCATION);
+ chunkValue = chunkValue + 100;
+ }
+
END_TEST;
}
+int UtcDaliProgressBarSetPropertyP2(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliProgressBarSetPropertyP2" );
+
+ ProgressBar progressBar = ProgressBar::New();
+ progressBar.SetParentOrigin(ParentOrigin::TOP_LEFT);
+ progressBar.SetAnchorPoint(ParentOrigin::TOP_LEFT);
+ progressBar.SetPosition( 0.0f, 0.0f );
+ progressBar.SetProperty(ProgressBar::Property::LABEL_VISUAL, "test");
+ progressBar.SetProperty(ProgressBar::Property::INDETERMINATE, true);
+ progressBar.SetProperty(ProgressBar::Property::TRACK_VISUAL, trackImage);
+ progressBar.SetProperty(ProgressBar::Property::PROGRESS_VISUAL, progressImage);
+ progressBar.SetProperty(ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, secondaryProgressImage);
+ progressBar.SetProperty(ProgressBar::Property::INDETERMINATE_VISUAL, indeterminateImage);
+
+ Property::Map transitionMap;
+ transitionMap["target"] = "indeterminateVisual";
+ transitionMap["property"] = "offset";
+ transitionMap["initialValue"] = Vector2( 0.0f, 0.0f );
+ transitionMap["targetValue"] = Vector2( 10.0f, 0.0f );
+ transitionMap["animator"] = Property::Map().Add("alphaFunction", "EASE_IN_OUT_BACK")
+ .Add("timePeriod", Property::Map().Add("delay", 0.5f).Add("duration", 1.0f));
+ progressBar.SetProperty(ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION, transitionMap);
+ progressBar.SetProperty(ProgressBar::Property::PROGRESS_VALUE, 0.2f);
+ progressBar.SetProperty(ProgressBar::Property::SECONDARY_PROGRESS_VALUE, 0.3f);
+
+ progressBar.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
+ progressBar.SetSize( Vector2( Stage::GetCurrent().GetSize().x, 20.0f ) );
+ Stage::GetCurrent().Add(progressBar);
+ application.SendNotification();
+ application.Render();
+
+ // Test get/set INDETERMINATE
+ bool val = progressBar.GetProperty<bool>(ProgressBar::Property::INDETERMINATE);
+ DALI_TEST_EQUALS(val, true, TEST_LOCATION);
+
+ progressBar.SetProperty(ProgressBar::Property::INDETERMINATE, false);
+ val = progressBar.GetProperty<bool>(ProgressBar::Property::INDETERMINATE);
+ DALI_TEST_EQUALS(val, false, TEST_LOCATION);
+
+ END_TEST;
+}
/**
* @brief ProgressBar is a control to give the user an indication of the progress of an operation.
+ * *
+ * Determinate Progress State
+ *
+ * # : Progress visual
+ * * : Secondary Progress visual
+ * = : Track visual
+ * 40% : Label visual
+ *
+ * =============================================
+ * = ###############**** 40% =
+ * =============================================
+ *
+ * Indeterminate Progress State
+ *
+ * / : Indeterminate visual
+ *
+ * =============================================
+ * = ///////////////////////////////////////// =
+ * =============================================
*
* Also progress value percentage is shown as text inside the progress bar.
*
* |-------------------|-------------------------------|
* | valueChanged | @ref ValueChangedSignal() |
*/
+
class DALI_IMPORT_API ProgressBar : public Control
{
public:
PROGRESS_VALUE = PROPERTY_START_INDEX,
/**
+ * @brief The secondary progress value of progress bar, secondary progress runs form 0 to 1.
+ * @details Name "secondaryProgressValue", type Property::FLOAT.
+ * @note Optional. If not supplied, the default is 0.
+ * @note Value should be between 0 to 1.
+ * @note If Value is set to 0, progress bar will be set secondary progress to beginning.
+ * @note If Value is set to 1, progress bar will be set secondary progress to end.
+ * @note Any Value outside of the range is ignored.
+ */
+ SECONDARY_PROGRESS_VALUE,
+
+ /**
+ * @brief Sets the progress-bar as \e indeterminate state.
+ * @details name "indeterminate", type bool
+ */
+ INDETERMINATE,
+
+ /**
* @brief The track Visual value of progress bar, it's a full progress area and it's shown behind PROGRESS_VISUAL.
* @details Name "trackVisual", type Property::STRING if it is a url, map otherwise.
* @note Optional. If not supplied, the default track visual will be shown.
* @note Optional. If not supplied, the default progress visual will be shown.
*/
PROGRESS_VISUAL,
+
+ /**
+ * @brief The secondary progress visual of progress bar, size of the secondary progress visual is changed based on SECONDARY_PROGRESS_VALUE.
+ * @details Name "secondaryProgressVisual", type Property::STRING if it is a url, map otherwise.
+ * @note Optional. If not supplied, the secondary progress visual will not be shown.
+ */
+ SECONDARY_PROGRESS_VISUAL,
+
+ /**
+ * @brief The indeterminate visual of progress bar.
+ * @details Name "inditerminateVisual", type Property::STRING if it is a url, map otherwise.
+ * @note Optional. If not supplied, the default inditerminate visual will be shown.
+ */
+ INDETERMINATE_VISUAL,
+
+ /**
+ * @brief The transition data for indeterminate visual animation.
+ * @details Name "indeterminateVisualAnimation", type Property::STRING.
+ * @note Optional. If not supplied, default animation will be played.
+ */
+ INDETERMINATE_VISUAL_ANIMATION,
+
+ /**
+ * @brief The Label visual of progress bar.
+ * @details Name "labelVisual", type Property::MAP.
+ */
+ LABEL_VISUAL,
};
};
/**
* @brief Value changed signal type.
*/
- typedef Signal< void ( ProgressBar, float ) > ValueChangedSignalType;
+ typedef Signal< void ( ProgressBar, float, float ) > ValueChangedSignalType;
/**
* @brief Signal emitted when the ProgressBar value changes.
*
* A callback of the following type may be connected:
* @code
- * void YourCallbackName( ProgressBar progressBar, float value );
+ * void YourCallbackName( ProgressBar progressBar, float progressValue, float secondaryProgressValue );
* @endcode
* @return The signal to connect to
*/
ValueChangedSignalType& ValueChangedSignal();
+
public: // Not intended for application developers
/// @cond internal
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/public-api/size-negotiation/relayout-container.h>
#include <dali/public-api/math/math-utils.h>
+#include <dali-toolkit/devel-api/align-enums.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
+#include <dali-toolkit/public-api/visuals/color-visual-properties.h>
+#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
+#include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
+#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+
+#include <dali/integration-api/debug.h>
namespace Dali
{
// Setup properties, signals and actions using the type-registry.
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ProgressBar, Toolkit::Control, Create )
-DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "progressValue", FLOAT, PROGRESS_VALUE )
-DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "trackVisual", MAP, TRACK_VISUAL )
-DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "progressVisual", MAP, PROGRESS_VISUAL )
-DALI_SIGNAL_REGISTRATION( Toolkit, ProgressBar, "valueChanged", SIGNAL_VALUE_CHANGED )
+DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "progressValue", FLOAT, PROGRESS_VALUE )
+DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "secondaryProgressValue", FLOAT, SECONDARY_PROGRESS_VALUE )
+DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminate", BOOLEAN, INDETERMINATE )
+DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "trackVisual", MAP, TRACK_VISUAL )
+DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "progressVisual", MAP, PROGRESS_VISUAL )
+DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "secondaryProgressVisual", MAP, SECONDARY_PROGRESS_VISUAL )
+DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminateVisual", MAP, INDETERMINATE_VISUAL )
+DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminateVisualAnimation", ARRAY, INDETERMINATE_VISUAL_ANIMATION )
+DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "labelVisual", MAP, LABEL_VISUAL )
+DALI_SIGNAL_REGISTRATION( Toolkit, ProgressBar, "valueChanged", SIGNAL_VALUE_CHANGED )
DALI_TYPE_REGISTRATION_END()
-const char* SKINNED_TRACK_VISUAL = DALI_IMAGE_DIR "slider-skin.9.png";
-const char* SKINNED_PROGRESS_VISUAL = DALI_IMAGE_DIR "slider-skin-progress.9.png";
+struct ProgressDepthIndex
+{
+ // Enum to make sure the visual order
+ enum
+ {
+ TRACK_VISUAL,
+ SECONDARY_PROGRESS_VISUAL,
+ PROGRESS_VISUAL,
+ LABEL_VISUAL,
+ INDETERMINATE_VISUAL
+ };
+};
float DEFAULT_VALUE = 0.0f;
float DEFAULT_LOWER_BOUND = 0.0f;
float DEFAULT_UPPER_BOUND = 1.0f;
+float DEFAULT_FONT_SIZE = 12.0f;
} // Unnamed namespace
ProgressBar::ProgressBar()
: Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
- mTrackVisual(""),
- mProgressVisual(""),
- mTrackMap(),
- mTrackVisualSize(),
- mProgressVisualSize(),
- mValue( DEFAULT_VALUE )
+ mProgressValue( DEFAULT_VALUE ),
+ mSecondaryProgressValue( DEFAULT_VALUE ),
+ mIndeterminate( false )
{
}
void ProgressBar::OnInitialize()
{
- // Setup
- CreateChildren();
-
- // Properties
- SetTrackVisual( SKINNED_TRACK_VISUAL );
- SetProgressVisual( SKINNED_PROGRESS_VISUAL );
-
- DisplayValue( mValue, false ); // Run this last to display the correct value
}
void ProgressBar::OnRelayout( const Vector2& size, RelayoutContainer& container )
{
- // Track
- if( mTrack )
+
+ Vector2 trackSize( size );
+ mDomain = CalcDomain( size );
+
+ trackSize.width = std::max( 0.0f, size.width ); // Ensure we don't go negative
+
+ Toolkit::Visual::Base trackVisual = GetVisual( Toolkit::ProgressBar::Property::TRACK_VISUAL );
+ Toolkit::Visual::Base secondProgressVisual = GetVisual( Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL );
+ Toolkit::Visual::Base progressVisual = GetVisual( Toolkit::ProgressBar::Property::PROGRESS_VISUAL );
+ Toolkit::Visual::Base labelVisual = GetVisual( Toolkit::ProgressBar::Property::LABEL_VISUAL );
+ Toolkit::Visual::Base indeterminateVisual = GetVisual( Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL );
+
+ if( trackVisual )
+ {
+ Property::Map visualTransform;
+
+ visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, trackSize )
+ .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_SIZE_MODE, Vector4( 1.0f, 1.0f, 1.0f, 1.0f ) ); // Use Absolute size
+ trackVisual.SetTransformAndSize( visualTransform, trackSize );
+ }
+
+ if( secondProgressVisual )
{
- container.Add( mTrack, size );
+ Property::Map visualTransform;
- // mValueTextLabel will have its relayout method called automatically as it's a child of mTrack,
- // which is added to the container
+ visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, Vector2( mDomain.from.x + mSecondaryProgressValue * ( mDomain.to.x - mDomain.from.x ), trackSize.height ) )
+ .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_SIZE_MODE, Vector4( 1.0f, 1.0f, 1.0f, 1.0f ) ) // Use Absolute size
+ .Add( Toolkit::DevelVisual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
+ .Add( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN );
+ secondProgressVisual.SetTransformAndSize( visualTransform, trackSize );
}
- // Progress bar
- if( mProgress )
+ if( progressVisual )
{
- mDomain = CalcDomain( size );
+ Property::Map visualTransform;
+
+ visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, Vector2( mDomain.from.x + mProgressValue * ( mDomain.to.x - mDomain.from.x ), trackSize.height ) )
+ .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_SIZE_MODE, Vector4( 1.0f, 1.0f, 1.0f, 1.0f ) ) // Use Absolute size
+ .Add( Toolkit::DevelVisual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
+ .Add( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN );
+ progressVisual.SetTransformAndSize( visualTransform, trackSize );
+ }
- Vector2 progressSize( size );
+ if( labelVisual )
+ {
+ Property::Map visualTransform;
- // If no progress, then we do not want a n-patch image shown incorrectly
- progressSize.width = std::max( mProgressVisualSize.width, mDomain.from.x + mValue * ( mDomain.to.x - mDomain.from.x ) );
- progressSize.width = std::min( progressSize.width, size.width ); // We should not exceed given size
+ visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, trackSize )
+ .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_SIZE_MODE, Vector4( 1.0f, 1.0f, 1.0f, 1.0f ) ); // Use Absolute size
- container.Add( mProgress, progressSize );
+ labelVisual.SetTransformAndSize( visualTransform, trackSize );
}
+
+ if( indeterminateVisual )
+ {
+ Property::Map visualTransform;
+
+ visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, trackSize )
+ .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_SIZE_MODE, Vector4( 1.0f, 1.0f, 1.0f, 1.0f ) ); // Use Absolute size
+ indeterminateVisual.SetTransformAndSize( visualTransform, trackSize );
+ }
+
}
Vector3 ProgressBar::GetNaturalSize()
{
- // Return the maximum width/height combinations of our visuals
+ // Return the bigger size after comparing trackVisual naturalSize and labelVisual naturalSize
+ Toolkit::Visual::Base trackVisual = GetVisual( Toolkit::ProgressBar::Property::TRACK_VISUAL );
+ Toolkit::Visual::Base labelVisual = GetVisual( Toolkit::ProgressBar::Property::LABEL_VISUAL );
+
+ Size trackSize;
+ Size labelSize;
+
+ if ( trackVisual )
+ {
+ trackVisual.GetNaturalSize( trackSize );
+ }
+ if ( labelVisual )
+ {
+ labelVisual.GetNaturalSize( labelSize );
+ }
Vector3 naturalSize;
- naturalSize.width = std::max( mTrackVisualSize.width, mProgressVisualSize.width );
- naturalSize.height = std::max( mTrackVisualSize.height, mProgressVisualSize.height );
+ naturalSize.width = ( trackSize.width > labelSize.width ) ? trackSize.width: labelSize.width;
+ naturalSize.height = ( trackSize.height > labelSize.height ) ? trackSize.height: labelSize.height;
+
return naturalSize;
}
return Domain( Vector2( 0.0f, 0.0f ), currentSize );
}
-void ProgressBar::DisplayValue( float value, bool raiseSignals )
+Toolkit::ProgressBar::ValueChangedSignalType& ProgressBar::ValueChangedSignal()
{
- // Signals
- if( raiseSignals )
- {
- Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast( Self() );
- mValueChangedSignal.Emit( self, value );
- }
+ return mValueChangedSignal;
+}
- // Change the value of the text label
- if( mValueTextLabel )
+void ProgressBar::SetProgressValue( float value )
+{
+ // update the progress bar value (taking float precision errors into account)
+ // TODO : it seems 0.0f cannot into this statement.
+ if( ( mProgressValue != value ) &&
+ ( ( value >= DEFAULT_LOWER_BOUND ) || ( Equals( value, DEFAULT_LOWER_BOUND ) ) ) &&
+ ( ( value <= DEFAULT_UPPER_BOUND ) || ( Equals( value, DEFAULT_UPPER_BOUND ) ) ) )
{
- std::stringstream ss;
- ss.precision( 0 );
- ss << std::fixed << ( value * 100 ) << "%";
+ mProgressValue = Clamp( value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND );
- std::string label = mValueTextLabel.GetProperty<std::string>( Toolkit::TextLabel::Property::TEXT );
- if( label.compare(ss.str()) )
- {
- mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
- }
+ Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast( Self() );
+ mValueChangedSignal.Emit( self, mProgressValue, mSecondaryProgressValue );
+ RelayoutRequest();
}
}
-Toolkit::ImageView ProgressBar::CreateTrack()
+float ProgressBar::GetProgressValue() const
{
- Toolkit::ImageView track = Toolkit::ImageView::New();
- track.SetParentOrigin( ParentOrigin::CENTER );
- track.SetAnchorPoint( AnchorPoint::CENTER );
- track.SetResizePolicy(ResizePolicy::USE_ASSIGNED_SIZE, Dimension::ALL_DIMENSIONS );
-
- return track;
+ return mProgressValue;
}
-void ProgressBar::SetTrackVisual( const std::string& filename )
+void ProgressBar::SetSecondaryProgressValue( float value )
{
- if( mTrack && filename.size() > 0 )
+ // update the progress bar value (taking float precision errors into account)
+ // TODO : it seems 0.0f cannot into this statement.
+ if( ( mSecondaryProgressValue != value ) &&
+ ( ( value >= DEFAULT_LOWER_BOUND ) || ( Equals( value, DEFAULT_LOWER_BOUND ) ) ) &&
+ ( ( value <= DEFAULT_UPPER_BOUND ) || ( Equals( value, DEFAULT_UPPER_BOUND ) ) ) )
{
- mTrack.SetImage( filename );
- mTrackVisual = filename;
- mTrackVisualSize = Vector2::ZERO;
+ mSecondaryProgressValue = Clamp( value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND );
+
+ Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast( Self() );
+ mValueChangedSignal.Emit( self, mProgressValue, mSecondaryProgressValue );
+
RelayoutRequest();
}
}
-void ProgressBar::SetTrackVisual( Property::Map map )
+float ProgressBar::GetSecondaryProgressValue() const
{
- bool relayoutRequired = false;
+ return mSecondaryProgressValue;
+}
- Property::Value* imageValue = map.Find( "url" );
- if( imageValue )
+void ProgressBar::SetIndeterminate( bool value )
+{
+ mIndeterminate = value;
+ EnableVisual( Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL, mIndeterminate );
+
+ if( mIndeterminate )
{
- mTrackVisual.clear();
- std::string filename;
- if( imageValue->Get( filename ) )
+ RelayoutRequest();
+ if( mIndeterminateVisualTransition )
{
- if( mTrack && ( filename.size() > 0 ) )
- {
- mTrack.SetImage( filename );
- mTrackMap = map;
- relayoutRequired = true;
- }
+ PlayIndeterminateVisualTransition();
}
}
-
- Property::Value* sizeValue = map.Find( "size" );
- if( sizeValue )
+ else
{
- Vector2 size;
- if( sizeValue->Get( size ) )
+ if( mIndeterminateVisualAni )
{
- mTrackVisualSize = size;
- relayoutRequired = true;
+ mIndeterminateVisualAni.Stop();
}
}
+}
- // Visual and/or visual size changed so we need to relayout
- if( relayoutRequired )
- {
- RelayoutRequest();
- }
+bool ProgressBar::GetIndeterminate() const
+{
+ return mIndeterminate;
}
-std::string ProgressBar::GetTrackVisual()
+void ProgressBar::SetIndeterminateVisualTransition( Toolkit::TransitionData transition )
{
- return mTrackVisual;
+ mIndeterminateVisualTransition = transition;
+ if( mIndeterminate )
+ {
+ PlayIndeterminateVisualTransition();
+ }
}
-Toolkit::ImageView ProgressBar::CreateProgress()
+void ProgressBar::PlayIndeterminateVisualTransition()
{
- Toolkit::ImageView progress = Toolkit::ImageView::New();
- progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
- progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
- progress.SetResizePolicy(ResizePolicy::USE_ASSIGNED_SIZE, Dimension::ALL_DIMENSIONS );
+ if( mIndeterminateVisualAni )
+ {
+ mIndeterminateVisualAni.Stop();
+ mIndeterminateVisualAni.Clear();
+ }
+
+ mIndeterminateVisualAni = CreateTransition( mIndeterminateVisualTransition );
- return progress;
+ if( mIndeterminate && mIndeterminateVisualAni )
+ {
+ mIndeterminateVisualAni.SetLooping(true);
+ mIndeterminateVisualAni.Play();
+ }
}
-void ProgressBar::SetProgressVisual( const std::string& filename )
+Toolkit::TransitionData ProgressBar::ConvertPropertyToTransition( const Property::Value& value )
{
- if( mProgress && ( filename.size() > 0 ) )
+ Toolkit::TransitionData transitionData;
+
+ if( value.GetType() == Property::ARRAY )
{
- mProgress.SetImage( filename );
- mProgressVisual = filename;
- mProgressVisualSize = Vector2::ZERO;
- RelayoutRequest();
+ transitionData = Toolkit::TransitionData::New( *value.GetArray() );
+ }
+ else if( value.GetType() == Property::MAP )
+ {
+ transitionData = Toolkit::TransitionData::New( *value.GetMap() );
}
+
+ return transitionData;
}
-void ProgressBar::SetProgressVisual( Property::Map map )
+/**
+ * Create Visual for given index from a property map or url.
+ * 1) Check if value passed in is a url and create visual
+ * 2) Create visual from map if step (1) is false
+ * 3) Register visual with control with false for enable flag.
+ * 4) Unregister visual if empty map was provided. This is the method to remove a visual
+ */
+
+void ProgressBar::CreateVisualsForComponent( Property::Index index, const Property::Value& value, const float visualDepth )
{
- bool relayoutRequired = false;
+ Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
+ Toolkit::Visual::Base progressVisual;
- Property::Value* imageValue = map.Find( "url" );
- if( imageValue )
+ std::string imageUrl;
+ if( value.Get( imageUrl ) )
{
- mProgressVisual.clear();
- std::string filename;
- if( imageValue->Get( filename ) )
+ if ( !imageUrl.empty() )
{
- if( mProgress && ( filename.size() > 0 ) )
- {
- mProgress.SetImage( filename );
- mProgressMap = map;
- relayoutRequired = true;
- }
+ progressVisual = visualFactory.CreateVisual( imageUrl, ImageDimensions() );
}
}
-
- Property::Value* sizeValue = map.Find( "size" );
- if( sizeValue )
+ else // Does this code make text-visual can be accepted as visual?
{
- Vector2 size;
- if( sizeValue->Get( size ) )
+ // if its not a string then get a Property::Map from the property if possible.
+ Property::Map *map = value.GetMap();
+ if( map && !map->Empty() ) // Empty map results in current visual removal.
{
- mProgressVisualSize = size;
- relayoutRequired = true;
+ progressVisual = visualFactory.CreateVisual( *map );
}
}
- // Visual and/or visual size changed so we need to relayout
- if( relayoutRequired )
+ if ( progressVisual )
{
- RelayoutRequest();
+ progressVisual.SetDepthIndex( visualDepth );
+ if( index == Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL )
+ {
+ RegisterVisual( index, progressVisual, mIndeterminate );
+ }
+ else
+ {
+ RegisterVisual( index, progressVisual, true );
+ }
+ }
+ else
+ {
+ UnregisterVisual( index );
}
}
-std::string ProgressBar::GetProgressVisual()
-{
- return mProgressVisual;
-}
-
-Toolkit::ProgressBar::ValueChangedSignalType& ProgressBar::ValueChangedSignal()
-{
- return mValueChangedSignal;
-}
-
-void ProgressBar::CreateChildren()
+bool ProgressBar::GetPropertyMapForVisual( Property::Index visualIndex, Property::Map& retreivedMap ) const
{
- Actor self = Self();
-
- // Track
- mTrack = CreateTrack();
- self.Add( mTrack ); // Needs to be a direct child as we want to manipulate its size
-
- // Progress bar
- mProgress = CreateProgress();
- self.Add( mProgress ); // Needs to be a direct child as we want to manipulate its size
-
- // Value Text
- mValueTextLabel = Toolkit::TextLabel::New();
- mValueTextLabel.SetName( "ProgressBarValueTextLabel" );
- mValueTextLabel.SetStyleName( "ProgressBarValueTextLabel" );
- mValueTextLabel.SetParentOrigin( ParentOrigin::CENTER );
- mValueTextLabel.SetAnchorPoint( AnchorPoint::CENTER );
- mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
- mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
- mTrack.Add( mValueTextLabel ); // Add to mTrack and let it automatically set its size
-}
+ bool success = false;
+ Toolkit::Visual::Base visual = GetVisual( visualIndex );
-void ProgressBar::SetProgressValue( float value )
-{
- // update the progress bar value (taking float precision errors into account)
- if( ( mValue != value ) &&
- ( ( value >= DEFAULT_LOWER_BOUND ) || ( Equals( value, DEFAULT_LOWER_BOUND ) ) ) &&
- ( ( value <= DEFAULT_UPPER_BOUND ) || ( Equals( value, DEFAULT_UPPER_BOUND ) ) ) )
+ if ( visual )
{
- mValue = Clamp( value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND );
- DisplayValue( mValue, true );
- RelayoutRequest();
+ visual.CreatePropertyMap( retreivedMap );
+ success = true;
}
-}
-float ProgressBar::GetProgressValue() const
-{
- return mValue;
+ return success;
}
// Static class method to support script connecting signals
switch ( propertyIndex )
{
- case Toolkit::ProgressBar::Property::PROGRESS_VALUE:
+ case Toolkit::ProgressBar::Property::TRACK_VISUAL:
{
- progressBarImpl.SetProgressValue( value.Get< float >() );
+ progressBarImpl.CreateVisualsForComponent( propertyIndex, value, ProgressDepthIndex::TRACK_VISUAL );
break;
}
- case Toolkit::ProgressBar::Property::TRACK_VISUAL:
+ case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL:
{
- Property::Map map;
- if( value.Get( map ) )
- {
- progressBarImpl.SetTrackVisual( map );
- }
+ progressBarImpl.CreateVisualsForComponent( propertyIndex, value, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL );
break;
}
case Toolkit::ProgressBar::Property::PROGRESS_VISUAL:
{
+ progressBarImpl.CreateVisualsForComponent( propertyIndex, value, ProgressDepthIndex::PROGRESS_VISUAL );
+ break;
+ }
+
+ case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL:
+ {
+ progressBarImpl.CreateVisualsForComponent( propertyIndex, value, ProgressDepthIndex::INDETERMINATE_VISUAL );
+ break;
+ }
+
+ case Toolkit::ProgressBar::Property::LABEL_VISUAL:
+ {
Property::Map map;
- if( value.Get( map ) )
+ std::string textString;
+
+ if ( value.Get( textString ) )
+ {
+ // set new text string as TEXT property
+ Property::Map newTextMap;
+ Toolkit::Visual::Base label = progressBarImpl.GetVisual( Toolkit::ProgressBar::Property::LABEL_VISUAL );
+
+ if( label )
+ {
+ label.CreatePropertyMap( map );
+ }
+
+ // if LABEL_VISUAL doesn't set before, add Visual property "TYPE" to create new text Visual
+ if( map.Empty() )
+ {
+ newTextMap.Add( Toolkit::Visual::Property::TYPE, Toolkit::DevelVisual::TEXT );
+ newTextMap.Add( Toolkit::TextVisual::Property::POINT_SIZE, DEFAULT_FONT_SIZE );
+ }
+ newTextMap.Add( Toolkit::TextVisual::Property::TEXT, textString );
+
+ map.Merge( newTextMap );
+ }
+ else
{
- progressBarImpl.SetProgressVisual( map );
+ value.Get( map );
}
+
+ if( !map.Empty() )
+ {
+ progressBarImpl.CreateVisualsForComponent( propertyIndex, map, ProgressDepthIndex::LABEL_VISUAL );
+ }
+ break;
+ }
+
+ case Toolkit::ProgressBar::Property::PROGRESS_VALUE:
+ {
+ progressBarImpl.SetProgressValue( value.Get< float >() );
+ break;
+ }
+
+ case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE:
+ {
+ progressBarImpl.SetSecondaryProgressValue( value.Get< float >() );
+ break;
+ }
+
+ case Toolkit::ProgressBar::Property::INDETERMINATE:
+ {
+ progressBarImpl.SetIndeterminate( value.Get< bool >() );
+ break;
+ }
+
+ case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION:
+ {
+ progressBarImpl.SetIndeterminateVisualTransition( progressBarImpl.ConvertPropertyToTransition( value ) );
break;
}
}
switch ( propertyIndex )
{
+ case Toolkit::ProgressBar::Property::TRACK_VISUAL:
+ case Toolkit::ProgressBar::Property::PROGRESS_VISUAL:
+ case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL:
+ case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL:
+ case Toolkit::ProgressBar::Property::LABEL_VISUAL:
+ {
+ Property::Map visualProperty;
+ if ( progressBarImpl.GetPropertyMapForVisual( propertyIndex, visualProperty ) )
+ {
+ value = visualProperty;
+ }
+ break;
+ }
+
case Toolkit::ProgressBar::Property::PROGRESS_VALUE:
{
value = progressBarImpl.GetProgressValue();
break;
}
- case Toolkit::ProgressBar::Property::TRACK_VISUAL:
+ case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE:
{
- if( !progressBarImpl.mTrackVisual.empty() )
- {
- value = progressBarImpl.GetTrackVisual();
- }
- else if( !progressBarImpl.mTrackMap.Empty() )
- {
- value = progressBarImpl.mTrackMap;
- }
+ value = progressBarImpl.GetSecondaryProgressValue();
break;
}
- case Toolkit::ProgressBar::Property::PROGRESS_VISUAL:
+ case Toolkit::ProgressBar::Property::INDETERMINATE:
{
- if( !progressBarImpl.mProgressVisual.empty() )
- {
- value = progressBarImpl.GetProgressVisual();
- }
- else if( !progressBarImpl.mProgressMap.Empty() )
- {
- value = progressBarImpl.mProgressMap;
- }
+ value = progressBarImpl.GetIndeterminate();
break;
}
+
+ case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION:
+ {
+ //TODO: Return INDETERMINATE_VISUAL_TRANSITION;
+ }
}
}
return value;
}
+void ProgressBar::OnStageConnection( int depth )
+{
+ // Chain up first (ensures visuals are ready to draw)
+ Control::OnStageConnection( depth );
+
+ if( mIndeterminate )
+ {
+ PlayIndeterminateVisualTransition();
+ }
+}
+
} // namespace Internal
} // namespace Toolkit
*
*/
-// EXTERNAL INCLUDES
-#include <dali/public-api/object/property-map.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali/public-api/animation/animation.h>
#include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
-#include <dali-toolkit/public-api/controls/image-view/image-view.h>
-#include <dali-toolkit/public-api/controls/text-controls/text-label.h>
+#include <dali-toolkit/devel-api/visual-factory/transition-data.h>
namespace Dali
{
*
* @param[in] value The value to set. Will be clamped to [lowerBound .. upperBound]
*/
-
void SetProgressValue( float value );
/**
*/
float GetProgressValue() const;
+ /**
+ * Set the secondary progress value of the ProgressBar
+ *
+ * @param[in] value The secondary progress value to set. Will be clamped to [lowerBound .. upperBound]
+ */
+ void SetSecondaryProgressValue( float value );
+
+ /**
+ * Get the secondary progress value of the ProgressBar
+ *
+ * @return The current secondary progress value of the ProgressBar
+ */
+ float GetSecondaryProgressValue() const;
+
+ /**
+ * Set the indeterminate state of the ProgressBar
+ *
+ * @param[in] value The value to set.
+ */
+ void SetIndeterminate( bool value );
+
+ /**
+ * Get the indeterminate state value of the ProgressBar
+ *
+ * @return The current determined state of the ProgressBar
+ */
+ bool GetIndeterminate() const;
+
+ /**
+ * Set the indeterminate visual transition of the ProgressBar
+ *
+ * @param[in] Transition data map to set.
+ */
+ void SetIndeterminateVisualTransition( Property::Map transtion );
+
+ /**
+ * Get the indeterminate visual transition data map of the ProgressBar
+ *
+ * @return The current indeterminate visual transition data map of the ProgressBar
+ */
+ Property::Map GetIndeterminateVisualTransition() const;
+
+ /**
+ * Play the indeterminate visual transition
+ */
+ void PlayIndeterminateVisualTransition();
+
public:
//Signals
/**
- * @copydoc Toolkit::ProgressBar::ValueChangedSignal()
+ * @copydoc toolkit::progressbar::valuechangedsignal()
*/
Toolkit::ProgressBar::ValueChangedSignalType& ValueChangedSignal();
+
/**
* Connects a callback function with the object's signals.
* @param[in] object The object providing the signal.
Domain CalcDomain( const Vector2& currentSize );
/**
- * Create the track for the ProgressBar
- *
- * @return The track actor
- */
- Toolkit::ImageView CreateTrack();
-
- /**
- * Create the progress track for the ProgressBar
- *
- * @return The track actor
- */
- Toolkit::ImageView CreateProgress();
-
- /**
- * Create all the children
- */
- void CreateChildren();
-
- /**
- * Set value choosing whether to fire signals or not
- *
- * @paramp[in] value The value to set
- * @param[in] raiseSignals Configure signals to be raised or not.
- */
- void DisplayValue( float value, bool raiseSignals );
-
- /**
- * Create the image for the track
- *
- * @param[in] filename The track image
- */
- void SetTrackVisual( const std::string& filename );
-
- /**
- * @brief Set the track visual from an Dali::Property::Map
- *
- * @param[in] map The Dali::Property::Map to use for to display
+ * Set indeterminate visual transition animation
*/
- void SetTrackVisual( Dali::Property::Map map );
+ void SetIndeterminateVisualTransition( Toolkit::TransitionData transtion );
/**
- * @brief Return the track image.
- *
- * @return The track image.
+ * Convert value to transition data
*/
- std::string GetTrackVisual();
+ Toolkit::TransitionData ConvertPropertyToTransition( const Property::Value& value );
/**
- * Create the image for the progress bar
- *
- * @param[in] filename The progress bar image
+ * Update progress bar label when progress value is changed
*/
- void SetProgressVisual( const std::string& filename );
+ void CreateVisualsForComponent( Property::Index index, const Property::Value& value, const float visualDepth );
/**
- * @brief Set the progress visual from an Dali::Property::Map
- *
- * @param[in] map The Dali::Property::Map to use for to display
+ * Update progress bar label when progress value is changed
*/
- void SetProgressVisual( Dali::Property::Map map );
+ bool GetPropertyMapForVisual( Property::Index visualIndex, Property::Map& retreivedMap ) const;
/**
- * @brief Return the progress bar image.
- *
- * @return The progress bar image if it exists.
+ * Check if we should start animating
*/
- std::string GetProgressVisual();
+ virtual void OnStageConnection( int depth );
private:
private:
- Domain mDomain; ///< Current domain of the handle
-
- Toolkit::ImageView mTrack; ///< Track image
- Toolkit::ImageView mProgress; ///< Progress bar
- Toolkit::TextLabel mValueTextLabel; ///< Text value to show progress percentage
- Toolkit::ProgressBar::ValueChangedSignalType mValueChangedSignal; ///< Signal emitted when the value is changed
-
- std::string mTrackVisual; ///< Image for track image
- std::string mProgressVisual; ///< Image for progress bar image
-
- Property::Map mTrackMap; ///< the Property::Map if the image came from a Property::Map, empty otherwise
- Property::Map mProgressMap; ///< the Property::Map if the image came from a Property::Map, empty otherwise
+ Domain mDomain; ///< Current domain of the handle
- Vector2 mTrackVisualSize; ///< Size of the track image used
- Vector2 mProgressVisualSize; ///< Size of progress image used
+ Animation mIndeterminateVisualAni; ///< Animation for indetrminate visual. Transition animation.
+ Toolkit::ProgressBar::ValueChangedSignalType mValueChangedSignal; ///< Signal emitted when the value is changed
- float mValue; ///< Current value of ProgressBar
+ Toolkit::TransitionData mIndeterminateVisualTransition; ///< Transition data map for mIndeterminateVisualAni
+ float mProgressValue; ///< Current value of ProgressBar
+ float mSecondaryProgressValue; ///< Current loading value of ProgressBar
+ bool mIndeterminate; ///< Whether the progress state is determined or not
};
} // namespace Internal
\
$(toolkit_src_dir)/focus-manager/keyboard-focus-manager-impl.cpp \
$(toolkit_src_dir)/focus-manager/keyinput-focus-manager-impl.cpp \
+ $(toolkit_src_dir)/helpers/property-helper.cpp \
$(toolkit_src_dir)/filters/blur-two-pass-filter.cpp \
$(toolkit_src_dir)/filters/emboss-filter.cpp \
$(toolkit_src_dir)/filters/image-filter.cpp \
--- /dev/null
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// HEADER
+#include <dali-toolkit/internal/helpers/property-helper.h>
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/property-array.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Internal
+{
+
+bool GetStringFromProperty( const Property::Value& value, std::string& output )
+{
+ bool extracted = false;
+ if( value.Get( output ) )
+ {
+ extracted = true;
+ }
+ else
+ {
+ Property::Array* array = value.GetArray();
+ if( array )
+ {
+ const unsigned int arraySize = array->Size();
+ for( unsigned int i = 0; i < arraySize; ++i )
+ {
+ std::string element;
+ if( array->GetElementAt( i ).Get( element ) )
+ {
+ extracted = true;
+ output += element + '\n';
+ }
+ else
+ {
+ // If property in array is anything other than a string, then it is invalid so break and clear output.
+ output.clear();
+ extracted = false;
+ break;
+ }
+ }
+ }
+ }
+
+ return extracted;
+}
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_TOOLKIT_INTERNAL_PROPERTY_HELPER_H
+#define DALI_TOOLKIT_INTERNAL_PROPERTY_HELPER_H
+
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <string>
+#include <dali/public-api/object/property.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Internal
+{
+
+/**
+ * @brief Parses a Property::Value to retrieve the string.
+ *
+ * If value is a Property::STRING, then it simply extracts the required string.
+ * If value is a Property::ARRAY, then it combines all the strings it contains into one adding a newline character to each line.
+ * The second option allows users to write long strings over several lines in a JSON file.
+ *
+ * @return True if a string was extracted successfully.
+ */
+bool GetStringFromProperty( const Property::Value& value, std::string& output );
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+
+#endif // DALI_TOOLKIT_INTERNAL_PROPERTY_HELPER_H
}
TextVerticalScroller::TextVerticalScroller()
-: mDuration( DEFAULT_VERTICAL_SCROLL_DURATION )
+: mDuration( DEFAULT_VERTICAL_SCROLL_DURATION ),
+ mScrollTo( 0.0f )
{
}
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
+#include <dali-toolkit/internal/helpers/property-helper.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
namespace Dali
Property::Value* vertexShaderValue = shaderMap.Find( Toolkit::Visual::Shader::Property::VERTEX_SHADER, CUSTOM_VERTEX_SHADER );
if( vertexShaderValue )
{
- if( !vertexShaderValue->Get( mVertexShader ) )
+ if( ! GetStringFromProperty( *vertexShaderValue, mVertexShader ) )
{
DALI_LOG_ERROR( "'%s' parameter does not correctly specify a string\n", CUSTOM_VERTEX_SHADER );
}
Property::Value* fragmentShaderValue = shaderMap.Find( Toolkit::Visual::Shader::Property::FRAGMENT_SHADER, CUSTOM_FRAGMENT_SHADER );
if( fragmentShaderValue )
{
- if( !fragmentShaderValue->Get( mFragmentShader ) )
+ if( ! GetStringFromProperty( *fragmentShaderValue, mFragmentShader ) )
{
DALI_LOG_ERROR( "'%s' parameter does not correctly specify a string\n", CUSTOM_FRAGMENT_SHADER );
}
#define DALI_TOOLKIT_VISUAL_PROPERTIES_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
{
/**
* @brief The vertex shader.
- * @details Name "vertexShader", type Property::STRING.
+ * @details Name "vertexShader", type Property::STRING or Property::ARRAY of Property::STRING.
+ * A Property::ARRAY of Property::STRING values can be used to split the shader string over multiple lines.
* @SINCE_1_1.45
* @note Optional
* @note If not supplied, the visual's already set vertex shader is used.
/**
* @brief The fragment shader.
- * @details Name "fragmentShader", type Property::STRING.
+ * @details Name "fragmentShader", type Property::STRING or Property::ARRAY of Property::STRING.
+ * A Property::ARRAY of Property::STRING values can be used to split the shader string over multiple lines.
* @SINCE_1_1.45
* @note Optional
* @note If not supplied, the visual's already set fragment shader is used.
},
"ProgressBar":
{
- "progressValue": 0,
"trackVisual":{
- "url":"{DALI_IMAGE_DIR}progress-skin.9.png",
- "size":[24,24]
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-track.9.png"
},
"progressVisual":{
- "url":"{DALI_IMAGE_DIR}progress-skin-progress.9.png",
- "size":[24,24]
- }
- },
- "ProgressBarValueTextLabel":
- {
- "textColor":[0.8,0.8,1,1]
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-progress.9.png"
+ },
+ "secondaryProgressVisual":{
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-secondary-progress.9.png"
+ },
+ "indeterminateVisual":{
+ "visualType":"IMAGE",
+ "pixelArea":[0.0, 0.0, 10.0, 1.0],
+ "wrapModeU":"REPEAT",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-indeterminate.png"
+ },
+ "indeterminateVisualAnimation":
+ [
+ {
+ "target":"indeterminateVisual",
+ "property":"pixelArea",
+ "initialValue":[0.0, 0.0, 10.0, 1.0],
+ "targetValue":[-1.0, 0.0, 10.0, 1.0],
+ "animator":
+ {
+ "alphaFunction":"DEFAULT",
+ "timePeriod":
+ {
+ "duration":0.8,
+ "delay":0
+ }
+ }
+ }
+ ],
+ "labelVisual":{
+ "visualType": "TEXT",
+ "textColor": [ 1.0, 1.0, 1.0, 1.0 ],
+ "pointSize" : 12.0, // Point size must always be provided to Text Visual
+ "horizontalAlignment": "CENTER",
+ "verticalAlignment": "CENTER"
+ },
+ "progressValue": 0.0,
+ "secondaryProgressValue":0.0,
+ "indeterminate": false
},
"Button":
{
"url": "{DALI_IMAGE_DIR}button-disabled.9.png"
}
},
+ "ToggleButton":
+ {
+ "styles":["Button"]
+ },
"CheckBoxButton":
{
"styles":["Button"],
},
"ProgressBar":
{
- "progressValue": 0,
"trackVisual":{
- "url":"{DALI_IMAGE_DIR}progress-skin.9.png",
- "size":[24,24]
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-track.9.png"
},
"progressVisual":{
- "url":"{DALI_IMAGE_DIR}progress-skin-progress.9.png",
- "size":[24,24]
- }
- },
- "ProgressBarValueTextLabel":
- {
- "textColor":[0.8,0.8,1,1]
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-progress.9.png"
+ },
+ "secondaryProgressVisual":{
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-secondary-progress.9.png"
+ },
+ "indeterminateVisual":{
+ "visualType":"IMAGE",
+ "pixelArea":[0.0, 0.0, 10.0, 1.0],
+ "wrapModeU":"REPEAT",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-indeterminate.png"
+ },
+ "indeterminateVisualAnimation":
+ [
+ {
+ "target":"indeterminateVisual",
+ "property":"pixelArea",
+ "initialValue":[0.0, 0.0, 10.0, 1.0],
+ "targetValue":[-1.0, 0.0, 10.0, 1.0],
+ "animator":
+ {
+ "alphaFunction":"DEFAULT",
+ "timePeriod":
+ {
+ "duration":0.8,
+ "delay":0
+ }
+ }
+ }
+ ],
+ "labelVisual":{
+ "visualType": "TEXT",
+ "textColor": [ 1.0, 1.0, 1.0, 1.0 ],
+ "pointSize" : 12.0, // Point size must always be provided to Text Visual
+ "horizontalAlignment": "CENTER",
+ "verticalAlignment": "CENTER"
+ },
+ "progressValue": 0.0,
+ "secondaryProgressValue":0.0,
+ "indeterminate": false
},
"Button":
{
"url": "{DALI_IMAGE_DIR}button-disabled.9.png"
}
},
+ "ToggleButton":
+ {
+ "styles":["Button"]
+ },
"CheckBoxButton":
{
"styles":["Button"],
},
"ProgressBar":
{
- "progressValue": 0,
"trackVisual":{
- "url":"{DALI_IMAGE_DIR}progress-skin.9.png",
- "size":[24,24]
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-track.9.png"
},
"progressVisual":{
- "url":"{DALI_IMAGE_DIR}progress-skin-progress.9.png",
- "size":[24,24]
- }
- },
- "ProgressBarValueTextLabel":
- {
- "textColor":[0.8,0.8,1,1]
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-progress.9.png"
+ },
+ "secondaryProgressVisual":{
+ "visualType":"IMAGE",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-secondary-progress.9.png"
+ },
+ "indeterminateVisual":{
+ "visualType":"IMAGE",
+ "pixelArea":[0.0, 0.0, 10.0, 1.0],
+ "wrapModeU":"REPEAT",
+ "url":"{DALI_IMAGE_DIR}progress-bar-skin-indeterminate.png"
+ },
+ "indeterminateVisualAnimation":
+ [
+ {
+ "target":"indeterminateVisual",
+ "property":"pixelArea",
+ "initialValue":[0.0, 0.0, 10.0, 1.0],
+ "targetValue":[-1.0, 0.0, 10.0, 1.0],
+ "animator":
+ {
+ "alphaFunction":"DEFAULT",
+ "timePeriod":
+ {
+ "duration":0.8,
+ "delay":0
+ }
+ }
+ }
+ ],
+ "labelVisual":{
+ "visualType": "TEXT",
+ "textColor": [ 1.0, 1.0, 1.0, 1.0 ],
+ "pointSize" : 12.0, // Point size must always be provided to Text Visual
+ "horizontalAlignment": "CENTER",
+ "verticalAlignment": "CENTER"
+ },
+ "progressValue": 0.0,
+ "secondaryProgressValue":0.0,
+ "indeterminate": false
},
"Button":
{
Visuals also have a custom **shader** property. Whilst it's possible to change the shader, please note that some visuals rely on the vertex shader to perform certain functions. For example, the NPatch visual uses the vertex shader to perform the stretching. The **shader** property is a Property::Map with the following keys:
-| Property | String | Type | Required | Description |
-|-------------------------------------------------|----------|:-------:|:--------:|---------------------------|
-| Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER | vertexShader | STRING | No | The vertex shader code. |
-| Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER | fragmentShader | STRING | No | The fragment shader code. |
-| Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X | subdivideGridX | INTEGER | No | How to subdivide the grid along the X-Axis. Defaults to 1 |
-| Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y | subdivideGridY | INTEGER | No | How to subdivide the grid along the Y-Axis. Defaults to 1 |
-| Dali::Toolkit::Visual::Shader::Property::HINTS | hints | INTEGER or ARRAY of STRING | No | Shader hints bitmask [More info](@ref shader-hints) |
+| Property | String | Type | Required | Description |
+|-----------------------------------------------------------|----------------|:--------------------------:|:--------:|--------------------------------------------------------------------------------------------|
+| Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER | vertexShader | STRING or ARRAY of STRING | No | The vertex shader code. Can use an array of strings to split shader over multiple lines. |
+| Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER | fragmentShader | STRING or ARRAY of STRING | No | The fragment shader code. Can use an array of strings to split shader over multiple lines. |
+| Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X | subdivideGridX | INTEGER | No | How to subdivide the grid along the X-Axis. Defaults to 1. |
+| Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y | subdivideGridY | INTEGER | No | How to subdivide the grid along the Y-Axis. Defaults to 1. |
+| Dali::Toolkit::Visual::Shader::Property::HINTS | hints | INTEGER or ARRAY of STRING | No | Shader hints bitmask [More info](@ref shader-hints) |
## Shader hints {#shader-hints}
projects / platform / core / uifw / dali-toolkit.git / commitdiff
