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::Actor self = Self();
 161   Dali::Accessibility::States s;
 162   s[Dali::Accessibility::State::FOCUSABLE] = self.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE);
 163   s[Dali::Accessibility::State::FOCUSED]   = Toolkit::KeyboardFocusManager::Get().GetCurrentFocusActor() == self;
 164   if(self.GetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE).GetType() == Dali::Property::NONE)
 165     s[Dali::Accessibility::State::HIGHLIGHTABLE] = false;
 166   else
 167     s[Dali::Accessibility::State::HIGHLIGHTABLE] = self.GetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE).Get<bool>();
 168   s[Dali::Accessibility::State::HIGHLIGHTED] = GetCurrentlyHighlightedActor() == self;
 169   s[Dali::Accessibility::State::ENABLED]     = true;
 170   s[Dali::Accessibility::State::SENSITIVE]   = true;
 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   Dali::Actor self = Self();
 225   Vector2 screenPosition =
 226     self.GetProperty(Dali::DevelActor::Property::SCREEN_POSITION)
 227       .Get<Vector2>();
 228   auto size = self.GetCurrentProperty<Vector3>(Actor::Property::SIZE) * self.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE);
 229   bool positionUsesAnchorPoint =
 230     self.GetProperty(Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT)
 231       .Get<bool>();
 232   Vector3 anchorPointOffSet =
 233     size * (positionUsesAnchorPoint ? self.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT)
 234                                     : AnchorPoint::TOP_LEFT);
 235   Vector2 position = Vector2(screenPosition.x - anchorPointOffSet.x,
 236                              screenPosition.y - anchorPointOffSet.y);
 237
 238   return {position.x, position.y, size.x, size.y};
 239 }
 240
 241 int16_t AccessibleImpl::GetMdiZOrder()
 242 {
 243   return 0;
 244 }
 245 double AccessibleImpl::GetAlpha()
 246 {
 247   return 0;
 248 }
 249
 250 bool AccessibleImpl::GrabFocus()
 251 {
 252   return Toolkit::KeyboardFocusManager::Get().SetCurrentFocusActor(Self());
 253 }
 254
 255 static Dali::Actor CreateHighlightIndicatorActor()
 256 {
 257   std::string focusBorderImagePath(AssetManager::GetDaliImagePath());
 258   focusBorderImagePath += "/keyboard_focus.9.png";
 259   // Create the default if it hasn't been set and one that's shared by all the
 260   // keyboard focusable actors
 261   auto actor = Toolkit::ImageView::New(focusBorderImagePath);
 262   actor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
 263   DevelControl::AppendAccessibilityAttribute(actor, "highlight", "");
 264   actor.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, false);
 265
 266   return actor;
 267 }
 268
 269 void AccessibleImpl::ScrollToSelf()
 270 {
 271   auto* child = this;
 272   auto* parent = dynamic_cast<Toolkit::DevelControl::AccessibleImpl*>(child->GetParent());
 273
 274   while (parent)
 275   {
 276     if (parent->IsScrollable())
 277     {
 278       parent->ScrollToChild(child->Self());
 279     }
 280
 281     child = parent;
 282     parent = dynamic_cast<Toolkit::DevelControl::AccessibleImpl*>(parent->GetParent());
 283   }
 284 }
 285
 286 bool AccessibleImpl::GrabHighlight()
 287 {
 288   Dali::Actor self = Self();
 289   auto old = GetCurrentlyHighlightedActor();
 290
 291   if(!Dali::Accessibility::IsUp())
 292     return false;
 293   if(self == old)
 294     return true;
 295   if(old)
 296   {
 297     auto c = dynamic_cast<Dali::Accessibility::Component*>(Internal::Control::Impl::GetAccessibilityObject(old));
 298     if(c)
 299       c->ClearHighlight();
 300   }
 301   auto highlight = GetHighlightActor();
 302   if(!highlight)
 303   {
 304     highlight = CreateHighlightIndicatorActor();
 305     SetHighlightActor(highlight);
 306   }
 307   highlight.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 308   highlight.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
 309   highlight.SetProperty(Actor::Property::POSITION_Z, 1.0f);
 310   highlight.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
 311
 312   // Remember the highlight actor, so that when the default is changed with
 313   // SetHighlightActor(), the currently displayed highlight can still be cleared.
 314   currentHighlightActor = highlight;
 315   ScrollToSelf();
 316   self.Add(highlight);
 317   SetCurrentlyHighlightedActor(self);
 318   EmitHighlighted(true);
 319
 320   return true;
 321 }
 322
 323 bool AccessibleImpl::ClearHighlight()
 324 {
 325   Dali::Actor self = Self();
 326
 327   if(!Dali::Accessibility::IsUp())
 328     return false;
 329   if(GetCurrentlyHighlightedActor() == self)
 330   {
 331     self.Remove(currentHighlightActor.GetHandle());
 332     currentHighlightActor = {};
 333     SetCurrentlyHighlightedActor({});
 334     EmitHighlighted(false);
 335     return true;
 336   }
 337   return false;
 338 }
 339
 340 std::string AccessibleImpl::GetActionName(size_t index)
 341 {
 342   if(index >= GetActionCount()) return "";
 343   Dali::TypeInfo type;
 344   Self().GetTypeInfo(type);
 345   DALI_ASSERT_ALWAYS(type && "no TypeInfo object");
 346   return type.GetActionName(index);
 347 }
 348
 349 std::string AccessibleImpl::GetLocalizedActionName(size_t index)
 350 {
 351   // TODO: add localization
 352   return GetActionName(index);
 353 }
 354
 355 std::string AccessibleImpl::GetActionDescription(size_t index)
 356 {
 357   return "";
 358 }
 359
 360 size_t AccessibleImpl::GetActionCount()
 361 {
 362   Dali::TypeInfo type;
 363   Self().GetTypeInfo(type);
 364   DALI_ASSERT_ALWAYS(type && "no TypeInfo object");
 365   return type.GetActionCount();
 366 }
 367
 368 std::string AccessibleImpl::GetActionKeyBinding(size_t index)
 369 {
 370   return "";
 371 }
 372
 373 bool AccessibleImpl::DoAction(size_t index)
 374 {
 375   std::string actionName = GetActionName(index);
 376   return Self().DoAction(actionName, {});
 377 }
 378
 379 bool AccessibleImpl::DoAction(const std::string& name)
 380 {
 381   return Self().DoAction(name, {});
 382 }
 383
 384 bool AccessibleImpl::DoGesture(const Dali::Accessibility::GestureInfo& gestureInfo)
 385 {
 386   auto control = Dali::Toolkit::Control::DownCast(Self());
 387
 388   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 389   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 390
 391   if(!controlImpl.mAccessibilityDoGestureSignal.Empty())
 392   {
 393     auto ret = std::make_pair(gestureInfo, false);
 394     controlImpl.mAccessibilityDoGestureSignal.Emit(ret);
 395     return ret.second;
 396   }
 397
 398   return false;
 399 }
 400
 401 std::vector<Dali::Accessibility::Relation> AccessibleImpl::GetRelationSet()
 402 {
 403   auto control = Dali::Toolkit::Control::DownCast(Self());
 404
 405   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 406   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 407
 408   std::vector<Dali::Accessibility::Relation> ret;
 409
 410   auto& v = controlImpl.mAccessibilityRelations;
 411   for(auto i = 0u; i < v.size(); ++i)
 412   {
 413     if(v[i].empty())
 414       continue;
 415
 416     ret.emplace_back(Accessibility::Relation{static_cast<Accessibility::RelationType>(i), v[i]});
 417   }
 418
 419   return ret;
 420 }
 421
 422 bool AccessibleImpl::ScrollToChild(Actor child)
 423 {
 424   return false;
 425 }
 426
 427 Dali::Property::Index AccessibleImpl::GetNamePropertyIndex()
 428 {
 429   return Actor::Property::NAME;
 430 }
 431
 432 Dali::Property::Index AccessibleImpl::GetDescriptionPropertyIndex()
 433 {
 434   return Dali::Property::INVALID_INDEX;
 435 }
 436
 437 } // namespace Dali::Toolkit::DevelControl