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/devel-api/align-enums.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/public-api/visuals/color-visual-properties.h>
  32 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  33 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
  34 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  35 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  36
  37 #include <dali/integration-api/debug.h>
  38
  39 namespace Dali
  40 {
  41
  42 namespace Toolkit
  43 {
  44
  45 namespace Internal
  46 {
  47
  48 namespace // Unnamed namespace
  49 {
  50
  51 BaseHandle Create()
  52 {
  53   return Dali::Toolkit::ProgressBar::New();
  54 }
  55
  56 // Setup properties, signals and actions using the type-registry.
  57 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ProgressBar, Toolkit::Control, Create )
  58
  59 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "progressValue",                     FLOAT,    PROGRESS_VALUE                   )
  60 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "secondaryProgressValue",            FLOAT,    SECONDARY_PROGRESS_VALUE         )
  61 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminate",                     BOOLEAN,  INDETERMINATE                    )
  62 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "trackVisual",                       MAP,      TRACK_VISUAL                     )
  63 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "progressVisual",                    MAP,      PROGRESS_VISUAL                  )
  64 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "secondaryProgressVisual",           MAP,      SECONDARY_PROGRESS_VISUAL        )
  65 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminateVisual",               MAP,      INDETERMINATE_VISUAL             )
  66 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminateVisualAnimation",      ARRAY,    INDETERMINATE_VISUAL_ANIMATION   )
  67 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "labelVisual",                       MAP,      LABEL_VISUAL                     )
  68 DALI_SIGNAL_REGISTRATION(   Toolkit, ProgressBar, "valueChanged",                      SIGNAL_VALUE_CHANGED                       )
  69
  70 DALI_TYPE_REGISTRATION_END()
  71
  72 struct ProgressDepthIndex
  73 {
  74   // Enum to make sure the visual order
  75   enum
  76   {
  77     TRACK_VISUAL,
  78     SECONDARY_PROGRESS_VISUAL,
  79     PROGRESS_VISUAL,
  80     LABEL_VISUAL,
  81     INDETERMINATE_VISUAL
  82   };
  83 };
  84
  85 float DEFAULT_VALUE = 0.0f;
  86 float DEFAULT_LOWER_BOUND = 0.0f;
  87 float DEFAULT_UPPER_BOUND = 1.0f;
  88 float DEFAULT_FONT_SIZE = 12.0f;
  89
  90 } // Unnamed namespace
  91
  92 ///////////////////////////////////////////////////////////////////////////////////////////////////
  93 // ProgressBar
  94 ///////////////////////////////////////////////////////////////////////////////////////////////////
  95
  96 Dali::Toolkit::ProgressBar ProgressBar::New()
  97 {
  98   // Create the implementation
  99   ProgressBarPtr progressBar( new ProgressBar() );
 100
 101   // Pass ownership to CustomActor via derived handle
 102   Dali::Toolkit::ProgressBar handle( *progressBar );
 103
 104   // Second-phase init of the implementation
 105   // This can only be done after the CustomActor connection has been made...
 106   progressBar->Initialize();
 107
 108   return handle;
 109 }
 110
 111 ProgressBar::ProgressBar()
 112 : Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
 113   mProgressValue( DEFAULT_VALUE ),
 114   mSecondaryProgressValue( DEFAULT_VALUE ),
 115   mIndeterminate( false )
 116 {
 117 }
 118
 119 ProgressBar::~ProgressBar()
 120 {
 121 }
 122
 123 void ProgressBar::OnInitialize()
 124 {
 125 }
 126
 127 void ProgressBar::OnRelayout( const Vector2& size, RelayoutContainer& container )
 128 {
 129
 130   Vector2 trackSize( size );
 131   mDomain = CalcDomain( size );
 132
 133   trackSize.width = std::max( 0.0f, size.width ); // Ensure we don't go negative
 134
 135   Toolkit::Visual::Base trackVisual = DevelControl::GetVisual( *this, Toolkit::ProgressBar::Property::TRACK_VISUAL );
 136   Toolkit::Visual::Base secondProgressVisual = DevelControl::GetVisual( *this, Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL );
 137   Toolkit::Visual::Base progressVisual = DevelControl::GetVisual( *this, Toolkit::ProgressBar::Property::PROGRESS_VISUAL );
 138   Toolkit::Visual::Base labelVisual = DevelControl::GetVisual( *this, Toolkit::ProgressBar::Property::LABEL_VISUAL );
 139   Toolkit::Visual::Base indeterminateVisual = DevelControl::GetVisual( *this, Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL );
 140
 141   if( trackVisual )
 142   {
 143     Property::Map visualTransform;
 144
 145     visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, trackSize )
 146                    .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 147                    .Add( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) );
 148
 149     trackVisual.SetTransformAndSize( visualTransform, trackSize );
 150   }
 151
 152   if( secondProgressVisual )
 153   {
 154     Property::Map visualTransform;
 155
 156     visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, Vector2( mDomain.from.x + mSecondaryProgressValue * ( mDomain.to.x - mDomain.from.x ), trackSize.height  ) )
 157                    .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 158                    .Add( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 159                    .Add( Toolkit::DevelVisual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
 160                    .Add( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN );
 161     secondProgressVisual.SetTransformAndSize( visualTransform, trackSize );
 162   }
 163
 164   if( progressVisual )
 165   {
 166     Property::Map visualTransform;
 167
 168     visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, Vector2( mDomain.from.x + mProgressValue * ( mDomain.to.x - mDomain.from.x ), trackSize.height ) )
 169                    .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 170                    .Add( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 171                    .Add( Toolkit::DevelVisual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
 172                    .Add( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN );
 173     progressVisual.SetTransformAndSize( visualTransform, trackSize );
 174   }
 175
 176   if( labelVisual )
 177   {
 178     Property::Map visualTransform;
 179
 180     visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, trackSize )
 181                    .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 182                    .Add( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) );
 183     labelVisual.SetTransformAndSize( visualTransform, trackSize );
 184   }
 185
 186   if( indeterminateVisual )
 187   {
 188     Property::Map visualTransform;
 189
 190     visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, trackSize )
 191                    .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 192                    .Add( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) );
 193     indeterminateVisual.SetTransformAndSize( visualTransform, trackSize );
 194   }
 195
 196 }
 197
 198 Vector3 ProgressBar::GetNaturalSize()
 199 {
 200   // Return the bigger size after comparing trackVisual naturalSize and labelVisual naturalSize
 201   Toolkit::Visual::Base trackVisual =  DevelControl::GetVisual( *this, Toolkit::ProgressBar::Property::TRACK_VISUAL );
 202   Toolkit::Visual::Base labelVisual =  DevelControl::GetVisual( *this, Toolkit::ProgressBar::Property::LABEL_VISUAL );
 203
 204   Size trackSize;
 205   Size labelSize;
 206
 207   if ( trackVisual )
 208   {
 209     trackVisual.GetNaturalSize( trackSize );
 210   }
 211   if ( labelVisual )
 212   {
 213     labelVisual.GetNaturalSize( labelSize );
 214   }
 215
 216   Vector3 naturalSize;
 217   naturalSize.width = ( trackSize.width > labelSize.width ) ? trackSize.width: labelSize.width;
 218   naturalSize.height = ( trackSize.height > labelSize.height ) ? trackSize.height: labelSize.height;
 219
 220   return naturalSize;
 221 }
 222
 223 ProgressBar::Domain ProgressBar::CalcDomain( const Vector2& currentSize )
 224 {
 225    return Domain( Vector2( 0.0f, 0.0f ), currentSize );
 226 }
 227
 228 Toolkit::ProgressBar::ValueChangedSignalType& ProgressBar::ValueChangedSignal()
 229 {
 230   return mValueChangedSignal;
 231 }
 232
 233 void ProgressBar::SetProgressValue( float value )
 234 {
 235   // update the progress bar value (taking float precision errors into account)
 236   // TODO : it seems 0.0f cannot into this statement.
 237   if( ( mProgressValue != value ) &&
 238       ( ( value >= DEFAULT_LOWER_BOUND ) || ( Equals( value, DEFAULT_LOWER_BOUND ) ) ) &&
 239       ( ( value <= DEFAULT_UPPER_BOUND ) || ( Equals( value, DEFAULT_UPPER_BOUND ) ) ) )
 240   {
 241     mProgressValue = Clamp( value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND );
 242
 243     Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast( Self() );
 244     mValueChangedSignal.Emit( self, mProgressValue, mSecondaryProgressValue );
 245     RelayoutRequest();
 246   }
 247 }
 248
 249 float ProgressBar::GetProgressValue() const
 250 {
 251   return mProgressValue;
 252 }
 253
 254 void ProgressBar::SetSecondaryProgressValue( float value )
 255 {
 256   // update the progress bar value (taking float precision errors into account)
 257   // TODO : it seems 0.0f cannot into this statement.
 258   if( ( mSecondaryProgressValue != value ) &&
 259       ( ( value >= DEFAULT_LOWER_BOUND ) || ( Equals( value, DEFAULT_LOWER_BOUND ) ) ) &&
 260       ( ( value <= DEFAULT_UPPER_BOUND ) || ( Equals( value, DEFAULT_UPPER_BOUND ) ) ) )
 261   {
 262     mSecondaryProgressValue = Clamp( value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND );
 263
 264     Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast( Self() );
 265     mValueChangedSignal.Emit( self, mProgressValue, mSecondaryProgressValue );
 266
 267     RelayoutRequest();
 268   }
 269 }
 270
 271 float ProgressBar::GetSecondaryProgressValue() const
 272 {
 273   return mSecondaryProgressValue;
 274 }
 275
 276 void ProgressBar::SetIndeterminate( bool value )
 277 {
 278   mIndeterminate = value;
 279   DevelControl::EnableVisual( *this, Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL, mIndeterminate );
 280
 281   if( mIndeterminate )
 282   {
 283     RelayoutRequest();
 284     if( mIndeterminateVisualTransition )
 285     {
 286       PlayIndeterminateVisualTransition();
 287     }
 288   }
 289   else
 290   {
 291     if( mIndeterminateVisualAni )
 292     {
 293       mIndeterminateVisualAni.Stop();
 294     }
 295   }
 296 }
 297
 298 bool ProgressBar::GetIndeterminate() const
 299 {
 300   return mIndeterminate;
 301 }
 302
 303 void ProgressBar::SetIndeterminateVisualTransition( Toolkit::TransitionData transition )
 304 {
 305   mIndeterminateVisualTransition = transition;
 306   if( mIndeterminate )
 307   {
 308     PlayIndeterminateVisualTransition();
 309   }
 310 }
 311
 312 void ProgressBar::PlayIndeterminateVisualTransition()
 313 {
 314   if( mIndeterminateVisualAni )
 315   {
 316     mIndeterminateVisualAni.Stop();
 317     mIndeterminateVisualAni.Clear();
 318   }
 319
 320   mIndeterminateVisualAni = DevelControl::CreateTransition( *this, mIndeterminateVisualTransition );
 321
 322   if( mIndeterminate && mIndeterminateVisualAni )
 323   {
 324     mIndeterminateVisualAni.SetLooping(true);
 325     mIndeterminateVisualAni.Play();
 326   }
 327 }
 328
 329 Toolkit::TransitionData ProgressBar::ConvertPropertyToTransition( const Property::Value& value )
 330 {
 331   Toolkit::TransitionData transitionData;
 332
 333   if( value.GetType() == Property::ARRAY )
 334   {
 335     transitionData = Toolkit::TransitionData::New( *value.GetArray() );
 336   }
 337   else if( value.GetType() == Property::MAP )
 338   {
 339     transitionData = Toolkit::TransitionData::New( *value.GetMap() );
 340   }
 341
 342   return transitionData;
 343 }
 344
 345 /**
 346  * Create Visual for given index from a property map or url.
 347  * 1) Check if value passed in is a url and create visual
 348  * 2) Create visual from map if step (1) is false
 349  * 3) Register visual with control with false for enable flag.
 350  * 4) Unregister visual if empty map was provided. This is the method to remove a visual
 351  */
 352
 353 void ProgressBar::CreateVisualsForComponent( Property::Index index, const Property::Value& value, const float visualDepth )
 354 {
 355   Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
 356   Toolkit::Visual::Base progressVisual;
 357
 358   std::string imageUrl;
 359   if( value.Get( imageUrl ) )
 360   {
 361     if ( !imageUrl.empty() )
 362     {
 363       progressVisual = visualFactory.CreateVisual(  imageUrl, ImageDimensions()  );
 364     }
 365   }
 366   else // Does this code make text-visual can be accepted as visual?
 367   {
 368     // if its not a string then get a Property::Map from the property if possible.
 369     Property::Map *map = value.GetMap();
 370     if( map && !map->Empty()  ) // Empty map results in current visual removal.
 371     {
 372       progressVisual = visualFactory.CreateVisual( *map );
 373     }
 374   }
 375
 376   if ( progressVisual )
 377   {
 378     if( index == Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL )
 379     {
 380       DevelControl::RegisterVisual( *this, index, progressVisual, mIndeterminate, visualDepth );
 381     }
 382     else
 383     {
 384       DevelControl::RegisterVisual( *this, index, progressVisual, true, visualDepth );
 385     }
 386   }
 387   else
 388   {
 389     DevelControl::UnregisterVisual( *this, index );
 390   }
 391 }
 392
 393 bool ProgressBar::GetPropertyMapForVisual( Property::Index visualIndex, Property::Map& retreivedMap ) const
 394 {
 395   bool success = false;
 396   Toolkit::Visual::Base visual = DevelControl::GetVisual( *this, visualIndex );
 397
 398   if ( visual )
 399   {
 400     visual.CreatePropertyMap( retreivedMap );
 401     success = true;
 402   }
 403
 404   return success;
 405 }
 406
 407 // Static class method to support script connecting signals
 408 bool ProgressBar::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 409 {
 410   Dali::BaseHandle handle( object );
 411
 412   bool connected = true;
 413   Toolkit::ProgressBar ProgressBar = Toolkit::ProgressBar::DownCast( handle );
 414
 415   if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
 416   {
 417     ProgressBar.ValueChangedSignal().Connect( tracker, functor );
 418   }
 419   else
 420   {
 421     // signalName does not match any signal
 422     connected = false;
 423   }
 424
 425   return connected;
 426 }
 427
 428 void ProgressBar::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
 429 {
 430   Toolkit::ProgressBar progressBar = Toolkit::ProgressBar::DownCast( Dali::BaseHandle( object ) );
 431
 432   if ( progressBar )
 433   {
 434     ProgressBar& progressBarImpl( GetImpl( progressBar ) );
 435
 436     switch ( propertyIndex )
 437     {
 438       case Toolkit::ProgressBar::Property::TRACK_VISUAL:
 439       {
 440         progressBarImpl.CreateVisualsForComponent( propertyIndex, value, ProgressDepthIndex::TRACK_VISUAL );
 441         break;
 442       }
 443
 444       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL:
 445       {
 446         progressBarImpl.CreateVisualsForComponent( propertyIndex, value, ProgressDepthIndex::SECONDARY_PROGRESS_VISUAL );
 447         break;
 448       }
 449
 450       case Toolkit::ProgressBar::Property::PROGRESS_VISUAL:
 451       {
 452         progressBarImpl.CreateVisualsForComponent( propertyIndex, value, ProgressDepthIndex::PROGRESS_VISUAL );
 453         break;
 454       }
 455
 456       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL:
 457       {
 458         progressBarImpl.CreateVisualsForComponent( propertyIndex, value, ProgressDepthIndex::INDETERMINATE_VISUAL );
 459         break;
 460       }
 461
 462       case Toolkit::ProgressBar::Property::LABEL_VISUAL:
 463       {
 464         Property::Map map;
 465         std::string textString;
 466
 467         if ( value.Get( textString ) )
 468         {
 469           // set new text string as TEXT property
 470           Property::Map newTextMap;
 471           Toolkit::Visual::Base label = DevelControl::GetVisual( progressBarImpl, Toolkit::ProgressBar::Property::LABEL_VISUAL );
 472
 473           if( label )
 474           {
 475             label.CreatePropertyMap( map );
 476           }
 477
 478           // if LABEL_VISUAL doesn't set before, add Visual property "TYPE" to create new text Visual
 479           if( map.Empty() )
 480           {
 481             newTextMap.Add( Toolkit::Visual::Property::TYPE, Toolkit::DevelVisual::TEXT );
 482             newTextMap.Add( Toolkit::TextVisual::Property::POINT_SIZE, DEFAULT_FONT_SIZE );
 483           }
 484           newTextMap.Add( Toolkit::TextVisual::Property::TEXT, textString );
 485
 486           map.Merge( newTextMap );
 487         }
 488         else
 489         {
 490           value.Get( map );
 491         }
 492
 493         if( !map.Empty() )
 494         {
 495           progressBarImpl.CreateVisualsForComponent( propertyIndex, map, ProgressDepthIndex::LABEL_VISUAL );
 496         }
 497         break;
 498       }
 499
 500       case Toolkit::ProgressBar::Property::PROGRESS_VALUE:
 501       {
 502         progressBarImpl.SetProgressValue( value.Get< float >() );
 503         break;
 504       }
 505
 506       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE:
 507       {
 508         progressBarImpl.SetSecondaryProgressValue( value.Get< float >() );
 509         break;
 510       }
 511
 512       case Toolkit::ProgressBar::Property::INDETERMINATE:
 513       {
 514         progressBarImpl.SetIndeterminate( value.Get< bool >() );
 515         break;
 516       }
 517
 518       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION:
 519       {
 520         progressBarImpl.SetIndeterminateVisualTransition( progressBarImpl.ConvertPropertyToTransition( value ) );
 521         break;
 522       }
 523     }
 524   }
 525 }
 526
 527 Property::Value ProgressBar::GetProperty( BaseObject* object, Property::Index propertyIndex )
 528 {
 529   Property::Value value;
 530
 531   Toolkit::ProgressBar progressBar = Toolkit::ProgressBar::DownCast( Dali::BaseHandle( object ) );
 532
 533   if ( progressBar )
 534   {
 535     ProgressBar& progressBarImpl( GetImpl( progressBar ) );
 536
 537     switch ( propertyIndex )
 538     {
 539       case Toolkit::ProgressBar::Property::TRACK_VISUAL:
 540       case Toolkit::ProgressBar::Property::PROGRESS_VISUAL:
 541       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL:
 542       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL:
 543       case Toolkit::ProgressBar::Property::LABEL_VISUAL:
 544       {
 545         Property::Map visualProperty;
 546         if ( progressBarImpl.GetPropertyMapForVisual( propertyIndex, visualProperty ) )
 547         {
 548           value = visualProperty;
 549         }
 550         break;
 551       }
 552
 553       case Toolkit::ProgressBar::Property::PROGRESS_VALUE:
 554       {
 555         value = progressBarImpl.GetProgressValue();
 556         break;
 557       }
 558
 559       case Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE:
 560       {
 561         value = progressBarImpl.GetSecondaryProgressValue();
 562         break;
 563       }
 564
 565       case Toolkit::ProgressBar::Property::INDETERMINATE:
 566       {
 567         value = progressBarImpl.GetIndeterminate();
 568         break;
 569       }
 570
 571       case Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION:
 572       {
 573         //TODO: Return INDETERMINATE_VISUAL_TRANSITION;
 574       }
 575     }
 576   }
 577
 578   return value;
 579 }
 580
 581 void ProgressBar::OnStageConnection( int depth )
 582 {
 583   // Chain up first (ensures visuals are ready to draw)
 584   Control::OnStageConnection( depth );
 585
 586   if( mIndeterminate )
 587   {
 588     PlayIndeterminateVisualTransition();
 589   }
 590 }
 591
 592 } // namespace Internal
 593
 594 } // namespace Toolkit
 595
 596 } // namespace Dali