Fork for IVI: mesa fixing
[profile/ivi/uifw.git] / 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