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

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