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