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