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