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

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