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

   1 /*
   2  * Copyright (c) 2017 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 <cstring> // for strcmp
  23 #include <sstream>
  24 #include <algorithm>
  25 #include <dali/public-api/object/type-registry-helper.h>
  26 #include <dali/public-api/size-negotiation/relayout-container.h>
  27 #include <dali/public-api/math/math-utils.h>
  28 #include <dali-toolkit/public-api/align-enumerations.h>
  29 #include <dali-toolkit/devel-api/controls/control-devel.h>
  30 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
  31 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
  32 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  33 #include <dali-toolkit/devel-api/visuals/arc-visual-properties-devel.h>
  34 #include <dali-toolkit/public-api/visuals/color-visual-properties.h>
  35 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  36 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
  37 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  38 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  39
  40 #include <dali/integration-api/debug.h>
  41
  42 namespace Dali
  43 {
  44
  45 namespace Toolkit
  46 {
  47
  48 namespace Internal
  49 {
  50
  51 namespace // Unnamed namespace
  52 {
  53
  54 BaseHandle Create()
  55 {
  56   return Dali::Toolkit::ProgressBar::New();
  57 }
  58
  59 // Setup properties, signals and actions using the type-registry.
  60 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ProgressBar, Toolkit::Control, Create )
  61
  62 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "progressValue",                     FLOAT,    PROGRESS_VALUE                   )
  63 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "secondaryProgressValue",            FLOAT,    SECONDARY_PROGRESS_VALUE         )
  64 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminate",                     BOOLEAN,  INDETERMINATE                    )
  65 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "trackVisual",                       MAP,      TRACK_VISUAL                     )
  66 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "progressVisual",                    MAP,      PROGRESS_VISUAL                  )
  67 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "secondaryProgressVisual",           MAP,      SECONDARY_PROGRESS_VISUAL        )
  68 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminateVisual",               MAP,      INDETERMINATE_VISUAL             )
  69 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminateVisualAnimation",      ARRAY,    INDETERMINATE_VISUAL_ANIMATION   )
  70 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "labelVisual",                       MAP,      LABEL_VISUAL                     )
  71 DALI_SIGNAL_REGISTRATION(   Toolkit, ProgressBar, "valueChanged",                      SIGNAL_VALUE_CHANGED                       )
  72
  73 DALI_TYPE_REGISTRATION_END()
  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
  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   DevelControl::SetAccessibilityConstructor( Self(), []( Dali::Actor actor ) {
 170     return std::unique_ptr< Dali::Accessibility::Accessible >(
 171         new AccessibleImpl( actor, Dali::Accessibility::Role::PROGRESS_BAR ) );
 172   } );
 173   //Enable highightability
 174   Self().SetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true );
 175 }
 176
 177 void ProgressBar::OnRelayout( const Vector2& size, RelayoutContainer& container )
 178 {
 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
 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( ( 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     if (Self() == Dali::Accessibility::Accessible::GetCurrentlyHighlightedActor())
 276     {
 277       Control::Impl::GetAccessibilityObject(Self())->Emit(Dali::Accessibility::ObjectPropertyChangeEvent::VALUE);
 278     }
 279     RelayoutRequest();
 280   }
 281 }
 282
 283 float ProgressBar::GetProgressValue() const
 284 {
 285   return mProgressValue;
 286 }
 287
 288 void ProgressBar::SetSecondaryProgressValue( float value )
 289 {
 290   // update the progress bar value (taking float precision errors into account)
 291   // TODO : it seems 0.0f cannot into this statement.
 292   if( ( mSecondaryProgressValue != value ) &&
 293       ( ( value >= DEFAULT_LOWER_BOUND ) || ( Equals( value, DEFAULT_LOWER_BOUND ) ) ) &&
 294       ( ( value <= DEFAULT_UPPER_BOUND ) || ( Equals( value, DEFAULT_UPPER_BOUND ) ) ) )
 295   {
 296     mSecondaryProgressValue = Clamp( value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND );
 297
 298     ApplyProgressToVisual( mSecondaryProgressValue, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL );
 299
 300     Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast( Self() );
 301     mValueChangedSignal.Emit( self, mProgressValue, mSecondaryProgressValue );
 302
 303     RelayoutRequest();
 304   }
 305 }
 306
 307 float ProgressBar::GetSecondaryProgressValue() const
 308 {
 309   return mSecondaryProgressValue;
 310 }
 311
 312 void ProgressBar::SetIndeterminate( bool value )
 313 {
 314   mIndeterminate = value;
 315   DevelControl::EnableVisual( *this, Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL, mIndeterminate );
 316
 317   if( mIndeterminate )
 318   {
 319     RelayoutRequest();
 320     if( mIndeterminateVisualTransition )
 321     {
 322       PlayIndeterminateVisualTransition();
 323     }
 324   }
 325   else
 326   {
 327     if( mIndeterminateVisualAni )
 328     {
 329       mIndeterminateVisualAni.Stop();
 330     }
 331
 332     // Restore previous visual data after animation finished.
 333     RestoreVisualProperties( this, Toolkit::ProgressBar::Property::TRACK_VISUAL, mTrackVisualMap, ProgressDepthIndex::TRACK_VISUAL );
 334     RestoreVisualProperties( this, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, mSecondaryProgressVisualMap, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL );
 335     RestoreVisualProperties( this, Toolkit::ProgressBar::Property::PROGRESS_VISUAL, mProgressVisualMap, ProgressDepthIndex::PROGRESS_VISUAL );
 336
 337     RelayoutRequest();
 338   }
 339 }
 340
 341 bool ProgressBar::GetIndeterminate() const
 342 {
 343   return mIndeterminate;
 344 }
 345
 346 void ProgressBar::SetIndeterminateVisualTransition( Toolkit::TransitionData transition )
 347 {
 348   mIndeterminateVisualTransition = transition;
 349   if( mIndeterminate )
 350   {
 351     PlayIndeterminateVisualTransition();
 352   }
 353 }
 354
 355 void ProgressBar::PlayIndeterminateVisualTransition()
 356 {
 357   // Store current visual data before animation changes it.
 358   BackupVisualProperties( this, Toolkit::ProgressBar::Property::TRACK_VISUAL, mTrackVisualMap );
 359   BackupVisualProperties( this, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL, mSecondaryProgressVisualMap );
 360   BackupVisualProperties( this, Toolkit::ProgressBar::Property::PROGRESS_VISUAL, mProgressVisualMap );
 361
 362   if( mIndeterminateVisualAni )
 363   {
 364     mIndeterminateVisualAni.Stop();
 365     mIndeterminateVisualAni.Clear();
 366   }
 367
 368   mIndeterminateVisualAni = DevelControl::CreateTransition( *this, mIndeterminateVisualTransition );
 369
 370   if( mIndeterminate && mIndeterminateVisualAni )
 371   {
 372     mIndeterminateVisualAni.SetLooping(true);
 373     mIndeterminateVisualAni.Play();
 374   }
 375 }
 376
 377 Toolkit::TransitionData ProgressBar::ConvertPropertyToTransition( const Property::Value& value )
 378 {
 379   Toolkit::TransitionData transitionData;
 380
 381   if( value.GetType() == Property::ARRAY )
 382   {
 383     transitionData = Toolkit::TransitionData::New( *value.GetArray() );
 384   }
 385   else if( value.GetType() == Property::MAP )
 386   {
 387     transitionData = Toolkit::TransitionData::New( *value.GetMap() );
 388   }
 389
 390   return transitionData;
 391 }
 392
 393 /**
 394  * Create Visual for given index from a property map or url.
 395  * 1) Check if value passed in is a url and create visual
 396  * 2) Create visual from map if step (1) is false
 397  * 3) Register visual with control with false for enable flag.
 398  * 4) Unregister visual if empty map was provided. This is the method to remove a visual
 399  */
 400
 401 void ProgressBar::CreateVisualsForComponent( Property::Index index, const Property::Value& value, const int visualDepth )
 402 {
 403   Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
 404   Toolkit::Visual::Base progressVisual;
 405
 406   std::string imageUrl;
 407   if( value.Get( imageUrl ) )
 408   {
 409     if ( !imageUrl.empty() )
 410     {
 411       progressVisual = visualFactory.CreateVisual(  imageUrl, ImageDimensions()  );
 412     }
 413   }
 414   else // Does this code make text-visual can be accepted as visual?
 415   {
 416     // if its not a string then get a Property::Map from the property if possible.
 417     const Property::Map *map = value.GetMap();
 418     if( map && !map->Empty()  ) // Empty map results in current visual removal.
 419     {
 420       progressVisual = visualFactory.CreateVisual( *map );
 421     }
 422   }
 423
 424   if ( progressVisual )
 425   {
 426     if( index == Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL )
 427     {
 428       DevelControl::RegisterVisual( *this, index, progressVisual, mIndeterminate, visualDepth );
 429     }
 430     else
 431     {
 432       DevelControl::RegisterVisual( *this, index, progressVisual, true, visualDepth );
 433     }
 434   }
 435   else
 436   {
 437     DevelControl::UnregisterVisual( *this, index );
 438   }
 439 }
 440
 441 bool ProgressBar::GetPropertyMapForVisual( Property::Index visualIndex, Property::Map& retreivedMap ) const
 442 {
 443   bool success = false;
 444   Toolkit::Visual::Base visual = DevelControl::GetVisual( *this, visualIndex );
 445
 446   if ( visual )
 447   {
 448     visual.CreatePropertyMap( retreivedMap );
 449     success = true;
 450   }
 451
 452   return success;
 453 }
 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::AccessibleImpl::GetMinimum() { return DEFAULT_LOWER_BOUND; }
 684
 685 double ProgressBar::AccessibleImpl::GetCurrent()
 686 {
 687   auto p = Toolkit::ProgressBar::DownCast( self );
 688   return p.GetProperty( Toolkit::ProgressBar::Property::PROGRESS_VALUE )
 689       .Get< float >();
 690 }
 691
 692 double ProgressBar::AccessibleImpl::GetMaximum() { return DEFAULT_UPPER_BOUND; }
 693
 694 bool ProgressBar::AccessibleImpl::SetCurrent( double current )
 695 {
 696   if( current < GetMinimum() || current > GetMaximum() )
 697     return false;
 698   auto p = Toolkit::ProgressBar::DownCast( self );
 699   p.SetProperty( Toolkit::ProgressBar::Property::PROGRESS_VALUE,
 700                  static_cast< float >( current ) );
 701   return true;
 702 }
 703
 704 double ProgressBar::AccessibleImpl::GetMinimumIncrement() { return 0.0; }
 705
 706 } // namespace Internal
 707
 708 } // namespace Toolkit
 709
 710 } // namespace Dali