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 bool AccessibleImpl::IsShowing()
 203 {
 204   Dali::Actor self = Self();
 205   if(self.GetProperty(Dali::DevelActor::Property::CULLED).Get<bool>() || !self.GetCurrentProperty<bool>(Actor::Property::VISIBLE))
 206   {
 207     return false;
 208   }
 209
 210   auto* child  = this;
 211   auto* parent = dynamic_cast<Toolkit::DevelControl::AccessibleImpl*>(child->GetParent());
 212   if(!parent)
 213   {
 214     return true;
 215   }
 216
 217   auto childExtent = child->GetExtents(Dali::Accessibility::CoordinateType::WINDOW);
 218   while(parent)
 219   {
 220     auto control      = Dali::Toolkit::Control::DownCast(parent->Self());
 221     auto clipMode     = control.GetProperty(Actor::Property::CLIPPING_MODE).Get<bool>();
 222     auto parentExtent = parent->GetExtents(Dali::Accessibility::CoordinateType::WINDOW);
 223     if ((clipMode != ClippingMode::DISABLED) && !parentExtent.Intersects(childExtent))
 224     {
 225       return false;
 226     }
 227     parent = dynamic_cast<Toolkit::DevelControl::AccessibleImpl*>(parent->GetParent());
 228   }
 229
 230   return true;
 231 }
 232
 233 Dali::Accessibility::States AccessibleImpl::CalculateStates()
 234 {
 235   Dali::Actor self = Self();
 236   Dali::Accessibility::States state;
 237   state[Dali::Accessibility::State::FOCUSABLE] = self.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE);
 238   state[Dali::Accessibility::State::FOCUSED]   = Toolkit::KeyboardFocusManager::Get().GetCurrentFocusActor() == self;
 239
 240   if(self.GetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE).GetType() == Dali::Property::NONE)
 241   {
 242     state[Dali::Accessibility::State::HIGHLIGHTABLE] = false;
 243   }
 244   else
 245   {
 246     state[Dali::Accessibility::State::HIGHLIGHTABLE] = self.GetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE).Get<bool>();
 247   }
 248
 249   state[Dali::Accessibility::State::HIGHLIGHTED] = GetCurrentlyHighlightedActor() == self;
 250   state[Dali::Accessibility::State::ENABLED]     = true;
 251   state[Dali::Accessibility::State::SENSITIVE]   = true;
 252   state[Dali::Accessibility::State::VISIBLE]     = true;
 253
 254   if(mIsModal)
 255   {
 256     state[Dali::Accessibility::State::MODAL] = true;
 257   }
 258   state[Dali::Accessibility::State::SHOWING] = IsShowing();
 259   state[Dali::Accessibility::State::DEFUNCT] = !self.GetProperty(Dali::DevelActor::Property::CONNECTED_TO_SCENE).Get<bool>();
 260   return state;
 261 }
 262
 263 Dali::Accessibility::States AccessibleImpl::GetStates()
 264 {
 265   return CalculateStates();
 266 }
 267
 268 Dali::Accessibility::Attributes AccessibleImpl::GetAttributes()
 269 {
 270   std::unordered_map<std::string, std::string> attributeMap;
 271   auto control = Dali::Toolkit::Control::DownCast(Self());
 272   auto attribute = control.GetProperty(Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES);
 273   auto map = attribute.GetMap();
 274
 275   if(map)
 276   {
 277     auto mapSize = map->Count();
 278
 279     for(unsigned int i = 0; i < mapSize; i++)
 280     {
 281       auto mapKey = map->GetKeyAt(i);
 282       if(mapKey.type == Dali::Property::Key::STRING)
 283       {
 284         std::string mapValue;
 285         if(map->GetValue(i).Get(mapValue))
 286         {
 287           attributeMap.emplace(std::move(mapKey.stringKey), std::move(mapValue));
 288         }
 289       }
 290     }
 291   }
 292
 293   return attributeMap;
 294 }
 295
 296 Dali::Accessibility::ComponentLayer AccessibleImpl::GetLayer()
 297 {
 298   return Dali::Accessibility::ComponentLayer::WINDOW;
 299 }
 300
 301 Dali::Rect<> AccessibleImpl::GetExtents(Dali::Accessibility::CoordinateType type)
 302 {
 303   Dali::Actor self = Self();
 304
 305   Vector2 screenPosition = self.GetProperty(Dali::DevelActor::Property::SCREEN_POSITION).Get<Vector2>();
 306   auto size = self.GetCurrentProperty<Vector3>(Actor::Property::SIZE) * self.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE);
 307   bool positionUsesAnchorPoint = self.GetProperty(Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT).Get<bool>();
 308   Vector3 anchorPointOffSet = size * (positionUsesAnchorPoint ? self.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT) : AnchorPoint::TOP_LEFT);
 309   Vector2 position = Vector2((screenPosition.x - anchorPointOffSet.x), (screenPosition.y - anchorPointOffSet.y));
 310
 311   return {position.x, position.y, size.x, size.y};
 312 }
 313
 314 int16_t AccessibleImpl::GetMdiZOrder()
 315 {
 316   return 0;
 317 }
 318 double AccessibleImpl::GetAlpha()
 319 {
 320   return 0;
 321 }
 322
 323 bool AccessibleImpl::GrabFocus()
 324 {
 325   return Toolkit::KeyboardFocusManager::Get().SetCurrentFocusActor(Self());
 326 }
 327
 328 static Dali::Actor CreateHighlightIndicatorActor()
 329 {
 330   std::string focusBorderImagePath(AssetManager::GetDaliImagePath());
 331   focusBorderImagePath += "/keyboard_focus.9.png";
 332
 333   // Create the default if it hasn't been set and one that's shared by all the
 334   // keyboard focusable actors
 335   auto actor = Toolkit::ImageView::New(focusBorderImagePath);
 336   actor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
 337
 338   DevelControl::AppendAccessibilityAttribute(actor, "highlight", std::string());
 339   actor.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, false);
 340
 341   return actor;
 342 }
 343
 344 void AccessibleImpl::ScrollToSelf()
 345 {
 346   auto* child = this;
 347   auto* parent = dynamic_cast<Toolkit::DevelControl::AccessibleImpl*>(child->GetParent());
 348
 349   while (parent)
 350   {
 351     if (parent->IsScrollable())
 352     {
 353       parent->ScrollToChild(child->Self());
 354     }
 355
 356     child = parent;
 357     parent = dynamic_cast<Toolkit::DevelControl::AccessibleImpl*>(parent->GetParent());
 358   }
 359 }
 360
 361 void AccessibleImpl::RegisterPositionPropertyNotification()
 362 {
 363   auto                     control         = Dali::Toolkit::Control::DownCast(Self());
 364   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 365   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 366   controlImpl.RegisterAccessibilityPositionPropertyNotification();
 367 }
 368
 369 void AccessibleImpl::UnregisterPositionPropertyNotification()
 370 {
 371   auto                     control         = Dali::Toolkit::Control::DownCast(Self());
 372   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 373   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 374   controlImpl.UnregisterAccessibilityPositionPropertyNotification();
 375 }
 376
 377 bool AccessibleImpl::GrabHighlight()
 378 {
 379   Dali::Actor self = Self();
 380   auto oldHighlightedActor = GetCurrentlyHighlightedActor();
 381
 382   if(!Dali::Accessibility::IsUp())
 383   {
 384     return false;
 385   }
 386
 387   if(self == oldHighlightedActor)
 388   {
 389     return true;
 390   }
 391
 392   // Clear the old highlight.
 393   if(oldHighlightedActor)
 394   {
 395     auto oldHighlightObject = dynamic_cast<Dali::Accessibility::Component*>(Internal::Control::Impl::GetAccessibilityObject(oldHighlightedActor));
 396     if(oldHighlightObject)
 397     {
 398       oldHighlightObject->ClearHighlight();
 399     }
 400   }
 401
 402   auto highlight = GetHighlightActor();
 403   if(!highlight)
 404   {
 405     highlight = CreateHighlightIndicatorActor();
 406     SetHighlightActor(highlight);
 407   }
 408
 409   highlight.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 410   highlight.SetProperty(Actor::Property::POSITION_Z, 1.0f);
 411   highlight.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
 412
 413   // Need to set resize policy again, to update SIZE property which is set by
 414   // AccessibleImpl_NUI. The highlight could move from AccessibleImpl_NUI to
 415   // AccessibleImpl. In this case, highlight has incorrect size.
 416   highlight.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
 417
 418   // Remember the highlight actor, so that when the default is changed with
 419   // SetHighlightActor(), the currently displayed highlight can still be cleared.
 420   mCurrentHighlightActor = highlight;
 421   ScrollToSelf();
 422   self.Add(highlight);
 423   SetCurrentlyHighlightedActor(self);
 424   EmitHighlighted(true);
 425   RegisterPositionPropertyNotification();
 426
 427   return true;
 428 }
 429
 430 bool AccessibleImpl::ClearHighlight()
 431 {
 432   Dali::Actor self = Self();
 433
 434   if(!Dali::Accessibility::IsUp())
 435   {
 436     return false;
 437   }
 438
 439   if(GetCurrentlyHighlightedActor() == self)
 440   {
 441     UnregisterPositionPropertyNotification();
 442     self.Remove(mCurrentHighlightActor.GetHandle());
 443     mCurrentHighlightActor = {};
 444     SetCurrentlyHighlightedActor({});
 445     EmitHighlighted(false);
 446     return true;
 447   }
 448   return false;
 449 }
 450
 451 std::string AccessibleImpl::GetActionName(size_t index)
 452 {
 453   if(index >= GetActionCount())
 454   {
 455     return {};
 456   }
 457
 458   Dali::TypeInfo type;
 459   Self().GetTypeInfo(type);
 460   DALI_ASSERT_ALWAYS(type && "no TypeInfo object");
 461   return type.GetActionName(index);
 462 }
 463
 464 std::string AccessibleImpl::GetLocalizedActionName(size_t index)
 465 {
 466   return GetLocaleText(GetActionName(index));
 467 }
 468
 469 std::string AccessibleImpl::GetActionDescription(size_t index)
 470 {
 471   return {};
 472 }
 473
 474 size_t AccessibleImpl::GetActionCount()
 475 {
 476   Dali::TypeInfo type;
 477   Self().GetTypeInfo(type);
 478   DALI_ASSERT_ALWAYS(type && "no TypeInfo object");
 479   return type.GetActionCount();
 480 }
 481
 482 std::string AccessibleImpl::GetActionKeyBinding(size_t index)
 483 {
 484   return {};
 485 }
 486
 487 bool AccessibleImpl::DoAction(size_t index)
 488 {
 489   std::string actionName = GetActionName(index);
 490   return Self().DoAction(actionName, {});
 491 }
 492
 493 bool AccessibleImpl::DoAction(const std::string& name)
 494 {
 495   return Self().DoAction(name, {});
 496 }
 497
 498 bool AccessibleImpl::DoGesture(const Dali::Accessibility::GestureInfo& gestureInfo)
 499 {
 500   auto control = Dali::Toolkit::Control::DownCast(Self());
 501
 502   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 503   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 504
 505   if(!controlImpl.mAccessibilityDoGestureSignal.Empty())
 506   {
 507     auto ret = std::make_pair(gestureInfo, false);
 508     controlImpl.mAccessibilityDoGestureSignal.Emit(ret);
 509     return ret.second;
 510   }
 511
 512   return false;
 513 }
 514
 515 std::vector<Dali::Accessibility::Relation> AccessibleImpl::GetRelationSet()
 516 {
 517   auto control = Dali::Toolkit::Control::DownCast(Self());
 518
 519   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 520   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 521
 522   std::vector<Dali::Accessibility::Relation> ret;
 523
 524   auto& relation = controlImpl.mAccessibilityRelations;
 525   for(auto i = 0u; i < relation.size(); ++i)
 526   {
 527     if(relation[i].empty()) continue;
 528
 529     ret.emplace_back(Accessibility::Relation{static_cast<Accessibility::RelationType>(i), relation[i]});
 530   }
 531
 532   return ret;
 533 }
 534
 535 bool AccessibleImpl::ScrollToChild(Actor child)
 536 {
 537   return false;
 538 }
 539
 540 Dali::Property::Index AccessibleImpl::GetNamePropertyIndex()
 541 {
 542   return Actor::Property::NAME;
 543 }
 544
 545 Dali::Property::Index AccessibleImpl::GetDescriptionPropertyIndex()
 546 {
 547   return Dali::Property::INVALID_INDEX;
 548 }
 549
 550 void AccessibleImpl::SetLastPosition(Vector2 position)
 551 {
 552   mLastPosition = position;
 553 }
 554
 555 Vector2 AccessibleImpl::GetLastPosition() const
 556 {
 557   return mLastPosition;
 558 }
 559
 560 } // namespace Dali::Toolkit::DevelControl