dali-toolkit/internal/controls/progress-bar/progress-bar-impl.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-toolkit/internal/controls/progress-bar/progress-bar-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali-toolkit/devel-api/controls/control-devel.h>
  23 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
  24 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  25 #include <dali-toolkit/devel-api/visuals/arc-visual-properties-devel.h>
  26 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
  27 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
  28 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  29 #include <dali-toolkit/public-api/align-enumerations.h>
  30 #include <dali-toolkit/public-api/visuals/color-visual-properties.h>
  31 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  32 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
  33 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  34 #include <dali/public-api/math/math-utils.h>
  35 #include <dali/public-api/object/type-registry-helper.h>
  36 #include <dali/public-api/size-negotiation/relayout-container.h>
  37 #include <algorithm>
  38 #include <cstring> // for strcmp
  39 #include <sstream>
  40
  41 #include <dali/integration-api/debug.h>
  42
  43 namespace Dali
  44 {
  45 namespace Toolkit
  46 {
  47 namespace Internal
  48 {
  49 namespace // Unnamed namespace
  50 {
  51 BaseHandle Create()
  52 {
  53   return Dali::Toolkit::ProgressBar::New();
  54 }
  55
  56 // clang-format off
  57 // Setup properties, signals and actions using the type-registry.
  58 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::ProgressBar, Toolkit::Control, Create)
  59
  60 DALI_PROPERTY_REGISTRATION(Toolkit, ProgressBar, "progressValue",                FLOAT,   PROGRESS_VALUE                )
  61 DALI_PROPERTY_REGISTRATION(Toolkit, ProgressBar, "secondaryProgressValue",       FLOAT,   SECONDARY_PROGRESS_VALUE      )
  62 DALI_PROPERTY_REGISTRATION(Toolkit, ProgressBar, "indeterminate",                BOOLEAN, INDETERMINATE                 )
  63 DALI_PROPERTY_REGISTRATION(Toolkit, ProgressBar, "trackVisual",                  MAP,     TRACK_VISUAL                  )
  64 DALI_PROPERTY_REGISTRATION(Toolkit, ProgressBar, "progressVisual",               MAP,     PROGRESS_VISUAL               )
  65 DALI_PROPERTY_REGISTRATION(Toolkit, ProgressBar, "secondaryProgressVisual",      MAP,     SECONDARY_PROGRESS_VISUAL     )
  66 DALI_PROPERTY_REGISTRATION(Toolkit, ProgressBar, "indeterminateVisual",          MAP,     INDETERMINATE_VISUAL          )
  67 DALI_PROPERTY_REGISTRATION(Toolkit, ProgressBar, "indeterminateVisualAnimation", ARRAY,   INDETERMINATE_VISUAL_ANIMATION)
  68 DALI_PROPERTY_REGISTRATION(Toolkit, ProgressBar, "labelVisual",                  MAP,     LABEL_VISUAL                  )
  69
  70 DALI_SIGNAL_REGISTRATION(Toolkit, ProgressBar, "valueChanged", SIGNAL_VALUE_CHANGED)
  71
  72 DALI_TYPE_REGISTRATION_END()
  73 // clang-format on
  74
  75 struct ProgressDepthIndex
  76 {
  77   // Enum to make sure the visual order
  78   enum
  79   {
  80     TRACK_VISUAL,
  81     SECONDARY_PROGRESS_VISUAL,
  82     PROGRESS_VISUAL,
  83     LABEL_VISUAL,
  84     INDETERMINATE_VISUAL
  85   };
  86 };
  87
  88 float       DEFAULT_VALUE                    = 0.0f;
  89 float       DEFAULT_LOWER_BOUND              = 0.0f;
  90 float       DEFAULT_UPPER_BOUND              = 1.0f;
  91 float       DEFAULT_FONT_SIZE                = 12.0f;
  92 const char* CIRCULAR_PROGRESS_BAR_STYLE_NAME = "CircularProgressBar";
  93
  94 void BackupVisualProperties(const Control* control, Property::Index index, Property::Map& map)
  95 {
  96   Toolkit::Visual::Base visual = DevelControl::GetVisual(*control, index);
  97
  98   if(visual)
  99   {
 100     map.Clear();
 101     visual.CreatePropertyMap(map);
 102   }
 103 }
 104
 105 void RestoreVisualProperties(Control* control, Property::Index index, Property::Map& map, int depth)
 106 {
 107   if(!map.Empty())
 108   {
 109     Toolkit::Visual::Base visual = DevelControl::GetVisual(*control, index);
 110
 111     Visual::Base& visualImpl = Toolkit::GetImplementation(visual);
 112
 113     visualImpl.SetProperties(map);
 114
 115     DevelControl::UnregisterVisual(*control, index);
 116
 117     DevelControl::RegisterVisual(*control, index, visual, true, depth);
 118   }
 119 }
 120
 121 } // Unnamed namespace
 122
 123 ///////////////////////////////////////////////////////////////////////////////////////////////////
 124 // ProgressBar
 125 ///////////////////////////////////////////////////////////////////////////////////////////////////
 126
 127 Dali::Toolkit::ProgressBar ProgressBar::New(DevelProgressBar::Style progressBarStyle)
 128 {
 129   // Create the implementation
 130   ProgressBarPtr progressBar(new ProgressBar());
 131
 132   Dali::Toolkit::ProgressBar handle(*progressBar);
 133
 134   switch(progressBarStyle)
 135   {
 136     case DevelProgressBar::Style::CIRCULAR:
 137     {
 138       progressBar->SetStyleName(CIRCULAR_PROGRESS_BAR_STYLE_NAME);
 139       break;
 140     }
 141     default:
 142     {
 143       break;
 144     }
 145   }
 146
 147   // Second-phase init of the implementation
 148   // This can only be done after the CustomActor connection has been made...
 149   progressBar->Initialize();
 150
 151   return handle;
 152 }
 153
 154 ProgressBar::ProgressBar()
 155 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
 156   mProgressValue(DEFAULT_VALUE),
 157   mSecondaryProgressValue(DEFAULT_VALUE),
 158   mIndeterminate(false)
 159 {
 160 }
 161
 162 ProgressBar::~ProgressBar()
 163 {
 164 }
 165
 166 void ProgressBar::OnInitialize()
 167 {
 168   // Accessibility
 169   Self().SetProperty(DevelControl::Property::ACCESSIBILITY_ROLE, Dali::Accessibility::Role::PROGRESS_BAR);
 170   Self().SetProperty(DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true);
 171 }
 172
 173 DevelControl::ControlAccessible* ProgressBar::CreateAccessibleObject()
 174 {
 175   return new ProgressBarAccessible(Self());
 176 }
 177
 178 void ProgressBar::OnRelayout(const Vector2& size, RelayoutContainer& container)
 179 {
 180   Vector2 trackSize(size);
 181   mDomain = CalcDomain(size);
 182
 183   trackSize.width = std::max(0.0f, size.width); // Ensure we don't go negative
 184
 185   Toolkit::Visual::Base trackVisual         = DevelControl::GetVisual(*this, Toolkit::ProgressBar::Property::TRACK_VISUAL);
 186   Toolkit::Visual::Base labelVisual         = DevelControl::GetVisual(*this, Toolkit::ProgressBar::Property::LABEL_VISUAL);
 187   Toolkit::Visual::Base indeterminateVisual = DevelControl::GetVisual(*this, Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL);
 188
 189   if(trackVisual)
 190   {
 191     Property::Map visualTransform;
 192
 193     visualTransform.Add(Toolkit::Visual::Transform::Property::SIZE, trackSize)
 194       .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
 195       .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
 196
 197     trackVisual.SetTransformAndSize(visualTransform, trackSize);
 198   }
 199
 200   ApplyProgressToVisualTransform(mSecondaryProgressValue, trackSize, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL);
 201
 202   ApplyProgressToVisualTransform(mProgressValue, trackSize, Toolkit::ProgressBar::Property::PROGRESS_VISUAL);
 203
 204   if(labelVisual)
 205   {
 206     Property::Map visualTransform;
 207
 208     visualTransform.Add(Toolkit::Visual::Transform::Property::SIZE, trackSize)
 209       .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
 210       .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
 211     labelVisual.SetTransformAndSize(visualTransform, trackSize);
 212   }
 213
 214   if(indeterminateVisual)
 215   {
 216     Property::Map visualTransform;
 217
 218     visualTransform.Add(Toolkit::Visual::Transform::Property::SIZE, trackSize)
 219       .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
 220       .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
 221     indeterminateVisual.SetTransformAndSize(visualTransform, trackSize);
 222   }
 223 }
 224
 225 Vector3 ProgressBar::GetNaturalSize()
 226 {
 227   // Return the bigger size after comparing trackVisual naturalSize and labelVisual naturalSize
 228   Toolkit::Visual::Base trackVisual = DevelControl::GetVisual(*this, Toolkit::ProgressBar::Property::TRACK_VISUAL);
 229   Toolkit::Visual::Base labelVisual = DevelControl::GetVisual(*this, Toolkit::ProgressBar::Property::LABEL_VISUAL);
 230
 231   Size trackSize;
 232   Size labelSize;
 233
 234   if(trackVisual)
 235   {
 236     trackVisual.GetNaturalSize(trackSize);
 237   }
 238   if(labelVisual)
 239   {
 240     labelVisual.GetNaturalSize(labelSize);
 241   }
 242
 243   Vector3 naturalSize;
 244   naturalSize.width  = (trackSize.width > labelSize.width) ? trackSize.width : labelSize.width;
 245   naturalSize.height = (trackSize.height > labelSize.height) ? trackSize.height : labelSize.height;
 246
 247   return naturalSize;
 248 }
 249
 250 ProgressBar::Domain ProgressBar::CalcDomain(const Vector2& currentSize)
 251 {
 252   return Domain(Vector2(0.0f, 0.0f), currentSize);
 253 }
 254
 255 Toolkit::ProgressBar::ValueChangedSignalType& ProgressBar::ValueChangedSignal()
 256 {
 257   return mValueChangedSignal;
 258 }
 259
 260 void ProgressBar::SetProgressValue(float value)
 261 {
 262   // update the progress bar value (taking float precision errors into account)
 263   // TODO : it seems 0.0f cannot into this statement.
 264   if((!Equals(mProgressValue, value)) &&
 265      ((value >= DEFAULT_LOWER_BOUND) || (Equals(value, DEFAULT_LOWER_BOUND))) &&
 266      ((value <= DEFAULT_UPPER_BOUND) || (Equals(value, DEFAULT_UPPER_BOUND))))
 267   {
 268     mProgressValue = Clamp(value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND);
 269
 270     ApplyProgressToVisual(mProgressValue, Toolkit::ProgressBar::Property::PROGRESS_VISUAL, ProgressDepthIndex::PROGRESS_VISUAL);
 271
 272     Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast(Self());
 273     mValueChangedSignal.Emit(self, mProgressValue, mSecondaryProgressValue);
 274     if(Self() == Dali::Accessibility::Accessible::GetCurrentlyHighlightedActor())
 275     {
 276       GetAccessibleObject()->Emit(Dali::Accessibility::ObjectPropertyChangeEvent::VALUE);
 277     }
 278     RelayoutRequest();
 279   }
 280 }
 281
 282 float ProgressBar::GetProgressValue() const
 283 {
 284   return mProgressValue;
 285 }
 286
 287 void ProgressBar::SetSecondaryProgressValue(float value)
 288 {
 289   // update the progress bar value (taking float precision errors into account)
 290   // TODO : it seems 0.0f cannot into this statement.
 291   if((!Equals(mSecondaryProgressValue, value)) &&
 292      ((value >= DEFAULT_LOWER_BOUND) || (Equals(value, DEFAULT_LOWER_BOUND))) &&
 293      ((value <= DEFAULT_UPPER_BOUND) || (Equals(value, DEFAULT_UPPER_BOUND))))
 294   {
 295     mSecondaryProgressValue = Clamp(value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND);
 296
 297     ApplyProgressToVisual(mSecondaryProgressValue, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL);
 298
 299     Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast(Self());
 300     mValueChangedSignal.Emit(self, mProgressValue, mSecondaryProgressValue);
 301
 302     RelayoutRequest();
 303   }
 304 }
 305
 306 float ProgressBar::GetSecondaryProgressValue() const
 307 {
 308   return mSecondaryProgressValue;
 309 }
 310
 311 void ProgressBar::SetIndeterminate(bool value)
 312 {
 313   mIndeterminate = value;
 314   DevelControl::EnableVisual(*this, Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL, mIndeterminate);
 315
 316   if(mIndeterminate)
 317   {
 318     RelayoutRequest();
 319     if(mIndeterminateVisualTransition)
 320     {
 321       PlayIndeterminateVisualTransition();
 322     }
 323   }
 324   else
 325   {
 326     if(mIndeterminateVisualAni)
 327     {
 328       mIndeterminateVisualAni.Stop();
 329     }
 330
 331     // Restore previous visual data after animation finished.
 332     RestoreVisualProperties(this, Toolkit::ProgressBar::Property::TRACK_VISUAL, mTrackVisualMap, ProgressDepthIndex::TRACK_VISUAL);
 333     RestoreVisualProperties(this, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, mSecondaryProgressVisualMap, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL);
 334     RestoreVisualProperties(this, Toolkit::ProgressBar::Property::PROGRESS_VISUAL, mProgressVisualMap, ProgressDepthIndex::PROGRESS_VISUAL);
 335
 336     RelayoutRequest();
 337   }
 338 }
 339
 340 bool ProgressBar::GetIndeterminate() const
 341 {
 342   return mIndeterminate;
 343 }
 344
 345 void ProgressBar::SetIndeterminateVisualTransition(Toolkit::TransitionData transition)
 346 {
 347   mIndeterminateVisualTransition = transition;
 348   if(mIndeterminate)
 349   {
 350     PlayIndeterminateVisualTransition();
 351   }
 352 }
 353
 354 void ProgressBar::PlayIndeterminateVisualTransition()
 355 {
 356   // Store current visual data before animation changes it.
 357   BackupVisualProperties(this, Toolkit::ProgressBar::Property::TRACK_VISUAL, mTrackVisualMap);
 358   BackupVisualProperties(this, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, mSecondaryProgressVisualMap);
 359   BackupVisualProperties(this, Toolkit::ProgressBar::Property::PROGRESS_VISUAL, mProgressVisualMap);
 360
 361   if(mIndeterminateVisualAni)
 362   {
 363     mIndeterminateVisualAni.Stop();
 364     mIndeterminateVisualAni.Clear();
 365   }
 366
 367   mIndeterminateVisualAni = DevelControl::CreateTransition(*this, mIndeterminateVisualTransition);
 368
 369   if(mIndeterminate && mIndeterminateVisualAni)
 370   {
 371     mIndeterminateVisualAni.SetLooping(true);
 372     mIndeterminateVisualAni.Play();
 373   }
 374 }
 375
 376 Toolkit::TransitionData ProgressBar::ConvertPropertyToTransition(const Property::Value& value)
 377 {
 378   Toolkit::TransitionData transitionData;
 379
 380   if(value.GetType() == Property::ARRAY)
 381   {
 382     transitionData = Toolkit::TransitionData::New(*value.GetArray());
 383   }
 384   else if(value.GetType() == Property::MAP)
 385   {
 386     transitionData = Toolkit::TransitionData::New(*value.GetMap());
 387   }
 388
 389   return transitionData;
 390 }
 391
 392 /**
 393  * Create Visual for given index from a property map or url.
 394  * 1) Check if value passed in is a url and create visual
 395  * 2) Create visual from map if step (1) is false
 396  * 3) Register visual with control with false for enable flag.
 397  * 4) Unregister visual if empty map was provided. This is the method to remove a visual
 398  */
 399
 400 void ProgressBar::CreateVisualsForComponent(Property::Index index, const Property::Value& value, const int visualDepth)
 401 {
 402   Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
 403   Toolkit::Visual::Base  progressVisual;
 404
 405   std::string imageUrl;
 406   if(value.Get(imageUrl))
 407   {
 408     if(!imageUrl.empty())
 409     {
 410       progressVisual = visualFactory.CreateVisual(imageUrl, ImageDimensions());
 411     }
 412   }
 413   else // Does this code make text-visual can be accepted as visual?
 414   {
 415     // if its not a string then get a Property::Map from the property if possible.
 416     const Property::Map* map = value.GetMap();
 417     if(map && !map->Empty()) // Empty map results in current visual removal.
 418     {
 419       progressVisual = visualFactory.CreateVisual(*map);
 420     }
 421   }
 422
 423   if(progressVisual)
 424   {
 425     if(index == Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL)
 426     {
 427       DevelControl::RegisterVisual(*this, index, progressVisual, mIndeterminate, visualDepth);
 428     }
 429     else
 430     {
 431       DevelControl::RegisterVisual(*this, index, progressVisual, true, visualDepth);
 432     }
 433   }
 434   else
 435   {
 436     DevelControl::UnregisterVisual(*this, index);
 437   }
 438 }
 439
 440 bool ProgressBar::GetPropertyMapForVisual(Property::Index visualIndex, Property::Map& retreivedMap) const
 441 {
 442   bool                  success = false;
 443   Toolkit::Visual::Base visual  = DevelControl::GetVisual(*this, visualIndex);
 444
 445   if(visual)
 446   {
 447     visual.CreatePropertyMap(retreivedMap);
 448     success = true;
 449   }
 450
 451   return success;
 452 }
 453
 454 void ProgressBar::ApplyProgressToVisual(float progress, Property::Index index, int depth)
 455 {
 456   Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, index);
 457
 458   if(visual && static_cast<DevelVisual::Type>(visual.GetType()) == DevelVisual::ARC && !mIndeterminate)
 459   {
 460     Visual::Base& visualImpl = Toolkit::GetImplementation(visual);
 461
 462     Property::Map map;
 463
 464     map[Toolkit::DevelArcVisual::Property::SWEEP_ANGLE] = Property::Value(360.0f * progress);
 465
 466     visualImpl.SetProperties(map);
 467
 468     DevelControl::UnregisterVisual(*this, index);
 469     DevelControl::RegisterVisual(*this, index, visual, true, depth);
 470   }
 471 }
 472
 473 void ProgressBar::ApplyProgressToVisualTransform(float progress, Vector2 trackSize, Property::Index index)
 474 {
 475   Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, index);
 476
 477   if(visual)
 478   {
 479     Property::Map visualTransform;
 480
 481     if(static_cast<DevelVisual::Type>(visual.GetType()) != DevelVisual::ARC)
 482     {
 483       visualTransform.Add(Toolkit::Visual::Transform::Property::SIZE, Vector2(mDomain.from.x + progress * (mDomain.to.x - mDomain.from.x), trackSize.height))
 484         .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
 485         .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
 486         .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
 487         .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN);
 488     }
 489
 490     visual.SetTransformAndSize(visualTransform, trackSize);
 491   }
 492 }
 493
 494 // Static class method to support script connecting signals
 495 bool ProgressBar::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor)
 496 {
 497   Dali::BaseHandle handle(object);
 498
 499   bool                 connected   = true;
 500   Toolkit::ProgressBar ProgressBar = Toolkit::ProgressBar::DownCast(handle);
 501
 502   if(0 == strcmp(signalName.c_str(), SIGNAL_VALUE_CHANGED))
 503   {
 504     ProgressBar.ValueChangedSignal().Connect(tracker, functor);
 505   }
 506   else
 507   {
 508     // signalName does not match any signal
 509     connected = false;
 510   }
 511
 512   return connected;
 513 }
 514
 515 void ProgressBar::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
 516 {
 517   Toolkit::ProgressBar progressBar = Toolkit::ProgressBar::DownCast(Dali::BaseHandle(object));
 518
 519   if(progressBar)
 520   {
 521     ProgressBar& progressBarImpl(GetImpl(progressBar));
 522
 523     switch(propertyIndex)
 524     {
 525       case Toolkit::ProgressBar::Property::TRACK_VISUAL:
 526       {
 527         progressBarImpl.CreateVisualsForComponent(propertyIndex, value, ProgressDepthIndex::TRACK_VISUAL);
 528         break;
 529       }
 530
 531       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL:
 532       {
 533         progressBarImpl.CreateVisualsForComponent(propertyIndex, value, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL);
 534         progressBarImpl.ApplyProgressToVisual(progressBarImpl.mSecondaryProgressValue, propertyIndex, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL);
 535         break;
 536       }
 537
 538       case Toolkit::ProgressBar::Property::PROGRESS_VISUAL:
 539       {
 540         progressBarImpl.CreateVisualsForComponent(propertyIndex, value, ProgressDepthIndex::PROGRESS_VISUAL);
 541         progressBarImpl.ApplyProgressToVisual(progressBarImpl.mProgressValue, propertyIndex, ProgressDepthIndex::PROGRESS_VISUAL);
 542         break;
 543       }
 544
 545       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL:
 546       {
 547         progressBarImpl.CreateVisualsForComponent(propertyIndex, value, ProgressDepthIndex::INDETERMINATE_VISUAL);
 548         break;
 549       }
 550
 551       case Toolkit::ProgressBar::Property::LABEL_VISUAL:
 552       {
 553         Property::Map map;
 554         std::string   textString;
 555
 556         if(value.Get(textString))
 557         {
 558           // set new text string as TEXT property
 559           Property::Map         newTextMap;
 560           Toolkit::Visual::Base label = DevelControl::GetVisual(progressBarImpl, Toolkit::ProgressBar::Property::LABEL_VISUAL);
 561
 562           if(label)
 563           {
 564             label.CreatePropertyMap(map);
 565           }
 566
 567           // if LABEL_VISUAL doesn't set before, add Visual property "TYPE" to create new text Visual
 568           if(map.Empty())
 569           {
 570             newTextMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT);
 571             newTextMap.Add(Toolkit::TextVisual::Property::POINT_SIZE, DEFAULT_FONT_SIZE);
 572           }
 573           newTextMap.Add(Toolkit::TextVisual::Property::TEXT, textString);
 574
 575           map.Merge(newTextMap);
 576         }
 577         else
 578         {
 579           value.Get(map);
 580         }
 581
 582         if(!map.Empty())
 583         {
 584           progressBarImpl.CreateVisualsForComponent(propertyIndex, map, ProgressDepthIndex::LABEL_VISUAL);
 585         }
 586         break;
 587       }
 588
 589       case Toolkit::ProgressBar::Property::PROGRESS_VALUE:
 590       {
 591         progressBarImpl.SetProgressValue(value.Get<float>());
 592         break;
 593       }
 594
 595       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE:
 596       {
 597         progressBarImpl.SetSecondaryProgressValue(value.Get<float>());
 598         break;
 599       }
 600
 601       case Toolkit::ProgressBar::Property::INDETERMINATE:
 602       {
 603         progressBarImpl.SetIndeterminate(value.Get<bool>());
 604         break;
 605       }
 606
 607       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION:
 608       {
 609         progressBarImpl.SetIndeterminateVisualTransition(progressBarImpl.ConvertPropertyToTransition(value));
 610         break;
 611       }
 612     }
 613   }
 614 }
 615
 616 Property::Value ProgressBar::GetProperty(BaseObject* object, Property::Index propertyIndex)
 617 {
 618   Property::Value value;
 619
 620   Toolkit::ProgressBar progressBar = Toolkit::ProgressBar::DownCast(Dali::BaseHandle(object));
 621
 622   if(progressBar)
 623   {
 624     ProgressBar& progressBarImpl(GetImpl(progressBar));
 625
 626     switch(propertyIndex)
 627     {
 628       case Toolkit::ProgressBar::Property::TRACK_VISUAL:
 629       case Toolkit::ProgressBar::Property::PROGRESS_VISUAL:
 630       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL:
 631       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL:
 632       case Toolkit::ProgressBar::Property::LABEL_VISUAL:
 633       {
 634         Property::Map visualProperty;
 635         if(progressBarImpl.GetPropertyMapForVisual(propertyIndex, visualProperty))
 636         {
 637           value = visualProperty;
 638         }
 639         break;
 640       }
 641
 642       case Toolkit::ProgressBar::Property::PROGRESS_VALUE:
 643       {
 644         value = progressBarImpl.GetProgressValue();
 645         break;
 646       }
 647
 648       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE:
 649       {
 650         value = progressBarImpl.GetSecondaryProgressValue();
 651         break;
 652       }
 653
 654       case Toolkit::ProgressBar::Property::INDETERMINATE:
 655       {
 656         value = progressBarImpl.GetIndeterminate();
 657         break;
 658       }
 659
 660       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION:
 661       {
 662         //TODO: Return INDETERMINATE_VISUAL_TRANSITION;
 663       }
 664     }
 665   }
 666
 667   return value;
 668 }
 669
 670 void ProgressBar::OnSceneConnection(int depth)
 671 {
 672   // Chain up first (ensures visuals are ready to draw)
 673   Control::OnSceneConnection(depth);
 674
 675   if(mIndeterminate)
 676   {
 677     PlayIndeterminateVisualTransition();
 678   }
 679 }
 680
 681 double ProgressBar::ProgressBarAccessible::GetMinimum() const
 682 {
 683   return DEFAULT_LOWER_BOUND;
 684 }
 685
 686 double ProgressBar::ProgressBarAccessible::GetCurrent() const
 687 {
 688   auto self = Toolkit::ProgressBar::DownCast(Self());
 689   return self.GetProperty(Toolkit::ProgressBar::Property::PROGRESS_VALUE).Get<float>();
 690 }
 691
 692 double ProgressBar::ProgressBarAccessible::GetMaximum() const
 693 {
 694   return DEFAULT_UPPER_BOUND;
 695 }
 696
 697 bool ProgressBar::ProgressBarAccessible::SetCurrent(double current)
 698 {
 699   if(current < GetMinimum() || current > GetMaximum())
 700   {
 701     return false;
 702   }
 703
 704   auto self = Toolkit::ProgressBar::DownCast(Self());
 705   self.SetProperty(Toolkit::ProgressBar::Property::PROGRESS_VALUE, static_cast<float>(current));
 706   return true;
 707 }
 708
 709 double ProgressBar::ProgressBarAccessible::GetMinimumIncrement() const
 710 {
 711   return 0.0;
 712 }
 713
 714 } // namespace Internal
 715
 716 } // namespace Toolkit
 717
 718 } // namespace Dali