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