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

   1 /*
   2  * Copyright (c) 2023 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       auto accessible = GetAccessibleObject();
 277       if(DALI_LIKELY(accessible))
 278       {
 279         accessible->Emit(Dali::Accessibility::ObjectPropertyChangeEvent::VALUE);
 280       }
 281     }
 282     RelayoutRequest();
 283   }
 284 }
 285
 286 float ProgressBar::GetProgressValue() const
 287 {
 288   return mProgressValue;
 289 }
 290
 291 void ProgressBar::SetSecondaryProgressValue(float value)
 292 {
 293   // update the progress bar value (taking float precision errors into account)
 294   // TODO : it seems 0.0f cannot into this statement.
 295   if((!Equals(mSecondaryProgressValue, value)) &&
 296      ((value >= DEFAULT_LOWER_BOUND) || (Equals(value, DEFAULT_LOWER_BOUND))) &&
 297      ((value <= DEFAULT_UPPER_BOUND) || (Equals(value, DEFAULT_UPPER_BOUND))))
 298   {
 299     mSecondaryProgressValue = Clamp(value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND);
 300
 301     ApplyProgressToVisual(mSecondaryProgressValue, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL);
 302
 303     Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast(Self());
 304     mValueChangedSignal.Emit(self, mProgressValue, mSecondaryProgressValue);
 305
 306     RelayoutRequest();
 307   }
 308 }
 309
 310 float ProgressBar::GetSecondaryProgressValue() const
 311 {
 312   return mSecondaryProgressValue;
 313 }
 314
 315 void ProgressBar::SetIndeterminate(bool value)
 316 {
 317   mIndeterminate = value;
 318   DevelControl::EnableVisual(*this, Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL, mIndeterminate);
 319
 320   if(mIndeterminate)
 321   {
 322     RelayoutRequest();
 323     if(mIndeterminateVisualTransition)
 324     {
 325       PlayIndeterminateVisualTransition();
 326     }
 327   }
 328   else
 329   {
 330     if(mIndeterminateVisualAni)
 331     {
 332       mIndeterminateVisualAni.Stop();
 333     }
 334
 335     // Restore previous visual data after animation finished.
 336     RestoreVisualProperties(this, Toolkit::ProgressBar::Property::TRACK_VISUAL, mTrackVisualMap, ProgressDepthIndex::TRACK_VISUAL);
 337     RestoreVisualProperties(this, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, mSecondaryProgressVisualMap, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL);
 338     RestoreVisualProperties(this, Toolkit::ProgressBar::Property::PROGRESS_VISUAL, mProgressVisualMap, ProgressDepthIndex::PROGRESS_VISUAL);
 339
 340     RelayoutRequest();
 341   }
 342 }
 343
 344 bool ProgressBar::GetIndeterminate() const
 345 {
 346   return mIndeterminate;
 347 }
 348
 349 void ProgressBar::SetIndeterminateVisualTransition(Toolkit::TransitionData transition)
 350 {
 351   mIndeterminateVisualTransition = transition;
 352   if(mIndeterminate)
 353   {
 354     PlayIndeterminateVisualTransition();
 355   }
 356 }
 357
 358 void ProgressBar::PlayIndeterminateVisualTransition()
 359 {
 360   // Store current visual data before animation changes it.
 361   BackupVisualProperties(this, Toolkit::ProgressBar::Property::TRACK_VISUAL, mTrackVisualMap);
 362   BackupVisualProperties(this, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, mSecondaryProgressVisualMap);
 363   BackupVisualProperties(this, Toolkit::ProgressBar::Property::PROGRESS_VISUAL, mProgressVisualMap);
 364
 365   if(mIndeterminateVisualAni)
 366   {
 367     mIndeterminateVisualAni.Stop();
 368     mIndeterminateVisualAni.Clear();
 369   }
 370
 371   mIndeterminateVisualAni = DevelControl::CreateTransition(*this, mIndeterminateVisualTransition);
 372
 373   if(mIndeterminate && mIndeterminateVisualAni)
 374   {
 375     mIndeterminateVisualAni.SetLooping(true);
 376     mIndeterminateVisualAni.Play();
 377   }
 378 }
 379
 380 Toolkit::TransitionData ProgressBar::ConvertPropertyToTransition(const Property::Value& value)
 381 {
 382   Toolkit::TransitionData transitionData;
 383
 384   if(value.GetType() == Property::ARRAY)
 385   {
 386     transitionData = Toolkit::TransitionData::New(*value.GetArray());
 387   }
 388   else if(value.GetType() == Property::MAP)
 389   {
 390     transitionData = Toolkit::TransitionData::New(*value.GetMap());
 391   }
 392
 393   return transitionData;
 394 }
 395
 396 /**
 397  * Create Visual for given index from a property map or url.
 398  * 1) Check if value passed in is a url and create visual
 399  * 2) Create visual from map if step (1) is false
 400  * 3) Register visual with control with false for enable flag.
 401  * 4) Unregister visual if empty map was provided. This is the method to remove a visual
 402  */
 403
 404 void ProgressBar::CreateVisualsForComponent(Property::Index index, const Property::Value& value, const int visualDepth)
 405 {
 406   Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
 407   Toolkit::Visual::Base  progressVisual;
 408
 409   std::string imageUrl;
 410   if(value.Get(imageUrl))
 411   {
 412     if(!imageUrl.empty())
 413     {
 414       progressVisual = visualFactory.CreateVisual(imageUrl, ImageDimensions());
 415     }
 416   }
 417   else // Does this code make text-visual can be accepted as visual?
 418   {
 419     // if its not a string then get a Property::Map from the property if possible.
 420     const Property::Map* map = value.GetMap();
 421     if(map && !map->Empty()) // Empty map results in current visual removal.
 422     {
 423       progressVisual = visualFactory.CreateVisual(*map);
 424     }
 425   }
 426
 427   if(progressVisual)
 428   {
 429     if(index == Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL)
 430     {
 431       DevelControl::RegisterVisual(*this, index, progressVisual, mIndeterminate, visualDepth);
 432     }
 433     else
 434     {
 435       DevelControl::RegisterVisual(*this, index, progressVisual, true, visualDepth);
 436     }
 437   }
 438   else
 439   {
 440     DevelControl::UnregisterVisual(*this, index);
 441   }
 442 }
 443
 444 bool ProgressBar::GetPropertyMapForVisual(Property::Index visualIndex, Property::Map& retreivedMap) const
 445 {
 446   bool                  success = false;
 447   Toolkit::Visual::Base visual  = DevelControl::GetVisual(*this, visualIndex);
 448
 449   if(visual)
 450   {
 451     visual.CreatePropertyMap(retreivedMap);
 452     success = true;
 453   }
 454
 455   return success;
 456 }
 457
 458 void ProgressBar::ApplyProgressToVisual(float progress, Property::Index index, int depth)
 459 {
 460   Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, index);
 461
 462   if(visual && static_cast<DevelVisual::Type>(visual.GetType()) == DevelVisual::ARC && !mIndeterminate)
 463   {
 464     Visual::Base& visualImpl = Toolkit::GetImplementation(visual);
 465
 466     Property::Map map;
 467
 468     map[Toolkit::DevelArcVisual::Property::SWEEP_ANGLE] = Property::Value(360.0f * progress);
 469
 470     visualImpl.SetProperties(map);
 471
 472     DevelControl::UnregisterVisual(*this, index);
 473     DevelControl::RegisterVisual(*this, index, visual, true, depth);
 474   }
 475 }
 476
 477 void ProgressBar::ApplyProgressToVisualTransform(float progress, Vector2 trackSize, Property::Index index)
 478 {
 479   Toolkit::Visual::Base visual = DevelControl::GetVisual(*this, index);
 480
 481   if(visual)
 482   {
 483     Property::Map visualTransform;
 484
 485     if(static_cast<DevelVisual::Type>(visual.GetType()) != DevelVisual::ARC)
 486     {
 487       visualTransform.Add(Toolkit::Visual::Transform::Property::SIZE, Vector2(mDomain.from.x + progress * (mDomain.to.x - mDomain.from.x), trackSize.height))
 488         .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
 489         .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
 490         .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
 491         .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN);
 492     }
 493
 494     visual.SetTransformAndSize(visualTransform, trackSize);
 495   }
 496 }
 497
 498 // Static class method to support script connecting signals
 499 bool ProgressBar::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor)
 500 {
 501   Dali::BaseHandle handle(object);
 502
 503   bool                 connected   = true;
 504   Toolkit::ProgressBar ProgressBar = Toolkit::ProgressBar::DownCast(handle);
 505
 506   if(0 == strcmp(signalName.c_str(), SIGNAL_VALUE_CHANGED))
 507   {
 508     ProgressBar.ValueChangedSignal().Connect(tracker, functor);
 509   }
 510   else
 511   {
 512     // signalName does not match any signal
 513     connected = false;
 514   }
 515
 516   return connected;
 517 }
 518
 519 void ProgressBar::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
 520 {
 521   Toolkit::ProgressBar progressBar = Toolkit::ProgressBar::DownCast(Dali::BaseHandle(object));
 522
 523   if(progressBar)
 524   {
 525     ProgressBar& progressBarImpl(GetImpl(progressBar));
 526
 527     switch(propertyIndex)
 528     {
 529       case Toolkit::ProgressBar::Property::TRACK_VISUAL:
 530       {
 531         progressBarImpl.CreateVisualsForComponent(propertyIndex, value, ProgressDepthIndex::TRACK_VISUAL);
 532         break;
 533       }
 534
 535       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL:
 536       {
 537         progressBarImpl.CreateVisualsForComponent(propertyIndex, value, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL);
 538         progressBarImpl.ApplyProgressToVisual(progressBarImpl.mSecondaryProgressValue, propertyIndex, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL);
 539         break;
 540       }
 541
 542       case Toolkit::ProgressBar::Property::PROGRESS_VISUAL:
 543       {
 544         progressBarImpl.CreateVisualsForComponent(propertyIndex, value, ProgressDepthIndex::PROGRESS_VISUAL);
 545         progressBarImpl.ApplyProgressToVisual(progressBarImpl.mProgressValue, propertyIndex, ProgressDepthIndex::PROGRESS_VISUAL);
 546         break;
 547       }
 548
 549       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL:
 550       {
 551         progressBarImpl.CreateVisualsForComponent(propertyIndex, value, ProgressDepthIndex::INDETERMINATE_VISUAL);
 552         break;
 553       }
 554
 555       case Toolkit::ProgressBar::Property::LABEL_VISUAL:
 556       {
 557         Property::Map map;
 558         std::string   textString;
 559
 560         if(value.Get(textString))
 561         {
 562           // set new text string as TEXT property
 563           Property::Map         newTextMap;
 564           Toolkit::Visual::Base label = DevelControl::GetVisual(progressBarImpl, Toolkit::ProgressBar::Property::LABEL_VISUAL);
 565
 566           if(label)
 567           {
 568             label.CreatePropertyMap(map);
 569           }
 570
 571           // if LABEL_VISUAL doesn't set before, add Visual property "TYPE" to create new text Visual
 572           if(map.Empty())
 573           {
 574             newTextMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT);
 575             newTextMap.Add(Toolkit::TextVisual::Property::POINT_SIZE, DEFAULT_FONT_SIZE);
 576           }
 577           newTextMap.Add(Toolkit::TextVisual::Property::TEXT, textString);
 578
 579           map.Merge(newTextMap);
 580         }
 581         else
 582         {
 583           value.Get(map);
 584         }
 585
 586         if(!map.Empty())
 587         {
 588           progressBarImpl.CreateVisualsForComponent(propertyIndex, map, ProgressDepthIndex::LABEL_VISUAL);
 589         }
 590         break;
 591       }
 592
 593       case Toolkit::ProgressBar::Property::PROGRESS_VALUE:
 594       {
 595         progressBarImpl.SetProgressValue(value.Get<float>());
 596         break;
 597       }
 598
 599       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE:
 600       {
 601         progressBarImpl.SetSecondaryProgressValue(value.Get<float>());
 602         break;
 603       }
 604
 605       case Toolkit::ProgressBar::Property::INDETERMINATE:
 606       {
 607         progressBarImpl.SetIndeterminate(value.Get<bool>());
 608         break;
 609       }
 610
 611       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION:
 612       {
 613         progressBarImpl.SetIndeterminateVisualTransition(progressBarImpl.ConvertPropertyToTransition(value));
 614         break;
 615       }
 616     }
 617   }
 618 }
 619
 620 Property::Value ProgressBar::GetProperty(BaseObject* object, Property::Index propertyIndex)
 621 {
 622   Property::Value value;
 623
 624   Toolkit::ProgressBar progressBar = Toolkit::ProgressBar::DownCast(Dali::BaseHandle(object));
 625
 626   if(progressBar)
 627   {
 628     ProgressBar& progressBarImpl(GetImpl(progressBar));
 629
 630     switch(propertyIndex)
 631     {
 632       case Toolkit::ProgressBar::Property::TRACK_VISUAL:
 633       case Toolkit::ProgressBar::Property::PROGRESS_VISUAL:
 634       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL:
 635       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL:
 636       case Toolkit::ProgressBar::Property::LABEL_VISUAL:
 637       {
 638         Property::Map visualProperty;
 639         if(progressBarImpl.GetPropertyMapForVisual(propertyIndex, visualProperty))
 640         {
 641           value = visualProperty;
 642         }
 643         break;
 644       }
 645
 646       case Toolkit::ProgressBar::Property::PROGRESS_VALUE:
 647       {
 648         value = progressBarImpl.GetProgressValue();
 649         break;
 650       }
 651
 652       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE:
 653       {
 654         value = progressBarImpl.GetSecondaryProgressValue();
 655         break;
 656       }
 657
 658       case Toolkit::ProgressBar::Property::INDETERMINATE:
 659       {
 660         value = progressBarImpl.GetIndeterminate();
 661         break;
 662       }
 663
 664       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION:
 665       {
 666         //TODO: Return INDETERMINATE_VISUAL_TRANSITION;
 667       }
 668     }
 669   }
 670
 671   return value;
 672 }
 673
 674 void ProgressBar::OnSceneConnection(int depth)
 675 {
 676   // Chain up first (ensures visuals are ready to draw)
 677   Control::OnSceneConnection(depth);
 678
 679   if(mIndeterminate)
 680   {
 681     PlayIndeterminateVisualTransition();
 682   }
 683 }
 684
 685 double ProgressBar::ProgressBarAccessible::GetMinimum() const
 686 {
 687   return DEFAULT_LOWER_BOUND;
 688 }
 689
 690 double ProgressBar::ProgressBarAccessible::GetCurrent() const
 691 {
 692   auto self = Toolkit::ProgressBar::DownCast(Self());
 693   return self.GetProperty(Toolkit::ProgressBar::Property::PROGRESS_VALUE).Get<float>();
 694 }
 695
 696 std::string ProgressBar::ProgressBarAccessible::GetValueText() const
 697 {
 698   return {}; // Text mode is not used at the moment
 699 }
 700
 701 double ProgressBar::ProgressBarAccessible::GetMaximum() const
 702 {
 703   return DEFAULT_UPPER_BOUND;
 704 }
 705
 706 bool ProgressBar::ProgressBarAccessible::SetCurrent(double current)
 707 {
 708   if(current < GetMinimum() || current > GetMaximum())
 709   {
 710     return false;
 711   }
 712
 713   auto self = Toolkit::ProgressBar::DownCast(Self());
 714   self.SetProperty(Toolkit::ProgressBar::Property::PROGRESS_VALUE, static_cast<float>(current));
 715   return true;
 716 }
 717
 718 double ProgressBar::ProgressBarAccessible::GetMinimumIncrement() const
 719 {
 720   return 0.0;
 721 }
 722
 723 } // namespace Internal
 724
 725 } // namespace Toolkit
 726
 727 } // namespace Dali