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 && pCore->IsActivated(), 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         if (r == E_SUCCESS)
 209         {
 210                 const_cast<_AccessibilityElementImpl&>(element).GetCore().Activate(false);
 211                 delete pElement;
 212         }
 213         return r;
 214 }
 215
 216 result
 217 _AccessibilityContainerImpl::RemoveAllElement(void)
 218 {
 219         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 220         result r = E_SUCCESS;//__pCore->RemoveAllElement();
 221         if (r == E_SUCCESS)
 222         {
 223                 int count = __elementList.GetCount();
 224                 AccessibilityElement* pElement = null;
 225                 for (int i = 0; i < count; i++)
 226                 {
 227                         if (__elementList.GetAt(i, pElement) == E_SUCCESS)
 228                         {
 229                                 _AccessibilityElementImpl* pImpl = _AccessibilityElementImpl::GetInstance(*pElement);
 230                                 pImpl->GetCore().Activate(false);
 231                                 delete pElement;
 232                                 pElement = null;
 233                         }
 234                 }
 235                 __elementList.RemoveAll();
 236         }
 237         return r;
 238 }
 239
 240 String
 241 _AccessibilityContainerImpl::GetCurrentGrammar(void) const
 242 {
 243         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), L"", E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 244         return __pCore->GetCurrentGrammar();
 245 }
 246
 247 AccessibilityScreenReaderStatus
 248 _AccessibilityContainerImpl::GetStatus(void) const
 249 {
 250         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), ACCESSIBILITY_SCREEN_READER_STATUS__NONE, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 251         return __pCore->GetStatus();
 252 }
 253
 254 void
 255 _AccessibilityContainerImpl::ReadingAll(void)
 256 {
 257         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), , E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 258         return __pCore->ReadingAll();
 259 }
 260
 261 _AccessibilityContainerImpl*
 262 _AccessibilityContainerImpl::GetInstance(AccessibilityContainer& container)
 263 {
 264         return static_cast<_AccessibilityContainerImpl*> (container.__pAccessibilityContainerImpl);
 265 }
 266
 267 const _AccessibilityContainerImpl*
 268 _AccessibilityContainerImpl::GetInstance(const AccessibilityContainer& container)
 269 {
 270         return static_cast<_AccessibilityContainerImpl*> (container.__pAccessibilityContainerImpl);
 271 }
 272
 273 bool
 274 _AccessibilityContainerImpl::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 275 {
 276         return true;
 277 }
 278 bool
 279 _AccessibilityContainerImpl::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 280 {
 281         return true;
 282 }
 283 bool
 284 _AccessibilityContainerImpl::OnAccessibilityReadedElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 285 {
 286         int count = __listenerList.GetCount();
 287         if (count > 0)
 288         {
 289                 IAccessibilityListener* pListener = null;
 290                 for (int i = 0 ; i < count ; i++)
 291                 {
 292                         if(__listenerList.GetAt(i, pListener) == E_SUCCESS)
 293                         {
 294                                 AccessibilityElement* pElement = GetChildElement(element.GetName());
 295                                 if (pElement != null)
 296                                 {
 297                                         pListener->OnAccessibilityScreenReaderStatusChanged(GetOwner().GetPublic(),*pElement, ACCESSIBILITY_SCREEN_READER_STATUS_READY);
 298                                 }
 299                         }
 300                 }
 301         }
 302         return true;
 303 }
 304 bool
 305 _AccessibilityContainerImpl::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 306 {
 307         int count = __listenerList.GetCount();
 308         if (count > 0)
 309         {
 310                 IAccessibilityListener* pListener = null;
 311                 for (int i = 0 ; i < count ; i++)
 312                 {
 313                         if(__listenerList.GetAt(i, pListener) == E_SUCCESS)
 314                         {
 315                                 AccessibilityElement* pElement = GetChildElement(element.GetName());
 316                                 if (pElement != null)
 317                                 {
 318                                         pListener->OnAccessibilityScreenReaderStatusChanged(GetOwner().GetPublic(),*pElement, ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
 319                                 }
 320                         }
 321                 }
 322         }
 323         return true;
 324 }
 325
 326 bool
 327 _AccessibilityContainerImpl::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 328 {
 329         int count = __listenerList.GetCount();
 330         if (count > 0)
 331         {
 332                 IAccessibilityListener* pListener = null;
 333                 for (int i = 0 ; i < count ; i++)
 334                 {
 335                         if(__listenerList.GetAt(i, pListener) == E_SUCCESS)
 336                         {
 337                                 AccessibilityElement* pElement = GetChildElement(element.GetName());
 338                                 if (pElement != null)
 339                                 {
 340                                         pListener->OnAccessibilityFocusIn(GetOwner().GetPublic(),*pElement);
 341                                 }
 342                         }
 343                 }
 344         }
 345         return true;
 346 }
 347 bool
 348 _AccessibilityContainerImpl::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 349 {
 350         int count = __listenerList.GetCount();
 351         if (count > 0)
 352         {
 353                 IAccessibilityListener* pListener = null;
 354                 for (int i = 0 ; i < count ; i++)
 355                 {
 356                         if(__listenerList.GetAt(i, pListener) == E_SUCCESS)
 357                         {
 358                                 AccessibilityElement* pElement = GetChildElement(element.GetName());
 359                                 if (pElement != null)
 360                                 {
 361                                         pListener->OnAccessibilityFocusOut(GetOwner().GetPublic(),*pElement);
 362                                 }
 363                         }
 364                 }
 365         }
 366         return true;
 367 }
 368 bool
 369 _AccessibilityContainerImpl::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 370 {
 371         int count = __listenerList.GetCount();
 372         if (count > 0)
 373         {
 374                 IAccessibilityListener* pListener = null;
 375                 for (int i = 0 ; i < count ; i++)
 376                 {
 377                         if(__listenerList.GetAt(i, pListener) == E_SUCCESS)
 378                         {
 379                                 AccessibilityElement* pElement = GetChildElement(element.GetName());
 380                                 if (pElement != null)
 381                                 {
 382                                         pListener->OnAccessibilityActionPerformed(GetOwner().GetPublic(),*pElement);
 383                                 }
 384                         }
 385                 }
 386         }
 387         return true;
 388 }
 389 bool
 390 _AccessibilityContainerImpl::OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 391 {
 392         return true;
 393 }
 394 bool
 395 _AccessibilityContainerImpl::OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 396 {
 397         return true;
 398 }
 399 bool
 400 _AccessibilityContainerImpl::ControlCoreExists(_ControlHandle handle) const
 401 {
 402         _Control* p_Control = null;
 403         _ControlManager* pManager = _ControlManager::GetInstance();
 404         SysTryReturn(NID_UI, !(handle.IsNull()), false, E_SYSTEM, "[E_SYSTEM] System Error.");
 405         SysTryReturn(NID_UI, pManager, false, E_SYSTEM, "[E_SYSTEM] System Error.");
 406
 407         p_Control = pManager->GetObject(handle);
 408         SysTryReturn(NID_UI,
 409                                 p_Control && p_Control->GetHandle() == __pControlImpl->GetCore().GetHandle(), false, E_SYSTEM,
 410                                 "[E_SYSTEM] System Error.");
 411
 412         SetLastResult(E_SUCCESS);
 413         return true;
 414 }
 415
 416 result
 417 _AccessibilityContainerImpl::MoveElement(const _AccessibilityElementImpl* pPreviousElement, const _AccessibilityElementImpl& element)
 418 {
 419         _AccessibilityElement* pPreviousCore = null;
 420         if (pPreviousElement != null)
 421         {
 422                 pPreviousCore = &const_cast<_AccessibilityElement&>(pPreviousElement->GetCore());
 423         }
 424         return __pCore->MoveElement(pPreviousCore, element.GetCore());
 425 }
 426
 427 void
 428 _AccessibilityContainerImpl::AddSystemElement(const AccessibilityElement& element)
 429 {
 430 }
 431 }} //Tizen::Ui