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/visual-factory/visual-base.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/devel-api/visuals/text-visual-properties.h>
  33 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  34 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  35
  36 #include <dali/integration-api/debug.h>
  37
  38 namespace Dali
  39 {
  40
  41 namespace Toolkit
  42 {
  43
  44 namespace Internal
  45 {
  46
  47 namespace // Unnamed namespace
  48 {
  49
  50 BaseHandle Create()
  51 {
  52   return Dali::Toolkit::ProgressBar::New();
  53 }
  54
  55 // Setup properties, signals and actions using the type-registry.
  56 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ProgressBar, Toolkit::Control, Create )
  57
  58 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "progressValue",                     FLOAT,    PROGRESS_VALUE                   )
  59 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "secondaryProgressValue",            FLOAT,    SECONDARY_PROGRESS_VALUE         )
  60 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminate",                     BOOLEAN,  INDETERMINATE                    )
  61 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "trackVisual",                       MAP,      TRACK_VISUAL                     )
  62 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "progressVisual",                    MAP,      PROGRESS_VISUAL                  )
  63 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "secondaryProgressVisual",           MAP,      SECONDARY_PROGRESS_VISUAL        )
  64 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminateVisual",               MAP,      INDETERMINATE_VISUAL             )
  65 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "indeterminateVisualAnimation",      ARRAY,    INDETERMINATE_VISUAL_ANIMATION   )
  66 DALI_PROPERTY_REGISTRATION( Toolkit, ProgressBar, "labelVisual",                       MAP,      LABEL_VISUAL                     )
  67 DALI_SIGNAL_REGISTRATION(   Toolkit, ProgressBar, "valueChanged",                      SIGNAL_VALUE_CHANGED                       )
  68
  69 DALI_TYPE_REGISTRATION_END()
  70
  71 struct ProgressDepthIndex
  72 {
  73   // Enum to make sure the visual order
  74   enum
  75   {
  76     TRACK_VISUAL,
  77     SECONDARY_PROGRESS_VISUAL,
  78     PROGRESS_VISUAL,
  79     LABEL_VISUAL,
  80     INDETERMINATE_VISUAL
  81   };
  82 };
  83
  84 float DEFAULT_VALUE = 0.0f;
  85 float DEFAULT_LOWER_BOUND = 0.0f;
  86 float DEFAULT_UPPER_BOUND = 1.0f;
  87 float DEFAULT_FONT_SIZE = 12.0f;
  88
  89 } // Unnamed namespace
  90
  91 ///////////////////////////////////////////////////////////////////////////////////////////////////
  92 // ProgressBar
  93 ///////////////////////////////////////////////////////////////////////////////////////////////////
  94
  95 Dali::Toolkit::ProgressBar ProgressBar::New()
  96 {
  97   // Create the implementation
  98   ProgressBarPtr progressBar( new ProgressBar() );
  99
 100   // Pass ownership to CustomActor via derived handle
 101   Dali::Toolkit::ProgressBar handle( *progressBar );
 102
 103   // Second-phase init of the implementation
 104   // This can only be done after the CustomActor connection has been made...
 105   progressBar->Initialize();
 106
 107   return handle;
 108 }
 109
 110 ProgressBar::ProgressBar()
 111 : Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
 112   mProgressValue( DEFAULT_VALUE ),
 113   mSecondaryProgressValue( DEFAULT_VALUE ),
 114   mIndeterminate( false )
 115 {
 116 }
 117
 118 ProgressBar::~ProgressBar()
 119 {
 120 }
 121
 122 void ProgressBar::OnInitialize()
 123 {
 124 }
 125
 126 void ProgressBar::OnRelayout( const Vector2& size, RelayoutContainer& container )
 127 {
 128
 129   Vector2 trackSize( size );
 130   mDomain = CalcDomain( size );
 131
 132   trackSize.width = std::max( 0.0f, size.width ); // Ensure we don't go negative
 133
 134   Toolkit::Visual::Base trackVisual = GetVisual( Toolkit::ProgressBar::Property::TRACK_VISUAL );
 135   Toolkit::Visual::Base secondProgressVisual = GetVisual( Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL );
 136   Toolkit::Visual::Base progressVisual = GetVisual( Toolkit::ProgressBar::Property::PROGRESS_VISUAL );
 137   Toolkit::Visual::Base labelVisual = GetVisual( Toolkit::ProgressBar::Property::LABEL_VISUAL );
 138   Toolkit::Visual::Base indeterminateVisual = GetVisual( Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL );
 139
 140   if( trackVisual )
 141   {
 142     Property::Map visualTransform;
 143
 144     visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, trackSize )
 145                    .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 146                    .Add( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) );
 147
 148     trackVisual.SetTransformAndSize( visualTransform, trackSize );
 149   }
 150
 151   if( secondProgressVisual )
 152   {
 153     Property::Map visualTransform;
 154
 155     visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, Vector2( mDomain.from.x + mSecondaryProgressValue * ( mDomain.to.x - mDomain.from.x ), trackSize.height  ) )
 156                    .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 157                    .Add( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 158                    .Add( Toolkit::DevelVisual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
 159                    .Add( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN );
 160     secondProgressVisual.SetTransformAndSize( visualTransform, trackSize );
 161   }
 162
 163   if( progressVisual )
 164   {
 165     Property::Map visualTransform;
 166
 167     visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, Vector2( mDomain.from.x + mProgressValue * ( mDomain.to.x - mDomain.from.x ), trackSize.height ) )
 168                    .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 169                    .Add( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 170                    .Add( Toolkit::DevelVisual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
 171                    .Add( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN );
 172     progressVisual.SetTransformAndSize( visualTransform, trackSize );
 173   }
 174
 175   if( labelVisual )
 176   {
 177     Property::Map visualTransform;
 178
 179     visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, trackSize )
 180                    .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 181                    .Add( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) );
 182     labelVisual.SetTransformAndSize( visualTransform, trackSize );
 183   }
 184
 185   if( indeterminateVisual )
 186   {
 187     Property::Map visualTransform;
 188
 189     visualTransform.Add( Toolkit::DevelVisual::Transform::Property::SIZE, trackSize )
 190                    .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) )
 191                    .Add( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY, Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE ) );
 192     indeterminateVisual.SetTransformAndSize( visualTransform, trackSize );
 193   }
 194
 195 }
 196
 197 Vector3 ProgressBar::GetNaturalSize()
 198 {
 199   // Return the bigger size after comparing trackVisual naturalSize and labelVisual naturalSize
 200   Toolkit::Visual::Base trackVisual =  GetVisual( Toolkit::ProgressBar::Property::TRACK_VISUAL );
 201   Toolkit::Visual::Base labelVisual =  GetVisual( Toolkit::ProgressBar::Property::LABEL_VISUAL );
 202
 203   Size trackSize;
 204   Size labelSize;
 205
 206   if ( trackVisual )
 207   {
 208     trackVisual.GetNaturalSize( trackSize );
 209   }
 210   if ( labelVisual )
 211   {
 212     labelVisual.GetNaturalSize( labelSize );
 213   }
 214
 215   Vector3 naturalSize;
 216   naturalSize.width = ( trackSize.width > labelSize.width ) ? trackSize.width: labelSize.width;
 217   naturalSize.height = ( trackSize.height > labelSize.height ) ? trackSize.height: labelSize.height;
 218
 219   return naturalSize;
 220 }
 221
 222 ProgressBar::Domain ProgressBar::CalcDomain( const Vector2& currentSize )
 223 {
 224    return Domain( Vector2( 0.0f, 0.0f ), currentSize );
 225 }
 226
 227 Toolkit::ProgressBar::ValueChangedSignalType& ProgressBar::ValueChangedSignal()
 228 {
 229   return mValueChangedSignal;
 230 }
 231
 232 void ProgressBar::SetProgressValue( float value )
 233 {
 234   // update the progress bar value (taking float precision errors into account)
 235   // TODO : it seems 0.0f cannot into this statement.
 236   if( ( mProgressValue != value ) &&
 237       ( ( value >= DEFAULT_LOWER_BOUND ) || ( Equals( value, DEFAULT_LOWER_BOUND ) ) ) &&
 238       ( ( value <= DEFAULT_UPPER_BOUND ) || ( Equals( value, DEFAULT_UPPER_BOUND ) ) ) )
 239   {
 240     mProgressValue = Clamp( value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND );
 241
 242     Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast( Self() );
 243     mValueChangedSignal.Emit( self, mProgressValue, mSecondaryProgressValue );
 244     RelayoutRequest();
 245   }
 246 }
 247
 248 float ProgressBar::GetProgressValue() const
 249 {
 250   return mProgressValue;
 251 }
 252
 253 void ProgressBar::SetSecondaryProgressValue( float value )
 254 {
 255   // update the progress bar value (taking float precision errors into account)
 256   // TODO : it seems 0.0f cannot into this statement.
 257   if( ( mSecondaryProgressValue != value ) &&
 258       ( ( value >= DEFAULT_LOWER_BOUND ) || ( Equals( value, DEFAULT_LOWER_BOUND ) ) ) &&
 259       ( ( value <= DEFAULT_UPPER_BOUND ) || ( Equals( value, DEFAULT_UPPER_BOUND ) ) ) )
 260   {
 261     mSecondaryProgressValue = Clamp( value, DEFAULT_LOWER_BOUND, DEFAULT_UPPER_BOUND );
 262
 263     Toolkit::ProgressBar self = Toolkit::ProgressBar::DownCast( Self() );
 264     mValueChangedSignal.Emit( self, mProgressValue, mSecondaryProgressValue );
 265
 266     RelayoutRequest();
 267   }
 268 }
 269
 270 float ProgressBar::GetSecondaryProgressValue() const
 271 {
 272   return mSecondaryProgressValue;
 273 }
 274
 275 void ProgressBar::SetIndeterminate( bool value )
 276 {
 277   mIndeterminate = value;
 278   EnableVisual( Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL, mIndeterminate );
 279
 280   if( mIndeterminate )
 281   {
 282     RelayoutRequest();
 283     if( mIndeterminateVisualTransition )
 284     {
 285       PlayIndeterminateVisualTransition();
 286     }
 287   }
 288   else
 289   {
 290     if( mIndeterminateVisualAni )
 291     {
 292       mIndeterminateVisualAni.Stop();
 293     }
 294   }
 295 }
 296
 297 bool ProgressBar::GetIndeterminate() const
 298 {
 299   return mIndeterminate;
 300 }
 301
 302 void ProgressBar::SetIndeterminateVisualTransition( Toolkit::TransitionData transition )
 303 {
 304   mIndeterminateVisualTransition = transition;
 305   if( mIndeterminate )
 306   {
 307     PlayIndeterminateVisualTransition();
 308   }
 309 }
 310
 311 void ProgressBar::PlayIndeterminateVisualTransition()
 312 {
 313   if( mIndeterminateVisualAni )
 314   {
 315     mIndeterminateVisualAni.Stop();
 316     mIndeterminateVisualAni.Clear();
 317   }
 318
 319   mIndeterminateVisualAni = CreateTransition( mIndeterminateVisualTransition );
 320
 321   if( mIndeterminate && mIndeterminateVisualAni )
 322   {
 323     mIndeterminateVisualAni.SetLooping(true);
 324     mIndeterminateVisualAni.Play();
 325   }
 326 }
 327
 328 Toolkit::TransitionData ProgressBar::ConvertPropertyToTransition( const Property::Value& value )
 329 {
 330   Toolkit::TransitionData transitionData;
 331
 332   if( value.GetType() == Property::ARRAY )
 333   {
 334     transitionData = Toolkit::TransitionData::New( *value.GetArray() );
 335   }
 336   else if( value.GetType() == Property::MAP )
 337   {
 338     transitionData = Toolkit::TransitionData::New( *value.GetMap() );
 339   }
 340
 341   return transitionData;
 342 }
 343
 344 /**
 345  * Create Visual for given index from a property map or url.
 346  * 1) Check if value passed in is a url and create visual
 347  * 2) Create visual from map if step (1) is false
 348  * 3) Register visual with control with false for enable flag.
 349  * 4) Unregister visual if empty map was provided. This is the method to remove a visual
 350  */
 351
 352 void ProgressBar::CreateVisualsForComponent( Property::Index index, const Property::Value& value, const float visualDepth )
 353 {
 354   Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
 355   Toolkit::Visual::Base progressVisual;
 356
 357   std::string imageUrl;
 358   if( value.Get( imageUrl ) )
 359   {
 360     if ( !imageUrl.empty() )
 361     {
 362       progressVisual = visualFactory.CreateVisual(  imageUrl, ImageDimensions()  );
 363     }
 364   }
 365   else // Does this code make text-visual can be accepted as visual?
 366   {
 367     // if its not a string then get a Property::Map from the property if possible.
 368     Property::Map *map = value.GetMap();
 369     if( map && !map->Empty()  ) // Empty map results in current visual removal.
 370     {
 371       progressVisual = visualFactory.CreateVisual( *map );
 372     }
 373   }
 374
 375   if ( progressVisual )
 376   {
 377     progressVisual.SetDepthIndex( visualDepth );
 378     if( index == Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL )
 379     {
 380       RegisterVisual( index, progressVisual, mIndeterminate );
 381     }
 382     else
 383     {
 384       RegisterVisual( index, progressVisual, true );
 385     }
 386   }
 387   else
 388   {
 389     UnregisterVisual( 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 = GetVisual( 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 = progressBarImpl.GetVisual( 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