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   // Remember the highlight actor, so that when the default is changed with
 295   // SetHighlightActor(), the currently displayed highlight can still be cleared.
 296   currentHighlightActor = highlight;
 297   EnsureSelfVisible();
 298   self.Add(highlight);
 299   SetCurrentlyHighlightedActor(self);
 300   EmitHighlighted(true);
 301
 302   return true;
 303 }
 304
 305 bool AccessibleImpl::ClearHighlight()
 306 {
 307   if(!Dali::Accessibility::IsUp())
 308     return false;
 309   if(GetCurrentlyHighlightedActor() == self)
 310   {
 311     self.Remove(currentHighlightActor.GetHandle());
 312     currentHighlightActor = {};
 313     SetCurrentlyHighlightedActor({});
 314     EmitHighlighted(false);
 315     return true;
 316   }
 317   return false;
 318 }
 319
 320 std::string AccessibleImpl::GetActionName(size_t index)
 321 {
 322   if(index >= GetActionCount()) return "";
 323   Dali::TypeInfo type;
 324   self.GetTypeInfo(type);
 325   DALI_ASSERT_ALWAYS(type && "no TypeInfo object");
 326   return type.GetActionName(index);
 327 }
 328
 329 std::string AccessibleImpl::GetLocalizedActionName(size_t index)
 330 {
 331   // TODO: add localization
 332   return GetActionName(index);
 333 }
 334
 335 std::string AccessibleImpl::GetActionDescription(size_t index)
 336 {
 337   return "";
 338 }
 339
 340 size_t AccessibleImpl::GetActionCount()
 341 {
 342   Dali::TypeInfo type;
 343   self.GetTypeInfo(type);
 344   DALI_ASSERT_ALWAYS(type && "no TypeInfo object");
 345   return type.GetActionCount();
 346 }
 347
 348 std::string AccessibleImpl::GetActionKeyBinding(size_t index)
 349 {
 350   return "";
 351 }
 352
 353 bool AccessibleImpl::DoAction(size_t index)
 354 {
 355   std::string actionName = GetActionName(index);
 356   return self.DoAction(actionName, {});
 357 }
 358
 359 bool AccessibleImpl::DoAction(const std::string& name)
 360 {
 361   return self.DoAction(name, {});
 362 }
 363
 364 bool AccessibleImpl::DoGesture(const Dali::Accessibility::GestureInfo& gestureInfo)
 365 {
 366   auto control = Dali::Toolkit::Control::DownCast(self);
 367
 368   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 369   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 370
 371   if(!controlImpl.mAccessibilityDoGestureSignal.Empty())
 372   {
 373     auto ret = std::make_pair(gestureInfo, false);
 374     controlImpl.mAccessibilityDoGestureSignal.Emit(ret);
 375     return ret.second;
 376   }
 377
 378   return false;
 379 }
 380
 381 std::vector<Dali::Accessibility::Relation> AccessibleImpl::GetRelationSet()
 382 {
 383   auto control = Dali::Toolkit::Control::DownCast(self);
 384
 385   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 386   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 387
 388   std::vector<Dali::Accessibility::Relation> ret;
 389
 390   auto& v = controlImpl.mAccessibilityRelations;
 391   for(auto i = 0u; i < v.size(); ++i)
 392   {
 393     if(v[i].empty())
 394       continue;
 395
 396     ret.emplace_back(Accessibility::Relation{static_cast<Accessibility::RelationType>(i), v[i]});
 397   }
 398
 399   return ret;
 400 }
 401
 402 void AccessibleImpl::EnsureChildVisible(Actor child)
 403 {
 404 }
 405
 406 void AccessibleImpl::EnsureSelfVisible()
 407 {
 408   auto parent = dynamic_cast<AccessibleImpl*>(GetParent());
 409   if(parent)
 410   {
 411     parent->EnsureChildVisible(self);
 412   }
 413 }
 414
 415 Dali::Property::Index AccessibleImpl::GetNamePropertyIndex()
 416 {
 417   return Actor::Property::NAME;
 418 }
 419
 420 Dali::Property::Index AccessibleImpl::GetDescriptionPropertyIndex()
 421 {
 422   return Dali::Property::INVALID_INDEX;
 423 }
 424
 425 } // namespace Dali::Toolkit::DevelControl