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 = SnapToMark(value);
 851   if (fabsf(mark - value) < MARK_TOLERANCE)
 852     return mark;
 853
 854   return value;
 855 }
 856
 857 float Slider::SnapToMark( float value )
 858 {
 859   float closestMark = value;
 860   float closestDist = std::numeric_limits<float>::max();
 861
 862   float mark;
 863   for( MarkList::SizeType  i = 0; i < mMarks.Count(); ++i)
 864   {
 865     const Property::Value& propertyValue = mMarks[i];
 866     propertyValue.Get( mark );
 867     mark = MapValuePercentage( mark );
 868
 869     float dist = fabsf( mark - value );
 870     if( dist < closestDist )
 871     {
 872       closestDist = dist;
 873       closestMark = mark;
 874     }
 875   }
 876
 877   return closestMark;
 878 }
 879
 880 bool Slider::MarkReached( float value, int& outIndex )
 881 {
 882   const float MARK_TOLERANCE = GetMarkTolerance();
 883
 884   // Binary search
 885   int head = 0,
 886       tail = mMarks.Size() - 1;
 887   int current;
 888   float mark;
 889
 890   while( head <= tail )
 891   {
 892     current = head + ( tail - head ) / 2;
 893
 894     const Property::Value& propertyValue = mMarks[ current ];
 895     propertyValue.Get( mark );
 896     mark = MapValuePercentage( mark );
 897
 898     if( fabsf( mark - value ) < MARK_TOLERANCE )
 899     {
 900       outIndex = current;
 901       return true;
 902     }
 903
 904     if( value < mark )
 905     {
 906       tail = current - 1;
 907     }
 908     else
 909     {
 910       head = current + 1;
 911     }
 912   }
 913
 914   return false;
 915 }
 916
 917 bool Slider::HideValueView()
 918 {
 919   if( mValueDisplay )
 920   {
 921     mValueDisplay.SetProperty( Actor::Property::VISIBLE, false );
 922   }
 923
 924   return false;
 925 }
 926
 927 void Slider::SetLowerBound( float bound )
 928 {
 929   mLowerBound = bound;
 930   DisplayValue( GetValue(), false );
 931 }
 932
 933 float Slider::GetLowerBound() const
 934 {
 935   return mLowerBound;
 936 }
 937
 938 void Slider::SetUpperBound( float bound )
 939 {
 940   mUpperBound = bound;
 941   DisplayValue( GetValue(), false );
 942 }
 943
 944 float Slider::GetUpperBound() const
 945 {
 946   return mUpperBound;
 947 }
 948
 949 void Slider::SetValue( float value )
 950 {
 951   mValue = value;
 952   DisplayValue( mValue, true );
 953   if (Self() == Dali::Accessibility::Accessible::GetCurrentlyHighlightedActor())
 954   {
 955     Control::Impl::GetAccessibilityObject(Self())->Emit(Dali::Accessibility::ObjectPropertyChangeEvent::VALUE);
 956   }
 957 }
 958
 959 float Slider::GetValue() const
 960 {
 961   return mValue;
 962 }
 963
 964 void Slider::SetTrackRegion( const Vector2& region )
 965 {
 966   mTrackRegion = region;
 967
 968   if( mTrack )
 969   {
 970     mTrack.SetProperty( Actor::Property::SIZE, mTrackRegion );
 971   }
 972
 973   ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) );
 974
 975   mDomain = CalcDomain( mTrackRegion );
 976
 977   DisplayValue( GetValue(), false );  // Set the progress bar to correct width
 978 }
 979
 980 const Vector2& Slider::GetTrackRegion() const
 981 {
 982   return mTrackRegion;
 983 }
 984
 985 void Slider::SetHandleSize( const Vector2& size )
 986 {
 987   mHandleSize = size;
 988
 989   ResizeHandleSize( mHandleSize );
 990
 991   Vector2 hitRegion = GetHitRegion();
 992   hitRegion.x += mHandleSize.x;
 993   SetHitRegion( hitRegion );
 994 }
 995
 996 const Vector2& Slider::GetHandleSize() const
 997 {
 998   return mHandleSize;
 999 }
1000
1001 void Slider::SetDisabledColor( const Vector4& color )
1002 {
1003   mDisabledColor = color;
1004
1005   UpdateSkin();
1006 }
1007
1008 Vector4 Slider::GetDisabledColor() const
1009 {
1010   return mDisabledColor;
1011 }
1012
1013 void Slider::SetValuePrecision( int precision )
1014 {
1015   mValuePrecision = precision;
1016 }
1017
1018 int Slider::GetValuePrecision() const
1019 {
1020   return mValuePrecision;
1021 }
1022
1023 void Slider::SetShowPopup( bool showPopup )
1024 {
1025   mShowPopup = showPopup;
1026
1027   // Value display
1028   if( mShowPopup )
1029   {
1030     AddPopup();
1031   }
1032   else
1033   {
1034     RemovePopup();
1035   }
1036 }
1037
1038 bool Slider::GetShowPopup() const
1039 {
1040   return mShowPopup;
1041 }
1042
1043 void Slider::SetShowValue( bool showValue )
1044 {
1045   mShowValue = showValue;
1046
1047   if( mShowValue )
1048   {
1049     CreateHandleValueDisplay();
1050   }
1051   else
1052   {
1053     DestroyHandleValueDisplay();
1054   }
1055 }
1056
1057 bool Slider::GetShowValue() const
1058 {
1059   return mShowValue;
1060 }
1061
1062 void Slider::SetEnabled( bool enabled )
1063 {
1064   if( enabled )
1065   {
1066     mState = NORMAL;
1067   }
1068   else
1069   {
1070     mState = DISABLED;
1071   }
1072
1073   UpdateSkin();
1074 }
1075
1076 bool Slider::IsEnabled() const
1077 {
1078   return mState != DISABLED;
1079 }
1080
1081 void Slider::SetMarkTolerance( float tolerance )
1082 {
1083   mMarkTolerance = tolerance;
1084 }
1085
1086 float Slider::GetMarkTolerance() const
1087 {
1088   return mMarkTolerance;
1089 }
1090
1091 // Static class method to support script connecting signals
1092 bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
1093 {
1094   Dali::BaseHandle handle( object );
1095
1096   bool connected = true;
1097   Toolkit::Slider slider = Toolkit::Slider::DownCast( handle );
1098
1099   if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
1100   {
1101     slider.ValueChangedSignal().Connect( tracker, functor );
1102   }
1103   else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
1104   {
1105     slider.MarkReachedSignal().Connect( tracker, functor );
1106   }
1107   else
1108   {
1109     // signalName does not match any signal
1110     connected = false;
1111   }
1112
1113   return connected;
1114 }
1115
1116 void Slider::DisplayPopup( float value )
1117 {
1118   // Value displayDoConnectSignal
1119   if( mValueTextLabel )
1120   {
1121     std::stringstream ss;
1122     ss.precision( GetValuePrecision() );
1123     ss << std::fixed << value;
1124     mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
1125
1126     if( mValueDisplay )
1127     {
1128       mValueDisplay.SetProperty( Actor::Property::VISIBLE, true );
1129
1130       mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
1131     }
1132   }
1133 }
1134
1135 void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
1136 {
1137   Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1138
1139   if ( slider )
1140   {
1141     Slider& sliderImpl( GetImpl( slider ) );
1142
1143     switch ( propertyIndex )
1144     {
1145       case Toolkit::Slider::Property::LOWER_BOUND:
1146       {
1147         sliderImpl.SetLowerBound( value.Get< float >() );
1148         break;
1149       }
1150
1151       case Toolkit::Slider::Property::UPPER_BOUND:
1152       {
1153         sliderImpl.SetUpperBound( value.Get< float >() );
1154         break;
1155       }
1156
1157       case Toolkit::Slider::Property::VALUE:
1158       {
1159         sliderImpl.SetValue( value.Get< float >() );
1160         break;
1161       }
1162
1163       case Toolkit::Slider::Property::TRACK_VISUAL:
1164       {
1165         Property::Map map;
1166         if( value.Get( map ) )
1167         {
1168           sliderImpl.SetTrackVisual( map );
1169         }
1170         break;
1171       }
1172
1173       case Toolkit::Slider::Property::HANDLE_VISUAL:
1174       {
1175         Property::Map map;
1176         if( value.Get( map ) )
1177         {
1178           sliderImpl.SetHandleVisual( map );
1179         }
1180         break;
1181       }
1182
1183       case Toolkit::Slider::Property::PROGRESS_VISUAL:
1184       {
1185         Property::Map map;
1186         if( value.Get( map ) )
1187         {
1188           sliderImpl.SetProgressVisual( map );
1189         }
1190         break;
1191       }
1192
1193       case Toolkit::Slider::Property::POPUP_VISUAL:
1194       {
1195         std::string imageUrl;
1196         if( value.Get( imageUrl ) )
1197         {
1198           sliderImpl.SetPopupVisual( imageUrl );
1199         }
1200
1201         // If it is not a string, then get a Property::Map from the property if possible.
1202         Property::Map map;
1203         if( value.Get( map ) )
1204         {
1205           sliderImpl.SetPopupVisual( map );
1206         }
1207
1208         break;
1209       }
1210
1211       case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
1212       {
1213         Property::Map map;
1214         if( value.Get( map ) )
1215         {
1216           sliderImpl.SetPopupArrowVisual( map );
1217         }
1218         break;
1219       }
1220
1221       case Toolkit::Slider::Property::DISABLED_COLOR:
1222       {
1223         sliderImpl.SetDisabledColor( value.Get< Vector4 >() );
1224         break;
1225       }
1226
1227       case Toolkit::Slider::Property::VALUE_PRECISION:
1228       {
1229         sliderImpl.SetValuePrecision( value.Get< int >() );
1230         break;
1231       }
1232
1233       case Toolkit::Slider::Property::SHOW_POPUP:
1234       {
1235         sliderImpl.SetShowPopup( value.Get< bool >() );
1236         break;
1237       }
1238
1239       case Toolkit::Slider::Property::SHOW_VALUE:
1240       {
1241         sliderImpl.SetShowValue( value.Get< bool >() );
1242         break;
1243       }
1244
1245       case Toolkit::Slider::Property::MARKS:
1246       {
1247         sliderImpl.SetMarks( value.Get< Property::Array >() );
1248         break;
1249       }
1250
1251       case Toolkit::Slider::Property::SNAP_TO_MARKS:
1252       {
1253         sliderImpl.SetSnapToMarks( value.Get< bool >() );
1254         break;
1255       }
1256
1257       case Toolkit::Slider::Property::MARK_TOLERANCE:
1258       {
1259         sliderImpl.SetMarkTolerance( value.Get< float >() );
1260         break;
1261       }
1262     }
1263   }
1264 }
1265
1266 Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
1267 {
1268   Property::Value value;
1269
1270   Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1271
1272   if ( slider )
1273   {
1274     Slider& sliderImpl( GetImpl( slider ) );
1275
1276     switch ( propertyIndex )
1277     {
1278       case Toolkit::Slider::Property::LOWER_BOUND:
1279       {
1280         value = sliderImpl.GetLowerBound();
1281         break;
1282       }
1283
1284       case Toolkit::Slider::Property::UPPER_BOUND:
1285       {
1286         value = sliderImpl.GetUpperBound();
1287         break;
1288       }
1289
1290       case Toolkit::Slider::Property::VALUE:
1291       {
1292         value = sliderImpl.GetValue();
1293         break;
1294       }
1295
1296       case Toolkit::Slider::Property::TRACK_VISUAL:
1297       {
1298         if( !sliderImpl.mTrackVisual.empty() )
1299         {
1300           value = sliderImpl.GetTrackVisual();
1301         }
1302         else if( !sliderImpl.mTrackMap.Empty() )
1303         {
1304           value = sliderImpl.mTrackMap;
1305         }
1306         break;
1307       }
1308
1309       case Toolkit::Slider::Property::HANDLE_VISUAL:
1310       {
1311         if( !sliderImpl.mHandleVisual.empty() )
1312         {
1313           value = sliderImpl.GetHandleVisual();
1314         }
1315         else if( !sliderImpl.mHandleMap.Empty() )
1316         {
1317           value = sliderImpl.mHandleMap;
1318         }
1319         break;
1320       }
1321
1322       case Toolkit::Slider::Property::PROGRESS_VISUAL:
1323       {
1324         if( !sliderImpl.mProgressVisual.empty() )
1325         {
1326           value = sliderImpl.GetProgressVisual();
1327         }
1328         else if( !sliderImpl.mProgressMap.Empty() )
1329         {
1330           value = sliderImpl.mProgressMap;
1331         }
1332         break;
1333       }
1334
1335       case Toolkit::Slider::Property::POPUP_VISUAL:
1336       {
1337         if( !sliderImpl.mPopupVisual.empty() )
1338         {
1339           value = sliderImpl.GetPopupVisual();
1340         }
1341         else if( !sliderImpl.mPopupMap.Empty() )
1342         {
1343           value = sliderImpl.mPopupMap;
1344         }
1345         break;
1346       }
1347
1348       case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
1349       {
1350         if( !sliderImpl.mPopupArrowVisual.empty() )
1351         {
1352           value = sliderImpl.GetPopupArrowVisual();
1353         }
1354         else if( !sliderImpl.mPopupArrowMap.Empty() )
1355         {
1356           value = sliderImpl.mPopupArrowMap;
1357         }
1358         break;
1359       }
1360
1361       case Toolkit::Slider::Property::DISABLED_COLOR:
1362       {
1363         value = sliderImpl.GetDisabledColor();
1364         break;
1365       }
1366
1367       case Toolkit::Slider::Property::VALUE_PRECISION:
1368       {
1369         value = sliderImpl.GetValuePrecision();
1370         break;
1371       }
1372
1373       case Toolkit::Slider::Property::SHOW_POPUP:
1374       {
1375         value = sliderImpl.GetShowPopup();
1376         break;
1377       }
1378
1379       case Toolkit::Slider::Property::SHOW_VALUE:
1380       {
1381         value = sliderImpl.GetShowValue();
1382         break;
1383       }
1384
1385       case Toolkit::Slider::Property::MARKS:
1386       {
1387         Property::Value value1( Property::ARRAY );
1388         Property::Array* markArray = value1.GetArray();
1389
1390         if( markArray )
1391         {
1392           *markArray = sliderImpl.GetMarks();
1393         }
1394
1395         value = value1;
1396         break;
1397       }
1398
1399       case Toolkit::Slider::Property::SNAP_TO_MARKS:
1400       {
1401         value = sliderImpl.GetSnapToMarks();
1402         break;
1403       }
1404
1405       case Toolkit::Slider::Property::MARK_TOLERANCE:
1406       {
1407         value = sliderImpl.GetMarkTolerance();
1408         break;
1409       }
1410     }
1411   }
1412
1413   return value;
1414 }
1415
1416 double Slider::AccessibleImpl::GetMinimum()
1417 {
1418   auto p = Toolkit::Slider::DownCast( self );
1419   return p.GetProperty( Toolkit::Slider::Property::LOWER_BOUND ).Get< float >();
1420 }
1421
1422 double Slider::AccessibleImpl::GetCurrent()
1423 {
1424   auto p = Toolkit::Slider::DownCast( self );
1425   return p.GetProperty( Toolkit::Slider::Property::VALUE ).Get< float >();
1426 }
1427
1428 double Slider::AccessibleImpl::GetMaximum()
1429 {
1430   auto p = Toolkit::Slider::DownCast( self );
1431   return p.GetProperty( Toolkit::Slider::Property::UPPER_BOUND ).Get< float >();
1432 }
1433
1434 bool Slider::AccessibleImpl::SetCurrent( double current )
1435 {
1436   if (current < GetMinimum() || current > GetMaximum())
1437     return false;
1438
1439   auto p = Toolkit::Slider::DownCast( self );
1440   auto &impl = Toolkit::GetImpl(p);
1441
1442   const float prev = p.GetProperty<float>(Toolkit::Slider::Property::VALUE);
1443   float next = static_cast<float>(current);
1444
1445   if (fabsf(next - prev) < Math::MACHINE_EPSILON_0)
1446   {
1447     // do nothing
1448   }
1449   else if (p.GetProperty<bool>(Toolkit::Slider::Property::SNAP_TO_MARKS))
1450   {
1451     auto marks = p.GetProperty<Property::Array>(Toolkit::Slider::Property::MARKS);
1452
1453     int prevIdx;
1454     if (impl.MarkReached(impl.MapValuePercentage(prev), prevIdx))
1455     {
1456       int nextIdx = prevIdx;
1457       nextIdx += (next > prev) ? 1 : -1;
1458
1459       if (nextIdx < 0 || nextIdx >= static_cast<int>(marks.Count()))
1460         return false;
1461
1462       next = marks[nextIdx].Get<float>();
1463     }
1464     else
1465     {
1466       next = impl.MapBounds(impl.SnapToMark(impl.MapValuePercentage(next)), impl.GetLowerBound(), impl.GetUpperBound());
1467     }
1468   }
1469   else
1470   {
1471     next = impl.MapBounds(impl.MarkFilter(impl.MapValuePercentage(next)), impl.GetLowerBound(), impl.GetUpperBound());
1472   }
1473
1474   impl.SetValue(next);
1475   impl.DisplayPopup(next);
1476
1477   return true;
1478 }
1479
1480 double Slider::AccessibleImpl::GetMinimumIncrement()
1481 {
1482   auto p = Toolkit::Slider::DownCast( self );
1483
1484   bool hasMarks = !p.GetProperty<Property::Array>(Toolkit::Slider::Property::MARKS).Empty();
1485   float tolerance = p.GetProperty<float>(Toolkit::Slider::Property::MARK_TOLERANCE);
1486
1487   if (!hasMarks || fabsf(tolerance) < 0.01)
1488     return 0.0; // let screen-reader choose the increment
1489
1490   return Math::MACHINE_EPSILON_10000 + tolerance * (GetMaximum() - GetMinimum());
1491 }
1492
1493 } // namespace Internal
1494
1495 } // namespace Toolkit
1496
1497 } // namespace Dali