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