[dali_2.3.21] Merge branch 'devel/master'

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / slider / slider-impl.cpp

diff --git a/dali-toolkit/internal/controls/slider/slider-impl.cpp b/dali-toolkit/internal/controls/slider/slider-impl.cpp
index 6829485..20b498c 100644 (file)
--- a/dali-toolkit/internal/controls/slider/slider-impl.cpp
+++ b/dali-toolkit/internal/controls/slider/slider-impl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,6 +28,7 @@
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
+#include <dali-toolkit/internal/controls/control/control-data-impl.h>
 #include <dali-toolkit/public-api/controls/control-impl.h>
 #include <dali-toolkit/public-api/controls/image-view/image-view.h>
 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
@@ -201,16 +202,17 @@ void Slider::OnInitialize()
   // Size the Slider actor to a default
   self.SetProperty(Actor::Property::SIZE, Vector2(DEFAULT_HIT_REGION.x, DEFAULT_HIT_REGION.y));
 
-  // Set the Slider to be highlightable in Screen Reader mode
-  self.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true);
-
   // Connect to the touch signal
   self.TouchedSignal().Connect(this, &Slider::OnTouch);
 
-  DevelControl::SetAccessibilityConstructor(self, [](Dali::Actor actor) {
-    return std::unique_ptr<Dali::Accessibility::Accessible>(
-      new AccessibleImpl(actor, Dali::Accessibility::Role::SLIDER));
-  });
+  // Accessibility
+  self.SetProperty(DevelControl::Property::ACCESSIBILITY_ROLE, Dali::Accessibility::Role::SLIDER);
+  self.SetProperty(DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true);
+}
+
+DevelControl::ControlAccessible* Slider::CreateAccessibleObject()
+{
+  return new SliderAccessible(Self());
 }
 
 void Slider::OnRelayout(const Vector2& size, RelayoutContainer& container)
@@ -860,14 +862,16 @@ float Slider::SnapToMark(float value)
   for(MarkList::SizeType i = 0; i < mMarks.Count(); ++i)
   {
     const Property::Value& propertyValue = mMarks[i];
-    propertyValue.Get(mark);
-    mark = MapValuePercentage(mark);
-
-    float dist = fabsf(mark - value);
-    if(dist < closestDist)
+    if(propertyValue.Get(mark))
     {
-      closestDist = dist;
-      closestMark = mark;
+      mark = MapValuePercentage(mark);
+
+      float dist = fabsf(mark - value);
+      if(dist < closestDist)
+      {
+        closestDist = dist;
+        closestMark = mark;
+      }
     }
   }
 
@@ -889,22 +893,24 @@ bool Slider::MarkReached(float value, int& outIndex)
     current = head + (tail - head) / 2;
 
     const Property::Value& propertyValue = mMarks[current];
-    propertyValue.Get(mark);
-    mark = MapValuePercentage(mark);
-
-    if(fabsf(mark - value) < MARK_TOLERANCE)
+    if(propertyValue.Get(mark))
     {
-      outIndex = current;
-      return true;
-    }
+      mark = MapValuePercentage(mark);
 
-    if(value < mark)
-    {
-      tail = current - 1;
-    }
-    else
-    {
-      head = current + 1;
+      if(fabsf(mark - value) < MARK_TOLERANCE)
+      {
+        outIndex = current;
+        return true;
+      }
+
+      if(value < mark)
+      {
+        tail = current - 1;
+      }
+      else
+      {
+        head = current + 1;
+      }
     }
   }
 
@@ -947,9 +953,11 @@ void Slider::SetValue(float value)
 {
   mValue = value;
   DisplayValue(mValue, true);
-  if(Self() == Dali::Accessibility::Accessible::GetCurrentlyHighlightedActor())
+
+  auto accessible = GetAccessibleObject();
+  if(DALI_LIKELY(accessible) && accessible->IsHighlighted())
   {
-    Control::Impl::GetAccessibilityObject(Self())->Emit(Dali::Accessibility::ObjectPropertyChangeEvent::VALUE);
+    accessible->Emit(Dali::Accessibility::ObjectPropertyChangeEvent::VALUE);
   }
 }
 
@@ -1410,42 +1418,47 @@ Property::Value Slider::GetProperty(BaseObject* object, Property::Index property
   return value;
 }
 
-double Slider::AccessibleImpl::GetMinimum()
+double Slider::SliderAccessible::GetMinimum() const
 {
-  auto p = Toolkit::Slider::DownCast(self);
-  return p.GetProperty(Toolkit::Slider::Property::LOWER_BOUND).Get<float>();
+  auto self = Toolkit::Slider::DownCast(Self());
+  return self.GetProperty(Toolkit::Slider::Property::LOWER_BOUND).Get<float>();
 }
 
-double Slider::AccessibleImpl::GetCurrent()
+double Slider::SliderAccessible::GetCurrent() const
 {
-  auto p = Toolkit::Slider::DownCast(self);
-  return p.GetProperty(Toolkit::Slider::Property::VALUE).Get<float>();
+  auto self = Toolkit::Slider::DownCast(Self());
+  return self.GetProperty(Toolkit::Slider::Property::VALUE).Get<float>();
 }
 
-double Slider::AccessibleImpl::GetMaximum()
+std::string Slider::SliderAccessible::GetValueText() const
 {
-  auto p = Toolkit::Slider::DownCast(self);
-  return p.GetProperty(Toolkit::Slider::Property::UPPER_BOUND).Get<float>();
+  return {}; // Text mode is not used at the moment
 }
 
-bool Slider::AccessibleImpl::SetCurrent(double current)
+double Slider::SliderAccessible::GetMaximum() const
+{
+  auto self = Toolkit::Slider::DownCast(Self());
+  return self.GetProperty(Toolkit::Slider::Property::UPPER_BOUND).Get<float>();
+}
+
+bool Slider::SliderAccessible::SetCurrent(double current)
 {
   if(current < GetMinimum() || current > GetMaximum())
     return false;
 
-  auto  p    = Toolkit::Slider::DownCast(self);
-  auto& impl = Toolkit::GetImpl(p);
+  auto  self = Toolkit::Slider::DownCast(Self());
+  auto& impl = Toolkit::GetImpl(self);
 
-  const float prev = p.GetProperty<float>(Toolkit::Slider::Property::VALUE);
+  const float prev = self.GetProperty<float>(Toolkit::Slider::Property::VALUE);
   float       next = static_cast<float>(current);
 
   if(fabsf(next - prev) < Math::MACHINE_EPSILON_0)
   {
     // do nothing
   }
-  else if(p.GetProperty<bool>(Toolkit::Slider::Property::SNAP_TO_MARKS))
+  else if(self.GetProperty<bool>(Toolkit::Slider::Property::SNAP_TO_MARKS))
   {
-    auto marks = p.GetProperty<Property::Array>(Toolkit::Slider::Property::MARKS);
+    auto marks = self.GetProperty<Property::Array>(Toolkit::Slider::Property::MARKS);
 
     int prevIdx;
     if(impl.MarkReached(impl.MapValuePercentage(prev), prevIdx))
@@ -1454,7 +1467,9 @@ bool Slider::AccessibleImpl::SetCurrent(double current)
       nextIdx += (next > prev) ? 1 : -1;
 
       if(nextIdx < 0 || nextIdx >= static_cast<int>(marks.Count()))
+      {
         return false;
+      }
 
       next = marks[nextIdx].Get<float>();
     }
@@ -1474,15 +1489,17 @@ bool Slider::AccessibleImpl::SetCurrent(double current)
   return true;
 }
 
-double Slider::AccessibleImpl::GetMinimumIncrement()
+double Slider::SliderAccessible::GetMinimumIncrement() const
 {
-  auto p = Toolkit::Slider::DownCast(self);
+  auto self = Toolkit::Slider::DownCast(Self());
 
-  bool  hasMarks  = !p.GetProperty<Property::Array>(Toolkit::Slider::Property::MARKS).Empty();
-  float tolerance = p.GetProperty<float>(Toolkit::Slider::Property::MARK_TOLERANCE);
+  bool  hasMarks  = !self.GetProperty<Property::Array>(Toolkit::Slider::Property::MARKS).Empty();
+  float tolerance = self.GetProperty<float>(Toolkit::Slider::Property::MARK_TOLERANCE);
 
   if(!hasMarks || fabsf(tolerance) < 0.01)
+  {
     return 0.0; // let screen-reader choose the increment
+  }
 
   return Math::MACHINE_EPSILON_10000 + tolerance * (GetMaximum() - GetMinimum());
 }