src/ui/FUi_AccessibilityContainerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <FBaseSysLog.h>
  19 #include <FBaseString.h>
  20 #include <FUiAccessibilityElement.h>
  21 #include <FUiAccessibilityContainer.h>
  22 #include <FUiIAccessibilityListener.h>
  23 #include "FUi_ControlImpl.h"
  24 #include "FUi_AccessibilityElement.h"
  25 #include "FUi_AccessibilityElementImpl.h"
  26 #include "FUi_AccessibilityContainer.h"
  27 #include "FUi_AccessibilityContainerImpl.h"
  28
  29 using namespace Tizen::Base;
  30 using namespace Tizen::Base::Collection;
  31 using namespace Tizen::Graphics;
  32
  33 namespace Tizen { namespace Ui {
  34 _AccessibilityContainerImpl::_AccessibilityContainerImpl(const _ControlImpl& controlImpl, const AccessibilityContainer& publicInstance, const _AccessibilityContainer& coreInstance)
  35         : __pControlImpl(null)
  36         , __pPublic(null)
  37         , __pCore(null)
  38 {
  39         __pControlImpl = &const_cast<_ControlImpl&>(controlImpl);
  40         __pPublic = &const_cast<AccessibilityContainer&>(publicInstance);
  41         __pCore = &const_cast<_AccessibilityContainer&>(coreInstance);
  42         __coreHandle = controlImpl.GetCore().GetHandle();
  43 }
  44 AccessibilityContainer*
  45 _AccessibilityContainerImpl::CreateAccessibilityContainerN(const _ControlImpl& controlImpl)
  46 {
  47         _ControlImpl* pControlImpl = const_cast <_ControlImpl*>(&controlImpl);
  48         _AccessibilityContainer* pCore = pControlImpl->GetCore().GetAccessibilityContainer();
  49         SysTryReturn(NID_UI, pCore, null, E_SYSTEM, "[E_SYSTEM] This instance has not constructed.");
  50
  51         AccessibilityContainer* pPublic = new (std::nothrow) AccessibilityContainer();
  52         SysTryReturn(NID_UI, pPublic, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed");
  53
  54         _AccessibilityContainerImpl* pImpl = new (std::nothrow) _AccessibilityContainerImpl(controlImpl, *pPublic, *pCore);
  55         SysTryCatch(NID_UI, pImpl,,E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed");
  56         pPublic->__pAccessibilityContainerImpl = pImpl;
  57         return pPublic;
  58
  59 CATCH:
  60         delete pPublic;
  61         return null;
  62 }
  63 _AccessibilityContainerImpl::~_AccessibilityContainerImpl(void)
  64 {
  65         AccessibilityElement* pElement = null;
  66         int count = __elementList.GetCount();
  67         result r = E_SUCCESS;
  68         for ( int i = 0 ; i < count ; i++)
  69         {
  70                 r = __elementList.GetAt(i, pElement);
  71                 if (r == E_SUCCESS)
  72                 {
  73                         delete pElement;
  74                         pElement = null;
  75                 }
  76         }
  77         __elementList.RemoveAll();
  78         delete __pPublic;
  79         __pPublic = null;
  80         __listenerList.RemoveAll();
  81 }
  82 _ControlImpl&
  83 _AccessibilityContainerImpl::GetOwner(void)
  84 {
  85         return *__pControlImpl;
  86 }
  87
  88 AccessibilityContainer&
  89 _AccessibilityContainerImpl::GetPublic(void)
  90 {
  91         return *__pPublic;
  92 }
  93
  94 AccessibilityElement*
  95 _AccessibilityContainerImpl::GetChildElement(const String& name)
  96 {
  97         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), null, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
  98         _AccessibilityElementImpl* pNewElementImpl = null;
  99         _AccessibilityElement* pElement = __pCore->GetChildElement(name);
 100         SysTryReturn(NID_UI, pElement, null, E_SYSTEM,"[E_SYSTEM]");
 101         if(pElement->GetUserData() == null)
 102         {
 103                 pNewElementImpl = new (std::nothrow) _AccessibilityElementImpl(*pElement);
 104                 SysTryReturn(NID_UI, pNewElementImpl, null, E_OUT_OF_MEMORY,"[E_OUT_OF_MEMORY] Memory allocation is failed");
 105                 pElement->SetUserData(pNewElementImpl);
 106                 __elementList.Add(&(pNewElementImpl->GetPublic()));
 107                 return &(pNewElementImpl->GetPublic());
 108         }
 109         return &(static_cast<_AccessibilityElementImpl*>(pElement->GetUserData())->GetPublic());
 110 }
 111
 112 result
 113 _AccessibilityContainerImpl::AddAccessibilityListener(const IAccessibilityListener& listener)
 114 {
 115         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 116         result r = E_OBJ_ALREADY_EXIST;
 117         __pCore->AddListener(*this);
 118         int index = 0;
 119         IAccessibilityListener* pListener = &const_cast<IAccessibilityListener&>(listener);
 120         SysTryReturn(NID_UI,pListener && __listenerList.IndexOf(pListener,index) != E_SUCCESS, E_OBJ_ALREADY_EXIST, E_OBJ_ALREADY_EXIST,"[E_OBJ_ALREADY_EXIST] The listener is already exist.");
 121         r = __listenerList.Add(pListener);
 122         SysTryReturn(NID_UI, r == E_SUCCESS, r, r,"[%s]",GetErrorMessage(r));
 123
 124         return r;
 125 }
 126
 127 result
 128 _AccessibilityContainerImpl::RemoveAccessibilityListener(const IAccessibilityListener& listener)
 129 {
 130         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 131         result r = E_OBJ_NOT_FOUND;
 132         SysTryReturn(NID_UI, __listenerList.GetCount() > 0, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND,"[E_OBJ_NOT_FOUND] the listener has been not added.");
 133
 134         int index = 0;
 135         IAccessibilityListener* pListener = &const_cast<IAccessibilityListener&>(listener);
 136         SysTryReturn(NID_UI,pListener && __listenerList.IndexOf(pListener,index) == E_SUCCESS, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND,"[E_OBJ_NOT_FOUND] the listener has been not added.");
 137         r = __listenerList.Remove(pListener);
 138         SysTryReturn(NID_UI, r == E_SUCCESS, r, r,"[%s]",GetErrorMessage(r));
 139
 140         if(__listenerList.GetCount() < 1)
 141         {
 142                 __pCore->RemoveListener(*this);
 143         }
 144         return r;
 145 }
 146
 147 result
 148 _AccessibilityContainerImpl::AddElement(const _AccessibilityElementImpl& element)
 149 {
 150         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 151         __elementList.Add(&(const_cast<_AccessibilityElementImpl&>(element).GetPublic()));
 152         return __pCore->AddElement(element.GetCore());
 153 }
 154
 155 result
 156 _AccessibilityContainerImpl::AddElements(const IList& elementList)
 157 {
 158         return E_SYSTEM;
 159 }
 160
 161 IList*
 162 _AccessibilityContainerImpl::GetElementsN(void)
 163 {
 164         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), null, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 165         LinkedList* _pList = new (std::nothrow) LinkedList;
 166         SysTryReturn(NID_UI, _pList, null, E_OUT_OF_MEMORY,"[E_OUT_OF_MEMORY] Memory allocation is failed");
 167         int count = 0;
 168         result r = E_SUCCESS;
 169         _AccessibilityElement* pItem = null;
 170         IListT<_AccessibilityElement*>* pList = __pCore->GetElementsN();
 171         SysTryCatch(NID_UI, pList, , E_SYSTEM,"[E_SYSTEM]");
 172         count = pList->GetCount();
 173         SysTryCatch(NID_UI, count >= 1, , E_SYSTEM,"[E_SYSTEM]");
 174
 175         for (int i = 0;i < count; i++)
 176         {
 177                 _AccessibilityElementImpl* pNewElementImpl = null;
 178                 r = pList->GetAt(i,pItem);
 179                 SysTryCatch(NID_UI, r == E_SUCCESS, , E_SYSTEM,"[E_SYSTEM]");
 180
 181                 if(pItem->GetUserData() == null)
 182                 {
 183                         pNewElementImpl = new (std::nothrow) _AccessibilityElementImpl(*pItem);
 184                         SysTryCatch(NID_UI, pNewElementImpl, , E_OUT_OF_MEMORY,"[E_OUT_OF_MEMORY] Memory allocation is failed");
 185                         pItem->SetUserData(pNewElementImpl);
 186                         AddSystemElement(pNewElementImpl->GetPublic());
 187                 }
 188                 else
 189                 {
 190                         pNewElementImpl = static_cast<_AccessibilityElementImpl*>(pItem->GetUserData());
 191                 }
 192                 _pList->Add(pNewElementImpl->GetPublic());
 193         }
 194         delete pList;
 195         return _pList;
 196 CATCH:
 197         delete pList;
 198         delete _pList;
 199         return null;
 200 }
 201
 202 result
 203 _AccessibilityContainerImpl::RemoveElement(const _AccessibilityElementImpl& element)
 204 {
 205         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 206         AccessibilityElement* pElement = const_cast<AccessibilityElement*>(&(element.GetPublic()));
 207         result r = __elementList.Remove(pElement);
 208         const_cast<_AccessibilityElementImpl&>(element).GetCore().Activate(false);
 209         delete pElement;
 210         return r;
 211 }
 212
 213 result
 214 _AccessibilityContainerImpl::RemoveAllElement(void)
 215 {
 216         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 217         result r = E_SUCCESS;//__pCore->RemoveAllElement();
 218         if (r == E_SUCCESS)
 219         {
 220                 int count = __elementList.GetCount();
 221                 AccessibilityElement* pElement = null;
 222                 for (int i = 0; i < count; i++)
 223                 {
 224                         if (__elementList.GetAt(i, pElement) == E_SUCCESS)
 225                         {
 226                                 _AccessibilityElementImpl* pImpl = _AccessibilityElementImpl::GetInstance(*pElement);
 227                                 pImpl->GetCore().Activate(false);
 228                                 delete pElement;
 229                                 pElement = null;
 230                         }
 231                 }
 232                 __elementList.RemoveAll();
 233         }
 234         if (__pCore)
 235         {
 236                 LinkedListT<_AccessibilityElement*> list;
 237                 __pCore->GetElements(list);
 238                 int count = list.GetCount();
 239                 for (int i = 0; i < count; i++)
 240                 {
 241                         _AccessibilityElement* pElement = null;
 242                         if (list.GetAt(i, pElement) == E_SUCCESS)
 243                         {
 244                                 pElement->Activate(false);
 245                         }
 246                 }
 247         }
 248         return r;
 249 }
 250
 251 String
 252 _AccessibilityContainerImpl::GetCurrentGrammar(void) const
 253 {
 254         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), L"", E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 255         return __pCore->GetCurrentGrammar();
 256 }
 257
 258 AccessibilityScreenReaderStatus
 259 _AccessibilityContainerImpl::GetStatus(void) const
 260 {
 261         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), ACCESSIBILITY_SCREEN_READER_STATUS__NONE, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 262         return __pCore->GetStatus();
 263 }
 264
 265 void
 266 _AccessibilityContainerImpl::ReadingAll(void)
 267 {
 268         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), , E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 269         return __pCore->ReadingAll();
 270 }
 271
 272 _AccessibilityContainerImpl*
 273 _AccessibilityContainerImpl::GetInstance(AccessibilityContainer& container)
 274 {
 275         return static_cast<_AccessibilityContainerImpl*> (container.__pAccessibilityContainerImpl);
 276 }
 277
 278 const _AccessibilityContainerImpl*
 279 _AccessibilityContainerImpl::GetInstance(const AccessibilityContainer& container)
 280 {
 281         return static_cast<_AccessibilityContainerImpl*> (container.__pAccessibilityContainerImpl);
 282 }
 283
 284 bool
 285 _AccessibilityContainerImpl::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 286 {
 287         return true;
 288 }
 289 bool
 290 _AccessibilityContainerImpl::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 291 {
 292         return true;
 293 }
 294 bool
 295 _AccessibilityContainerImpl::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 296 {
 297         int count = __listenerList.GetCount();
 298         if (count > 0)
 299         {
 300                 IAccessibilityListener* pListener = null;
 301                 for (int i = 0 ; i < count ; i++)
 302                 {
 303                         if(__listenerList.GetAt(i, pListener) == E_SUCCESS)
 304                         {
 305                                 AccessibilityElement* pElement = GetChildElement(element.GetName());
 306                                 if (pElement != null)
 307                                 {
 308                                         pListener->OnAccessibilityScreenReaderStatusChanged(GetOwner().GetPublic(),*pElement, ACCESSIBILITY_SCREEN_READER_STATUS_READY);
 309                                 }
 310                         }
 311                 }
 312         }
 313         return true;
 314 }
 315 bool
 316 _AccessibilityContainerImpl::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 317 {
 318         int count = __listenerList.GetCount();
 319         if (count > 0)
 320         {
 321                 IAccessibilityListener* pListener = null;
 322                 for (int i = 0 ; i < count ; i++)
 323                 {
 324                         if(__listenerList.GetAt(i, pListener) == E_SUCCESS)
 325                         {
 326                                 AccessibilityElement* pElement = GetChildElement(element.GetName());
 327                                 if (pElement != null)
 328                                 {
 329                                         pListener->OnAccessibilityScreenReaderStatusChanged(GetOwner().GetPublic(),*pElement, ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
 330                                 }
 331                         }
 332                 }
 333         }
 334         return true;
 335 }
 336
 337 bool
 338 _AccessibilityContainerImpl::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 339 {
 340         int count = __listenerList.GetCount();
 341         if (count > 0)
 342         {
 343                 IAccessibilityListener* pListener = null;
 344                 for (int i = 0 ; i < count ; i++)
 345                 {
 346                         if(__listenerList.GetAt(i, pListener) == E_SUCCESS)
 347                         {
 348                                 AccessibilityElement* pElement = GetChildElement(element.GetName());
 349                                 if (pElement != null)
 350                                 {
 351                                         pListener->OnAccessibilityFocusIn(GetOwner().GetPublic(),*pElement);
 352                                 }
 353                         }
 354                 }
 355         }
 356         return true;
 357 }
 358 bool
 359 _AccessibilityContainerImpl::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 360 {
 361         int count = __listenerList.GetCount();
 362         if (count > 0)
 363         {
 364                 IAccessibilityListener* pListener = null;
 365                 for (int i = 0 ; i < count ; i++)
 366                 {
 367                         if(__listenerList.GetAt(i, pListener) == E_SUCCESS)
 368                         {
 369                                 AccessibilityElement* pElement = GetChildElement(element.GetName());
 370                                 if (pElement != null)
 371                                 {
 372                                         pListener->OnAccessibilityFocusOut(GetOwner().GetPublic(),*pElement);
 373                                 }
 374                         }
 375                 }
 376         }
 377         return true;
 378 }
 379 bool
 380 _AccessibilityContainerImpl::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 381 {
 382         int count = __listenerList.GetCount();
 383         if (count > 0)
 384         {
 385                 IAccessibilityListener* pListener = null;
 386                 for (int i = 0 ; i < count ; i++)
 387                 {
 388                         if(__listenerList.GetAt(i, pListener) == E_SUCCESS)
 389                         {
 390                                 AccessibilityElement* pElement = GetChildElement(element.GetName());
 391                                 if (pElement != null)
 392                                 {
 393                                         pListener->OnAccessibilityActionPerformed(GetOwner().GetPublic(),*pElement);
 394                                 }
 395                         }
 396                 }
 397         }
 398         return true;
 399 }
 400 bool
 401 _AccessibilityContainerImpl::OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 402 {
 403         return false;
 404 }
 405 bool
 406 _AccessibilityContainerImpl::OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 407 {
 408         return false;
 409 }
 410 bool
 411 _AccessibilityContainerImpl::ControlCoreExists(_ControlHandle handle) const
 412 {
 413         _Control* p_Control = null;
 414         _ControlManager* pManager = _ControlManager::GetInstance();
 415         SysTryReturn(NID_UI, !(handle.IsNull()), false, E_SYSTEM, "[E_SYSTEM] System Error.");
 416         SysTryReturn(NID_UI, pManager, false, E_SYSTEM, "[E_SYSTEM] System Error.");
 417
 418         p_Control = pManager->GetObject(handle);
 419         SysTryReturn(NID_UI,
 420                                 p_Control && p_Control->GetHandle() == __pControlImpl->GetCore().GetHandle(), false, E_SYSTEM,
 421                                 "[E_SYSTEM] System Error.");
 422
 423         SetLastResult(E_SUCCESS);
 424         return true;
 425 }
 426
 427 result
 428 _AccessibilityContainerImpl::MoveElement(const _AccessibilityElementImpl* pPreviousElement, const _AccessibilityElementImpl& element)
 429 {
 430         _AccessibilityElement* pPreviousCore = null;
 431         if (pPreviousElement != null)
 432         {
 433                 pPreviousCore = &const_cast<_AccessibilityElement&>(pPreviousElement->GetCore());
 434         }
 435         return __pCore->MoveElement(pPreviousCore, element.GetCore());
 436 }
 437
 438 void
 439 _AccessibilityContainerImpl::AddSystemElement(const AccessibilityElement& element)
 440 {
 441 }
 442 }} //Tizen::Ui