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