dali-toolkit/devel-api/controls/accessible-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 "accessible-impl.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/actors/actor-devel.h>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
  26 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
  27 #include <dali-toolkit/public-api/controls/control-impl.h>
  28 #include <dali-toolkit/public-api/controls/control.h>
  29 #include <dali-toolkit/public-api/controls/image-view/image-view.h>
  30 #include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
  31
  32 namespace Dali::Toolkit::DevelControl {
  33
  34 AccessibleImpl::AccessibleImpl(Dali::Actor self, Dali::Accessibility::Role role, bool modal)
  35 : self(self),
  36   modal(modal)
  37 {
  38   auto control = Dali::Toolkit::Control::DownCast(self);
  39
  40   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
  41   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
  42   if(controlImpl.mAccessibilityRole == Dali::Accessibility::Role::UNKNOWN)
  43     controlImpl.mAccessibilityRole = role;
  44
  45   self.PropertySetSignal().Connect(&controlImpl, [this, &controlImpl](Dali::Handle& handle, Dali::Property::Index index, Dali::Property::Value value) {
  46     if(this->self != Dali::Accessibility::Accessible::GetCurrentlyHighlightedActor())
  47     {
  48       return;
  49     }
  50
  51     if(index == DevelControl::Property::ACCESSIBILITY_NAME || (index == GetNamePropertyIndex() && !controlImpl.mAccessibilityNameSet))
  52     {
  53       if(controlImpl.mAccessibilityGetNameSignal.Empty())
  54       {
  55         Emit(Dali::Accessibility::ObjectPropertyChangeEvent::NAME);
  56       }
  57     }
  58
  59     if(index == DevelControl::Property::ACCESSIBILITY_DESCRIPTION || (index == GetDescriptionPropertyIndex() && !controlImpl.mAccessibilityDescriptionSet))
  60     {
  61       if(controlImpl.mAccessibilityGetDescriptionSignal.Empty())
  62       {
  63         Emit(Dali::Accessibility::ObjectPropertyChangeEvent::DESCRIPTION);
  64       }
  65     }
  66   });
  67 }
  68
  69 std::string AccessibleImpl::GetName()
  70 {
  71   auto control = Dali::Toolkit::Control::DownCast(self);
  72
  73   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
  74   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
  75
  76   if(!controlImpl.mAccessibilityGetNameSignal.Empty())
  77   {
  78     std::string ret;
  79     controlImpl.mAccessibilityGetNameSignal.Emit(ret);
  80     return ret;
  81   }
  82
  83   if(controlImpl.mAccessibilityNameSet)
  84     return controlImpl.mAccessibilityName;
  85
  86   if(auto raw = GetNameRaw(); !raw.empty())
  87     return raw;
  88
  89   return self.GetProperty<std::string>(Actor::Property::NAME);
  90 }
  91
  92 std::string AccessibleImpl::GetNameRaw()
  93 {
  94   return {};
  95 }
  96
  97 std::string AccessibleImpl::GetDescription()
  98 {
  99   auto control = Dali::Toolkit::Control::DownCast(self);
 100
 101   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 102   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 103
 104   if(!controlImpl.mAccessibilityGetDescriptionSignal.Empty())
 105   {
 106     std::string ret;
 107     controlImpl.mAccessibilityGetDescriptionSignal.Emit(ret);
 108     return ret;
 109   }
 110
 111   if(controlImpl.mAccessibilityDescriptionSet)
 112     return controlImpl.mAccessibilityDescription;
 113
 114   return GetDescriptionRaw();
 115 }
 116
 117 std::string AccessibleImpl::GetDescriptionRaw()
 118 {
 119   return "";
 120 }
 121
 122 Dali::Accessibility::Accessible* AccessibleImpl::GetParent()
 123 {
 124   return Dali::Accessibility::Accessible::Get(self.GetParent());
 125 }
 126
 127 size_t AccessibleImpl::GetChildCount()
 128 {
 129   return self.GetChildCount();
 130 }
 131
 132 Dali::Accessibility::Accessible* AccessibleImpl::GetChildAtIndex(size_t index)
 133 {
 134   return Dali::Accessibility::Accessible::Get(self.GetChildAt(static_cast<unsigned int>(index)));
 135 }
 136
 137 size_t AccessibleImpl::GetIndexInParent()
 138 {
 139   auto s      = self;
 140   auto parent = s.GetParent();
 141   DALI_ASSERT_ALWAYS(parent && "can't call GetIndexInParent on object without parent");
 142   auto count = parent.GetChildCount();
 143   for(auto i = 0u; i < count; ++i)
 144   {
 145     auto c = parent.GetChildAt(i);
 146     if(c == s)
 147       return i;
 148   }
 149   DALI_ASSERT_ALWAYS(false && "object isn't child of it's parent");
 150   return static_cast<size_t>(-1);
 151 }
 152
 153 Dali::Accessibility::Role AccessibleImpl::GetRole()
 154 {
 155   return self.GetProperty<Dali::Accessibility::Role>(Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE);
 156 }
 157
 158 Dali::Accessibility::States AccessibleImpl::CalculateStates()
 159 {
 160   Dali::Accessibility::States s;
 161   s[Dali::Accessibility::State::FOCUSABLE] = self.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE);
 162   s[Dali::Accessibility::State::FOCUSED]   = Toolkit::KeyboardFocusManager::Get().GetCurrentFocusActor() == self;
 163   if(self.GetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE).GetType() == Dali::Property::NONE)
 164     s[Dali::Accessibility::State::HIGHLIGHTABLE] = false;
 165   else
 166     s[Dali::Accessibility::State::HIGHLIGHTABLE] = self.GetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE).Get<bool>();
 167   s[Dali::Accessibility::State::HIGHLIGHTED] = GetCurrentlyHighlightedActor() == self;
 168   s[Dali::Accessibility::State::ENABLED]     = true;
 169   s[Dali::Accessibility::State::SENSITIVE]   = true;
 170   s[Dali::Accessibility::State::ANIMATED]    = self.GetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_ANIMATED).Get<bool>();
 171   s[Dali::Accessibility::State::VISIBLE]     = true;
 172   if(modal)
 173   {
 174     s[Dali::Accessibility::State::MODAL] = true;
 175   }
 176   s[Dali::Accessibility::State::SHOWING] = !self.GetProperty(Dali::DevelActor::Property::CULLED).Get<bool>() && self.GetCurrentProperty<bool>(Actor::Property::VISIBLE);
 177
 178   s[Dali::Accessibility::State::DEFUNCT] = !self.GetProperty(Dali::DevelActor::Property::CONNECTED_TO_SCENE).Get<bool>();
 179   return s;
 180 }
 181
 182 Dali::Accessibility::States AccessibleImpl::GetStates()
 183 {
 184   return CalculateStates();
 185 }
 186
 187 Dali::Accessibility::Attributes AccessibleImpl::GetAttributes()
 188 {
 189   std::unordered_map<std::string, std::string> attribute_map;
 190   auto                                         q = Dali::Toolkit::Control::DownCast(self);
 191   auto                                         w =
 192     q.GetProperty(Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES);
 193   auto z = w.GetMap();
 194
 195   if(z)
 196   {
 197     auto map_size = z->Count();
 198
 199     for(unsigned int i = 0; i < map_size; i++)
 200     {
 201       auto map_key = z->GetKeyAt(i);
 202       if(map_key.type == Dali::Property::Key::STRING)
 203       {
 204         std::string map_value;
 205         if(z->GetValue(i).Get(map_value))
 206         {
 207           attribute_map.emplace(std::move(map_key.stringKey),
 208                                 std::move(map_value));
 209         }
 210       }
 211     }
 212   }
 213
 214   return attribute_map;
 215 }
 216
 217 Dali::Accessibility::ComponentLayer AccessibleImpl::GetLayer()
 218 {
 219   return Dali::Accessibility::ComponentLayer::WINDOW;
 220 }
 221
 222 Dali::Rect<> AccessibleImpl::GetExtents(Dali::Accessibility::CoordType ctype)
 223 {
 224   Vector2 screenPosition =
 225     self.GetProperty(Dali::DevelActor::Property::SCREEN_POSITION)
 226       .Get<Vector2>();
 227   auto size = self.GetCurrentProperty<Vector3>(Actor::Property::SIZE) * self.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE);
 228   bool positionUsesAnchorPoint =
 229     self.GetProperty(Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT)
 230       .Get<bool>();
 231   Vector3 anchorPointOffSet =
 232     size * (positionUsesAnchorPoint ? self.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT)
 233                                     : AnchorPoint::TOP_LEFT);
 234   Vector2 position = Vector2(screenPosition.x - anchorPointOffSet.x,
 235                              screenPosition.y - anchorPointOffSet.y);
 236
 237   return {position.x, position.y, size.x, size.y};
 238 }
 239
 240 int16_t AccessibleImpl::GetMdiZOrder()
 241 {
 242   return 0;
 243 }
 244 double AccessibleImpl::GetAlpha()
 245 {
 246   return 0;
 247 }
 248
 249 bool AccessibleImpl::GrabFocus()
 250 {
 251   return Toolkit::KeyboardFocusManager::Get().SetCurrentFocusActor(self);
 252 }
 253
 254 static Dali::Actor CreateHighlightIndicatorActor()
 255 {
 256   std::string focusBorderImagePath(AssetManager::GetDaliImagePath());
 257   focusBorderImagePath += "/keyboard_focus.9.png";
 258   // Create the default if it hasn't been set and one that's shared by all the
 259   // keyboard focusable actors
 260   auto actor = Toolkit::ImageView::New(focusBorderImagePath);
 261   actor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
 262   DevelControl::AppendAccessibilityAttribute(actor, "highlight", "");
 263   actor.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_ANIMATED, true);
 264   actor.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, false);
 265
 266   return actor;
 267 }
 268
 269 bool AccessibleImpl::GrabHighlight()
 270 {
 271   auto old = GetCurrentlyHighlightedActor();
 272
 273   if(!Dali::Accessibility::IsUp())
 274     return false;
 275   if(self == old)
 276     return true;
 277   if(old)
 278   {
 279     auto c = dynamic_cast<Dali::Accessibility::Component*>(Internal::Control::Impl::GetAccessibilityObject(old));
 280     if(c)
 281       c->ClearHighlight();
 282   }
 283   auto highlight = GetHighlightActor();
 284   if(!highlight)
 285   {
 286     highlight = CreateHighlightIndicatorActor();
 287     SetHighlightActor(highlight);
 288   }
 289   highlight.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 290   highlight.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
 291   highlight.SetProperty(Actor::Property::POSITION_Z, 1.0f);
 292   highlight.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
 293
 294   EnsureSelfVisible();
 295   self.Add(highlight);
 296   SetCurrentlyHighlightedActor(self);
 297   EmitHighlighted(true);
 298
 299   return true;
 300 }
 301
 302 bool AccessibleImpl::ClearHighlight()
 303 {
 304   if(!Dali::Accessibility::IsUp())
 305     return false;
 306   if(GetCurrentlyHighlightedActor() == self)
 307   {
 308     self.Remove(GetHighlightActor());
 309     SetCurrentlyHighlightedActor({});
 310     EmitHighlighted(false);
 311     return true;
 312   }
 313   return false;
 314 }
 315
 316 std::string AccessibleImpl::GetActionName(size_t index)
 317 {
 318   if(index >= GetActionCount()) return "";
 319   Dali::TypeInfo type;
 320   self.GetTypeInfo(type);
 321   DALI_ASSERT_ALWAYS(type && "no TypeInfo object");
 322   return type.GetActionName(index);
 323 }
 324
 325 std::string AccessibleImpl::GetLocalizedActionName(size_t index)
 326 {
 327   // TODO: add localization
 328   return GetActionName(index);
 329 }
 330
 331 std::string AccessibleImpl::GetActionDescription(size_t index)
 332 {
 333   return "";
 334 }
 335
 336 size_t AccessibleImpl::GetActionCount()
 337 {
 338   Dali::TypeInfo type;
 339   self.GetTypeInfo(type);
 340   DALI_ASSERT_ALWAYS(type && "no TypeInfo object");
 341   return type.GetActionCount();
 342 }
 343
 344 std::string AccessibleImpl::GetActionKeyBinding(size_t index)
 345 {
 346   return "";
 347 }
 348
 349 bool AccessibleImpl::DoAction(size_t index)
 350 {
 351   std::string actionName = GetActionName(index);
 352   return self.DoAction(actionName, {});
 353 }
 354
 355 bool AccessibleImpl::DoAction(const std::string& name)
 356 {
 357   return self.DoAction(name, {});
 358 }
 359
 360 bool AccessibleImpl::DoGesture(const Dali::Accessibility::GestureInfo& gestureInfo)
 361 {
 362   auto control = Dali::Toolkit::Control::DownCast(self);
 363
 364   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 365   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 366
 367   if(!controlImpl.mAccessibilityDoGestureSignal.Empty())
 368   {
 369     auto ret = std::make_pair(gestureInfo, false);
 370     controlImpl.mAccessibilityDoGestureSignal.Emit(ret);
 371     return ret.second;
 372   }
 373
 374   return false;
 375 }
 376
 377 std::vector<Dali::Accessibility::Relation> AccessibleImpl::GetRelationSet()
 378 {
 379   auto control = Dali::Toolkit::Control::DownCast(self);
 380
 381   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 382   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 383
 384   std::vector<Dali::Accessibility::Relation> ret;
 385
 386   auto& v = controlImpl.mAccessibilityRelations;
 387   for(auto i = 0u; i < v.size(); ++i)
 388   {
 389     if(v[i].empty())
 390       continue;
 391
 392     ret.emplace_back(Accessibility::Relation{static_cast<Accessibility::RelationType>(i), v[i]});
 393   }
 394
 395   return ret;
 396 }
 397
 398 void AccessibleImpl::EnsureChildVisible(Actor child)
 399 {
 400 }
 401
 402 void AccessibleImpl::EnsureSelfVisible()
 403 {
 404   auto parent = dynamic_cast<AccessibleImpl*>(GetParent());
 405   if(parent)
 406   {
 407     parent->EnsureChildVisible(self);
 408   }
 409 }
 410
 411 Dali::Property::Index AccessibleImpl::GetNamePropertyIndex()
 412 {
 413   return Actor::Property::NAME;
 414 }
 415
 416 Dali::Property::Index AccessibleImpl::GetDescriptionPropertyIndex()
 417 {
 418   return Dali::Property::INVALID_INDEX;
 419 }
 420
 421 } // namespace Dali::Toolkit::DevelControl