src/ui/FUi_UiEventManager.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_UiEventManager.cpp
  19  * @brief               This is the implementation file for the _UiEventManager class.
  20  */
  21
  22 #include <pthread.h>
  23 #include <FBaseColHashMapT.h>
  24 #include <FBaseColIMapEnumeratorT.h>
  25 #include <FBaseColLinkedListT.h>
  26 #include <FBaseSysLog.h>
  27 #include "FUi_UiEventManager.h"
  28 #include "FUi_UiEvent.h"
  29 #include "FUi_INotificationEventListener.h"
  30 #include "FUi_IKeyEventListener.h"
  31 #include "FUi_ITouchEventListener.h"
  32 #include "FUi_IFocusEventListener.h"
  33 #include "FUi_EflUiEventManager.h"
  34 #include "FUi_Control.h"
  35 #include "FUi_ControlManager.h"
  36 #include "FUi_TouchManager.h"
  37 #include "FUi_TouchGestureDetector.h"
  38 #include "FUiAnim_ControlVisualElement.h"
  39 #include "FUi_UiKeyEvent.h"
  40 #include "FUi_KeyEventManager.h"
  41 #if defined(MULTI_WINDOW)
  42 #include "FUi_Window.h"
  43 #endif
  44
  45 using namespace std;
  46 using namespace Tizen::Base;
  47 using namespace Tizen::Base::Collection;
  48 using namespace Tizen::Graphics;
  49 using namespace Tizen::Ui::Animations;
  50
  51 namespace Tizen { namespace Ui
  52 {
  53
  54 _UiEventManager* _UiEventManager::__pInstance = null;
  55
  56 void
  57 _UiEventManager::Initialize(void)
  58 {
  59         static pthread_once_t once_block = PTHREAD_ONCE_INIT;
  60
  61         if (!__pInstance)
  62         {
  63                 pthread_once(&once_block, InitInstance);
  64         }
  65 }
  66
  67 void
  68 _UiEventManager::Release(void)
  69 {
  70         delete __pInstance;
  71         __pInstance = null;
  72 }
  73
  74 _UiEventManager*
  75 _UiEventManager::GetInstance(void)
  76 {
  77         return __pInstance;
  78 }
  79
  80 void
  81 _UiEventManager::InitInstance(void)
  82 {
  83         if (!__pInstance)
  84         {
  85                 __pInstance = new (std::nothrow) _UiEventManager;
  86                 SysAssert(__pInstance);
  87         }
  88 }
  89
  90 result
  91 _UiEventManager::AddTouchEventListener(const _ITouchEventListener& listener)
  92 {
  93         return AddEventListener(_UI_EVENT_TOUCH, false, listener);
  94 }
  95
  96 result
  97 _UiEventManager::AddKeyEventListener(const _IKeyEventListener& listener)
  98 {
  99         return AddEventListener(_UI_EVENT_KEY, false, listener);
 100 }
 101
 102 result
 103 _UiEventManager::AddFocusEventListener(const _IFocusEventListener& listener)
 104 {
 105         return AddEventListener(_UI_EVENT_FOCUS, false, listener);
 106 }
 107
 108 result
 109 _UiEventManager::AddNotificationEventListener(const _INotificationEventListener& listener)
 110 {
 111         return AddEventListener(_UI_EVENT_NOTIFICAITON, false, listener);
 112 }
 113
 114 result
 115 _UiEventManager::RemoveTouchEventListener(const _ITouchEventListener& listener)
 116 {
 117         return RemoveEventListener(_UI_EVENT_TOUCH, false, listener);
 118 }
 119
 120 result
 121 _UiEventManager::RemoveKeyEventListener(const _IKeyEventListener& listener)
 122 {
 123         return RemoveEventListener(_UI_EVENT_KEY, false, listener);
 124 }
 125
 126 result
 127 _UiEventManager::RemoveFocusEventListener(const _IFocusEventListener& listener)
 128 {
 129         return RemoveEventListener(_UI_EVENT_FOCUS, false, listener);
 130 }
 131
 132 result
 133 _UiEventManager::RemoveNotificationEventListener(const _INotificationEventListener& listener)
 134 {
 135         return RemoveEventListener(_UI_EVENT_NOTIFICAITON, false, listener);
 136 }
 137
 138 result
 139 _UiEventManager::AddPostKeyEventListener(const _IKeyEventListener& listener)
 140 {
 141         return AddEventListener(_UI_EVENT_KEY, true, listener);
 142 }
 143
 144 result
 145 _UiEventManager::RemovePostKeyEventListener(const _IKeyEventListener& listener)
 146 {
 147         return RemoveEventListener(_UI_EVENT_KEY, true, listener);
 148 }
 149
 150 result
 151 _UiEventManager::SendEvent(const _UiEvent& event)
 152 {
 153         result r = E_SUCCESS;
 154
 155         r = Fire(event);
 156
 157         return r;
 158 }
 159
 160 result
 161 _UiEventManager::PostEvent(const _UiEvent& event)
 162 {
 163         return __pEventManager->PostEvent(event);
 164 }
 165
 166 result
 167 _UiEventManager::GenerateKeyEvent(KeyState keyState, _KeyCode keyCode, _KeyModifier keyModifier, bool async)
 168 {
 169         result r = E_SUCCESS;
 170
 171         _UiObjectHandle uiObjectHandle = GetTarget();
 172         if (uiObjectHandle.IsNull())
 173         {
 174                 return r;
 175         }
 176
 177         _UiEventRouteType routeType = (keyState == KEY_LONGPRESSED) ? _UI_EVENT_ROUTE_DIRECT : _UI_EVENT_ROUTE_TUNNEL_BUBBLE;
 178
 179         _KeyInfo keyInfo(keyState, keyCode, keyModifier, null);
 180
 181         _UiKeyEvent event(uiObjectHandle, keyInfo, routeType);
 182
 183         if (async)
 184         {
 185                 r = PostEvent(event);
 186         }
 187         else
 188         {
 189                 r = SendEvent(event);
 190         }
 191
 192         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 193
 194         return r;
 195 }
 196
 197 result
 198 _UiEventManager::GenerateTouchEvent(_TouchStatus touchStatus, int x, int y, bool async)
 199 {
 200         result r = E_SUCCESS;
 201
 202         _UiObjectHandle uiObjectHandle = GetTarget(x, y);
 203         if (uiObjectHandle.IsNull())
 204         {
 205                 return r;
 206         }
 207
 208         const unsigned long DEVICE_ID = 0;
 209
 210         Point current(x, y);
 211         unsigned int pointId = 0;
 212         _UiEventRouteType routeType = _UI_EVENT_ROUTE_TUNNEL_BUBBLE;
 213
 214         _TouchManager* pTouchManager = _TouchManager::GetInstance();
 215         SysTryReturn(NID_UI, pTouchManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 216
 217         switch (touchStatus)
 218         {
 219         case _TOUCH_PRESSED:
 220                 pointId = pTouchManager->GeneratePointId(DEVICE_ID);
 221                 break;
 222
 223         case _TOUCH_LONG_PRESSED:
 224                 // fall through
 225         case _TOUCH_DOUBLE_PRESSED:
 226                 routeType = _UI_EVENT_ROUTE_DIRECT;
 227                 pointId = pTouchManager->GetPointId(DEVICE_ID);
 228                 break;
 229
 230         default:
 231                 pointId = pTouchManager->GetPointId(DEVICE_ID);
 232                 break;
 233         }
 234
 235         _TouchInfo touchInfo(pointId, touchStatus, current, false, 0);
 236         _UiTouchEvent event(uiObjectHandle, touchInfo, routeType);
 237
 238         if (async)
 239         {
 240                 r = PostEvent(event);
 241         }
 242         else
 243         {
 244                 r = SendEvent(event);
 245         }
 246
 247         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 248
 249         return r;
 250 }
 251
 252 _IUiEventManager*
 253 _UiEventManager::GetEventManager(void) const
 254 {
 255         return __pEventManager.get();
 256 }
 257
 258 result
 259 _UiEventManager::AddEventListener(_UiEventType eventType, bool postListener, const _IUiEventListener& listener)
 260 {
 261         result r = E_SUCCESS;
 262
 263         SysTryReturn(NID_UI, !IsListenerRegistered(eventType, postListener, listener), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 264
 265         LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(eventType, postListener);
 266         if (pEventListeners)
 267         {
 268                 pEventListeners->Add(const_cast <_IUiEventListener*>(&listener));
 269         }
 270
 271         return r;
 272 }
 273
 274 result
 275 _UiEventManager::RemoveEventListener(_UiEventType eventType, bool postListener, const _IUiEventListener& listener)
 276 {
 277         result r = E_SUCCESS;
 278
 279         LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(eventType, postListener);
 280         if (pEventListeners)
 281         {
 282                 pEventListeners->Remove(const_cast <_IUiEventListener*>(&listener));
 283         }
 284
 285         return r;
 286 }
 287
 288 bool
 289 _UiEventManager::IsListenerRegistered(_UiEventType eventType, bool postListener, const _IUiEventListener& listener)
 290 {
 291         bool isRegistered = false;
 292
 293         LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(eventType, postListener);
 294         if (pEventListeners)
 295         {
 296                 Tizen::Base::Collection::IEnumeratorT <_IUiEventListener*>* pEnumerator = pEventListeners->GetEnumeratorN();
 297                 SysTryReturn(NID_UI, pEnumerator, false, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 298
 299                 while (pEnumerator->MoveNext() == E_SUCCESS)
 300                 {
 301                         _IUiEventListener* pEventListener = null;
 302                         pEnumerator->GetCurrent(pEventListener);
 303                         if (!pEventListener)
 304                         {
 305                                 continue;
 306                         }
 307
 308                         if (pEventListener == &listener)
 309                         {
 310                                 isRegistered = true;
 311                                 break;
 312                         }
 313                 }
 314
 315                 delete pEnumerator;
 316         }
 317
 318         return isRegistered;
 319 }
 320
 321 result
 322 _UiEventManager::Fire(const _UiEvent& event)
 323 {
 324         result r = E_SUCCESS;
 325
 326         bool isFiltered = false;
 327
 328         r = ProcessListener(event, isFiltered);
 329         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 330
 331         if (!isFiltered)
 332         {
 333                 r = ProcessGlobalGesture(event, isFiltered);
 334                 SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 335         }
 336
 337         if (event.GetEventType() == _UI_EVENT_TOUCH)
 338         {
 339                 r = ProcessEvent(event, isFiltered);
 340                 SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 341         }
 342         else if (!isFiltered)
 343         {
 344                 r = ProcessEvent(event, isFiltered);
 345                 SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 346         }
 347
 348         return r;
 349 }
 350
 351 LinkedListT <_IUiEventListener*>*
 352 _UiEventManager::GetEventListeners(_UiEventType eventType, bool postListener) const
 353 {
 354         LinkedListT <_IUiEventListener*>* pEventListeners = null;
 355
 356         if (postListener)
 357         {
 358                 __pPostEventListenerMap->GetValue(eventType, pEventListeners);
 359         }
 360         else
 361         {
 362                 result r = E_SUCCESS;
 363
 364                 r = __pEventListenerMap->GetValue(eventType, pEventListeners);
 365                 SysTryReturn(NID_UI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 366         }
 367
 368         return pEventListeners;
 369 }
 370
 371 result
 372 _UiEventManager::ProcessListener(const _UiEvent& event, bool& isFiltered)
 373 {
 374         return ProcessListener(event, false, isFiltered);
 375 }
 376
 377 result
 378 _UiEventManager::ProcessPostListener(const _UiEvent& event, bool& isFiltered)
 379 {
 380         return ProcessListener(event, true, isFiltered);
 381 }
 382
 383 result
 384 _UiEventManager::ProcessListener(const _UiEvent& event, bool postListener, bool& isFiltered)
 385 {
 386         result r = E_SUCCESS;
 387
 388         LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(event.GetEventType(), postListener);
 389         if (pEventListeners)
 390         {
 391                 Tizen::Base::Collection::IEnumeratorT <_IUiEventListener*>* pEnumerator = pEventListeners->GetEnumeratorN();
 392                 SysTryReturn(NID_UI, pEnumerator, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 393
 394                 while (pEnumerator->MoveNext() == E_SUCCESS)
 395                 {
 396                         _IUiEventListener* pEventListener = null;
 397
 398                         pEnumerator->GetCurrent(pEventListener);
 399                         if (!pEventListener)
 400                         {
 401                                 continue;
 402                         }
 403
 404                         r = const_cast<_UiEvent&>(event).ProcessListener(*pEventListener, isFiltered);
 405                         if (isFiltered)
 406                         {
 407                                 break;
 408                         }
 409                 }
 410
 411                 delete pEnumerator;
 412         }
 413
 414         return r;
 415 }
 416
 417 result
 418 _UiEventManager::ProcessEvent(const _UiEvent& event, bool& isFiltered)
 419 {
 420         result r = E_SUCCESS;
 421
 422         switch (event.GetRouteType())
 423         {
 424         case _UI_EVENT_ROUTE_TUNNEL_BUBBLE:
 425                 {
 426                         LinkedListT <_UiObjectHandle> tunnelingPath;
 427                         LinkedListT <_UiObjectHandle> bubblingPath;
 428
 429                         r = MakeRoutingPath(tunnelingPath, bubblingPath, event);
 430
 431                         if (r == E_SUCCESS)
 432                         {
 433                                 ProcessTunnelingEvent(tunnelingPath, event, isFiltered);
 434
 435                                 if (event.GetEventType() == _UI_EVENT_TOUCH)
 436                                 {
 437                                         ProcessBubblingEvent(bubblingPath, event, isFiltered);
 438                                 }
 439                                 else if (!isFiltered)
 440                                 {
 441                                         ProcessBubblingEvent(bubblingPath, event, isFiltered);
 442                                 }
 443                         }
 444                 }
 445                 break;
 446
 447         case _UI_EVENT_ROUTE_DIRECT:
 448                 {
 449                         _ControlManager* pControlManager = _ControlManager::GetInstance();
 450                         SysTryReturn(NID_UI, pControlManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 451
 452                         const _Control* pTarget = pControlManager->GetObject(event.GetDestination());
 453                         if (pTarget)
 454                         {
 455                                 r = const_cast<_UiEvent&>(event).ProcessEvent(*pTarget, isFiltered);
 456                         }
 457                 }
 458                 break;
 459
 460         default:
 461                 break;
 462         }
 463
 464         return r;
 465 }
 466
 467 result
 468 _UiEventManager::ProcessGlobalGesture(const _UiEvent& event, bool& isFiltered)
 469 {
 470         if (event.GetEventType() != _UI_EVENT_TOUCH)
 471         {
 472                 return E_SUCCESS;
 473         }
 474
 475         if (event.GetAccessibilityEvent())
 476         {
 477                 return E_SUCCESS;
 478         }
 479
 480         _ControlManager* pControlManager = _ControlManager::GetInstance();
 481         SysTryReturn(NID_UI, pControlManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 482
 483         _TouchManager* pTouchManager = _TouchManager::GetInstance();
 484         SysTryReturn(NID_UI, pTouchManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 485
 486         Tizen::Base::Collection::IListT<_TouchGestureDetector*>* pGestureList = pControlManager->GetGestureDetectorList();
 487         if (!pGestureList || (pGestureList && (pGestureList->GetCount() <= 0)))
 488         {
 489                 return E_SUCCESS;
 490         }
 491
 492         result r = E_SUCCESS;
 493
 494         Tizen::Base::Collection::IEnumeratorT <_TouchGestureDetector*>* pEnumerator = pGestureList->GetEnumeratorN();
 495         SysTryReturn(NID_UI, pEnumerator, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 496
 497         _TouchGestureDetector* pGestureDetector = null;
 498         while (pEnumerator->MoveNext() == E_SUCCESS)
 499         {
 500                 pEnumerator->GetCurrent(pGestureDetector);
 501
 502                 if (!pGestureDetector)
 503                 {
 504                         continue;
 505                 }
 506
 507                 r = const_cast<_UiEvent&>(event).ProcessListener(*pGestureDetector, isFiltered);
 508                 if (isFiltered)
 509                 {
 510                         break;
 511                 }
 512         }
 513
 514         delete pEnumerator;
 515
 516         return r;
 517 }
 518
 519 result
 520 _UiEventManager::MakeRoutingPath(Tizen::Base::Collection::LinkedListT <_UiObjectHandle>& tunnelingPath, Tizen::Base::Collection::LinkedListT <_UiObjectHandle>& bubblingPath, const _UiEvent& event)
 521 {
 522         result r = E_SUCCESS;
 523
 524         _ControlManager* pControlManager = _ControlManager::GetInstance();
 525         SysTryReturn(NID_UI, pControlManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 526
 527         _Control* pControl = pControlManager->GetObject(event.GetDestination());
 528         SysTryReturn(NID_UI, pControl, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 529
 530         // Bubbling path
 531         _Control* pBubblingTarget = pControl;
 532         while (pBubblingTarget)
 533         {
 534                 bubblingPath.Add(pBubblingTarget->GetHandle());
 535                 pBubblingTarget = pBubblingTarget->GetParent();
 536         }
 537
 538         // Tunneling path
 539         for (int i = bubblingPath.GetCount() - 1; i > 0; i--)
 540         {
 541                 _UiObjectHandle uiObjectHandle;
 542
 543                 r = bubblingPath.GetAt(i, uiObjectHandle);
 544                 if (r == E_SUCCESS)
 545                 {
 546                         tunnelingPath.Add(uiObjectHandle);
 547                 }
 548         }
 549
 550         return r;
 551 }
 552
 553 result
 554 _UiEventManager::ProcessTunnelingEvent(const Tizen::Base::Collection::LinkedListT <_UiObjectHandle>& routingPath, const _UiEvent& event, bool& isFiltered)
 555 {
 556         result r = E_SUCCESS;
 557
 558         Tizen::Base::Collection::IEnumeratorT <_UiObjectHandle>* pEnumerator = routingPath.GetEnumeratorN();
 559         SysTryReturn(NID_UI, pEnumerator, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 560
 561         _UiObjectHandle uiObjectHandle;
 562         while (pEnumerator->MoveNext() == E_SUCCESS)
 563         {
 564                 pEnumerator->GetCurrent(uiObjectHandle);
 565                 if (uiObjectHandle.IsNull())
 566                 {
 567                         continue;
 568                 }
 569
 570                 const _Control* pControl = event.GetControl(uiObjectHandle);
 571                 if (!pControl)
 572                 {
 573                         continue;
 574                 }
 575
 576                 r = const_cast<_UiEvent&>(event).ProcessPreviewEvent(*pControl, isFiltered);
 577                 if (isFiltered)
 578                 {
 579                         r = E_SUCCESS;
 580                         break;
 581                 }
 582         }
 583
 584         delete pEnumerator;
 585
 586         return r;
 587 }
 588
 589 result
 590 _UiEventManager::ProcessBubblingEvent(const Tizen::Base::Collection::LinkedListT <_UiObjectHandle>& routingPath, const _UiEvent& event, bool& isFiltered)
 591 {
 592         result r = E_SUCCESS;
 593
 594         Tizen::Base::Collection::IEnumeratorT <_UiObjectHandle>* pEnumerator = routingPath.GetEnumeratorN();
 595         SysTryReturn(NID_UI, pEnumerator, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 596
 597         _UiObjectHandle uiObjectHandle;
 598         while (pEnumerator->MoveNext() == E_SUCCESS)
 599         {
 600                 pEnumerator->GetCurrent(uiObjectHandle);
 601                 if (uiObjectHandle.IsNull())
 602                 {
 603                         continue;
 604                 }
 605
 606                 const _Control* pControl = event.GetControl(uiObjectHandle);
 607                 if (!pControl)
 608                 {
 609                         continue;
 610                 }
 611
 612                 r = const_cast<_UiEvent&>(event).ProcessEvent(*pControl, isFiltered);
 613
 614                 if (!isFiltered && (event.GetDestination() == uiObjectHandle))
 615                 {
 616                         ProcessPostListener(event, isFiltered);
 617                 }
 618         }
 619
 620         delete pEnumerator;
 621
 622         return r;
 623 }
 624
 625 _UiObjectHandle
 626 _UiEventManager::GetTarget(void) const
 627 {
 628         _Control* pControl = _ControlManager::GetInstance()->GetFocusedControl();
 629         SysTryReturn(NID_UI, pControl, _UiObjectHandle(), E_SYSTEM, "[E_SYSTEM] System error occurred.");
 630
 631         return pControl->GetHandle();
 632 }
 633
 634 _UiObjectHandle
 635 _UiEventManager::GetTarget(int x, int y) const
 636 {
 637         Tizen::Graphics::FloatPoint ptf((float) x, (float) y);
 638
 639 #if !defined(MULTI_WINDOW)
 640         _ControlVisualElement* pRootControlElement =
 641                 dynamic_cast <_ControlVisualElement*>(_ControlManager::GetInstance()->GetRoot().GetVisualElement());
 642 #else
 643         _ControlVisualElement* pRootControlElement =
 644                 dynamic_cast <_ControlVisualElement*>(_ControlManager::GetInstance()->GetTopVisibleWindowAt(Point(x, y))->GetVisualElement());
 645 #endif
 646         SysTryReturn(NID_UI, pRootControlElement, _UiObjectHandle(), E_SYSTEM, "[E_SYSTEM] System error occurred.");
 647
 648         _ControlVisualElement* pControlVisualElement = pRootControlElement->GetControlChildAtPoint(ptf);
 649         SysTryReturn(NID_UI, pControlVisualElement, _UiObjectHandle(), E_SYSTEM, "[E_SYSTEM] System error occurred.");
 650
 651         _Control* pControl = static_cast <_Control*>(pControlVisualElement->GetUserData());
 652         SysTryReturn(NID_UI, pControl, _UiObjectHandle(), E_SYSTEM, "[E_SYSTEM] System error occurred.");
 653
 654         return pControl->GetHandle();
 655 }
 656
 657 void
 658 _UiEventManager::SetKeyCapture(const _Control& control, _KeyCode keyCode)
 659 {
 660         __pEventManager->SetKeyCapture(control, keyCode);
 661
 662         _KeyEventManager* pKeyEventManager = _KeyEventManager::GetInstance();
 663         SysAssert(pKeyEventManager != null);
 664
 665         pKeyEventManager->SetCapturingControl(control, keyCode, true);
 666 }
 667
 668 void
 669 _UiEventManager::ReleaseKeyCapture(const _Control& control, _KeyCode keyCode)
 670 {
 671         __pEventManager->ReleaseKeyCapture(control, keyCode);
 672
 673         _KeyEventManager* pKeyEventManager = _KeyEventManager::GetInstance();
 674         SysAssert(pKeyEventManager != null);
 675
 676         pKeyEventManager->SetCapturingControl(control, keyCode, false);
 677 }
 678
 679 void
 680 _UiEventManager::RemoveAllEventListenerList(Tizen::Base::Collection::HashMapT<_UiEventType, Tizen::Base::Collection::LinkedListT<_IUiEventListener*>*>* pMap)
 681 {
 682         Tizen::Base::Collection::IMapEnumeratorT<_UiEventType, Tizen::Base::Collection::LinkedListT<_IUiEventListener*>*>* pMapEnumerator = pMap->GetMapEnumeratorN();
 683         SysTryReturnVoidResult(NID_UI, pMapEnumerator, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 684
 685         while (pMapEnumerator->MoveNext() == E_SUCCESS)
 686         {
 687                 Tizen::Base::Collection::LinkedListT<_IUiEventListener*>* pListeners = null;
 688                 pMapEnumerator->GetValue(pListeners);
 689
 690                 if (!pListeners)
 691                 {
 692                         continue;
 693                 }
 694
 695                 delete pListeners;
 696         }
 697
 698         delete pMapEnumerator;
 699 }
 700
 701 _UiEventManager::_UiEventManager(void)
 702         : __pEventManager(new (std::nothrow) _EflUiEventManager)
 703 {
 704         unique_ptr<HashMapT<_UiEventType, LinkedListT<_IUiEventListener*>*> > pEventListenerMap(new (std::nothrow) HashMapT<_UiEventType, LinkedListT<_IUiEventListener*>*>);
 705         SysTryReturnVoidResult(NID_UI, pEventListenerMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 706
 707         result r = pEventListenerMap->Construct();
 708         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 709
 710         // Touch
 711         LinkedListT<_IUiEventListener*>* pTouchEventListeners = new (std::nothrow) LinkedListT<_IUiEventListener*>;
 712         SysTryReturnVoidResult(NID_UI, pTouchEventListeners, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 713
 714         r = pEventListenerMap->Add(_UI_EVENT_TOUCH, pTouchEventListeners);
 715         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 716
 717         // Key
 718         LinkedListT<_IUiEventListener*>* pKeyEventListeners = new (std::nothrow) LinkedListT<_IUiEventListener*>;
 719         SysTryReturnVoidResult(NID_UI, pKeyEventListeners, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 720
 721         r = pEventListenerMap->Add(_UI_EVENT_KEY, pKeyEventListeners);
 722         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 723
 724         // Focus
 725         LinkedListT<_IUiEventListener*>* pFocusEventListeners = new (std::nothrow) LinkedListT<_IUiEventListener*>;
 726         SysTryReturnVoidResult(NID_UI, pFocusEventListeners, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 727
 728         r = pEventListenerMap->Add(_UI_EVENT_FOCUS, pFocusEventListeners);
 729         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 730
 731         // Notification
 732         LinkedListT <_IUiEventListener*>* pNotificationEventListeners = new (std::nothrow) LinkedListT<_IUiEventListener*>;
 733         SysTryReturnVoidResult(NID_UI, pNotificationEventListeners, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 734
 735         r = pEventListenerMap->Add(_UI_EVENT_NOTIFICAITON, pNotificationEventListeners);
 736         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 737
 738         // post
 739         unique_ptr<HashMapT<_UiEventType, LinkedListT<_IUiEventListener*>*> > pPostEventListenerMap(new (std::nothrow) HashMapT<_UiEventType, LinkedListT<_IUiEventListener*>*>);
 740         SysTryReturnVoidResult(NID_UI, pPostEventListenerMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 741
 742         r = pPostEventListenerMap->Construct();
 743         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 744
 745         // Key
 746         LinkedListT<_IUiEventListener*>* pPostKeyEventListeners = new (std::nothrow) LinkedListT<_IUiEventListener*>;
 747         SysTryReturnVoidResult(NID_UI, pPostKeyEventListeners, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 748
 749         r = pPostEventListenerMap->Add(_UI_EVENT_KEY, pPostKeyEventListeners);
 750         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 751
 752         // move pointer
 753         __pEventListenerMap = move(pEventListenerMap);
 754         __pPostEventListenerMap = move(pPostEventListenerMap);
 755 }
 756
 757 _UiEventManager::~_UiEventManager(void)
 758 {
 759         RemoveAllEventListenerList(__pEventListenerMap.get());
 760         RemoveAllEventListenerList(__pPostEventListenerMap.get());
 761 }
 762
 763 }} // Tizen::Ui