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