dali-toolkit/internal/controls/slider/slider-impl.cpp

   1 /*
   2  * Copyright (c) 2020 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/slider/slider-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <cstring> // for strcmp
  23 #include <sstream>
  24 #include <limits>
  25 #include <dali/public-api/events/touch-event.h>
  26 #include <dali/public-api/object/type-registry.h>
  27 #include <dali/public-api/object/type-registry-helper.h>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
  31 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  32 #include <dali-toolkit/public-api/controls/control-impl.h>
  33 #include <dali-toolkit/public-api/controls/image-view/image-view.h>
  34
  35 using namespace Dali;
  36
  37 namespace Dali
  38 {
  39
  40 namespace Toolkit
  41 {
  42
  43 namespace Internal
  44 {
  45
  46 namespace // Unnamed namespace
  47 {
  48
  49 BaseHandle Create()
  50 {
  51   return Dali::Toolkit::Slider::New();
  52 }
  53
  54 // Setup properties, signals and actions using the type-registry.
  55 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Slider, Toolkit::Control, Create )
  56
  57 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "lowerBound",             FLOAT,    LOWER_BOUND            )
  58 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "upperBound",             FLOAT,    UPPER_BOUND            )
  59 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "value",                  FLOAT,    VALUE                  )
  60 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "trackVisual",            MAP,      TRACK_VISUAL           )
  61 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handleVisual",           MAP,      HANDLE_VISUAL          )
  62 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "progressVisual",         MAP,      PROGRESS_VISUAL        )
  63 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupVisual",            MAP,      POPUP_VISUAL           )
  64 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupArrowVisual",       MAP,      POPUP_ARROW_VISUAL     )
  65 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "disabledColor",          VECTOR4,  DISABLED_COLOR         )
  66 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "valuePrecision",         INTEGER,  VALUE_PRECISION        )
  67 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showPopup",              BOOLEAN,  SHOW_POPUP             )
  68 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showValue",              BOOLEAN,  SHOW_VALUE             )
  69 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "marks",                  ARRAY,    MARKS                  )
  70 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "snapToMarks",            BOOLEAN,  SNAP_TO_MARKS          )
  71 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "markTolerance",          FLOAT,    MARK_TOLERANCE         )
  72
  73 DALI_SIGNAL_REGISTRATION(   Toolkit, Slider, "valueChanged",                     SIGNAL_VALUE_CHANGED   )
  74 DALI_SIGNAL_REGISTRATION(   Toolkit, Slider, "mark",                             SIGNAL_MARK            )
  75
  76 DALI_TYPE_REGISTRATION_END()
  77
  78 const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width
  79
  80 const int VALUE_VIEW_SHOW_DURATION = 1000;  // millisec
  81 const int VALUE_VIEW_SHOW_DURATION_LONG = 2000;  // millisec
  82
  83 const float VALUE_VERTICAL_OFFSET = 48.0f;
  84
  85 const float DEFAULT_WIDTH = 0.0f;
  86 const float DEFAULT_HEIGHT = 27.0f;
  87 const float DEFAULT_HIT_HEIGHT = 72.0f;
  88 const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT;
  89 const float POPUP_TEXT_PADDING = 10.0f;
  90
  91 const char* SKINNED_TRACK_VISUAL_FILE_NAME = "slider-skin.9.png";
  92 const char* SKINNED_HANDLE_VISUAL_FILE_NAME = "slider-skin-handle.png";
  93 const char* SKINNED_PROGRESS_VISUAL_FILE_NAME = "slider-skin-progress.9.png";
  94 const char* SKINNED_POPUP_VISUAL_FILE_NAME = "slider-popup.9.png";
  95 const char* SKINNED_POPUP_ARROW_VISUAL_FILE_NAME = "slider-popup-arrow.png";
  96
  97 const Vector2 DEFAULT_HIT_REGION( DEFAULT_WIDTH, DEFAULT_HIT_HEIGHT );
  98 const Vector2 DEFAULT_TRACK_REGION( DEFAULT_WIDTH, DEFAULT_HEIGHT );
  99 const Vector2 DEFAULT_HANDLE_SIZE( DEFAULT_HANDLE_HEIGHT, DEFAULT_HANDLE_HEIGHT );
 100
 101 const Vector4 DEFAULT_DISABLED_COLOR( 0.5f, 0.5f, 0.5f, 1.0f );
 102
 103 const float VALUE_POPUP_MARGIN = 10.0f;
 104 const float VALUE_POPUP_HEIGHT = 81.0f;
 105 const float VALUE_POPUP_MIN_WIDTH = 54.0f;
 106
 107 const float DEFAULT_LOWER_BOUND = 0.0f;
 108 const float DEFAULT_UPPER_BOUND = 1.0f;
 109 const float DEFAULT_VALUE = 0.0f;
 110 const int DEFAULT_VALUE_PRECISION = 0;
 111 const bool DEFAULT_SHOW_POPUP = false;
 112 const bool DEFAULT_SHOW_VALUE = true;
 113 const bool DEFAULT_ENABLED = true;
 114 const bool DEFAULT_SNAP_TO_MARKS = false;
 115
 116 } // Unnamed namespace
 117
 118 ///////////////////////////////////////////////////////////////////////////////////////////////////
 119 // Slider
 120 ///////////////////////////////////////////////////////////////////////////////////////////////////
 121
 122 Dali::Toolkit::Slider Slider::New()
 123 {
 124   // Create the implementation
 125   SliderPtr slider( new Slider() );
 126
 127   // Pass ownership to CustomActor via derived handle
 128   Dali::Toolkit::Slider handle( *slider );
 129
 130   // Second-phase init of the implementation
 131   // This can only be done after the CustomActor connection has been made...
 132   slider->Initialize();
 133
 134   return handle;
 135 }
 136
 137 Slider::Slider()
 138 : Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
 139   mState( NORMAL ),
 140   mPopupVisual(""),
 141   mPopupArrowVisual(""),
 142   mTrackVisual(""),
 143   mHandleVisual(""),
 144   mProgressVisual(""),
 145   mPopupMap(),
 146   mTrackMap(),
 147   mHandleMap(),
 148   mPopupArrowMap(),
 149   mDisabledColor( 0.0f, 0.0f, 0.0f, 0.0f ),
 150   mHitRegion( 0.0f, 0.0f ),
 151   mTrackRegion( 0.0f, 0.0f ),
 152   mHandleSize( 0.0f, 0.0f ),
 153   mLowerBound( 0.0f ),
 154   mUpperBound( 0.0f ),
 155   mValue( 0.0f ),
 156   mMarkTolerance( 0.0f ),
 157   mValuePrecision( 0 ),
 158   mShowPopup( false ),
 159   mShowValue( false ),
 160   mSnapToMarks( false )
 161 {
 162 }
 163
 164 Slider::~Slider()
 165 {
 166 }
 167
 168 void Slider::OnInitialize()
 169 {
 170   // Setup
 171   CreateChildren();
 172
 173   // Properties
 174   Actor self = Self();
 175
 176   SetHitRegion(     DEFAULT_HIT_REGION     );
 177   SetTrackRegion(   DEFAULT_TRACK_REGION   );
 178   SetHandleSize(    DEFAULT_HANDLE_SIZE    );
 179
 180   const std::string imageDirPath = AssetManager::GetDaliImagePath();
 181   SetTrackVisual(            imageDirPath + SKINNED_TRACK_VISUAL_FILE_NAME             );
 182   SetHandleVisual(           imageDirPath + SKINNED_HANDLE_VISUAL_FILE_NAME            );
 183   SetProgressVisual(         imageDirPath + SKINNED_PROGRESS_VISUAL_FILE_NAME          );
 184   SetPopupVisual(            imageDirPath + SKINNED_POPUP_VISUAL_FILE_NAME             );
 185   SetPopupArrowVisual(       imageDirPath + SKINNED_POPUP_ARROW_VISUAL_FILE_NAME       );
 186
 187   SetShowPopup( DEFAULT_SHOW_POPUP );
 188   SetShowValue( DEFAULT_SHOW_VALUE );
 189
 190   SetEnabled( DEFAULT_ENABLED );
 191   SetDisabledColor( DEFAULT_DISABLED_COLOR );
 192
 193   SetSnapToMarks( DEFAULT_SNAP_TO_MARKS );
 194   SetMarkTolerance( MARK_SNAP_TOLERANCE );
 195
 196   SetLowerBound( DEFAULT_LOWER_BOUND );
 197   SetUpperBound( DEFAULT_UPPER_BOUND );
 198   UpdateSkin();
 199   SetValuePrecision( DEFAULT_VALUE_PRECISION );
 200   mValue = DEFAULT_VALUE;
 201   DisplayValue( mValue, false );       // Run this last to display the correct value
 202
 203   // Size the Slider actor to a default
 204   self.SetProperty( Actor::Property::SIZE, Vector2( DEFAULT_HIT_REGION.x, DEFAULT_HIT_REGION.y ) );
 205
 206   // Set the Slider to be highlightable in Screen Reader mode
 207   self.SetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true );
 208
 209   // Connect to the touch signal
 210   self.TouchedSignal().Connect( this, &Slider::OnTouch );
 211
 212   DevelControl::SetAccessibilityConstructor( self, []( Dali::Actor actor ) {
 213     return std::unique_ptr< Dali::Accessibility::Accessible >(
 214       new AccessibleImpl( actor, Dali::Accessibility::Role::SLIDER ) );
 215   } );
 216 }
 217
 218 void Slider::OnRelayout( const Vector2& size, RelayoutContainer& container )
 219 {
 220   SetHitRegion( Vector2( size.x, GetHitRegion().y ) );
 221   // Factor in handle overshoot into size of backing
 222   SetTrackRegion( Vector2( size.x - GetHandleSize().x, GetTrackRegion().y ) );
 223   Control::OnRelayout( size, container );
 224 }
 225
 226 bool Slider::OnTouch(Actor actor, const TouchEvent& touch)
 227 {
 228   if( mState != DISABLED )
 229   {
 230     const PointState::Type touchState = touch.GetState(0);
 231
 232     if( touchState == PointState::DOWN )
 233     {
 234       mState = PRESSED;
 235
 236       float percentage = MapPercentage( touch.GetLocalPosition( 0 ) );
 237       float value = MapBounds( ( GetSnapToMarks() ) ? SnapToMark( percentage ) : MarkFilter( percentage ), GetLowerBound(), GetUpperBound() );
 238       SetValue( value );
 239       DisplayPopup( value );
 240     }
 241     else if( touchState == PointState::UP )
 242     {
 243       if( mState == PRESSED )
 244       {
 245         mState = NORMAL;
 246         mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
 247       }
 248     }
 249   }
 250
 251   return false;
 252 }
 253
 254 void Slider::OnPan( Actor actor, const PanGesture& gesture )
 255 {
 256   // gesture.position is in local actor coordinates
 257   if( mState != DISABLED )
 258   {
 259     switch( gesture.GetState() )
 260     {
 261       case GestureState::CONTINUING:
 262       {
 263         if( mState == PRESSED )
 264         {
 265           float value = MapBounds( MarkFilter ( MapPercentage( gesture.GetPosition() ) ), GetLowerBound(), GetUpperBound() );
 266           SetValue( value );
 267           DisplayPopup( value );
 268         }
 269         break;
 270       }
 271       case GestureState::FINISHED:
 272       {
 273         if( mState == PRESSED  )
 274         {
 275           if( GetSnapToMarks() )
 276           {
 277             float value = MapBounds( SnapToMark( MapPercentage( gesture.GetPosition() ) ), GetLowerBound(), GetUpperBound() );
 278             SetValue( value );
 279             DisplayPopup( value );
 280           }
 281           mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
 282         }
 283
 284         mState = NORMAL;
 285         break;
 286       }
 287       default:
 288       {
 289         break;
 290       }
 291     }
 292   }
 293 }
 294
 295 float Slider::HitSpaceToDomain( float x )
 296 {
 297   float halfRegionWidth = GetHitRegion().x * 0.5f;
 298   float halfDomainWidth = ( mDomain.to.x - mDomain.from.x ) * 0.5f;
 299   float endDiff = halfRegionWidth - halfDomainWidth;
 300
 301   return x - endDiff;
 302 }
 303
 304 float Slider::MapPercentage( const Vector2& point )
 305 {
 306   return Clamp( ( HitSpaceToDomain( point.x ) - mDomain.from.x ) / ( mDomain.to.x - mDomain.from.x ), 0.0f, 1.0f );
 307 }
 308
 309 float Slider::MapValuePercentage( float value )
 310 {
 311   return ( value - GetLowerBound() ) / ( GetUpperBound() - GetLowerBound() );
 312 }
 313
 314 float Slider::MapBounds( float percent, float lowerBound, float upperBound )
 315 {
 316   return lowerBound + percent * ( upperBound - lowerBound );
 317 }
 318
 319 Slider::Domain Slider::CalcDomain( const Vector2& currentSize )
 320 {
 321    return Domain( Vector2( 0.0f, 0.0f ), currentSize );
 322 }
 323
 324 void Slider::DisplayValue( float value, bool raiseSignals )
 325 {
 326   float clampedValue = Clamp( value, GetLowerBound(), GetUpperBound() );
 327
 328   float percent = MapValuePercentage( clampedValue );
 329
 330   float x = mDomain.from.x + percent * ( mDomain.to.x - mDomain.from.x );
 331
 332   mHandle.SetProperty( Actor::Property::POSITION_X,  x );
 333
 334   // Progress bar
 335   if( mProgress )
 336   {
 337     mProgress.SetProperty( Actor::Property::SIZE, Vector2( x, GetTrackRegion().y ) );
 338   }
 339
 340   // Signals
 341   if( raiseSignals )
 342   {
 343     Toolkit::Slider self = Toolkit::Slider::DownCast( Self() );
 344     mValueChangedSignal.Emit( self, clampedValue );
 345
 346     int markIndex;
 347     if( MarkReached( percent, markIndex ) )
 348     {
 349       mMarkReachedSignal.Emit( self, markIndex );
 350     }
 351   }
 352
 353   if( mHandleValueTextLabel )
 354   {
 355     std::stringstream ss;
 356     ss.precision( GetValuePrecision() );
 357     ss << std::fixed << clampedValue;
 358
 359     std::string label = mHandleValueTextLabel.GetProperty<std::string>( Toolkit::TextLabel::Property::TEXT );
 360     if( label.compare(ss.str()) )
 361     {
 362       mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
 363     }
 364   }
 365 }
 366
 367 void Slider::SetMarks( const MarkList& marks )
 368 {
 369   mMarks = marks;
 370 }
 371
 372 const Slider::MarkList& Slider::GetMarks() const
 373 {
 374   return mMarks;
 375 }
 376
 377 void Slider::SetSnapToMarks( bool snap )
 378 {
 379   mSnapToMarks = snap;
 380 }
 381
 382 bool Slider::GetSnapToMarks() const
 383 {
 384   return mSnapToMarks;
 385 }
 386
 387 Actor Slider::CreateHitRegion()
 388 {
 389   Actor hitRegion = Actor::New();
 390   hitRegion.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 391   hitRegion.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
 392   hitRegion.TouchedSignal().Connect( this, &Slider::OnTouch );
 393
 394   return hitRegion;
 395 }
 396
 397 Toolkit::ImageView Slider::CreateTrack()
 398 {
 399   Toolkit::ImageView track = Toolkit::ImageView::New();
 400   track.SetProperty( Dali::Actor::Property::NAME,"SliderTrack");
 401   track.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 402   track.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
 403   return track;
 404 }
 405
 406 void Slider::SetTrackVisual( const std::string& filename )
 407 {
 408   if( mHandle && ( filename.size() > 0 ) )
 409   {
 410     mTrack.SetImage( filename );
 411     mTrackVisual = filename;
 412   }
 413 }
 414
 415 void Slider::SetTrackVisual( Property::Map map )
 416 {
 417   Property::Value* imageValue = map.Find( "url" );
 418   if( imageValue )
 419   {
 420     mTrackVisual.clear();
 421     std::string filename;
 422     if( imageValue->Get( filename ) )
 423     {
 424       if( mTrack && ( filename.size() > 0 ) )
 425       {
 426         mTrack.SetImage( filename );
 427         mTrackMap = map;
 428       }
 429     }
 430   }
 431
 432   Property::Value* sizeValue = map.Find( "size" );
 433   if( sizeValue )
 434   {
 435     Vector2 size;
 436     if( sizeValue->Get( size ) )
 437     {
 438       mTrackRegion = size;
 439       if( mTrack )
 440       {
 441         mTrack.SetProperty( Actor::Property::SIZE, mTrackRegion );
 442       }
 443
 444     ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) );
 445
 446     mDomain = CalcDomain( mTrackRegion );
 447
 448     // Set the progress bar to correct width
 449     DisplayValue( GetValue(), false );
 450     }
 451   }
 452 }
 453
 454 std::string Slider::GetTrackVisual()
 455 {
 456   return mTrackVisual;
 457 }
 458
 459 Toolkit::ImageView Slider::CreateProgress()
 460 {
 461   Toolkit::ImageView progress = Toolkit::ImageView::New();
 462   progress.SetProperty( Dali::Actor::Property::NAME,"SliderProgress");
 463   progress.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
 464   progress.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
 465
 466   return progress;
 467 }
 468
 469 void Slider::SetProgressVisual( const std::string& filename )
 470 {
 471   if( mProgress && ( filename.size() > 0 ) )
 472   {
 473     mProgress.SetImage( filename );
 474     mProgressVisual = filename;
 475   }
 476 }
 477
 478 void Slider::SetProgressVisual( Property::Map map )
 479 {
 480   Property::Value* imageValue = map.Find( "url" );
 481   if( imageValue )
 482   {
 483     mProgressVisual.clear();
 484     std::string filename;
 485     if( imageValue->Get( filename ) )
 486     {
 487       if( mProgress && ( filename.size() > 0 ) )
 488       {
 489         mProgress.SetImage( filename );
 490         mProgressMap = map;
 491       }
 492     }
 493   }
 494 }
 495
 496 std::string Slider::GetProgressVisual()
 497 {
 498   return mProgressVisual;
 499 }
 500
 501 void Slider::SetPopupVisual( const std::string& filename )
 502 {
 503   mPopupVisual = filename;
 504 }
 505
 506 void Slider::SetPopupVisual( Property::Map map )
 507 {
 508   Property::Value* imageValue = map.Find( "url" );
 509   if( imageValue )
 510   {
 511     mPopupVisual.clear();
 512     std::string filename;
 513     if( imageValue->Get( filename ) )
 514     {
 515       if( mPopup && ( filename.size() > 0 ) )
 516       {
 517         mPopup.SetImage( filename );
 518         mPopupMap = map;
 519       }
 520     }
 521   }
 522 }
 523
 524 std::string Slider::GetPopupVisual()
 525 {
 526   return mPopupVisual;
 527 }
 528
 529 void Slider::CreatePopupImage( const std::string& filename )
 530 {
 531   if( mPopup && ( filename.size() > 0 ) )
 532   {
 533     Property::Map map;
 534     map[Toolkit::ImageVisual::Property::URL] = filename;
 535     mPopup.SetProperty( Toolkit::ImageView::Property::IMAGE, map );
 536   }
 537 }
 538
 539 void Slider::SetPopupArrowVisual( const std::string& filename )
 540 {
 541   mPopupArrowVisual = filename;
 542 }
 543
 544 void Slider::SetPopupArrowVisual( Property::Map map )
 545 {
 546   Property::Value* imageValue = map.Find( "url" );
 547   if( imageValue )
 548   {
 549     mPopupArrowVisual.clear();
 550     std::string filename;
 551     if( imageValue->Get( filename ) )
 552     {
 553       if( mPopupArrow && ( filename.size() > 0 ) )
 554       {
 555         mPopupArrow.SetImage( filename );
 556         mPopupArrowMap = map;
 557       }
 558     }
 559   }
 560 }
 561
 562 std::string Slider::GetPopupArrowVisual()
 563 {
 564   return mPopupArrowVisual;
 565 }
 566
 567 void Slider::CreatePopupArrowImage( const std::string& filename )
 568 {
 569   if( mPopupArrow && ( filename.size() > 0 ) )
 570   {
 571     Property::Map map;
 572     map[Toolkit::ImageVisual::Property::URL] = filename;
 573     mPopupArrow.SetProperty( Toolkit::ImageView::Property::IMAGE, map );
 574   }
 575 }
 576
 577 void Slider::ResizeProgressRegion( const Vector2& region )
 578 {
 579   if( mProgress )
 580   {
 581     mProgress.SetProperty( Actor::Property::SIZE, region );
 582   }
 583 }
 584
 585 Toolkit::ImageView Slider::CreateHandle()
 586 {
 587   Toolkit::ImageView handle = Toolkit::ImageView::New();
 588   handle.SetProperty( Dali::Actor::Property::NAME,"SliderHandle");
 589   handle.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
 590   handle.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
 591
 592   return handle;
 593 }
 594
 595 Toolkit::ImageView Slider::CreatePopupArrow()
 596 {
 597   Toolkit::ImageView arrow = Toolkit::ImageView::New();
 598   arrow.SetStyleName("SliderPopupArrow");
 599   arrow.SetProperty( Dali::Actor::Property::NAME,"SliderPopupArrow");
 600   arrow.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_CENTER );
 601   arrow.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER );
 602
 603   return arrow;
 604 }
 605
 606 Toolkit::TextLabel Slider::CreatePopupText()
 607 {
 608   Toolkit::TextLabel textLabel = Toolkit::TextLabel::New();
 609   textLabel.SetProperty( Dali::Actor::Property::NAME, "SliderPopupTextLabel" );
 610   textLabel.SetStyleName( "SliderPopupTextLabel" );
 611   textLabel.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 612   textLabel.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
 613   textLabel.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
 614   textLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
 615   textLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
 616   textLabel.SetProperty( Actor::Property::PADDING, Padding( POPUP_TEXT_PADDING, POPUP_TEXT_PADDING, 0.0f, 0.0f ) );
 617   textLabel.SetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, false );
 618   return textLabel;
 619 }
 620
 621 Toolkit::ImageView Slider::CreatePopup()
 622 {
 623   Toolkit::ImageView popup = Toolkit::ImageView::New();
 624   popup.SetProperty( Dali::Actor::Property::NAME, "SliderPopup" );
 625   popup.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER );
 626   popup.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER );
 627   popup.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::WIDTH );
 628
 629   mValueTextLabel = CreatePopupText();
 630   popup.Add( mValueTextLabel );
 631
 632   return popup;
 633 }
 634
 635 void Slider::SetHandleVisual( const std::string& filename )
 636 {
 637   if( mHandle && ( filename.size() > 0 ) )
 638   {
 639     mHandle.SetImage( filename );
 640     mHandleVisual = filename;
 641   }
 642 }
 643
 644 void Slider::SetHandleVisual( Property::Map map )
 645 {
 646   Property::Value* imageValue = map.Find( "url" );
 647   if( imageValue )
 648   {
 649     mHandleVisual.clear();
 650     std::string filename;
 651     if( imageValue->Get( filename ) )
 652     {
 653       if( mHandle && ( filename.size() > 0 ) )
 654       {
 655         mHandle.SetImage( filename );
 656         mHandleMap = map;
 657       }
 658     }
 659   }
 660
 661   Property::Value* sizeValue = map.Find( "size" );
 662   if( sizeValue )
 663   {
 664     Vector2 size;
 665     if( sizeValue->Get( size ) )
 666     {
 667       mHandleSize = size;
 668       ResizeHandleSize( mHandleSize );
 669
 670       Vector2 hitRegion = GetHitRegion();
 671       hitRegion.x += mHandleSize.x;
 672       SetHitRegion( hitRegion );
 673     }
 674   }
 675 }
 676
 677 std::string Slider::GetHandleVisual()
 678 {
 679   return mHandleVisual;
 680 }
 681
 682 void Slider::ResizeHandleSize( const Vector2& size )
 683 {
 684   if( mHandle )
 685   {
 686     mHandle.SetProperty( Actor::Property::SIZE, size );
 687   }
 688 }
 689
 690 void Slider::CreateHandleValueDisplay()
 691 {
 692   if( mHandle && !mHandleValueTextLabel )
 693   {
 694     mHandleValueTextLabel = Toolkit::TextLabel::New();
 695     mHandleValueTextLabel.SetProperty( Dali::Actor::Property::NAME,"SliderHandleTextLabel");
 696     mHandleValueTextLabel.SetStyleName("SliderHandleTextLabel");
 697     mHandleValueTextLabel.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 698     mHandleValueTextLabel.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
 699     mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
 700     mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
 701     mHandleValueTextLabel.SetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, false );
 702     mHandle.Add( mHandleValueTextLabel );
 703   }
 704 }
 705
 706 void Slider::DestroyHandleValueDisplay()
 707 {
 708   UnparentAndReset(mHandleValueTextLabel);
 709 }
 710
 711 Actor Slider::CreateValueDisplay()
 712 {
 713   Actor popup = Actor::New();
 714   popup.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER );
 715   popup.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER );
 716
 717   mPopupArrow = CreatePopupArrow();
 718   popup.Add( mPopupArrow );
 719
 720   mPopup = CreatePopup();
 721   mPopup.SetProperty( Actor::Property::SIZE, Vector2( 0.0f, VALUE_POPUP_HEIGHT ) );
 722   mPopupArrow.Add( mPopup );
 723
 724   return popup;
 725 }
 726
 727 Toolkit::Slider::ValueChangedSignalType& Slider::ValueChangedSignal()
 728 {
 729   return mValueChangedSignal;
 730 }
 731
 732 Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal()
 733 {
 734   return mSlidingFinishedSignal;
 735 }
 736
 737 Toolkit::Slider::MarkReachedSignalType& Slider::MarkReachedSignal()
 738 {
 739   return mMarkReachedSignal;
 740 }
 741
 742 void Slider::UpdateSkin()
 743 {
 744   switch( mState )
 745   {
 746     case NORMAL:
 747     {
 748       mTrack.SetProperty( Actor::Property::COLOR, Color::WHITE );
 749       mHandle.SetProperty( Actor::Property::COLOR, Color::WHITE );
 750       mProgress.SetProperty( Actor::Property::COLOR, Color::WHITE );
 751       break;
 752     }
 753     case DISABLED:
 754     {
 755       Vector4 disabledColor = GetDisabledColor();
 756       mTrack.SetProperty( Actor::Property::COLOR, disabledColor );
 757       mHandle.SetProperty( Actor::Property::COLOR, disabledColor );
 758       mProgress.SetProperty( Actor::Property::COLOR, disabledColor );
 759       break;
 760     }
 761     case PRESSED:
 762     {
 763       break;
 764     }
 765     case FOCUSED:
 766     {
 767       break;
 768     }
 769   }
 770 }
 771
 772 void Slider::CreateChildren()
 773 {
 774   Actor self = Self();
 775
 776   // Hit region
 777   mHitArea = CreateHitRegion();
 778   mPanDetector = PanGestureDetector::New();
 779   mPanDetector.Attach( mHitArea );
 780   mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan );
 781   self.Add( mHitArea );
 782
 783   // Track
 784   mTrack = CreateTrack();
 785   self.Add( mTrack );
 786
 787   // Progress bar
 788   mProgress = CreateProgress();
 789   mTrack.Add( mProgress );
 790
 791   // Handle
 792   mHandle = CreateHandle();
 793   mProgress.Add( mHandle );
 794 }
 795
 796 void Slider::SetHitRegion( const Vector2& size )
 797 {
 798   mHitRegion = size;
 799
 800   if( mHitArea )
 801   {
 802     mHitArea.SetProperty( Actor::Property::SIZE, mHitRegion );
 803   }
 804 }
 805
 806 const Vector2& Slider::GetHitRegion() const
 807 {
 808   return mHitRegion;
 809 }
 810
 811 void Slider::AddPopup()
 812 {
 813   if( !mValueDisplay )
 814   {
 815     mValueDisplay = CreateValueDisplay();
 816     mValueDisplay.SetProperty( Actor::Property::VISIBLE, false );
 817     mHandle.Add( mValueDisplay );
 818
 819     CreatePopupImage( GetPopupVisual() );
 820     CreatePopupArrowImage( GetPopupArrowVisual() );
 821
 822     mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION );
 823     mValueTimer.TickSignal().Connect( this, &Slider::HideValueView );
 824   }
 825 }
 826
 827 void Slider::RemovePopup()
 828 {
 829   if( mValueDisplay )
 830   {
 831     mPopup.Unparent();
 832     mPopup.Reset();
 833
 834     mPopupArrow.Unparent();
 835     mPopupArrow.Reset();
 836
 837     mValueDisplay.Unparent();
 838     mValueDisplay.Reset();
 839
 840     mValueTimer.TickSignal().Disconnect( this, &Slider::HideValueView );
 841     mValueTimer.Reset();
 842   }
 843 }
 844
 845
 846 float Slider::MarkFilter( float value )
 847 {
 848   const float MARK_TOLERANCE = GetMarkTolerance();
 849
 850   float mark;
 851   for( MarkList::SizeType i = 0; i < mMarks.Count(); ++i)
 852   {
 853     const Property::Value& propertyValue = mMarks[i];
 854     propertyValue.Get( mark );
 855     mark = MapValuePercentage( mark );
 856
 857     // If close to a mark, return the mark
 858     if( fabsf( mark - value ) < MARK_TOLERANCE )
 859     {
 860       return mark;
 861     }
 862   }
 863
 864   return value;
 865 }
 866
 867 float Slider::SnapToMark( float value )
 868 {
 869   float closestMark = value;
 870   float closestDist = std::numeric_limits<float>::max();
 871
 872   float mark;
 873   for( MarkList::SizeType  i = 0; i < mMarks.Count(); ++i)
 874   {
 875     const Property::Value& propertyValue = mMarks[i];
 876     propertyValue.Get( mark );
 877     mark = MapValuePercentage( mark );
 878
 879     float dist = fabsf( mark - value );
 880     if( dist < closestDist )
 881     {
 882       closestDist = dist;
 883       closestMark = mark;
 884     }
 885   }
 886
 887   return closestMark;
 888 }
 889
 890 bool Slider::MarkReached( float value, int& outIndex )
 891 {
 892   const float MARK_TOLERANCE = GetMarkTolerance();
 893
 894   // Binary search
 895   int head = 0,
 896       tail = mMarks.Size() - 1;
 897   int current;
 898   float mark;
 899
 900   while( head <= tail )
 901   {
 902     current = head + ( tail - head ) / 2;
 903
 904     const Property::Value& propertyValue = mMarks[ current ];
 905     propertyValue.Get( mark );
 906     mark = MapValuePercentage( mark );
 907
 908     if( fabsf( mark - value ) < MARK_TOLERANCE )
 909     {
 910       outIndex = current;
 911       return true;
 912     }
 913
 914     if( value < mark )
 915     {
 916       tail = current - 1;
 917     }
 918     else
 919     {
 920       head = current + 1;
 921     }
 922   }
 923
 924   return false;
 925 }
 926
 927 bool Slider::HideValueView()
 928 {
 929   if( mValueDisplay )
 930   {
 931     mValueDisplay.SetProperty( Actor::Property::VISIBLE, false );
 932   }
 933
 934   return false;
 935 }
 936
 937 void Slider::SetLowerBound( float bound )
 938 {
 939   mLowerBound = bound;
 940   DisplayValue( GetValue(), false );
 941 }
 942
 943 float Slider::GetLowerBound() const
 944 {
 945   return mLowerBound;
 946 }
 947
 948 void Slider::SetUpperBound( float bound )
 949 {
 950   mUpperBound = bound;
 951   DisplayValue( GetValue(), false );
 952 }
 953
 954 float Slider::GetUpperBound() const
 955 {
 956   return mUpperBound;
 957 }
 958
 959 void Slider::SetValue( float value )
 960 {
 961   mValue = value;
 962   DisplayValue( mValue, true );
 963 }
 964
 965 float Slider::GetValue() const
 966 {
 967   return mValue;
 968 }
 969
 970 void Slider::SetTrackRegion( const Vector2& region )
 971 {
 972   mTrackRegion = region;
 973
 974   if( mTrack )
 975   {
 976     mTrack.SetProperty( Actor::Property::SIZE, mTrackRegion );
 977   }
 978
 979   ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) );
 980
 981   mDomain = CalcDomain( mTrackRegion );
 982
 983   DisplayValue( GetValue(), false );  // Set the progress bar to correct width
 984 }
 985
 986 const Vector2& Slider::GetTrackRegion() const
 987 {
 988   return mTrackRegion;
 989 }
 990
 991 void Slider::SetHandleSize( const Vector2& size )
 992 {
 993   mHandleSize = size;
 994
 995   ResizeHandleSize( mHandleSize );
 996
 997   Vector2 hitRegion = GetHitRegion();
 998   hitRegion.x += mHandleSize.x;
 999   SetHitRegion( hitRegion );
1000 }
1001
1002 const Vector2& Slider::GetHandleSize() const
1003 {
1004   return mHandleSize;
1005 }
1006
1007 void Slider::SetDisabledColor( const Vector4& color )
1008 {
1009   mDisabledColor = color;
1010
1011   UpdateSkin();
1012 }
1013
1014 Vector4 Slider::GetDisabledColor() const
1015 {
1016   return mDisabledColor;
1017 }
1018
1019 void Slider::SetValuePrecision( int precision )
1020 {
1021   mValuePrecision = precision;
1022 }
1023
1024 int Slider::GetValuePrecision() const
1025 {
1026   return mValuePrecision;
1027 }
1028
1029 void Slider::SetShowPopup( bool showPopup )
1030 {
1031   mShowPopup = showPopup;
1032
1033   // Value display
1034   if( mShowPopup )
1035   {
1036     AddPopup();
1037   }
1038   else
1039   {
1040     RemovePopup();
1041   }
1042 }
1043
1044 bool Slider::GetShowPopup() const
1045 {
1046   return mShowPopup;
1047 }
1048
1049 void Slider::SetShowValue( bool showValue )
1050 {
1051   mShowValue = showValue;
1052
1053   if( mShowValue )
1054   {
1055     CreateHandleValueDisplay();
1056   }
1057   else
1058   {
1059     DestroyHandleValueDisplay();
1060   }
1061 }
1062
1063 bool Slider::GetShowValue() const
1064 {
1065   return mShowValue;
1066 }
1067
1068 void Slider::SetEnabled( bool enabled )
1069 {
1070   if( enabled )
1071   {
1072     mState = NORMAL;
1073   }
1074   else
1075   {
1076     mState = DISABLED;
1077   }
1078
1079   UpdateSkin();
1080 }
1081
1082 bool Slider::IsEnabled() const
1083 {
1084   return mState != DISABLED;
1085 }
1086
1087 void Slider::SetMarkTolerance( float tolerance )
1088 {
1089   mMarkTolerance = tolerance;
1090 }
1091
1092 float Slider::GetMarkTolerance() const
1093 {
1094   return mMarkTolerance;
1095 }
1096
1097 // Static class method to support script connecting signals
1098 bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
1099 {
1100   Dali::BaseHandle handle( object );
1101
1102   bool connected = true;
1103   Toolkit::Slider slider = Toolkit::Slider::DownCast( handle );
1104
1105   if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
1106   {
1107     slider.ValueChangedSignal().Connect( tracker, functor );
1108   }
1109   else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
1110   {
1111     slider.MarkReachedSignal().Connect( tracker, functor );
1112   }
1113   else
1114   {
1115     // signalName does not match any signal
1116     connected = false;
1117   }
1118
1119   return connected;
1120 }
1121
1122 void Slider::DisplayPopup( float value )
1123 {
1124   // Value displayDoConnectSignal
1125   if( mValueTextLabel )
1126   {
1127     std::stringstream ss;
1128     ss.precision( GetValuePrecision() );
1129     ss << std::fixed << value;
1130     mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
1131
1132     if( mValueDisplay )
1133     {
1134       mValueDisplay.SetProperty( Actor::Property::VISIBLE, true );
1135
1136       mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
1137     }
1138   }
1139 }
1140
1141 void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
1142 {
1143   Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1144
1145   if ( slider )
1146   {
1147     Slider& sliderImpl( GetImpl( slider ) );
1148
1149     switch ( propertyIndex )
1150     {
1151       case Toolkit::Slider::Property::LOWER_BOUND:
1152       {
1153         sliderImpl.SetLowerBound( value.Get< float >() );
1154         break;
1155       }
1156
1157       case Toolkit::Slider::Property::UPPER_BOUND:
1158       {
1159         sliderImpl.SetUpperBound( value.Get< float >() );
1160         break;
1161       }
1162
1163       case Toolkit::Slider::Property::VALUE:
1164       {
1165         sliderImpl.SetValue( value.Get< float >() );
1166         break;
1167       }
1168
1169       case Toolkit::Slider::Property::TRACK_VISUAL:
1170       {
1171         Property::Map map;
1172         if( value.Get( map ) )
1173         {
1174           sliderImpl.SetTrackVisual( map );
1175         }
1176         break;
1177       }
1178
1179       case Toolkit::Slider::Property::HANDLE_VISUAL:
1180       {
1181         Property::Map map;
1182         if( value.Get( map ) )
1183         {
1184           sliderImpl.SetHandleVisual( map );
1185         }
1186         break;
1187       }
1188
1189       case Toolkit::Slider::Property::PROGRESS_VISUAL:
1190       {
1191         Property::Map map;
1192         if( value.Get( map ) )
1193         {
1194           sliderImpl.SetProgressVisual( map );
1195         }
1196         break;
1197       }
1198
1199       case Toolkit::Slider::Property::POPUP_VISUAL:
1200       {
1201         std::string imageUrl;
1202         if( value.Get( imageUrl ) )
1203         {
1204           sliderImpl.SetPopupVisual( imageUrl );
1205         }
1206
1207         // If it is not a string, then get a Property::Map from the property if possible.
1208         Property::Map map;
1209         if( value.Get( map ) )
1210         {
1211           sliderImpl.SetPopupVisual( map );
1212         }
1213
1214         break;
1215       }
1216
1217       case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
1218       {
1219         Property::Map map;
1220         if( value.Get( map ) )
1221         {
1222           sliderImpl.SetPopupArrowVisual( map );
1223         }
1224         break;
1225       }
1226
1227       case Toolkit::Slider::Property::DISABLED_COLOR:
1228       {
1229         sliderImpl.SetDisabledColor( value.Get< Vector4 >() );
1230         break;
1231       }
1232
1233       case Toolkit::Slider::Property::VALUE_PRECISION:
1234       {
1235         sliderImpl.SetValuePrecision( value.Get< int >() );
1236         break;
1237       }
1238
1239       case Toolkit::Slider::Property::SHOW_POPUP:
1240       {
1241         sliderImpl.SetShowPopup( value.Get< bool >() );
1242         break;
1243       }
1244
1245       case Toolkit::Slider::Property::SHOW_VALUE:
1246       {
1247         sliderImpl.SetShowValue( value.Get< bool >() );
1248         break;
1249       }
1250
1251       case Toolkit::Slider::Property::MARKS:
1252       {
1253         sliderImpl.SetMarks( value.Get< Property::Array >() );
1254         break;
1255       }
1256
1257       case Toolkit::Slider::Property::SNAP_TO_MARKS:
1258       {
1259         sliderImpl.SetSnapToMarks( value.Get< bool >() );
1260         break;
1261       }
1262
1263       case Toolkit::Slider::Property::MARK_TOLERANCE:
1264       {
1265         sliderImpl.SetMarkTolerance( value.Get< float >() );
1266         break;
1267       }
1268     }
1269   }
1270 }
1271
1272 Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
1273 {
1274   Property::Value value;
1275
1276   Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1277
1278   if ( slider )
1279   {
1280     Slider& sliderImpl( GetImpl( slider ) );
1281
1282     switch ( propertyIndex )
1283     {
1284       case Toolkit::Slider::Property::LOWER_BOUND:
1285       {
1286         value = sliderImpl.GetLowerBound();
1287         break;
1288       }
1289
1290       case Toolkit::Slider::Property::UPPER_BOUND:
1291       {
1292         value = sliderImpl.GetUpperBound();
1293         break;
1294       }
1295
1296       case Toolkit::Slider::Property::VALUE:
1297       {
1298         value = sliderImpl.GetValue();
1299         break;
1300       }
1301
1302       case Toolkit::Slider::Property::TRACK_VISUAL:
1303       {
1304         if( !sliderImpl.mTrackVisual.empty() )
1305         {
1306           value = sliderImpl.GetTrackVisual();
1307         }
1308         else if( !sliderImpl.mTrackMap.Empty() )
1309         {
1310           value = sliderImpl.mTrackMap;
1311         }
1312         break;
1313       }
1314
1315       case Toolkit::Slider::Property::HANDLE_VISUAL:
1316       {
1317         if( !sliderImpl.mHandleVisual.empty() )
1318         {
1319           value = sliderImpl.GetHandleVisual();
1320         }
1321         else if( !sliderImpl.mHandleMap.Empty() )
1322         {
1323           value = sliderImpl.mHandleMap;
1324         }
1325         break;
1326       }
1327
1328       case Toolkit::Slider::Property::PROGRESS_VISUAL:
1329       {
1330         if( !sliderImpl.mProgressVisual.empty() )
1331         {
1332           value = sliderImpl.GetProgressVisual();
1333         }
1334         else if( !sliderImpl.mProgressMap.Empty() )
1335         {
1336           value = sliderImpl.mProgressMap;
1337         }
1338         break;
1339       }
1340
1341       case Toolkit::Slider::Property::POPUP_VISUAL:
1342       {
1343         if( !sliderImpl.mPopupVisual.empty() )
1344         {
1345           value = sliderImpl.GetPopupVisual();
1346         }
1347         else if( !sliderImpl.mPopupMap.Empty() )
1348         {
1349           value = sliderImpl.mPopupMap;
1350         }
1351         break;
1352       }
1353
1354       case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
1355       {
1356         if( !sliderImpl.mPopupArrowVisual.empty() )
1357         {
1358           value = sliderImpl.GetPopupArrowVisual();
1359         }
1360         else if( !sliderImpl.mPopupArrowMap.Empty() )
1361         {
1362           value = sliderImpl.mPopupArrowMap;
1363         }
1364         break;
1365       }
1366
1367       case Toolkit::Slider::Property::DISABLED_COLOR:
1368       {
1369         value = sliderImpl.GetDisabledColor();
1370         break;
1371       }
1372
1373       case Toolkit::Slider::Property::VALUE_PRECISION:
1374       {
1375         value = sliderImpl.GetValuePrecision();
1376         break;
1377       }
1378
1379       case Toolkit::Slider::Property::SHOW_POPUP:
1380       {
1381         value = sliderImpl.GetShowPopup();
1382         break;
1383       }
1384
1385       case Toolkit::Slider::Property::SHOW_VALUE:
1386       {
1387         value = sliderImpl.GetShowValue();
1388         break;
1389       }
1390
1391       case Toolkit::Slider::Property::MARKS:
1392       {
1393         Property::Value value1( Property::ARRAY );
1394         Property::Array* markArray = value1.GetArray();
1395
1396         if( markArray )
1397         {
1398           *markArray = sliderImpl.GetMarks();
1399         }
1400
1401         value = value1;
1402         break;
1403       }
1404
1405       case Toolkit::Slider::Property::SNAP_TO_MARKS:
1406       {
1407         value = sliderImpl.GetSnapToMarks();
1408         break;
1409       }
1410
1411       case Toolkit::Slider::Property::MARK_TOLERANCE:
1412       {
1413         value = sliderImpl.GetMarkTolerance();
1414         break;
1415       }
1416     }
1417   }
1418
1419   return value;
1420 }
1421
1422 double Slider::AccessibleImpl::GetMinimum()
1423 {
1424   auto p = Toolkit::Slider::DownCast( self );
1425   return p.GetProperty( Toolkit::Slider::Property::LOWER_BOUND ).Get< float >();
1426 }
1427
1428 double Slider::AccessibleImpl::GetCurrent()
1429 {
1430   auto p = Toolkit::Slider::DownCast( self );
1431   return p.GetProperty( Toolkit::Slider::Property::VALUE ).Get< float >();
1432 }
1433
1434 double Slider::AccessibleImpl::GetMaximum()
1435 {
1436   auto p = Toolkit::Slider::DownCast( self );
1437   return p.GetProperty( Toolkit::Slider::Property::UPPER_BOUND ).Get< float >();
1438 }
1439
1440 bool Slider::AccessibleImpl::SetCurrent( double current )
1441 {
1442   if (current < GetMinimum() || current > GetMaximum())
1443     return false;
1444
1445   auto p = Toolkit::Slider::DownCast( self );
1446   auto &impl = Toolkit::GetImpl(p);
1447
1448   const float prev = p.GetProperty<float>(Toolkit::Slider::Property::VALUE);
1449   float next = static_cast<float>(current);
1450
1451   if (fabsf(next - prev) < Math::MACHINE_EPSILON_0)
1452   {
1453     // do nothing
1454   }
1455   else if (p.GetProperty<bool>(Toolkit::Slider::Property::SNAP_TO_MARKS))
1456   {
1457     auto marks = p.GetProperty<Property::Array>(Toolkit::Slider::Property::MARKS);
1458
1459     int prevIdx;
1460     if (impl.MarkReached(impl.MapValuePercentage(prev), prevIdx))
1461     {
1462       int nextIdx = prevIdx;
1463       nextIdx += (next > prev) ? 1 : -1;
1464
1465       if (nextIdx < 0 || nextIdx >= static_cast<int>(marks.Count()))
1466         return false;
1467
1468       next = marks[nextIdx].Get<float>();
1469     }
1470     else
1471     {
1472       next = impl.MapBounds(impl.SnapToMark(impl.MapValuePercentage(next)), impl.GetLowerBound(), impl.GetUpperBound());
1473     }
1474   }
1475   else
1476   {
1477     next = impl.MapBounds(impl.MarkFilter(impl.MapValuePercentage(next)), impl.GetLowerBound(), impl.GetUpperBound());
1478   }
1479
1480   impl.SetValue(next);
1481   impl.DisplayPopup(next);
1482
1483   return true;
1484 }
1485
1486 double Slider::AccessibleImpl::GetMinimumIncrement()
1487 {
1488   auto p = Toolkit::Slider::DownCast( self );
1489
1490   bool hasMarks = !p.GetProperty<Property::Array>(Toolkit::Slider::Property::MARKS).Empty();
1491   float tolerance = p.GetProperty<float>(Toolkit::Slider::Property::MARK_TOLERANCE);
1492
1493   if (!hasMarks || fabsf(tolerance) < 0.01)
1494     return 0.0; // let screen-reader choose the increment
1495
1496   return Math::MACHINE_EPSILON_10000 + tolerance * (GetMaximum() - GetMinimum());
1497 }
1498
1499 } // namespace Internal
1500
1501 } // namespace Toolkit
1502
1503 } // namespace Dali