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