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