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

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