[AT-SPI] Remove GetBoundAccessibilityObject
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / devel-api / controls / control-devel.cpp
index 487aa1b..5ab6b79 100644 (file)
@@ -122,126 +122,89 @@ Dali::Property GetVisualProperty(Control control, Dali::Property::Index index, D
   return controlDataImpl.GetVisualProperty(index, visualPropertyKey);
 }
 
-void CreateTransitions(Control control, Dali::Animation& animation, Dali::Toolkit::Control source, AlphaFunction alphaFunction, TimePeriod timePeriod)
+static Toolkit::Internal::Control::Impl* GetControlImplementation(Dali::Actor actor)
 {
-  if(animation)
+  Dali::Toolkit::Control control = Toolkit::Control::DownCast(actor);
+  if(control)
   {
-    // make visual transition of control visual.
-    Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
-    Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get(internalControl);
-    controlDataImpl.MakeVisualTransition(animation, source, Toolkit::Control::Property::BACKGROUND, alphaFunction, timePeriod);
-    controlDataImpl.MakeVisualTransition(animation, source, Toolkit::DevelControl::Property::SHADOW, alphaFunction, timePeriod);
-    internalControl.OnCreateTransitions(animation, source, alphaFunction, timePeriod);
-  }
-}
-
-static Toolkit::Internal::Control::Impl* GetControlImplementationIfAny(Dali::Actor actor)
-{
-  Dali::Toolkit::Control c = Toolkit::Control::DownCast(actor);
-  if(c)
-  {
-    auto& impl1 = Toolkit::Internal::GetImplementation(c);
-    auto& impl2 = Toolkit::Internal::Control::Impl::Get(impl1);
-    return &impl2;
+    auto& internalControl = Toolkit::Internal::GetImplementation(control);
+    auto& controlDataImpl = Toolkit::Internal::Control::Impl::Get(internalControl);
+    return &controlDataImpl;
   }
   return nullptr;
 }
 
 Toolkit::DevelControl::AccessibilityActivateSignalType& AccessibilityActivateSignal(Toolkit::Control control)
 {
-  auto ac = GetControlImplementationIfAny(control);
-  return ac->mAccessibilityActivateSignal;
+  return GetControlImplementation(control)->mAccessibilityActivateSignal;
 }
 
 Toolkit::DevelControl::AccessibilityReadingSkippedSignalType& AccessibilityReadingSkippedSignal(Toolkit::Control control)
 {
-  auto ac = GetControlImplementationIfAny(control);
-  return ac->mAccessibilityReadingSkippedSignal;
+  return GetControlImplementation(control)->mAccessibilityReadingSkippedSignal;
 }
 
 Toolkit::DevelControl::AccessibilityReadingPausedSignalType& AccessibilityReadingPausedSignal(Toolkit::Control control)
 {
-  auto ac = GetControlImplementationIfAny(control);
-  return ac->mAccessibilityReadingPausedSignal;
+  return GetControlImplementation(control)->mAccessibilityReadingPausedSignal;
 }
 
 Toolkit::DevelControl::AccessibilityReadingResumedSignalType& AccessibilityReadingResumedSignal(Toolkit::Control control)
 {
-  auto ac = GetControlImplementationIfAny(control);
-  return ac->mAccessibilityReadingResumedSignal;
+  return GetControlImplementation(control)->mAccessibilityReadingResumedSignal;
 }
 
 Toolkit::DevelControl::AccessibilityReadingCancelledSignalType& AccessibilityReadingCancelledSignal(Toolkit::Control control)
 {
-  auto ac = GetControlImplementationIfAny(control);
-  return ac->mAccessibilityReadingCancelledSignal;
+  return GetControlImplementation(control)->mAccessibilityReadingCancelledSignal;
 }
 
 Toolkit::DevelControl::AccessibilityReadingStoppedSignalType& AccessibilityReadingStoppedSignal(Toolkit::Control control)
 {
-  auto ac = GetControlImplementationIfAny(control);
-  return ac->mAccessibilityReadingStoppedSignal;
+  return GetControlImplementation(control)->mAccessibilityReadingStoppedSignal;
 }
 
 Toolkit::DevelControl::AccessibilityGetNameSignalType& AccessibilityGetNameSignal(Toolkit::Control control)
 {
-  auto ac = GetControlImplementationIfAny(control);
-  return ac->mAccessibilityGetNameSignal;
+  return GetControlImplementation(control)->mAccessibilityGetNameSignal;
 }
 
 Toolkit::DevelControl::AccessibilityGetDescriptionSignalType& AccessibilityGetDescriptionSignal(Toolkit::Control control)
 {
-  auto ac = GetControlImplementationIfAny(control);
-  return ac->mAccessibilityGetDescriptionSignal;
+  return GetControlImplementation(control)->mAccessibilityGetDescriptionSignal;
 }
 
 Toolkit::DevelControl::AccessibilityDoGestureSignalType& AccessibilityDoGestureSignal(Toolkit::Control control)
 {
-  auto ac = GetControlImplementationIfAny(control);
-  return ac->mAccessibilityDoGestureSignal;
+  return GetControlImplementation(control)->mAccessibilityDoGestureSignal;
 }
 
 void AppendAccessibilityRelation(Dali::Actor control, Actor destination, Dali::Accessibility::RelationType relation)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    auto index = static_cast<Dali::Property::Array::SizeType>(relation);
-    if(index >= ac->mAccessibilityRelations.size())
+    auto object = controlDataImpl->GetAccessibilityObject(destination);
+    if(object)
     {
-      DALI_LOG_ERROR("Relation index exceeds vector size.");
-      return;
+      controlDataImpl->mAccessibilityRelations[relation].insert(object);
     }
-
-    auto obj = ac->GetAccessibilityObject(destination);
-    if(obj)
-      ac->mAccessibilityRelations[index].push_back(obj->GetAddress());
   }
 }
 
 void RemoveAccessibilityRelation(Dali::Actor control, Actor destination, Dali::Accessibility::RelationType relation)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    auto index = static_cast<Dali::Property::Array::SizeType>(relation);
-    if(index >= ac->mAccessibilityRelations.size())
+    auto object = controlDataImpl->GetAccessibilityObject(destination);
+    if(object)
     {
-      DALI_LOG_ERROR("Relation index exceeds vector size.");
-      return;
-    }
-
-    auto obj = ac->GetAccessibilityObject(destination);
-    if(!obj)
-      return;
+      auto& relations = controlDataImpl->mAccessibilityRelations;
 
-    auto address = obj->GetAddress();
+      relations[relation].erase(object);
 
-    auto& targets = ac->mAccessibilityRelations[index];
-    for(auto i = 0u; i < targets.size(); ++i)
-    {
-      if(targets[i].ToString() == address.ToString())
+      if(relations[relation].empty())
       {
-        targets[i] = targets.back();
-        targets.erase(targets.end() - 1);
+        relations.erase(relation);
       }
     }
   }
@@ -249,118 +212,131 @@ void RemoveAccessibilityRelation(Dali::Actor control, Actor destination, Dali::A
 
 std::vector<std::vector<Accessibility::Address>> GetAccessibilityRelations(Dali::Actor control)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    return ac->mAccessibilityRelations;
+    std::vector<std::vector<Accessibility::Address>> result(static_cast<std::size_t>(Accessibility::RelationType::MAX_COUNT));
+
+    // Map every Accessible* to its Address
+    for(auto& relation : controlDataImpl->mAccessibilityRelations)
+    {
+      auto  index   = static_cast<std::size_t>(relation.first);
+      auto& targets = relation.second;
+
+      std::transform(targets.begin(), targets.end(), std::back_inserter(result[index]), [](auto* x) {
+        return x->GetAddress();
+      });
+    }
+
+    return result;
   }
+
   return {};
 }
 
 void ClearAccessibilityRelations(Dali::Actor control)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    for(auto& it : ac->mAccessibilityRelations)
-      it.clear();
+    controlDataImpl->mAccessibilityRelations.clear();
   }
 }
 
-void SetAccessibilityConstructor(Dali::Actor                                                                  control,
-                                 std::function<std::unique_ptr<Dali::Accessibility::Accessible>(Dali::Actor)> constructor)
+void SetAccessibilityConstructor(Dali::Actor control, std::function<std::unique_ptr<Dali::Accessibility::Accessible>(Dali::Actor)> constructor)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    ac->accessibilityConstructor = constructor;
+    controlDataImpl->mAccessibilityConstructor = constructor;
   }
 }
 
 void AppendAccessibilityAttribute(Dali::Actor control, const std::string& key, const std::string value)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    ac->AppendAccessibilityAttribute(key, value);
+    controlDataImpl->AppendAccessibilityAttribute(key, value);
   }
 }
 
 void RemoveAccessibilityAttribute(Dali::Actor control, const std::string& key)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    ac->RemoveAccessibilityAttribute(key);
+    controlDataImpl->RemoveAccessibilityAttribute(key);
   }
 }
 
 void ClearAccessibilityAttributes(Dali::Actor control)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    ac->ClearAccessibilityAttributes();
+    controlDataImpl->ClearAccessibilityAttributes();
   }
 }
 
 void SetAccessibilityReadingInfoType(Dali::Actor control, const Dali::Accessibility::ReadingInfoTypes types)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    ac->SetAccessibilityReadingInfoType(types);
+    controlDataImpl->SetAccessibilityReadingInfoType(types);
   }
 }
 
 Dali::Accessibility::ReadingInfoTypes GetAccessibilityReadingInfoType(Dali::Actor control)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    return ac->GetAccessibilityReadingInfoType();
+    return controlDataImpl->GetAccessibilityReadingInfoType();
   }
   return {};
 }
 
 bool ClearAccessibilityHighlight(Dali::Actor control)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    auto ptr = dynamic_cast<Dali::Accessibility::Component*>(ac->GetAccessibilityObject());
-    if(ptr)
-      return ptr->ClearHighlight();
+    auto object = dynamic_cast<Dali::Accessibility::Component*>(controlDataImpl->GetAccessibilityObject());
+    if(object)
+    {
+      return object->ClearHighlight();
+    }
   }
   return false;
 }
 
 bool GrabAccessibilityHighlight(Dali::Actor control)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    auto ptr = dynamic_cast<Dali::Accessibility::Component*>(ac->GetAccessibilityObject());
-    if(ptr)
-      return ptr->GrabHighlight();
+    auto object = dynamic_cast<Dali::Accessibility::Component*>(controlDataImpl->GetAccessibilityObject());
+    if(object)
+    {
+      return object->GrabHighlight();
+    }
   }
   return false;
 }
 
 Dali::Accessibility::States GetAccessibilityStates(Dali::Actor control)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    auto ptr = dynamic_cast<Dali::Accessibility::Component*>(ac->GetAccessibilityObject());
-    if(ptr)
-      return ptr->GetStates();
+    auto object = dynamic_cast<Dali::Accessibility::Component*>(controlDataImpl->GetAccessibilityObject());
+    if(object)
+    {
+      return object->GetStates();
+    }
   }
   return {};
 }
 
-void NotifyAccessibilityStateChange(Dali::Actor control, Dali::Accessibility::States states, bool doRecursive)
+void NotifyAccessibilityStateChange(Dali::Actor control, Dali::Accessibility::States states, bool isRecursive)
 {
-  if(auto ac = GetControlImplementationIfAny(control))
+  if(auto controlDataImpl = GetControlImplementation(control))
   {
-    ac->GetAccessibilityObject()->NotifyAccessibilityStateChange(std::move(states), doRecursive);
+    controlDataImpl->GetAccessibilityObject()->NotifyAccessibilityStateChange(std::move(states), isRecursive);
   }
 }
 
-Dali::Accessibility::Accessible* GetBoundAccessibilityObject(Dali::Actor control)
-{
-  return Dali::Accessibility::Accessible::Get(control);
-}
-
 } // namespace DevelControl
 
 } // namespace Toolkit