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

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