src/ui/FUi_KeyEventManager.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 * @file             FUi_KeyEventManager.cpp
  19 * @brief                This is the implementation file for _KeyEventManager class.
  20 * @version              2.0
  21 * @see                  Tizen::Ui::_KeyEventManager
  22 *
  23 */
  24
  25 // includes
  26 #include <new>
  27 #include <FBaseColIEnumeratorT.h>
  28 #include <FBaseRtIEventListener.h>
  29 #include <FUiControl.h>
  30 #include <FBaseSysLog.h>
  31 #include <pthread.h>
  32 #include "FUi_KeyEventManager.h"
  33 #include "FUi_KeyEventManagerImpl.h"
  34 #include "FUi_Control.h"
  35 #include "FUi_ControlImpl.h"
  36 #include "FUi_ControlManager.h"
  37 #include "FUi_IKeyEventListener.h"
  38 #include "FUi_UiEventManager.h"
  39 #include "FUi_UiKeyEvent.h"
  40
  41 // using namespaces
  42 using namespace Tizen::Ui;
  43 using namespace Tizen::Base::Collection;
  44
  45 namespace
  46 {
  47 class _KeyEventListener
  48         : public _IKeyEventListener
  49         , virtual public _IUiEventListener
  50         , virtual public Tizen::Base::Runtime::IEventListener
  51 {
  52 public:
  53         _KeyEventListener(void)
  54         {
  55         }
  56
  57         virtual ~_KeyEventListener(void)
  58         {
  59         }
  60
  61         virtual bool OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
  62         {
  63                 _KeyEventManager* pKeyManager = _KeyEventManager::GetInstance();
  64                 SysTryReturn(NID_UI, pKeyManager, false, E_SYSTEM, "[E_SYSTEM] System error occurred. ");
  65
  66                 LinkedListT<Tizen::Ui::_IKeyEventListener*>* pList = pKeyManager->GetKeyEventListener();
  67
  68                 bool isFiltered = false;
  69
  70                 if (pList)
  71                 {
  72                         IEnumeratorT<_IKeyEventListener*>* pEnumerator = pList->GetEnumeratorN();
  73
  74                         if (pEnumerator)
  75                         {
  76                                 while (pEnumerator->MoveNext() == E_SUCCESS)
  77                                 {
  78                                         _IKeyEventListener* pKeyEventListener = null;
  79                                         pEnumerator->GetCurrent(pKeyEventListener);
  80
  81                                         if (pKeyEventListener != null)
  82                                         {
  83                                                 isFiltered = pKeyEventListener->OnKeyPressed(source, keyInfo);
  84                                         }
  85
  86                                         //only call first key listener
  87                                         if (keyInfo.GetKeyCode() == _KEY_END)
  88                                         {
  89                                                 break;
  90                                         }
  91                                 }
  92
  93                                 delete pEnumerator;
  94                         }
  95                 }
  96
  97                 return isFiltered;
  98         }
  99
 100         virtual bool OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
 101         {
 102                 _KeyEventManager* pKeyManager = _KeyEventManager::GetInstance();
 103                 SysTryReturn(NID_UI, pKeyManager, false, E_SYSTEM, "[E_SYSTEM] System error occurred. ");
 104
 105                 LinkedListT<Tizen::Ui::_IKeyEventListener*>* pList = pKeyManager->GetKeyEventListener();
 106                 bool isFiltered = false;
 107
 108                 if (pList)
 109                 {
 110                         IEnumeratorT<_IKeyEventListener*>* pEnumerator = pList->GetEnumeratorN();
 111
 112                         if (pEnumerator)
 113                         {
 114                                 while (pEnumerator->MoveNext() == E_SUCCESS)
 115                                 {
 116                                         _IKeyEventListener* pKeyEventListener = null;
 117                                         pEnumerator->GetCurrent(pKeyEventListener);
 118
 119                                         if (pKeyEventListener != null)
 120                                         {
 121                                                 isFiltered = pKeyEventListener->OnKeyReleased(source, keyInfo);
 122                                         }
 123
 124                                         //only call first key listener
 125                                         if (keyInfo.GetKeyCode() == _KEY_END)
 126                                         {
 127                                                 break;
 128                                         }
 129                                 }
 130
 131                                 delete pEnumerator;
 132                         }
 133                 }
 134
 135                 return isFiltered;
 136         }
 137 };
 138 }
 139
 140
 141 namespace Tizen { namespace Ui
 142 {
 143
 144 _KeyEventManager* _KeyEventManager::__pInstance = null;
 145
 146 _KeyEventManager::_KeyEventManager(void)
 147         : __pKeyEventListeners(null)
 148         , __pKeyEventListener(null)
 149         , __pKeyCapturingMap(null)
 150 {
 151         _UiEventManager* pEventManager = _UiEventManager::GetInstance();
 152         SysTryReturnVoidResult(NID_UI, pEventManager, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 153
 154         __pKeyEventListener = new (std::nothrow)_KeyEventListener;
 155         SysTryReturnVoidResult(NID_UI, __pKeyEventListener, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 156
 157         __pKeyCapturingMap = new (std::nothrow) HashMapT<_KeyCode, _ControlHandle>;
 158         SysTryCatch(NID_UI, __pKeyCapturingMap, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 159         SysTryCatch(NID_UI, __pKeyCapturingMap->Construct() == E_SUCCESS, , GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 160
 161         __pKeyEventListeners = new (std::nothrow) LinkedListT<Tizen::Ui::_IKeyEventListener*>;
 162         SysTryCatch(NID_UI, __pKeyEventListeners, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 163
 164         pEventManager->AddKeyEventListener(*__pKeyEventListener);
 165
 166         return;
 167
 168 CATCH:
 169         if (__pKeyEventListener)
 170         {
 171                 delete __pKeyEventListener;
 172                 __pKeyEventListener = null;
 173         }
 174
 175         if (__pKeyCapturingMap)
 176         {
 177                 delete __pKeyCapturingMap;
 178                 __pKeyCapturingMap = null;
 179         }
 180 }
 181
 182 _KeyEventManager::~_KeyEventManager(void)
 183 {
 184         if (__pKeyEventListeners)
 185         {
 186                 delete __pKeyEventListeners;
 187                 __pKeyEventListeners = null;
 188         }
 189
 190         if (__pKeyEventListener)
 191         {
 192                 _UiEventManager* pEventManager = _UiEventManager::GetInstance();
 193                 if (pEventManager)
 194                 {
 195                         pEventManager->RemoveKeyEventListener(*__pKeyEventListener);
 196                 }
 197
 198                 delete __pKeyEventListener;
 199                 __pKeyEventListener = null;
 200         }
 201
 202         if (__pKeyCapturingMap)
 203         {
 204                 delete __pKeyCapturingMap;
 205                 __pKeyCapturingMap = null;
 206         }
 207 }
 208
 209 void
 210 _KeyEventManager::Initialize(void)
 211 {
 212         static pthread_once_t once_block = PTHREAD_ONCE_INIT;
 213
 214         if (__pInstance == null)
 215         {
 216                 pthread_once(&once_block, InitializeInstance);
 217         }
 218         }
 219
 220 _KeyEventManager*
 221 _KeyEventManager::GetInstance(void)
 222 {
 223         return __pInstance;
 224 }
 225
 226 void
 227 _KeyEventManager::InitializeInstance(void)
 228 {
 229         ClearLastResult();
 230
 231         if (__pInstance == null)
 232         {
 233         __pInstance = new (std::nothrow) _KeyEventManager;
 234         SysTryReturnVoidResult(NID_UI, __pInstance != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 235 }
 236 }
 237
 238 void
 239 _KeyEventManager::ReleaseInstance(void)
 240 {
 241         if (__pInstance)
 242         {
 243                 delete __pInstance;
 244                 __pInstance = null;
 245         }
 246 }
 247
 248 void
 249 _KeyEventManager::AddKeyEventListener(const _IKeyEventListener& listener)
 250 {
 251         __pKeyEventListeners->Add(const_cast<_IKeyEventListener*>(&listener));
 252 }
 253
 254
 255 void
 256 _KeyEventManager::RemoveKeyEventListener(const _IKeyEventListener& listener)
 257 {
 258         __pKeyEventListeners->Remove(const_cast<_IKeyEventListener*>(&listener));
 259 }
 260
 261 LinkedListT<Tizen::Ui::_IKeyEventListener*>*
 262 _KeyEventManager::GetKeyEventListener(void) const
 263 {
 264         return __pKeyEventListeners;
 265 }
 266
 267 _Control*
 268 _KeyEventManager::GetCapturingControl(_KeyCode keyCode) const
 269 {
 270         _ControlManager* pControlManager = _ControlManager::GetInstance();
 271         SysAssert(pControlManager != null);
 272
 273          _ControlHandle handle;
 274         __pKeyCapturingMap->GetValue(keyCode, handle);
 275         return pControlManager->GetObject(handle);
 276 }
 277
 278 void
 279 _KeyEventManager::SetCapturingControl(const _Control& control,  _KeyCode keyCode, bool captureAllowed)
 280 {
 281         if (captureAllowed)
 282         {
 283                 bool exist = false;
 284                 __pKeyCapturingMap->ContainsKey(keyCode, exist);
 285
 286                 if (exist)
 287                 {
 288                         __pKeyCapturingMap->Remove(keyCode);
 289                 }
 290
 291                 __pKeyCapturingMap->Add(keyCode, control.GetHandle());
 292         }
 293         else
 294         {
 295                 __pKeyCapturingMap->Add(keyCode, _ControlHandle());
 296         }
 297 }
 298
 299 } } //Tizen::Ui