src/ui/FUi_AccessibilityContainerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
  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 "FUi_ControlImpl.h"
  23 #include "FUi_AccessibilityElement.h"
  24 #include "FUi_AccessibilityElementImpl.h"
  25 #include "FUi_AccessibilityContainer.h"
  26 #include "FUi_AccessibilityContainerImpl.h"
  27
  28 using namespace Tizen::Base;
  29 using namespace Tizen::Base::Collection;
  30 using namespace Tizen::Graphics;
  31
  32 namespace Tizen { namespace Ui {
  33 _AccessibilityContainerImpl::_AccessibilityContainerImpl(const _ControlImpl& controlImpl, const AccessibilityContainer& publicInstance, const _AccessibilityContainer& coreInstance)
  34         : __pControlImpl(null)
  35         , __pPublic(null)
  36         , __pCore(null)
  37 {
  38         __pControlImpl = &const_cast<_ControlImpl&>(controlImpl);
  39         __pPublic = &const_cast<AccessibilityContainer&>(publicInstance);
  40         __pCore = &const_cast<_AccessibilityContainer&>(coreInstance);
  41         __coreHandle = controlImpl.GetCore().GetHandle();
  42 }
  43 AccessibilityContainer*
  44 _AccessibilityContainerImpl::CreateAccessibilityContainerN(const _ControlImpl& controlImpl)
  45 {
  46         _ControlImpl* pControlImpl = const_cast <_ControlImpl*>(&controlImpl);
  47         _AccessibilityContainer* pCore = pControlImpl->GetCore().GetAccessibilityContainer();
  48         SysTryReturn(NID_UI, pCore && pCore->IsActivated(), null, E_SYSTEM, "[E_SYSTEM] This instance has not constructed.");
  49
  50         AccessibilityContainer* pPublic = new (std::nothrow) AccessibilityContainer();
  51         SysTryReturn(NID_UI, pPublic, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed");
  52
  53         _AccessibilityContainerImpl* pImpl = new (std::nothrow) _AccessibilityContainerImpl(controlImpl, *pPublic, *pCore);
  54         SysTryCatch(NID_UI, pImpl,,E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed");
  55         pPublic->__pAccessibilityContainerImpl = pImpl;
  56         return pPublic;
  57
  58 CATCH:
  59         delete pPublic;
  60         return null;
  61 }
  62 _AccessibilityContainerImpl::~_AccessibilityContainerImpl(void)
  63 {
  64         AccessibilityElement* pElement = null;
  65         int count = __elementList.GetCount();
  66         result r = E_SUCCESS;
  67         for ( int i = 0 ; i < count ; i++)
  68         {
  69                 r = __elementList.GetAt(i, pElement);
  70                 if (r == E_SUCCESS)
  71                 {
  72                         delete pElement;
  73                         pElement = null;
  74                 }
  75         }
  76         __elementList.RemoveAll();
  77         delete __pPublic;
  78         __pPublic = null;
  79         __listenerList.RemoveAll();
  80 }
  81 _ControlImpl&
  82 _AccessibilityContainerImpl::GetOwner(void)
  83 {
  84         return *__pControlImpl;
  85 }
  86
  87 AccessibilityContainer&
  88 _AccessibilityContainerImpl::GetPublic(void)
  89 {
  90         return *__pPublic;
  91 }
  92
  93 AccessibilityElement*
  94 _AccessibilityContainerImpl::GetChildElement(const String& name)
  95 {
  96         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), null, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
  97         _AccessibilityElementImpl* pNewElementImpl = null;
  98         _AccessibilityElement* pElement = __pCore->GetChildElement(name);
  99         SysTryReturn(NID_UI, pElement, null, E_SYSTEM,"[E_SYSTEM]");
 100         if(pElement->GetUserData() == null)
 101         {
 102                 pNewElementImpl = new (std::nothrow) _AccessibilityElementImpl(*pElement);
 103                 SysTryReturn(NID_UI, pNewElementImpl, null, E_OUT_OF_MEMORY,"[E_OUT_OF_MEMORY] Memory allocation is failed");
 104                 pElement->SetUserData(pNewElementImpl);
 105                 __elementList.Add(&(pNewElementImpl->GetPublic()));
 106                 return &(pNewElementImpl->GetPublic());
 107         }
 108         return &(static_cast<_AccessibilityElementImpl*>(pElement->GetUserData())->GetPublic());
 109 }
 110
 111 result
 112 _AccessibilityContainerImpl::AddAccessibilityListener(const IAccessibilityListener& listener)
 113 {
 114         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 115         result r = E_OBJ_ALREADY_EXIST;
 116         __pCore->AddListener(*this);
 117         int index = 0;
 118         IAccessibilityListener* pListener = &const_cast<IAccessibilityListener&>(listener);
 119         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.");
 120         r = __listenerList.Add(pListener);
 121         SysTryReturn(NID_UI, r == E_SUCCESS, r, r,"[%s]",GetErrorMessage(r));
 122
 123         return r;
 124 }
 125
 126 result
 127 _AccessibilityContainerImpl::RemoveAccessibilityListener(const IAccessibilityListener& listener)
 128 {
 129         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 130         result r = E_OBJ_NOT_FOUND;
 131         SysTryReturn(NID_UI, __listenerList.GetCount() > 0, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND,"[E_OBJ_NOT_FOUND] the listener has been not added.");
 132
 133         int index = 0;
 134         IAccessibilityListener* pListener = &const_cast<IAccessibilityListener&>(listener);
 135         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.");
 136         r = __listenerList.Remove(pListener);
 137         SysTryReturn(NID_UI, r == E_SUCCESS, r, r,"[%s]",GetErrorMessage(r));
 138
 139         if(__listenerList.GetCount() < 1)
 140         {
 141                 __pCore->RemoveListener(*this);
 142         }
 143         return r;
 144 }
 145
 146 result
 147 _AccessibilityContainerImpl::AddElement(const _AccessibilityElementImpl& element)
 148 {
 149         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 150         __elementList.Add(&(const_cast<_AccessibilityElementImpl&>(element).GetPublic()));
 151         return __pCore->AddElement(element.GetCore());
 152 }
 153
 154 result
 155 _AccessibilityContainerImpl::AddElements(const IList& elementList)
 156 {
 157         return E_SYSTEM;
 158 }
 159
 160 IList*
 161 _AccessibilityContainerImpl::GetElementsN(void)
 162 {
 163         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), null, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 164         LinkedList* _pList = new (std::nothrow) LinkedList;
 165         SysTryReturn(NID_UI, _pList, null, E_OUT_OF_MEMORY,"[E_OUT_OF_MEMORY] Memory allocation is failed");
 166         int count = 0;
 167         result r = E_SUCCESS;
 168         _AccessibilityElement* pItem = null;
 169         IListT<_AccessibilityElement*>* pList = __pCore->GetElementsN();
 170         SysTryCatch(NID_UI, pList, , E_SYSTEM,"[E_SYSTEM]");
 171         count = pList->GetCount();
 172         SysTryCatch(NID_UI, count >= 1, , E_SYSTEM,"[E_SYSTEM]");
 173
 174         for (int i = 0;i < count; i++)
 175         {
 176                 _AccessibilityElementImpl* pNewElementImpl = null;
 177                 r = pList->GetAt(i,pItem);
 178                 SysTryCatch(NID_UI, r == E_SUCCESS, , E_SYSTEM,"[E_SYSTEM]");
 179
 180                 if(pItem->GetUserData() == null)
 181                 {
 182                         pNewElementImpl = new (std::nothrow) _AccessibilityElementImpl(*pItem);
 183                         SysTryCatch(NID_UI, pNewElementImpl, , E_OUT_OF_MEMORY,"[E_OUT_OF_MEMORY] Memory allocation is failed");
 184                         pItem->SetUserData(pNewElementImpl);
 185                         AddSystemElement(pNewElementImpl->GetPublic());
 186                 }
 187                 else
 188                 {
 189                         pNewElementImpl = static_cast<_AccessibilityElementImpl*>(pItem->GetUserData());
 190                 }
 191                 _pList->Add(pNewElementImpl->GetPublic());
 192         }
 193         delete pList;
 194         return _pList;
 195 CATCH:
 196         delete pList;
 197         delete _pList;
 198         return null;
 199 }
 200
 201 result
 202 _AccessibilityContainerImpl::RemoveElement(const _AccessibilityElementImpl& element)
 203 {
 204         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 205         result r = __pCore->RemoveElement(element.GetCore());
 206         AccessibilityElement* pElement = const_cast<AccessibilityElement*>(&(element.GetPublic()));
 207         __elementList.Remove(pElement);
 208         delete pElement;
 209         return r;
 210 }
 211
 212 result
 213 _AccessibilityContainerImpl::RemoveAllElement(void)
 214 {
 215         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 216         result r = __pCore->RemoveAllElement();
 217         if (r == E_SUCCESS)
 218         {
 219                 int count = __elementList.GetCount();
 220                 AccessibilityElement* pElement = null;
 221                 for (int i = 0; i < count; i++)
 222                 {
 223                         if (__elementList.GetAt(i, pElement) == E_SUCCESS)
 224                         {
 225                                 delete pElement;
 226                                 pElement = null;
 227                         }
 228                 }
 229                 __elementList.RemoveAll();
 230         }
 231         return r;
 232 }
 233
 234 String
 235 _AccessibilityContainerImpl::GetCurrentGrammar(void) const
 236 {
 237         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), L"", E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 238         return __pCore->GetCurrentGrammar();
 239 }
 240
 241 AccessibilityScreenReaderStatus
 242 _AccessibilityContainerImpl::GetStatus(void) const
 243 {
 244         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), ACCESSIBILITY_SCREEN_READER_STATUS__NONE, E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 245         return __pCore->GetStatus();
 246 }
 247
 248 void
 249 _AccessibilityContainerImpl::ReadingAll(void)
 250 {
 251         SysTryReturn(NID_UI, ControlCoreExists(__coreHandle), , E_SYSTEM,"[E_SYSTEM] A core of control is invalid.");
 252         return __pCore->ReadingAll();
 253 }
 254
 255 _AccessibilityContainerImpl*
 256 _AccessibilityContainerImpl::GetInstance(AccessibilityContainer& container)
 257 {
 258         return static_cast<_AccessibilityContainerImpl*> (container.__pAccessibilityContainerImpl);
 259 }
 260
 261 const _AccessibilityContainerImpl*
 262 _AccessibilityContainerImpl::GetInstance(const AccessibilityContainer& container)
 263 {
 264         return static_cast<_AccessibilityContainerImpl*> (container.__pAccessibilityContainerImpl);
 265 }
 266
 267 bool
 268 _AccessibilityContainerImpl::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 269 {
 270         return true;
 271 }
 272 bool
 273 _AccessibilityContainerImpl::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 274 {
 275         return true;
 276 }
 277 bool
 278 _AccessibilityContainerImpl::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 279 {
 280         return true;
 281 }
 282 bool
 283 _AccessibilityContainerImpl::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 284 {
 285         return true;
 286 }
 287 bool
 288 _AccessibilityContainerImpl::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 289 {
 290         return true;
 291 }
 292 bool
 293 _AccessibilityContainerImpl::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 294 {
 295         return true;
 296 }
 297 bool
 298 _AccessibilityContainerImpl::OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 299 {
 300         return true;
 301 }
 302 bool
 303 _AccessibilityContainerImpl::OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 304 {
 305         return true;
 306 }
 307 bool
 308 _AccessibilityContainerImpl::ControlCoreExists(_ControlHandle handle) const
 309 {
 310         _Control* p_Control = null;
 311         _ControlManager* pManager = _ControlManager::GetInstance();
 312         SysTryReturn(NID_UI, !(handle.IsNull()), false, E_SYSTEM, "[E_SYSTEM] System Error.");
 313         SysTryReturn(NID_UI, pManager, false, E_SYSTEM, "[E_SYSTEM] System Error.");
 314
 315         p_Control = pManager->GetObject(handle);
 316         SysTryReturn(NID_UI,
 317                                 p_Control && p_Control->GetHandle() == __pControlImpl->GetCore().GetHandle(), false, E_SYSTEM,
 318                                 "[E_SYSTEM] System Error.");
 319
 320         SetLastResult(E_SUCCESS);
 321         return true;
 322 }
 323
 324 result
 325 _AccessibilityContainerImpl::MoveElement(const _AccessibilityElementImpl* pPreviousElement, const _AccessibilityElementImpl& element)
 326 {
 327         _AccessibilityElement* pPreviousCore = null;
 328         if (pPreviousElement != null)
 329         {
 330                 pPreviousCore = &const_cast<_AccessibilityElement&>(pPreviousElement->GetCore());
 331         }
 332         return __pCore->MoveElement(pPreviousCore, element.GetCore());
 333 }
 334
 335 void
 336 _AccessibilityContainerImpl::AddSystemElement(const AccessibilityElement& element)
 337 {
 338 }
 339 }} //Tizen::Ui