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