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 void AccessibleImpl::RegisterPositionPropertyNotification()
 332 {
 333   auto                     control         = Dali::Toolkit::Control::DownCast(Self());
 334   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 335   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 336   controlImpl.RegisterAccessibilityPositionPropertyNotification();
 337 }
 338
 339 void AccessibleImpl::UnregisterPositionPropertyNotification()
 340 {
 341   auto                     control         = Dali::Toolkit::Control::DownCast(Self());
 342   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 343   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 344   controlImpl.UnregisterAccessibilityPositionPropertyNotification();
 345 }
 346
 347 bool AccessibleImpl::GrabHighlight()
 348 {
 349   Dali::Actor self = Self();
 350   auto oldHighlightedActor = GetCurrentlyHighlightedActor();
 351
 352   if(!Dali::Accessibility::IsUp())
 353   {
 354     return false;
 355   }
 356
 357   if(self == oldHighlightedActor)
 358   {
 359     return true;
 360   }
 361
 362   // Clear the old highlight.
 363   if(oldHighlightedActor)
 364   {
 365     auto oldHighlightObject = dynamic_cast<Dali::Accessibility::Component*>(Internal::Control::Impl::GetAccessibilityObject(oldHighlightedActor));
 366     if(oldHighlightObject)
 367     {
 368       oldHighlightObject->ClearHighlight();
 369     }
 370   }
 371
 372   auto highlight = GetHighlightActor();
 373   if(!highlight)
 374   {
 375     highlight = CreateHighlightIndicatorActor();
 376     SetHighlightActor(highlight);
 377   }
 378
 379   highlight.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 380   highlight.SetProperty(Actor::Property::POSITION_Z, 1.0f);
 381   highlight.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
 382
 383   // Need to set resize policy again, to update SIZE property which is set by
 384   // AccessibleImpl_NUI. The highlight could move from AccessibleImpl_NUI to
 385   // AccessibleImpl. In this case, highlight has incorrect size.
 386   highlight.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
 387
 388   // Remember the highlight actor, so that when the default is changed with
 389   // SetHighlightActor(), the currently displayed highlight can still be cleared.
 390   mCurrentHighlightActor = highlight;
 391   ScrollToSelf();
 392   self.Add(highlight);
 393   SetCurrentlyHighlightedActor(self);
 394   EmitHighlighted(true);
 395   RegisterPositionPropertyNotification();
 396
 397   return true;
 398 }
 399
 400 bool AccessibleImpl::ClearHighlight()
 401 {
 402   Dali::Actor self = Self();
 403
 404   if(!Dali::Accessibility::IsUp())
 405   {
 406     return false;
 407   }
 408
 409   if(GetCurrentlyHighlightedActor() == self)
 410   {
 411     UnregisterPositionPropertyNotification();
 412     self.Remove(mCurrentHighlightActor.GetHandle());
 413     mCurrentHighlightActor = {};
 414     SetCurrentlyHighlightedActor({});
 415     EmitHighlighted(false);
 416     return true;
 417   }
 418   return false;
 419 }
 420
 421 std::string AccessibleImpl::GetActionName(size_t index)
 422 {
 423   if(index >= GetActionCount())
 424   {
 425     return {};
 426   }
 427
 428   Dali::TypeInfo type;
 429   Self().GetTypeInfo(type);
 430   DALI_ASSERT_ALWAYS(type && "no TypeInfo object");
 431   return type.GetActionName(index);
 432 }
 433
 434 std::string AccessibleImpl::GetLocalizedActionName(size_t index)
 435 {
 436   return GetLocaleText(GetActionName(index));
 437 }
 438
 439 std::string AccessibleImpl::GetActionDescription(size_t index)
 440 {
 441   return {};
 442 }
 443
 444 size_t AccessibleImpl::GetActionCount()
 445 {
 446   Dali::TypeInfo type;
 447   Self().GetTypeInfo(type);
 448   DALI_ASSERT_ALWAYS(type && "no TypeInfo object");
 449   return type.GetActionCount();
 450 }
 451
 452 std::string AccessibleImpl::GetActionKeyBinding(size_t index)
 453 {
 454   return {};
 455 }
 456
 457 bool AccessibleImpl::DoAction(size_t index)
 458 {
 459   std::string actionName = GetActionName(index);
 460   return Self().DoAction(actionName, {});
 461 }
 462
 463 bool AccessibleImpl::DoAction(const std::string& name)
 464 {
 465   return Self().DoAction(name, {});
 466 }
 467
 468 bool AccessibleImpl::DoGesture(const Dali::Accessibility::GestureInfo& gestureInfo)
 469 {
 470   auto control = Dali::Toolkit::Control::DownCast(Self());
 471
 472   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 473   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 474
 475   if(!controlImpl.mAccessibilityDoGestureSignal.Empty())
 476   {
 477     auto ret = std::make_pair(gestureInfo, false);
 478     controlImpl.mAccessibilityDoGestureSignal.Emit(ret);
 479     return ret.second;
 480   }
 481
 482   return false;
 483 }
 484
 485 std::vector<Dali::Accessibility::Relation> AccessibleImpl::GetRelationSet()
 486 {
 487   auto control = Dali::Toolkit::Control::DownCast(Self());
 488
 489   Internal::Control&       internalControl = Toolkit::Internal::GetImplementation(control);
 490   Internal::Control::Impl& controlImpl     = Internal::Control::Impl::Get(internalControl);
 491
 492   std::vector<Dali::Accessibility::Relation> ret;
 493
 494   auto& relation = controlImpl.mAccessibilityRelations;
 495   for(auto i = 0u; i < relation.size(); ++i)
 496   {
 497     if(relation[i].empty()) continue;
 498
 499     ret.emplace_back(Accessibility::Relation{static_cast<Accessibility::RelationType>(i), relation[i]});
 500   }
 501
 502   return ret;
 503 }
 504
 505 bool AccessibleImpl::ScrollToChild(Actor child)
 506 {
 507   return false;
 508 }
 509
 510 Dali::Property::Index AccessibleImpl::GetNamePropertyIndex()
 511 {
 512   return Actor::Property::NAME;
 513 }
 514
 515 Dali::Property::Index AccessibleImpl::GetDescriptionPropertyIndex()
 516 {
 517   return Dali::Property::INVALID_INDEX;
 518 }
 519
 520 void AccessibleImpl::SetLastPosition(Vector2 position)
 521 {
 522   mLastPosition = position;
 523 }
 524
 525 Vector2 AccessibleImpl::GetLastPosition() const
 526 {
 527   return mLastPosition;
 528 }
 529
 530 } // namespace Dali::Toolkit::DevelControl