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

   1 /*
   2  * Copyright (c) 2024 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 <dali/public-api/events/touch-event.h>
  23 #include <dali/public-api/object/type-registry-helper.h>
  24 #include <dali/public-api/object/type-registry.h>
  25 #include <cstring> // for strcmp
  26 #include <limits>
  27 #include <sstream>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
  31 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
  32 #include <dali-toolkit/public-api/controls/control-impl.h>
  33 #include <dali-toolkit/public-api/controls/image-view/image-view.h>
  34 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  35
  36 using namespace Dali;
  37
  38 namespace Dali
  39 {
  40 namespace Toolkit
  41 {
  42 namespace Internal
  43 {
  44 namespace // Unnamed namespace
  45 {
  46 BaseHandle Create()
  47 {
  48   return Dali::Toolkit::Slider::New();
  49 }
  50
  51 // clang-format off
  52 // Setup properties, signals and actions using the type-registry.
  53 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::Slider, Toolkit::Control, Create )
  54
  55 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "lowerBound",       FLOAT,    LOWER_BOUND       )
  56 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "upperBound",       FLOAT,    UPPER_BOUND       )
  57 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "value",            FLOAT,    VALUE             )
  58 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "trackVisual",      MAP,      TRACK_VISUAL      )
  59 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "handleVisual",     MAP,      HANDLE_VISUAL     )
  60 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "progressVisual",   MAP,      PROGRESS_VISUAL   )
  61 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "popupVisual",      MAP,      POPUP_VISUAL      )
  62 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "popupArrowVisual", MAP,      POPUP_ARROW_VISUAL)
  63 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "disabledColor",    VECTOR4,  DISABLED_COLOR    )
  64 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "valuePrecision",   INTEGER,  VALUE_PRECISION   )
  65 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "showPopup",        BOOLEAN,  SHOW_POPUP        )
  66 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "showValue",        BOOLEAN,  SHOW_VALUE        )
  67 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "marks",            ARRAY,    MARKS             )
  68 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "snapToMarks",      BOOLEAN,  SNAP_TO_MARKS     )
  69 DALI_PROPERTY_REGISTRATION(Toolkit, Slider, "markTolerance",    FLOAT,    MARK_TOLERANCE    )
  70
  71 DALI_SIGNAL_REGISTRATION(Toolkit, Slider, "valueChanged", SIGNAL_VALUE_CHANGED)
  72 DALI_SIGNAL_REGISTRATION(Toolkit, Slider, "mark",         SIGNAL_MARK         )
  73
  74 DALI_TYPE_REGISTRATION_END()
  75 // clang-format on
  76
  77 const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width
  78
  79 const int VALUE_VIEW_SHOW_DURATION      = 1000; // millisec
  80 const int VALUE_VIEW_SHOW_DURATION_LONG = 2000; // millisec
  81
  82 const float VALUE_VERTICAL_OFFSET = 48.0f;
  83
  84 const float DEFAULT_WIDTH         = 0.0f;
  85 const float DEFAULT_HEIGHT        = 27.0f;
  86 const float DEFAULT_HIT_HEIGHT    = 72.0f;
  87 const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT;
  88 const float POPUP_TEXT_PADDING    = 10.0f;
  89
  90 const char* SKINNED_TRACK_VISUAL_FILE_NAME       = "slider-skin.9.png";
  91 const char* SKINNED_HANDLE_VISUAL_FILE_NAME      = "slider-skin-handle.png";
  92 const char* SKINNED_PROGRESS_VISUAL_FILE_NAME    = "slider-skin-progress.9.png";
  93 const char* SKINNED_POPUP_VISUAL_FILE_NAME       = "slider-popup.9.png";
  94 const char* SKINNED_POPUP_ARROW_VISUAL_FILE_NAME = "slider-popup-arrow.png";
  95
  96 const Vector2 DEFAULT_HIT_REGION(DEFAULT_WIDTH, DEFAULT_HIT_HEIGHT);
  97 const Vector2 DEFAULT_TRACK_REGION(DEFAULT_WIDTH, DEFAULT_HEIGHT);
  98 const Vector2 DEFAULT_HANDLE_SIZE(DEFAULT_HANDLE_HEIGHT, DEFAULT_HANDLE_HEIGHT);
  99
 100 const Vector4 DEFAULT_DISABLED_COLOR(0.5f, 0.5f, 0.5f, 1.0f);
 101
 102 const float VALUE_POPUP_MARGIN    = 10.0f;
 103 const float VALUE_POPUP_HEIGHT    = 81.0f;
 104 const float VALUE_POPUP_MIN_WIDTH = 54.0f;
 105
 106 const float DEFAULT_LOWER_BOUND     = 0.0f;
 107 const float DEFAULT_UPPER_BOUND     = 1.0f;
 108 const float DEFAULT_VALUE           = 0.0f;
 109 const int   DEFAULT_VALUE_PRECISION = 0;
 110 const bool  DEFAULT_SHOW_POPUP      = false;
 111 const bool  DEFAULT_SHOW_VALUE      = true;
 112 const bool  DEFAULT_ENABLED         = true;
 113 const bool  DEFAULT_SNAP_TO_MARKS   = false;
 114
 115 } // Unnamed namespace
 116
 117 ///////////////////////////////////////////////////////////////////////////////////////////////////
 118 // Slider
 119 ///////////////////////////////////////////////////////////////////////////////////////////////////
 120
 121 Dali::Toolkit::Slider Slider::New()
 122 {
 123   // Create the implementation
 124   SliderPtr slider(new Slider());
 125
 126   // Pass ownership to CustomActor via derived handle
 127   Dali::Toolkit::Slider handle(*slider);
 128
 129   // Second-phase init of the implementation
 130   // This can only be done after the CustomActor connection has been made...
 131   slider->Initialize();
 132
 133   return handle;
 134 }
 135
 136 Slider::Slider()
 137 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
 138   mState(NORMAL),
 139   mPopupVisual(""),
 140   mPopupArrowVisual(""),
 141   mTrackVisual(""),
 142   mHandleVisual(""),
 143   mProgressVisual(""),
 144   mPopupMap(),
 145   mTrackMap(),
 146   mHandleMap(),
 147   mPopupArrowMap(),
 148   mDisabledColor(0.0f, 0.0f, 0.0f, 0.0f),
 149   mHitRegion(0.0f, 0.0f),
 150   mTrackRegion(0.0f, 0.0f),
 151   mHandleSize(0.0f, 0.0f),
 152   mLowerBound(0.0f),
 153   mUpperBound(0.0f),
 154   mValue(0.0f),
 155   mMarkTolerance(0.0f),
 156   mValuePrecision(0),
 157   mShowPopup(false),
 158   mShowValue(false),
 159   mSnapToMarks(false)
 160 {
 161 }
 162
 163 Slider::~Slider()
 164 {
 165 }
 166
 167 void Slider::OnInitialize()
 168 {
 169   // Setup
 170   CreateChildren();
 171
 172   // Properties
 173   Actor self = Self();
 174
 175   SetHitRegion(DEFAULT_HIT_REGION);
 176   SetTrackRegion(DEFAULT_TRACK_REGION);
 177   SetHandleSize(DEFAULT_HANDLE_SIZE);
 178
 179   const std::string imageDirPath = AssetManager::GetDaliImagePath();
 180   SetTrackVisual(imageDirPath + SKINNED_TRACK_VISUAL_FILE_NAME);
 181   SetHandleVisual(imageDirPath + SKINNED_HANDLE_VISUAL_FILE_NAME);
 182   SetProgressVisual(imageDirPath + SKINNED_PROGRESS_VISUAL_FILE_NAME);
 183   SetPopupVisual(imageDirPath + SKINNED_POPUP_VISUAL_FILE_NAME);
 184   SetPopupArrowVisual(imageDirPath + SKINNED_POPUP_ARROW_VISUAL_FILE_NAME);
 185
 186   SetShowPopup(DEFAULT_SHOW_POPUP);
 187   SetShowValue(DEFAULT_SHOW_VALUE);
 188
 189   SetEnabled(DEFAULT_ENABLED);
 190   SetDisabledColor(DEFAULT_DISABLED_COLOR);
 191
 192   SetSnapToMarks(DEFAULT_SNAP_TO_MARKS);
 193   SetMarkTolerance(MARK_SNAP_TOLERANCE);
 194
 195   SetLowerBound(DEFAULT_LOWER_BOUND);
 196   SetUpperBound(DEFAULT_UPPER_BOUND);
 197   UpdateSkin();
 198   SetValuePrecision(DEFAULT_VALUE_PRECISION);
 199   mValue = DEFAULT_VALUE;
 200   DisplayValue(mValue, false); // Run this last to display the correct value
 201
 202   // Size the Slider actor to a default
 203   self.SetProperty(Actor::Property::SIZE, Vector2(DEFAULT_HIT_REGION.x, DEFAULT_HIT_REGION.y));
 204
 205   // Connect to the touch signal
 206   self.TouchedSignal().Connect(this, &Slider::OnTouch);
 207
 208   // Accessibility
 209   self.SetProperty(DevelControl::Property::ACCESSIBILITY_ROLE, Dali::Accessibility::Role::SLIDER);
 210   self.SetProperty(DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true);
 211 }
 212
 213 DevelControl::ControlAccessible* Slider::CreateAccessibleObject()
 214 {
 215   return new SliderAccessible(Self());
 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 float Slider::MarkFilter(float value)
 846 {
 847   const float MARK_TOLERANCE = GetMarkTolerance();
 848
 849   float mark = SnapToMark(value);
 850   if(fabsf(mark - value) < MARK_TOLERANCE)
 851     return mark;
 852
 853   return value;
 854 }
 855
 856 float Slider::SnapToMark(float value)
 857 {
 858   float closestMark = value;
 859   float closestDist = std::numeric_limits<float>::max();
 860
 861   float mark;
 862   for(MarkList::SizeType i = 0; i < mMarks.Count(); ++i)
 863   {
 864     const Property::Value& propertyValue = mMarks[i];
 865     if(propertyValue.Get(mark))
 866     {
 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
 878   return closestMark;
 879 }
 880
 881 bool Slider::MarkReached(float value, int& outIndex)
 882 {
 883   const float MARK_TOLERANCE = GetMarkTolerance();
 884
 885   // Binary search
 886   int head = 0,
 887       tail = mMarks.Size() - 1;
 888   int   current;
 889   float mark;
 890
 891   while(head <= tail)
 892   {
 893     current = head + (tail - head) / 2;
 894
 895     const Property::Value& propertyValue = mMarks[current];
 896     if(propertyValue.Get(mark))
 897     {
 898       mark = MapValuePercentage(mark);
 899
 900       if(fabsf(mark - value) < MARK_TOLERANCE)
 901       {
 902         outIndex = current;
 903         return true;
 904       }
 905
 906       if(value < mark)
 907       {
 908         tail = current - 1;
 909       }
 910       else
 911       {
 912         head = current + 1;
 913       }
 914     }
 915   }
 916
 917   return false;
 918 }
 919
 920 bool Slider::HideValueView()
 921 {
 922   if(mValueDisplay)
 923   {
 924     mValueDisplay.SetProperty(Actor::Property::VISIBLE, false);
 925   }
 926
 927   return false;
 928 }
 929
 930 void Slider::SetLowerBound(float bound)
 931 {
 932   mLowerBound = bound;
 933   DisplayValue(GetValue(), false);
 934 }
 935
 936 float Slider::GetLowerBound() const
 937 {
 938   return mLowerBound;
 939 }
 940
 941 void Slider::SetUpperBound(float bound)
 942 {
 943   mUpperBound = bound;
 944   DisplayValue(GetValue(), false);
 945 }
 946
 947 float Slider::GetUpperBound() const
 948 {
 949   return mUpperBound;
 950 }
 951
 952 void Slider::SetValue(float value)
 953 {
 954   mValue = value;
 955   DisplayValue(mValue, true);
 956
 957   auto accessible = GetAccessibleObject();
 958   if(DALI_LIKELY(accessible) && accessible->IsHighlighted())
 959   {
 960     accessible->Emit(Dali::Accessibility::ObjectPropertyChangeEvent::VALUE);
 961   }
 962 }
 963
 964 float Slider::GetValue() const
 965 {
 966   return mValue;
 967 }
 968
 969 void Slider::SetTrackRegion(const Vector2& region)
 970 {
 971   mTrackRegion = region;
 972
 973   if(mTrack)
 974   {
 975     mTrack.SetProperty(Actor::Property::SIZE, mTrackRegion);
 976   }
 977
 978   ResizeProgressRegion(Vector2(0.0f, mTrackRegion.y));
 979
 980   mDomain = CalcDomain(mTrackRegion);
 981
 982   DisplayValue(GetValue(), false); // Set the progress bar to correct width
 983 }
 984
 985 const Vector2& Slider::GetTrackRegion() const
 986 {
 987   return mTrackRegion;
 988 }
 989
 990 void Slider::SetHandleSize(const Vector2& size)
 991 {
 992   mHandleSize = size;
 993
 994   ResizeHandleSize(mHandleSize);
 995
 996   Vector2 hitRegion = GetHitRegion();
 997   hitRegion.x += mHandleSize.x;
 998   SetHitRegion(hitRegion);
 999 }
1000
1001 const Vector2& Slider::GetHandleSize() const
1002 {
1003   return mHandleSize;
1004 }
1005
1006 void Slider::SetDisabledColor(const Vector4& color)
1007 {
1008   mDisabledColor = color;
1009
1010   UpdateSkin();
1011 }
1012
1013 Vector4 Slider::GetDisabledColor() const
1014 {
1015   return mDisabledColor;
1016 }
1017
1018 void Slider::SetValuePrecision(int precision)
1019 {
1020   mValuePrecision = precision;
1021 }
1022
1023 int Slider::GetValuePrecision() const
1024 {
1025   return mValuePrecision;
1026 }
1027
1028 void Slider::SetShowPopup(bool showPopup)
1029 {
1030   mShowPopup = showPopup;
1031
1032   // Value display
1033   if(mShowPopup)
1034   {
1035     AddPopup();
1036   }
1037   else
1038   {
1039     RemovePopup();
1040   }
1041 }
1042
1043 bool Slider::GetShowPopup() const
1044 {
1045   return mShowPopup;
1046 }
1047
1048 void Slider::SetShowValue(bool showValue)
1049 {
1050   mShowValue = showValue;
1051
1052   if(mShowValue)
1053   {
1054     CreateHandleValueDisplay();
1055   }
1056   else
1057   {
1058     DestroyHandleValueDisplay();
1059   }
1060 }
1061
1062 bool Slider::GetShowValue() const
1063 {
1064   return mShowValue;
1065 }
1066
1067 void Slider::SetEnabled(bool enabled)
1068 {
1069   if(enabled)
1070   {
1071     mState = NORMAL;
1072   }
1073   else
1074   {
1075     mState = DISABLED;
1076   }
1077
1078   UpdateSkin();
1079 }
1080
1081 bool Slider::IsEnabled() const
1082 {
1083   return mState != DISABLED;
1084 }
1085
1086 void Slider::SetMarkTolerance(float tolerance)
1087 {
1088   mMarkTolerance = tolerance;
1089 }
1090
1091 float Slider::GetMarkTolerance() const
1092 {
1093   return mMarkTolerance;
1094 }
1095
1096 // Static class method to support script connecting signals
1097 bool Slider::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor)
1098 {
1099   Dali::BaseHandle handle(object);
1100
1101   bool            connected = true;
1102   Toolkit::Slider slider    = Toolkit::Slider::DownCast(handle);
1103
1104   if(0 == strcmp(signalName.c_str(), SIGNAL_VALUE_CHANGED))
1105   {
1106     slider.ValueChangedSignal().Connect(tracker, functor);
1107   }
1108   else if(0 == strcmp(signalName.c_str(), SIGNAL_MARK))
1109   {
1110     slider.MarkReachedSignal().Connect(tracker, functor);
1111   }
1112   else
1113   {
1114     // signalName does not match any signal
1115     connected = false;
1116   }
1117
1118   return connected;
1119 }
1120
1121 void Slider::DisplayPopup(float value)
1122 {
1123   // Value displayDoConnectSignal
1124   if(mValueTextLabel)
1125   {
1126     std::stringstream ss;
1127     ss.precision(GetValuePrecision());
1128     ss << std::fixed << value;
1129     mValueTextLabel.SetProperty(Toolkit::TextLabel::Property::TEXT, ss.str());
1130
1131     if(mValueDisplay)
1132     {
1133       mValueDisplay.SetProperty(Actor::Property::VISIBLE, true);
1134
1135       mValueTimer.SetInterval(VALUE_VIEW_SHOW_DURATION);
1136     }
1137   }
1138 }
1139
1140 void Slider::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
1141 {
1142   Toolkit::Slider slider = Toolkit::Slider::DownCast(Dali::BaseHandle(object));
1143
1144   if(slider)
1145   {
1146     Slider& sliderImpl(GetImpl(slider));
1147
1148     switch(propertyIndex)
1149     {
1150       case Toolkit::Slider::Property::LOWER_BOUND:
1151       {
1152         sliderImpl.SetLowerBound(value.Get<float>());
1153         break;
1154       }
1155
1156       case Toolkit::Slider::Property::UPPER_BOUND:
1157       {
1158         sliderImpl.SetUpperBound(value.Get<float>());
1159         break;
1160       }
1161
1162       case Toolkit::Slider::Property::VALUE:
1163       {
1164         sliderImpl.SetValue(value.Get<float>());
1165         break;
1166       }
1167
1168       case Toolkit::Slider::Property::TRACK_VISUAL:
1169       {
1170         Property::Map map;
1171         if(value.Get(map))
1172         {
1173           sliderImpl.SetTrackVisual(map);
1174         }
1175         break;
1176       }
1177
1178       case Toolkit::Slider::Property::HANDLE_VISUAL:
1179       {
1180         Property::Map map;
1181         if(value.Get(map))
1182         {
1183           sliderImpl.SetHandleVisual(map);
1184         }
1185         break;
1186       }
1187
1188       case Toolkit::Slider::Property::PROGRESS_VISUAL:
1189       {
1190         Property::Map map;
1191         if(value.Get(map))
1192         {
1193           sliderImpl.SetProgressVisual(map);
1194         }
1195         break;
1196       }
1197
1198       case Toolkit::Slider::Property::POPUP_VISUAL:
1199       {
1200         std::string imageUrl;
1201         if(value.Get(imageUrl))
1202         {
1203           sliderImpl.SetPopupVisual(imageUrl);
1204         }
1205
1206         // If it is not a string, then get a Property::Map from the property if possible.
1207         Property::Map map;
1208         if(value.Get(map))
1209         {
1210           sliderImpl.SetPopupVisual(map);
1211         }
1212
1213         break;
1214       }
1215
1216       case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
1217       {
1218         Property::Map map;
1219         if(value.Get(map))
1220         {
1221           sliderImpl.SetPopupArrowVisual(map);
1222         }
1223         break;
1224       }
1225
1226       case Toolkit::Slider::Property::DISABLED_COLOR:
1227       {
1228         sliderImpl.SetDisabledColor(value.Get<Vector4>());
1229         break;
1230       }
1231
1232       case Toolkit::Slider::Property::VALUE_PRECISION:
1233       {
1234         sliderImpl.SetValuePrecision(value.Get<int>());
1235         break;
1236       }
1237
1238       case Toolkit::Slider::Property::SHOW_POPUP:
1239       {
1240         sliderImpl.SetShowPopup(value.Get<bool>());
1241         break;
1242       }
1243
1244       case Toolkit::Slider::Property::SHOW_VALUE:
1245       {
1246         sliderImpl.SetShowValue(value.Get<bool>());
1247         break;
1248       }
1249
1250       case Toolkit::Slider::Property::MARKS:
1251       {
1252         sliderImpl.SetMarks(value.Get<Property::Array>());
1253         break;
1254       }
1255
1256       case Toolkit::Slider::Property::SNAP_TO_MARKS:
1257       {
1258         sliderImpl.SetSnapToMarks(value.Get<bool>());
1259         break;
1260       }
1261
1262       case Toolkit::Slider::Property::MARK_TOLERANCE:
1263       {
1264         sliderImpl.SetMarkTolerance(value.Get<float>());
1265         break;
1266       }
1267     }
1268   }
1269 }
1270
1271 Property::Value Slider::GetProperty(BaseObject* object, Property::Index propertyIndex)
1272 {
1273   Property::Value value;
1274
1275   Toolkit::Slider slider = Toolkit::Slider::DownCast(Dali::BaseHandle(object));
1276
1277   if(slider)
1278   {
1279     Slider& sliderImpl(GetImpl(slider));
1280
1281     switch(propertyIndex)
1282     {
1283       case Toolkit::Slider::Property::LOWER_BOUND:
1284       {
1285         value = sliderImpl.GetLowerBound();
1286         break;
1287       }
1288
1289       case Toolkit::Slider::Property::UPPER_BOUND:
1290       {
1291         value = sliderImpl.GetUpperBound();
1292         break;
1293       }
1294
1295       case Toolkit::Slider::Property::VALUE:
1296       {
1297         value = sliderImpl.GetValue();
1298         break;
1299       }
1300
1301       case Toolkit::Slider::Property::TRACK_VISUAL:
1302       {
1303         if(!sliderImpl.mTrackVisual.empty())
1304         {
1305           value = sliderImpl.GetTrackVisual();
1306         }
1307         else if(!sliderImpl.mTrackMap.Empty())
1308         {
1309           value = sliderImpl.mTrackMap;
1310         }
1311         break;
1312       }
1313
1314       case Toolkit::Slider::Property::HANDLE_VISUAL:
1315       {
1316         if(!sliderImpl.mHandleVisual.empty())
1317         {
1318           value = sliderImpl.GetHandleVisual();
1319         }
1320         else if(!sliderImpl.mHandleMap.Empty())
1321         {
1322           value = sliderImpl.mHandleMap;
1323         }
1324         break;
1325       }
1326
1327       case Toolkit::Slider::Property::PROGRESS_VISUAL:
1328       {
1329         if(!sliderImpl.mProgressVisual.empty())
1330         {
1331           value = sliderImpl.GetProgressVisual();
1332         }
1333         else if(!sliderImpl.mProgressMap.Empty())
1334         {
1335           value = sliderImpl.mProgressMap;
1336         }
1337         break;
1338       }
1339
1340       case Toolkit::Slider::Property::POPUP_VISUAL:
1341       {
1342         if(!sliderImpl.mPopupVisual.empty())
1343         {
1344           value = sliderImpl.GetPopupVisual();
1345         }
1346         else if(!sliderImpl.mPopupMap.Empty())
1347         {
1348           value = sliderImpl.mPopupMap;
1349         }
1350         break;
1351       }
1352
1353       case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
1354       {
1355         if(!sliderImpl.mPopupArrowVisual.empty())
1356         {
1357           value = sliderImpl.GetPopupArrowVisual();
1358         }
1359         else if(!sliderImpl.mPopupArrowMap.Empty())
1360         {
1361           value = sliderImpl.mPopupArrowMap;
1362         }
1363         break;
1364       }
1365
1366       case Toolkit::Slider::Property::DISABLED_COLOR:
1367       {
1368         value = sliderImpl.GetDisabledColor();
1369         break;
1370       }
1371
1372       case Toolkit::Slider::Property::VALUE_PRECISION:
1373       {
1374         value = sliderImpl.GetValuePrecision();
1375         break;
1376       }
1377
1378       case Toolkit::Slider::Property::SHOW_POPUP:
1379       {
1380         value = sliderImpl.GetShowPopup();
1381         break;
1382       }
1383
1384       case Toolkit::Slider::Property::SHOW_VALUE:
1385       {
1386         value = sliderImpl.GetShowValue();
1387         break;
1388       }
1389
1390       case Toolkit::Slider::Property::MARKS:
1391       {
1392         Property::Value  value1(Property::ARRAY);
1393         Property::Array* markArray = value1.GetArray();
1394
1395         if(markArray)
1396         {
1397           *markArray = sliderImpl.GetMarks();
1398         }
1399
1400         value = value1;
1401         break;
1402       }
1403
1404       case Toolkit::Slider::Property::SNAP_TO_MARKS:
1405       {
1406         value = sliderImpl.GetSnapToMarks();
1407         break;
1408       }
1409
1410       case Toolkit::Slider::Property::MARK_TOLERANCE:
1411       {
1412         value = sliderImpl.GetMarkTolerance();
1413         break;
1414       }
1415     }
1416   }
1417
1418   return value;
1419 }
1420
1421 double Slider::SliderAccessible::GetMinimum() const
1422 {
1423   auto self = Toolkit::Slider::DownCast(Self());
1424   return self.GetProperty(Toolkit::Slider::Property::LOWER_BOUND).Get<float>();
1425 }
1426
1427 double Slider::SliderAccessible::GetCurrent() const
1428 {
1429   auto self = Toolkit::Slider::DownCast(Self());
1430   return self.GetProperty(Toolkit::Slider::Property::VALUE).Get<float>();
1431 }
1432
1433 std::string Slider::SliderAccessible::GetValueText() const
1434 {
1435   return {}; // Text mode is not used at the moment
1436 }
1437
1438 double Slider::SliderAccessible::GetMaximum() const
1439 {
1440   auto self = Toolkit::Slider::DownCast(Self());
1441   return self.GetProperty(Toolkit::Slider::Property::UPPER_BOUND).Get<float>();
1442 }
1443
1444 bool Slider::SliderAccessible::SetCurrent(double current)
1445 {
1446   if(current < GetMinimum() || current > GetMaximum())
1447     return false;
1448
1449   auto  self = Toolkit::Slider::DownCast(Self());
1450   auto& impl = Toolkit::GetImpl(self);
1451
1452   const float prev = self.GetProperty<float>(Toolkit::Slider::Property::VALUE);
1453   float       next = static_cast<float>(current);
1454
1455   if(fabsf(next - prev) < Math::MACHINE_EPSILON_0)
1456   {
1457     // do nothing
1458   }
1459   else if(self.GetProperty<bool>(Toolkit::Slider::Property::SNAP_TO_MARKS))
1460   {
1461     auto marks = self.GetProperty<Property::Array>(Toolkit::Slider::Property::MARKS);
1462
1463     int prevIdx;
1464     if(impl.MarkReached(impl.MapValuePercentage(prev), prevIdx))
1465     {
1466       int nextIdx = prevIdx;
1467       nextIdx += (next > prev) ? 1 : -1;
1468
1469       if(nextIdx < 0 || nextIdx >= static_cast<int>(marks.Count()))
1470       {
1471         return false;
1472       }
1473
1474       next = marks[nextIdx].Get<float>();
1475     }
1476     else
1477     {
1478       next = impl.MapBounds(impl.SnapToMark(impl.MapValuePercentage(next)), impl.GetLowerBound(), impl.GetUpperBound());
1479     }
1480   }
1481   else
1482   {
1483     next = impl.MapBounds(impl.MarkFilter(impl.MapValuePercentage(next)), impl.GetLowerBound(), impl.GetUpperBound());
1484   }
1485
1486   impl.SetValue(next);
1487   impl.DisplayPopup(next);
1488
1489   return true;
1490 }
1491
1492 double Slider::SliderAccessible::GetMinimumIncrement() const
1493 {
1494   auto self = Toolkit::Slider::DownCast(Self());
1495
1496   bool  hasMarks  = !self.GetProperty<Property::Array>(Toolkit::Slider::Property::MARKS).Empty();
1497   float tolerance = self.GetProperty<float>(Toolkit::Slider::Property::MARK_TOLERANCE);
1498
1499   if(!hasMarks || fabsf(tolerance) < 0.01)
1500   {
1501     return 0.0; // let screen-reader choose the increment
1502   }
1503
1504   return Math::MACHINE_EPSILON_10000 + tolerance * (GetMaximum() - GetMinimum());
1505 }
1506
1507 } // namespace Internal
1508
1509 } // namespace Toolkit
1510
1511 } // namespace Dali