X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Fprogress-bar%2Fprogress-bar-impl.cpp;h=2df2b7718c9f5b1feedd756b150036dc34bffdc7;hb=b8da2e53925b9abb9fa362560069e8ca4aa62f81;hp=338cef7305d56388a8612b9d529a7a9bef774555;hpb=b81c20064def5a5017e77876effd01ddc5bb39d6;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git

diff --git a/dali-toolkit/internal/controls/progress-bar/progress-bar-impl.cpp b/dali-toolkit/internal/controls/progress-bar/progress-bar-impl.cpp
old mode 100755
new mode 100644
index 338cef7..2df2b77
--- a/dali-toolkit/internal/controls/progress-bar/progress-bar-impl.cpp
+++ b/dali-toolkit/internal/controls/progress-bar/progress-bar-impl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
@@ -19,47 +19,104 @@
 #include <dali-toolkit/internal/controls/progress-bar/progress-bar-impl.h>
 
 // EXTERNAL INCLUDES
-#include <cstring> // for strcmp
-#include <sstream>
-#include <algorithm>
+#include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+#include <dali-toolkit/devel-api/visuals/arc-visual-properties-devel.h>
+#include <dali-toolkit/internal/controls/control/control-data-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
+#include <dali-toolkit/internal/visuals/visual-string-constants.h>
+#include <dali-toolkit/public-api/align-enumerations.h>
+#include <dali-toolkit/public-api/visuals/color-visual-properties.h>
+#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
+#include <dali-toolkit/public-api/visuals/text-visual-properties.h>
+#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali/public-api/math/math-utils.h>
 #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 <algorithm>
+#include <cstring> // for strcmp
+#include <sstream>
+
+#include <dali/integration-api/debug.h>
 
 namespace Dali
 {
-
 namespace Toolkit
 {
-
 namespace Internal
 {
-
 namespace // Unnamed namespace
 {
-
 BaseHandle Create()
 {
   return Dali::Toolkit::ProgressBar::New();
 }
 
+// clang-format off
 // Setup properties, signals and actions using the type-registry.
-DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ProgressBar, Toolkit::Control, Create )
+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()
+// clang-format on
+
+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;
+const char* CIRCULAR_PROGRESS_BAR_STYLE_NAME = "CircularProgressBar";
+
+void BackupVisualProperties(const Control* control, Property::Index index, Property::Map& map)
+{
+  Toolkit::Visual::Base visual = DevelControl::GetVisual(*control, index);
+
+  if(visual)
+  {
+    map.Clear();
+    visual.CreatePropertyMap(map);
+  }
+}
+
+void RestoreVisualProperties(Control* control, Property::Index index, Property::Map& map, int depth)
+{
+  if(!map.Empty())
+  {
+    Toolkit::Visual::Base visual = DevelControl::GetVisual(*control, index);
+
+    Visual::Base& visualImpl = Toolkit::GetImplementation(visual);
 
-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";
+    visualImpl.SetProperties(map);
 
-float DEFAULT_VALUE = 0.0f;
-float DEFAULT_LOWER_BOUND = 0.0f;
-float DEFAULT_UPPER_BOUND = 1.0f;
-float DEFAULT_PADDING = 24.0f;
+    DevelControl::UnregisterVisual(*control, index);
+
+    DevelControl::RegisterVisual(*control, index, visual, true, depth);
+  }
+}
 
 } // Unnamed namespace
 
@@ -67,13 +124,25 @@ float DEFAULT_PADDING = 24.0f;
 // ProgressBar
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-Dali::Toolkit::ProgressBar ProgressBar::New()
+Dali::Toolkit::ProgressBar ProgressBar::New(DevelProgressBar::Style progressBarStyle)
 {
   // Create the implementation
-  ProgressBarPtr progressBar( new ProgressBar() );
+  ProgressBarPtr progressBar(new ProgressBar());
 
-  // Pass ownership to CustomActor via derived handle
-  Dali::Toolkit::ProgressBar handle( *progressBar );
+  Dali::Toolkit::ProgressBar handle(*progressBar);
+
+  switch(progressBarStyle)
+  {
+    case DevelProgressBar::Style::CIRCULAR:
+    {
+      progressBar->SetStyleName(CIRCULAR_PROGRESS_BAR_STYLE_NAME);
+      break;
+    }
+    default:
+    {
+      break;
+    }
+  }
 
   // Second-phase init of the implementation
   // This can only be done after the CustomActor connection has been made...
@@ -83,13 +152,10 @@ Dali::Toolkit::ProgressBar ProgressBar::New()
 }
 
 ProgressBar::ProgressBar()
-: Control( ControlBehaviour( REQUIRES_STYLE_CHANGE_SIGNALS ) ),
-  mTrackVisual(""),
-  mProgressVisual(""),
-  mTrackMap(),
-  mTrackVisualSize(),
-  mProgressVisualSize(),
-  mValue( DEFAULT_VALUE )
+: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
+  mProgressValue(DEFAULT_VALUE),
+  mSecondaryProgressValue(DEFAULT_VALUE),
+  mIndeterminate(false)
 {
 }
 
@@ -99,269 +165,341 @@ ProgressBar::~ProgressBar()
 
 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
+  DevelControl::SetAccessibilityConstructor(Self(), [](Dali::Actor actor) {
+    return std::unique_ptr<Dali::Accessibility::Accessible>(
+      new AccessibleImpl(actor, Dali::Accessibility::Role::PROGRESS_BAR));
+  });
+  //Enable highightability
+  Self().SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true);
 }
 
-void ProgressBar::OnRelayout( const Vector2& size, RelayoutContainer& container )
+void ProgressBar::OnRelayout(const Vector2& size, RelayoutContainer& container)
 {
-  Vector2 trackSize( size );
-  trackSize.width = std::max( 0.0f, size.width - DEFAULT_PADDING ); // Ensure we don't go negative
+  Vector2 trackSize(size);
+  mDomain = CalcDomain(size);
+
+  trackSize.width = std::max(0.0f, size.width); // Ensure we don't go negative
 
-  // Track
-  if( mTrack )
+  Toolkit::Visual::Base trackVisual         = DevelControl::GetVisual(*this, Toolkit::ProgressBar::Property::TRACK_VISUAL);
+  Toolkit::Visual::Base labelVisual         = DevelControl::GetVisual(*this, Toolkit::ProgressBar::Property::LABEL_VISUAL);
+  Toolkit::Visual::Base indeterminateVisual = DevelControl::GetVisual(*this, Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL);
+
+  if(trackVisual)
   {
-    container.Add( mTrack, trackSize );
+    Property::Map visualTransform;
+
+    visualTransform.Add(Toolkit::Visual::Transform::Property::SIZE, trackSize)
+      .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
+      .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
 
-    // mValueTextLabel will have its relayout method called automatically as it's a child of mTrack,
-    // which is added to the container
+    trackVisual.SetTransformAndSize(visualTransform, trackSize);
   }
 
-  // Progress bar
-  if( mProgress )
+  ApplyProgressToVisualTransform(mSecondaryProgressValue, trackSize, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL);
+
+  ApplyProgressToVisualTransform(mProgressValue, trackSize, Toolkit::ProgressBar::Property::PROGRESS_VISUAL);
+
+  if(labelVisual)
   {
-    mDomain = CalcDomain( trackSize );
+    Property::Map visualTransform;
 
-    Vector2 progressSize( trackSize );
+    visualTransform.Add(Toolkit::Visual::Transform::Property::SIZE, trackSize)
+      .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
+      .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
+    labelVisual.SetTransformAndSize(visualTransform, trackSize);
+  }
 
-    // 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, trackSize.width ); // We should not exceed given size
+  if(indeterminateVisual)
+  {
+    Property::Map visualTransform;
 
-    container.Add( mProgress, progressSize );
+    visualTransform.Add(Toolkit::Visual::Transform::Property::SIZE, trackSize)
+      .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
+      .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
+    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 = DevelControl::GetVisual(*this, Toolkit::ProgressBar::Property::TRACK_VISUAL);
+  Toolkit::Visual::Base labelVisual = DevelControl::GetVisual(*this, 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;
 }
 
-ProgressBar::Domain ProgressBar::CalcDomain( const Vector2& currentSize )
+ProgressBar::Domain ProgressBar::CalcDomain(const Vector2& currentSize)
 {
-   return Domain( Vector2( 0.0f, 0.0f ), currentSize );
+  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()) )
+    ApplyProgressToVisual(mProgressValue, Toolkit::ProgressBar::Property::PROGRESS_VISUAL, ProgressDepthIndex::PROGRESS_VISUAL);
+
+    Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast(Self());
+    mValueChangedSignal.Emit(self, mProgressValue, mSecondaryProgressValue);
+    if(Self() == Dali::Accessibility::Accessible::GetCurrentlyHighlightedActor())
     {
-      mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
+      Control::Impl::GetAccessibilityObject(Self())->Emit(Dali::Accessibility::ObjectPropertyChangeEvent::VALUE);
     }
+    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);
+
+    ApplyProgressToVisual(mSecondaryProgressValue, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL);
+
+    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;
+  DevelControl::EnableVisual(*this, 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 )
-  {
+    // Restore previous visual data after animation finished.
+    RestoreVisualProperties(this, Toolkit::ProgressBar::Property::TRACK_VISUAL, mTrackVisualMap, ProgressDepthIndex::TRACK_VISUAL);
+    RestoreVisualProperties(this, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, mSecondaryProgressVisualMap, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL);
+    RestoreVisualProperties(this, Toolkit::ProgressBar::Property::PROGRESS_VISUAL, mProgressVisualMap, ProgressDepthIndex::PROGRESS_VISUAL);
+
     RelayoutRequest();
   }
 }
 
-std::string ProgressBar::GetTrackVisual()
+bool ProgressBar::GetIndeterminate() const
 {
-  return mTrackVisual;
+  return mIndeterminate;
 }
 
-Toolkit::ImageView ProgressBar::CreateProgress()
+void ProgressBar::SetIndeterminateVisualTransition(Toolkit::TransitionData transition)
 {
-  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 );
+  mIndeterminateVisualTransition = transition;
+  if(mIndeterminate)
+  {
+    PlayIndeterminateVisualTransition();
+  }
+}
 
-  return progress;
+void ProgressBar::PlayIndeterminateVisualTransition()
+{
+  // Store current visual data before animation changes it.
+  BackupVisualProperties(this, Toolkit::ProgressBar::Property::TRACK_VISUAL, mTrackVisualMap);
+  BackupVisualProperties(this, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, mSecondaryProgressVisualMap);
+  BackupVisualProperties(this, Toolkit::ProgressBar::Property::PROGRESS_VISUAL, mProgressVisualMap);
+
+  if(mIndeterminateVisualAni)
+  {
+    mIndeterminateVisualAni.Stop();
+    mIndeterminateVisualAni.Clear();
+  }
+
+  mIndeterminateVisualAni = DevelControl::CreateTransition(*this, mIndeterminateVisualTransition);
+
+  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 int 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.
+    const 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();
+    if(index == Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL)
+    {
+      DevelControl::RegisterVisual(*this, index, progressVisual, mIndeterminate, visualDepth);
+    }
+    else
+    {
+      DevelControl::RegisterVisual(*this, index, progressVisual, true, visualDepth);
+    }
+  }
+  else
+  {
+    DevelControl::UnregisterVisual(*this, index);
   }
 }
 
-std::string ProgressBar::GetProgressVisual()
+bool ProgressBar::GetPropertyMapForVisual(Property::Index visualIndex, Property::Map& retreivedMap) const
 {
-  return mProgressVisual;
-}
+  bool                  success = false;
+  Toolkit::Visual::Base visual  = DevelControl::GetVisual(*this, visualIndex);
 
-Toolkit::ProgressBar::ValueChangedSignalType& ProgressBar::ValueChangedSignal()
-{
-  return mValueChangedSignal;
+  if(visual)
+  {
+    visual.CreatePropertyMap(retreivedMap);
+    success = true;
+  }
+
+  return success;
 }
 
-void ProgressBar::CreateChildren()
+void ProgressBar::ApplyProgressToVisual(float progress, Property::Index index, int depth)
 {
-  Actor self = Self();
+  Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, index);
 
-  // Track
-  mTrack = CreateTrack();
-  self.Add( mTrack ); // Needs to be a direct child as we want to manipulate its size
+  if(visual && static_cast<DevelVisual::Type>(visual.GetType()) == DevelVisual::ARC && !mIndeterminate)
+  {
+    Visual::Base& visualImpl = Toolkit::GetImplementation(visual);
 
-  // Progress bar
-  mProgress = CreateProgress();
-  self.Add( mProgress ); // Needs to be a direct child as we want to manipulate its size
+    Property::Map map;
 
-  // 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
-}
+    map[Toolkit::DevelArcVisual::Property::SWEEP_ANGLE] = Property::Value(360.0f * progress);
 
-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 ) ) ) )
-  {
-    mValue = Clamp( value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND );
-    DisplayValue( mValue, true );
-    RelayoutRequest();
+    visualImpl.SetProperties(map);
+
+    DevelControl::UnregisterVisual(*this, index);
+    DevelControl::RegisterVisual(*this, index, visual, true, depth);
   }
 }
 
-float ProgressBar::GetProgressValue() const
+void ProgressBar::ApplyProgressToVisualTransform(float progress, Vector2 trackSize, Property::Index index)
 {
-  return mValue;
+  Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, index);
+
+  if(visual)
+  {
+    Property::Map visualTransform;
+
+    if(static_cast<DevelVisual::Type>(visual.GetType()) != DevelVisual::ARC)
+    {
+      visualTransform.Add(Toolkit::Visual::Transform::Property::SIZE, Vector2(mDomain.from.x + progress * (mDomain.to.x - mDomain.from.x), trackSize.height))
+        .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
+        .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
+        .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
+        .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN);
+    }
+
+    visual.SetTransformAndSize(visualTransform, trackSize);
+  }
 }
 
 // Static class method to support script connecting signals
-bool ProgressBar::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
+bool ProgressBar::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor)
 {
-  Dali::BaseHandle handle( object );
+  Dali::BaseHandle handle(object);
 
-  bool connected = true;
-  Toolkit::ProgressBar ProgressBar = Toolkit::ProgressBar::DownCast( handle );
+  bool                 connected   = true;
+  Toolkit::ProgressBar ProgressBar = Toolkit::ProgressBar::DownCast(handle);
 
-  if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
+  if(0 == strcmp(signalName.c_str(), SIGNAL_VALUE_CHANGED))
   {
-    ProgressBar.ValueChangedSignal().Connect( tracker, functor );
+    ProgressBar.ValueChangedSignal().Connect(tracker, functor);
   }
   else
   {
@@ -372,94 +510,204 @@ bool ProgressBar::DoConnectSignal( BaseObject* object, ConnectionTrackerInterfac
   return connected;
 }
 
-void ProgressBar::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
+void ProgressBar::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
 {
-  Toolkit::ProgressBar progressBar = Toolkit::ProgressBar::DownCast( Dali::BaseHandle( object ) );
+  Toolkit::ProgressBar progressBar = Toolkit::ProgressBar::DownCast(Dali::BaseHandle(object));
 
-  if ( progressBar )
+  if(progressBar)
   {
-    ProgressBar& progressBarImpl( GetImpl( progressBar ) );
+    ProgressBar& progressBarImpl(GetImpl(progressBar));
 
-    switch ( propertyIndex )
+    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);
+        progressBarImpl.ApplyProgressToVisual(progressBarImpl.mSecondaryProgressValue, propertyIndex, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL);
         break;
       }
 
       case Toolkit::ProgressBar::Property::PROGRESS_VISUAL:
       {
+        progressBarImpl.CreateVisualsForComponent(propertyIndex, value, ProgressDepthIndex::PROGRESS_VISUAL);
+        progressBarImpl.ApplyProgressToVisual(progressBarImpl.mProgressValue, propertyIndex, 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 = DevelControl::GetVisual(progressBarImpl, 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::Visual::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;
       }
     }
   }
 }
 
-Property::Value ProgressBar::GetProperty( BaseObject* object, Property::Index propertyIndex )
+Property::Value ProgressBar::GetProperty(BaseObject* object, Property::Index propertyIndex)
 {
   Property::Value value;
 
-  Toolkit::ProgressBar progressBar = Toolkit::ProgressBar::DownCast( Dali::BaseHandle( object ) );
+  Toolkit::ProgressBar progressBar = Toolkit::ProgressBar::DownCast(Dali::BaseHandle(object));
 
-  if ( progressBar )
+  if(progressBar)
   {
-    ProgressBar& progressBarImpl( GetImpl( progressBar ) );
+    ProgressBar& progressBarImpl(GetImpl(progressBar));
 
-    switch ( propertyIndex )
+    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::OnSceneConnection(int depth)
+{
+  // Chain up first (ensures visuals are ready to draw)
+  Control::OnSceneConnection(depth);
+
+  if(mIndeterminate)
+  {
+    PlayIndeterminateVisualTransition();
+  }
+}
+
+double ProgressBar::AccessibleImpl::GetMinimum()
+{
+  return DEFAULT_LOWER_BOUND;
+}
+
+double ProgressBar::AccessibleImpl::GetCurrent()
+{
+  auto p = Toolkit::ProgressBar::DownCast(self);
+  return p.GetProperty(Toolkit::ProgressBar::Property::PROGRESS_VALUE)
+    .Get<float>();
+}
+
+double ProgressBar::AccessibleImpl::GetMaximum()
+{
+  return DEFAULT_UPPER_BOUND;
+}
+
+bool ProgressBar::AccessibleImpl::SetCurrent(double current)
+{
+  if(current < GetMinimum() || current > GetMaximum())
+    return false;
+  auto p = Toolkit::ProgressBar::DownCast(self);
+  p.SetProperty(Toolkit::ProgressBar::Property::PROGRESS_VALUE,
+                static_cast<float>(current));
+  return true;
+}
+
+double ProgressBar::AccessibleImpl::GetMinimumIncrement()
+{
+  return 0.0;
+}
+
 } // namespace Internal
 
 } // namespace Toolkit