#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
},
"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":
{
},
"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":
{
},
"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":
{
projects / platform / core / uifw / dali-toolkit.git / commitdiff
