src/ui/FUi_EflUiEventManager.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_EflUiEventManager.cpp
  19  * @brief               This is the implementation file for _EflUiEventManager class.
  20  */
  21 #include <utilX.h>
  22 #include <Ecore_X.h>
  23 #include <Ecore_Evas.h>
  24 #ifdef KEY_CAMERA
  25 #undef KEY_CAMERA
  26 #endif
  27 #include <X11/Xlib.h>
  28 #include <Evas.h>
  29 #include <FBaseColIEnumeratorT.h>
  30 #include <FBaseSysLog.h>
  31 #include "FUi_CoordinateSystemUtils.h"
  32 #include "FUi_Control.h"
  33 #include "FUi_ControlManager.h"
  34 #include "FUi_KeyEventManager.h"
  35 #include "FUi_Window.h"
  36 #include "FUi_UiEventManager.h"
  37 #include "FUi_EflUiEventManager.h"
  38 #include "FUi_UiTouchEvent.h"
  39 #include "FUi_UiNotificationEvent.h"
  40 #include "FUi_UiKeyEvent.h"
  41 #include "FUi_UiFocusEvent.h"
  42 #include "FUi_EcoreEvasMgr.h"
  43 #include "FUi_EcoreEvas.h"
  44 #include "FUi_TouchManager.h"
  45 #include "FUiAnim_EflNode.h"
  46 #include "FUiAnim_ControlVisualElement.h"
  47 #if defined(MULTI_WINDOW)
  48 #include "FUiAnim_RootVisualElement.h"
  49 #include "FUiAnim_EflLayer.h"
  50 #endif
  51
  52 using namespace std;
  53 using namespace Tizen::Ui;
  54 using namespace Tizen::Ui::Animations;
  55 using namespace Tizen::Graphics;
  56 using namespace Tizen::Base::Collection;
  57 using namespace Tizen::Base;
  58
  59 namespace
  60 {
  61 #define __UNUSED__
  62
  63 bool isPressed = false;
  64 Ecore_X_Atom keyboardExist = 0;
  65 const wchar_t* KEYBOARD_INSERTED_EVENT = L"KEYBOARD_INSERTED";
  66
  67 Evas_Object*
  68 GetEvasObject(const _Control& control)
  69 {
  70         _VisualElement* pVisualElement = control.GetVisualElement();
  71         SysTryReturn(NID_UI, pVisualElement, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
  72
  73         _EflNode* pEflNode = dynamic_cast<_EflNode*>(pVisualElement->GetNativeNode());
  74         SysTryReturn(NID_UI, pEflNode, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
  75
  76         return (Evas_Object*)pEflNode->GetGroupContainer();
  77 }
  78
  79 Evas*
  80 GetEvas(const _Control& control)
  81 {
  82         Evas* pEvas = null;
  83         Evas_Object* pEvasObject = GetEvasObject(control);
  84         if (pEvasObject)
  85         {
  86                 pEvas = evas_object_evas_get(pEvasObject);
  87                 SysTryReturn(NID_UI, pEvas, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
  88         }
  89
  90         return pEvas;
  91 }
  92
  93 class _Event
  94 {
  95 public:
  96         _Event(void)
  97                 : _pEventManager(null)
  98         {
  99                 _pEventManager = _UiEventManager::GetInstance();
 100                 SysTryReturnVoidResult(NID_UI, _pEventManager, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 101
 102                 SetLastResult(E_SUCCESS);
 103         }
 104
 105         virtual ~_Event(void)
 106         {
 107         }
 108
 109 private:
 110         _Event(const _Event& rhs);
 111         _Event& operator =(const _Event& rhs);
 112
 113         virtual result SendImpl(void) = 0;
 114
 115 public:
 116         result Send(void)
 117         {
 118                 return SendImpl();
 119         }
 120
 121 protected:
 122         _UiEventManager* _pEventManager;
 123 }; // _Event
 124
 125 struct _EvasConvertKeys
 126 {
 127         _KeyCode code;
 128         const char* pName;
 129 };
 130
 131 const _EvasConvertKeys keyTable[] =
 132 {
 133         { _KEY_SIDE_UP, "XF86AudioRaiseVolume" },
 134         { _KEY_SIDE_DOWN, "XF86AudioLowerVolume" },
 135         { _KEY_END, "XF86Stop" },
 136         { _KEY_ENTER, "Return" },
 137         { _KEY_BACKSPACE, "BackSpace" },
 138         { _KEY_NUM_LEFT, "KP_Left"},
 139         { _KEY_NUM_UP, "KP_Up"},
 140         { _KEY_NUM_DOWN, "KP_Down"},
 141         { _KEY_NUM_RIGHT, "KP_Right"},
 142         { _KEY_LEFT, "Left" },
 143         { _KEY_UP, "Up"},
 144         { _KEY_DOWN, "Down"},
 145         { _KEY_RIGHT, "Right"},
 146         { _KEY_0, "0"},
 147         { _KEY_1, "1"},
 148         { _KEY_2, "2"},
 149         { _KEY_3, "3"},
 150         { _KEY_4, "4"},
 151         { _KEY_5, "5"},
 152         { _KEY_6, "6"},
 153         { _KEY_7, "7"},
 154         { _KEY_8, "8"},
 155         { _KEY_9, "9"},
 156         { _KEY_A, "a"},
 157         { _KEY_B, "b"},
 158         { _KEY_C, "c"},
 159         { _KEY_D, "d"},
 160         { _KEY_E, "e"},
 161         { _KEY_F, "f"},
 162         { _KEY_G, "g"},
 163         { _KEY_H, "h"},
 164         { _KEY_I, "i"},
 165         { _KEY_J, "j"},
 166         { _KEY_K, "k"},
 167         { _KEY_L, "l"},
 168         { _KEY_M, "m"},
 169         { _KEY_N, "n"},
 170         { _KEY_O, "o"},
 171         { _KEY_P, "p"},
 172         { _KEY_Q, "q"},
 173         { _KEY_R, "r"},
 174         { _KEY_S, "s"},
 175         { _KEY_T, "t"},
 176         { _KEY_U, "u"},
 177         { _KEY_V, "v"},
 178         { _KEY_W, "w"},
 179         { _KEY_X, "x"},
 180         { _KEY_Y, "y"},
 181         { _KEY_Z, "z"},
 182         { _KEY_COMMA, "comma"},
 183         { _KEY_CAPSLOCK, "Caps_Lock"},
 184         { _KEY_ALT, "Alt_L"},
 185         { _KEY_ALT, "Alt_R"},
 186         { _KEY_SPACE, "space"},
 187         { _KEY_FN_1, "F1"},
 188         { _KEY_FN_2, "F2"},
 189         { _KEY_FN_3, "F3"},
 190         { _KEY_FN_4, "F4"},
 191         { _KEY_FN_5, "F5"},
 192         { _KEY_CLEAR, "BackSpace"},
 193         { _KEY_POWER_HOLD, "XF86PowerOff"},
 194         { _KEY_DELETE, "Delete"},
 195         { _KEY_DELETE, "KP_Delete"},
 196         { _KEY_CTRL_L, "XK_Control_L"},
 197         { _KEY_CTRL_L, "Control_L"},
 198         { _KEY_CTRL_R, "XK_Control_R"},
 199         { _KEY_CTRL_R, "Control_R"},
 200         { _KEY_SHIFT_L, "XK_Shift_L"},
 201         { _KEY_SHIFT_L, "Shift_L"},
 202         { _KEY_SHIFT_R, "XK_Shift_R"},
 203         { _KEY_SHIFT_R, "Shift_R"},
 204 };
 205
 206 class _KeyEvent
 207         : public _Event
 208 {
 209 public:
 210         _KeyEvent(KeyState keyState, _KeyCode keyCode, int keyModifier, void* pUserData)
 211                 : __pTarget(null)
 212                 , __keyInfo(keyState, keyCode, keyModifier, pUserData)
 213         {
 214                 __pTarget = GetTarget(keyCode);
 215         }
 216
 217         virtual ~_KeyEvent(void)
 218         {
 219         }
 220
 221         static _KeyCode GetKeyCode(const char* pKeyName)
 222         {
 223                 ClearLastResult();
 224
 225                 SysTryReturn(NID_UI, pKeyName, _KEY_INVALID, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 226
 227                 for (unsigned int i = 0; i < sizeof(keyTable) / sizeof(_EvasConvertKeys); ++i)
 228                 {
 229                         if (strcmp(keyTable[i].pName, pKeyName) == 0)
 230                         {
 231                                 return keyTable[i].code;
 232                         }
 233                 }
 234
 235                 return _KEY_INVALID;
 236         }
 237
 238         static int GetKeyModifier(const int keyModifier)
 239         {
 240                 ClearLastResult();
 241                 unsigned int modifier = _KEY_MODIFIER_NONE;
 242
 243                 if(ECORE_EVENT_MODIFIER_SHIFT & keyModifier)
 244                 {
 245                         modifier |= _KEY_MODIFIER_SHIFT;
 246                 }
 247                 if(ECORE_EVENT_MODIFIER_CTRL & keyModifier)
 248                 {
 249                         modifier |= _KEY_MODIFIER_CTRL;
 250                 }
 251                 if(ECORE_EVENT_MODIFIER_ALT & keyModifier)
 252                 {
 253                         modifier |= _KEY_MODIFIER_ALT;
 254                 }
 255                 if(ECORE_EVENT_MODIFIER_WIN & keyModifier)
 256                 {
 257                         modifier |= _KEY_MODIFIER_WIN;
 258                 }
 259                 if(ECORE_EVENT_MODIFIER_SCROLL & keyModifier)
 260                 {
 261                         modifier |= _KEY_MODIFIER_SCROLL;
 262                 }
 263                 if(ECORE_EVENT_MODIFIER_NUM & keyModifier)
 264                 {
 265                         modifier |= _KEY_MODIFIER_NUM;
 266                 }
 267                 if(ECORE_EVENT_MODIFIER_CAPS & keyModifier)
 268                 {
 269                         modifier |= _KEY_MODIFIER_CAPS;
 270                 }
 271                 if(ECORE_EVENT_LOCK_SCROLL & keyModifier)
 272                 {
 273                         modifier |= _KEY_LOCK_SCROLL;
 274                 }
 275                 if(ECORE_EVENT_LOCK_NUM & keyModifier)
 276                 {
 277                         modifier |= _KEY_LOCK_NUM;
 278                 }
 279                 if(ECORE_EVENT_LOCK_CAPS & keyModifier)
 280                 {
 281                         modifier |= _KEY_LOCK_CAPS;
 282                 }
 283                 if(ECORE_EVENT_LOCK_SHIFT & keyModifier)
 284                 {
 285                         modifier |= _KEY_LOCK_SHIFT;
 286                 }
 287                 if(ECORE_EVENT_MODIFIER_ALTGR & keyModifier)
 288                 {
 289                         modifier |= _KEY_MODIFIER_ALTGR;
 290                 }
 291
 292                 return modifier;
 293         }
 294
 295 private:
 296         _KeyEvent(const _KeyEvent& rhs);
 297         _KeyEvent& operator =(const _KeyEvent& rhs);
 298
 299         virtual result SendImpl(void)
 300         {
 301                 SysTryReturn(NID_UI, __pTarget, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 302
 303                 _UiKeyEvent event(__pTarget->GetHandle(), __keyInfo);
 304
 305                 return _pEventManager->SendEvent(event);
 306         }
 307
 308         _Control* GetTarget(_KeyCode keyCode) const
 309         {
 310                 _KeyEventManager* pKeyEventManager = _KeyEventManager::GetInstance();
 311                 SysTryReturn(NID_UI, pKeyEventManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 312
 313                 _Control* pControl = pKeyEventManager->GetCapturingControl(keyCode);
 314
 315                 if (pControl == null)
 316                 {
 317                         _ControlManager* pControlManager = _ControlManager::GetInstance();
 318                         SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 319
 320                         pControl = pControlManager->GetFocusedControl();
 321
 322                         if (!pControl)
 323                         {
 324                                 pControl = pControlManager->GetCurrentFrame();
 325                         }
 326                         SysTryReturn(NID_UI, pControl, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 327                 }
 328
 329                 _ControlManager* pControlManager = _ControlManager::GetInstance();
 330                 SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 331
 332                 pControl = pControlManager->GetFocusedControl();
 333                 if (!pControl)
 334                 {
 335                         pControl = pControlManager->GetCurrentFrame();
 336                 }
 337                 SysTryReturn(NID_UI, pControl, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 338
 339                 SetLastResult(E_SUCCESS);
 340
 341                 return pControl;
 342         }
 343
 344 private:
 345         _Control* __pTarget;
 346         _KeyInfo __keyInfo;
 347 }; // _KeyEvent
 348
 349 class _TouchEventManager
 350 {
 351 public:
 352         static _TouchEventManager* GetInstance(void)
 353         {
 354                 if (__pInstance == null)
 355                 {
 356                         __pInstance = new (std::nothrow) _TouchEventManager;
 357                         SysTryReturn(NID_UI, __pInstance, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 358                 }
 359
 360                 SetLastResult(E_SUCCESS);
 361
 362                 return __pInstance;
 363         }
 364
 365         result AddControl(int pointId, const _ControlHandle& controlHandle)
 366         {
 367                 bool exist = false;
 368                 result r = E_SUCCESS;
 369
 370                 __pTargetMap->ContainsKey(pointId, exist);
 371
 372                 if (exist)
 373                 {
 374                         r = __pTargetMap->Remove(pointId);
 375                         SysTryReturnResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 376                 }
 377
 378                 r = __pTargetMap->Add(pointId, controlHandle);
 379                 SysTryReturnResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 380
 381                 return r;
 382         }
 383
 384         _Control* GetControl(int pointId)
 385         {
 386                 SysTryReturn(NID_UI, __pTargetMap, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 387
 388                 _ControlHandle controlHandle;
 389
 390                 __pTargetMap->GetValue(pointId, controlHandle);
 391
 392                 _ControlManager* pControlManager = _ControlManager::GetInstance();
 393                 result r = GetLastResult();
 394                 SysTryReturn(NID_UI, pControlManager, null, r, "[%s] Propagating.", GetErrorMessage(r));
 395
 396                 return pControlManager->GetObject(controlHandle);
 397         }
 398
 399 private:
 400         _TouchEventManager(void)
 401         {
 402                 unique_ptr<HashMapT<int, _ControlHandle> > pTargetMap(new (std::nothrow) HashMapT<int, _ControlHandle>);
 403                 SysTryReturnVoidResult(NID_UI, pTargetMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 404
 405                 result r = pTargetMap->Construct();
 406                 SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 407
 408                 __pTargetMap = move(pTargetMap);
 409
 410                 SetLastResult(E_SUCCESS);
 411         }
 412
 413         ~_TouchEventManager(void)
 414         {
 415         }
 416
 417         _TouchEventManager(const _TouchEventManager& rhs);
 418         _TouchEventManager& operator =(const _TouchEventManager& rhs);
 419
 420 private:
 421         static _TouchEventManager* __pInstance;
 422         unique_ptr<HashMapT<int, _ControlHandle> > __pTargetMap;
 423 };
 424
 425 _TouchEventManager* _TouchEventManager::__pInstance = null;
 426
 427 class _TouchEvent
 428         : public _Event
 429 {
 430 public:
 431         _TouchEvent(int deviceId, _TouchStatus status, int x, int y, unsigned int timeStamp, const _Control* pRootControl)
 432                 : __pTouchEventManager(null)
 433         {
 434                 __pTouchEventManager = _TouchEventManager::GetInstance();
 435                 SysTryReturnVoidResult(NID_UI, __pTouchEventManager, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 436
 437                 result r = E_SUCCESS;
 438                 Tizen::Graphics::Point current(x, y);
 439
 440                 _TouchManager* pTouchManager = _TouchManager::GetInstance();
 441                 SysTryReturnVoidResult(NID_UI, pTouchManager, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 442
 443                 unsigned int pointId = 0;
 444
 445                 if (status == _TOUCH_PRESSED)
 446                 {
 447                         IListT<_FingerInfo*>* pFingerInfoList = pTouchManager->GetMultiFingerInfoListN();
 448                         SysTryReturnVoidResult(NID_UI, pFingerInfoList, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 449
 450                         const int count = pFingerInfoList->GetCount();
 451
 452                         for (int i = 0; i < count; i++)
 453                         {
 454                                 _FingerInfo* pFingerInfo = null;
 455                                 pFingerInfoList->GetAt(i, pFingerInfo);
 456                                 if (pFingerInfo == null)
 457                                 {
 458                                         continue;
 459                                 }
 460
 461                                 if (pFingerInfo->GetDeviceId() == deviceId && pFingerInfo->GetStatus() == _TOUCH_PRESSED)
 462                                 {
 463                                         pTouchManager->ResetTouchInfo();
 464                                         SysLog(NID_UI, "ResetTouchInfo x(%d), y(%d), deviceID(%d), pointID(%d)", current.x, current.y, deviceId, pFingerInfo->GetPointId());
 465                                         break;
 466                                 }
 467                         }
 468                         delete pFingerInfoList;
 469
 470                         pointId = pTouchManager->GeneratePointId(deviceId);
 471                 }
 472                 else
 473                 {
 474                         pointId = pTouchManager->GetPointId(deviceId);
 475                 }
 476
 477                 SysTryReturnVoidResult(NID_UI, pointId != INVALID_POINT_ID, E_INVALID_CONDITION, "[E_INVALID_CONDITION] pointId is invalid.");
 478
 479                 if (!pRootControl)
 480                 {
 481                         r = GetPosition(status, x, y, current);
 482 #if defined(MULTI_WINDOW)
 483                         SysTryReturnVoidResult(NID_UI, r != E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] A system error occurred.");
 484 #endif
 485                         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 486                 }
 487                 else
 488                 {
 489                         current = _CoordinateSystemUtils::InverseTransform(current);
 490                 }
 491
 492                 __touchInfo.SetTouchInfo(pointId, status, current, false, timeStamp);
 493
 494                 if (status == _TOUCH_PRESSED)
 495                 {
 496                         _Control* pControl = GetTarget(current.x, current.y, pRootControl);
 497
 498                         if (pControl == null)
 499                         {
 500                                 pTouchManager->ResetTouchInfo();
 501                                 SysLog(NID_UI, "ResetTouchInfo x(%d), y(%d), deviceID(%d), pointID(%d)", current.x, current.y, deviceId, pointId);
 502                                 ClearLastResult();
 503                         }
 504                         else
 505                         {
 506                                 r = __pTouchEventManager->AddControl(pointId, pControl->GetHandle());
 507                                 SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 508                         }
 509                 }
 510                 else
 511                 {
 512                         _Control* pControl = GetTarget(current.x, current.y, pRootControl);
 513                         if (pControl == null)
 514                         {
 515                                 ClearLastResult();
 516                         }
 517                         else
 518                         {
 519                                 if (pControl != null && pControl->GetChangingEventTarget() == true)
 520                                 {
 521                                         r = __pTouchEventManager->AddControl(pointId, pControl->GetHandle());
 522                                         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 523                                 }
 524                         }
 525                 }
 526         }
 527
 528         virtual ~_TouchEvent(void)
 529         {
 530         }
 531
 532 private:
 533         virtual result SendImpl(void)
 534         {
 535                 _Control* pTarget = __pTouchEventManager->GetControl(__touchInfo.GetPointId());
 536                 if (pTarget == null)
 537                 {
 538                         _TouchManager* pTouchManager = _TouchManager::GetInstance();
 539                         pTouchManager->ResetTouchInfo();
 540
 541                         SysLog(NID_UI, "ResetTouchInfo");
 542                         return E_SUCCESS;
 543                 }
 544
 545                 _UiTouchEvent event(pTarget->GetHandle(), __touchInfo);
 546
 547                 return _pEventManager->SendEvent(event);
 548         }
 549
 550 private:
 551         _TouchEvent(const _TouchEvent& rhs);
 552         _TouchEvent& operator =(const _TouchEvent& rhs);
 553
 554         _Control* GetTarget(int x, int y, const _Control* pRootControl) const
 555         {
 556                 ClearLastResult();
 557
 558                 _TouchManager* pTouchManager = _TouchManager::GetInstance();
 559                 SysTryReturn(NID_UI, pTouchManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 560
 561                 _Control* pCapturedControl = pTouchManager->GetCapturedControl();
 562                 _Control* pControl = null;
 563
 564                 if (pCapturedControl)
 565                 {
 566                         if (pTouchManager->IsCaptureAllowedOutOfBounds())
 567                         {
 568                                 pControl = pCapturedControl;
 569                         }
 570                         else
 571                         {
 572                                 Tizen::Graphics::Rectangle rc(pCapturedControl->GetAbsoluteBounds());
 573
 574                                 if ((x < rc.x) || (x > (rc.x + rc.width)) || (y < rc.y) || (y > (rc.y + rc.height)))
 575                                 {
 576                                         pControl = pCapturedControl;
 577                                 }
 578                         }
 579
 580                         if (pControl != null)
 581                         {
 582                                 return pControl;
 583                         }
 584                 }
 585
 586                 _ControlManager* pControlManager = _ControlManager::GetInstance();
 587                 SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 588
 589                 Tizen::Graphics::FloatPoint ptf(static_cast<float>(x), static_cast<float>(y));
 590
 591                 _ControlVisualElement* pRootControlElement = null;
 592                 if (pRootControl)
 593                 {
 594                         pRootControlElement = dynamic_cast<_ControlVisualElement*>(pRootControl->GetVisualElement());
 595                 }
 596                 else
 597                 {
 598                         _Window* pWindow = null;
 599 #if !defined(MULTI_WINDOW)
 600                         pWindow = pControlManager->GetCurrentFrame();
 601 #else
 602                         pWindow = pControlManager->GetTouchedWindow();
 603 #endif
 604                         SysTryReturn(NID_UI, pWindow, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 605
 606                         Rectangle winBounds = pWindow->GetBounds();
 607
 608                         ptf.x = static_cast<float>(x - winBounds.x);
 609                         ptf.y = static_cast<float>(y - winBounds.y);
 610
 611 #if !defined(MULTI_WINDOW)
 612                         pRootControlElement = dynamic_cast <_ControlVisualElement*>(pControlManager->GetRoot().GetVisualElement());
 613 #else
 614                         pRootControlElement = dynamic_cast <_ControlVisualElement*>(pWindow->GetVisualElement());
 615 #endif
 616                 }
 617
 618                 SysTryReturn(NID_UI, pRootControlElement, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 619
 620                 _ControlVisualElement* pControlVisualElement = pRootControlElement->GetControlChildAtPoint(ptf);
 621                 SysTryReturn(NID_UI, pControlVisualElement, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 622
 623                 pControl = static_cast <_Control*>(pControlVisualElement->GetUserData());
 624                 SysTryReturn(NID_UI, pControl, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 625
 626                 return pControl;
 627         }
 628
 629         result GetPosition(_TouchStatus status, int x, int y, Point& point) const
 630         {
 631                 result r = E_SUCCESS;
 632
 633                 _ControlManager* pControlManager = _ControlManager::GetInstance();
 634                 SysTryReturn(NID_UI, pControlManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 635
 636 #if !defined(MULTI_WINDOW)
 637                 _EcoreEvasMgr* pEcoreEvasMgr = GetEcoreEvasMgr();
 638                 SysTryReturn(NID_UI, pEcoreEvasMgr, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 639
 640                 _EcoreEvas* pEcoreEvas = pEcoreEvasMgr->GetEcoreEvas();
 641                 SysTryReturn(NID_UI, pEcoreEvas, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 642
 643                 Ecore_Evas* pEE = pEcoreEvas->GetEcoreEvas();
 644                 SysTryReturn(NID_UI, pEE, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 645 #else
 646                 _Window* pWindow = pControlManager->GetTouchedWindow();
 647                 SysTryReturn(NID_UI, pWindow, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] A system error occurred.");
 648
 649                 _RootVisualElement* pRootVE = pWindow->GetRootVisualElement();
 650                 SysTryReturn(NID_UI, pRootVE, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 651
 652                 _EflLayer* pLayer = static_cast<_EflLayer*>(pRootVE->GetNativeLayer());
 653                 SysTryReturn(NID_UI, pLayer, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 654
 655                 Ecore_Evas* pEE = pLayer->GetEcoreEvas();
 656                 SysTryReturn(NID_UI, pEE, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 657 #endif
 658
 659                 const int PORTRAIT = 0;
 660                 const int LANDSCAPE = 270;
 661                 const int PORTRAIT_REVERSE = 180;
 662                 const int LANDSCAPE_REVERSE = 90;
 663
 664                 Dimension dimension = pControlManager->GetScreenSize();
 665                 Point output(_CoordinateSystemUtils::InverseTransform(point));
 666                 int rotation = ecore_evas_rotation_get(pEE);
 667
 668                 switch (rotation)
 669                 {
 670                 case PORTRAIT:
 671                         point.x = output.x;
 672                         point.y = output.y;
 673                         break;
 674
 675                 case LANDSCAPE:
 676                         point.x = output.y;
 677                         point.y = dimension.width - output.x;
 678                         break;
 679
 680                 case PORTRAIT_REVERSE:
 681                         point.x = dimension.width - output.x;
 682                         point.y = dimension.height - output.y;
 683                         break;
 684
 685                 case LANDSCAPE_REVERSE:
 686                         point.x = dimension.height - output.y;
 687                         point.y = output.x;
 688                         break;
 689
 690                 default:
 691                         SysAssertf(0, "[E_SYSTEM][%d]", rotation);
 692                         r = E_SYSTEM;
 693                         break;
 694                 }
 695
 696                 return r;
 697         }
 698
 699 private:
 700         _TouchInfo __touchInfo;
 701         _TouchEventManager* __pTouchEventManager;
 702 }; // _TouchEvent
 703
 704 Eina_Bool
 705 OnNotified(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
 706 {
 707         if (pEventInfo)
 708         {
 709                 _UiEvent* pUiEvent = static_cast <_UiEvent*>(pEventInfo);
 710                 SysTryReturn(NID_UI, pUiEvent, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 711
 712                 _UiEventManager* pEventManager = _UiEventManager::GetInstance();
 713                 SysTryReturn(NID_UI, pEventManager, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 714
 715                 result r = pEventManager->SendEvent(*pUiEvent);
 716                 SysTryReturn(NID_UI, r == E_SUCCESS, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 717         }
 718
 719         SetLastResult(E_SUCCESS);
 720
 721         return ECORE_CALLBACK_PASS_ON;
 722 }
 723
 724 void
 725 FreeEvent(void* pData __UNUSED__, void* pEventInfo)
 726 {
 727         _UiEvent* pUiEvent = static_cast <_UiEvent*>(pEventInfo);
 728         if (pUiEvent)
 729         {
 730                 delete pUiEvent;
 731         }
 732 }
 733
 734 Eina_Bool
 735 OnKeyPressed(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
 736 {
 737         Ecore_Event_Key* pEv = static_cast <Ecore_Event_Key*>(pEventInfo);
 738         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 739
 740         //SysLog(NID_UI, "OnKeyPressed(%s, %d)", pEv->keyname, pEv->modifiers);
 741         _KeyEvent event(KEY_PRESSED, _KeyEvent::GetKeyCode(pEv->keyname), _KeyEvent::GetKeyModifier(pEv->modifiers), pEv);
 742         event.Send();
 743
 744         SetLastResult(E_SUCCESS);
 745
 746         return ECORE_CALLBACK_PASS_ON;
 747 }
 748
 749 Eina_Bool
 750 OnKeyReleased(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
 751 {
 752         Ecore_Event_Key* pEv = static_cast <Ecore_Event_Key*>(pEventInfo);
 753         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 754
 755         //SysLog(NID_UI, "OnKeyReleased(%s, %d)", pEv->keyname, pEv->modifiers);
 756         _KeyEvent event(KEY_RELEASED, _KeyEvent::GetKeyCode(pEv->keyname), _KeyEvent::GetKeyModifier(pEv->modifiers), pEv);
 757         event.Send();
 758
 759         SetLastResult(E_SUCCESS);
 760
 761         return ECORE_CALLBACK_PASS_ON;
 762 }
 763
 764 Eina_Bool
 765 OnTouchPressed(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
 766 {
 767         Ecore_Event_Mouse_Button* pEv = static_cast <Ecore_Event_Mouse_Button*>(pEventInfo);
 768         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 769
 770 #if defined(MULTI_WINDOW)
 771         _ControlManager* pControlManager = _ControlManager::GetInstance();
 772         SysTryReturn(NID_UI, pControlManager, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 773
 774         pControlManager->SetTouchedWindow((unsigned int)pEv->window);
 775 #endif
 776
 777         isPressed = true;
 778
 779         SysLog(NID_UI, "OnTouchPressed - x(%d), y(%d), deviceId(%d)", pEv->root.x, pEv->root.y, pEv->multi.device);
 780         _TouchEvent event(pEv->multi.device, _TOUCH_PRESSED, pEv->root.x, pEv->root.y, pEv->timestamp, null);
 781
 782         result r = GetLastResult();
 783         SysTryReturn(NID_UI, r == E_SUCCESS, ECORE_CALLBACK_PASS_ON, r, "[%s] Propagating.", GetErrorMessage(r));
 784
 785         event.Send();
 786
 787         SetLastResult(E_SUCCESS);
 788
 789         return ECORE_CALLBACK_PASS_ON;
 790 }
 791
 792 Eina_Bool
 793 OnTouchReleased(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
 794 {
 795         Ecore_Event_Mouse_Button* pEv = static_cast <Ecore_Event_Mouse_Button*>(pEventInfo);
 796         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 797
 798         isPressed = false;
 799
 800         SysLog(NID_UI, "OnTouchReleased - x(%d), y(%d), deviceId(%d)", pEv->root.x, pEv->root.y, pEv->multi.device);
 801         _TouchEvent event(pEv->multi.device, _TOUCH_RELEASED, pEv->root.x, pEv->root.y, pEv->timestamp, null);
 802
 803         result r = GetLastResult();
 804         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 805
 806         event.Send();
 807
 808         SetLastResult(E_SUCCESS);
 809
 810         return ECORE_CALLBACK_PASS_ON;
 811
 812 CATCH:
 813         _TouchManager* pTouchManager = _TouchManager::GetInstance();
 814         if (pTouchManager)
 815         {
 816                 SysLogException(NID_UI, E_SUCCESS, "ResetTouchInfo");
 817                 pTouchManager->SetTouchAllowed(false);
 818                 pTouchManager->ResetTouchInfo();
 819         }
 820
 821         return ECORE_CALLBACK_PASS_ON;
 822 }
 823
 824 Eina_Bool
 825 OnTouchMoved(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
 826 {
 827         Ecore_Event_Mouse_Move* pEv = static_cast <Ecore_Event_Mouse_Move*>(pEventInfo);
 828         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 829
 830         //SysLog(NID_UI, "OnTouchMoved - x(%d), y(%d), deviceId(%d)", pEv->root.x, pEv->root.y, pEv->multi.device);
 831         _TouchEvent event(pEv->multi.device, _TOUCH_MOVED, pEv->root.x, pEv->root.y, pEv->timestamp, null);
 832
 833         result r = GetLastResult();
 834         SysTryReturn(NID_UI, r == E_SUCCESS, ECORE_CALLBACK_PASS_ON, r, "[%s] Propagating.", GetErrorMessage(r));
 835
 836         event.Send();
 837
 838         SetLastResult(E_SUCCESS);
 839
 840         return ECORE_CALLBACK_PASS_ON;
 841 }
 842
 843 Eina_Bool
 844 OnKeyboardInserted(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
 845 {
 846         Ecore_X_Event_Window_Property *pEv = static_cast <Ecore_X_Event_Window_Property*>(pEventInfo);
 847         if ( pEv->atom != keyboardExist)
 848         {
 849 //              SysLog(NID_UI, "OnKeyboardInserted - atom of event(%d), keyboardExist(%d)", pEv->atom, keyboardExist);
 850                 return ECORE_CALLBACK_PASS_ON;
 851         }
 852
 853         ArrayList* pArgs = null;
 854         result r = E_SUCCESS;
 855         Boolean* pIsKeyboardOn = null;
 856         _UiEventManager* pEventManager = _UiEventManager::GetInstance();
 857         SysTryReturn(NID_UI, pEventManager, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 858
 859         _Control* pControl = _ControlManager::GetInstance()->GetFocusedControl();
 860         SysTryReturn(NID_UI, pControl, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 861
 862         bool isKeyboardOn = false;
 863         unsigned int value = 0;
 864         int returnResult = -1;
 865
 866         returnResult = ecore_x_window_prop_card32_get(pEv->win, keyboardExist, &value, 1);
 867         if (returnResult)
 868         {
 869                 if (value > 0)
 870                 {
 871                         isKeyboardOn = true;
 872                 }
 873
 874                 pArgs = new (std::nothrow) ArrayList;
 875                 SysTryReturn(NID_UI, pArgs, ECORE_CALLBACK_PASS_ON, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 876
 877                 r = pArgs->Construct();
 878                 SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 879
 880                 String* pString = new (std::nothrow) String(KEYBOARD_INSERTED_EVENT);
 881                 r = pArgs->Add(*pString);
 882                 SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 883
 884                 pIsKeyboardOn = new (std::nothrow) Boolean(isKeyboardOn);
 885                 r = pArgs->Add(*pIsKeyboardOn);
 886                 SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 887
 888                 _UiNotificationEvent event(pControl->GetHandle(), pArgs);
 889                 r = pEventManager->SendEvent(event);
 890 //              SysLog(NID_UI, "OnKeyboardInserted - sent keyboard inserted noti");
 891         }
 892
 893         SetLastResult(r);
 894
 895         return ECORE_CALLBACK_PASS_ON;
 896
 897 CATCH:
 898         if (pArgs)
 899         {
 900                 delete pArgs;
 901         }
 902
 903         if (pIsKeyboardOn)
 904         {
 905                 delete pIsKeyboardOn;
 906         }
 907
 908         return ECORE_CALLBACK_PASS_ON;
 909 }
 910
 911 Eina_Bool
 912 OnWindowFocusIn(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
 913 {
 914         SysLog(NID_UI, "Enter");
 915
 916         Ecore_X_Event_Window_Focus_In* pEv = static_cast<Ecore_X_Event_Window_Focus_In*>(pEventInfo);
 917         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 918
 919         _ControlManager* pControlManager = _ControlManager::GetInstance();
 920         SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 921
 922         int count = pControlManager->GetWindowCount();
 923
 924         _Control* pFocusedControl = null;
 925         for (int i = count - 1; i >= 0; --i)
 926         {
 927                 _Window* pWindow = pControlManager->GetWindow(i);
 928                 if (pWindow)
 929                 {
 930 #if !defined(MULTI_WINDOW)
 931                         pFocusedControl = pWindow->GetFocused();
 932                         if (pFocusedControl)
 933                         {
 934                                 pFocusedControl->SetFocused();
 935                                 break;
 936                         }
 937 #else
 938                         NativeWindowHandle nativeWindowHandle = pWindow->GetNativeHandle();
 939                         if (pEv->win == nativeWindowHandle)
 940                         {
 941                                 pFocusedControl = pWindow->GetFocused();
 942                                 if (pFocusedControl)
 943                                 {
 944                                         pFocusedControl->SetFocused();
 945                                         break;
 946                                 }
 947                         }
 948 #endif
 949                 }
 950         }
 951
 952         return ECORE_CALLBACK_PASS_ON;
 953 }
 954
 955 Eina_Bool
 956 OnWindowFocusOut(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
 957 {
 958         SysLog(NID_UI, "Enter");
 959
 960         Ecore_X_Event_Window_Focus_Out* pEv = static_cast<Ecore_X_Event_Window_Focus_Out*>(pEventInfo);
 961         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 962
 963         _ControlManager* pControlManager = _ControlManager::GetInstance();
 964         SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 965
 966 #if !defined(MULTI_WINDOW)
 967         _Control* pFocusedControl = pControlManager->GetFocusedControl();
 968         if (pFocusedControl)
 969         {
 970                 pControlManager->TakeFocusFromControl(*pFocusedControl);
 971         }
 972 #else
 973         _Control* pFocusedControl = pControlManager->GetFocusedControl();
 974         if (pFocusedControl)
 975         {
 976                 _Window* pRootWindow = pFocusedControl->GetRootWindow();
 977                 if (pRootWindow)
 978                 {
 979                         NativeWindowHandle nativeWindowHandle = pRootWindow->GetNativeHandle();
 980                         if (pEv->win == nativeWindowHandle)
 981                         {
 982                                 pControlManager->TakeFocusFromControl(*pFocusedControl);
 983                         }
 984                 }
 985         }
 986 #endif
 987
 988         return ECORE_CALLBACK_PASS_ON;
 989 }
 990
 991 // Evas Callbacks
 992 void
 993 OnEvasKeyPressed(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
 994 {
 995         Evas_Event_Key_Down* pEv = static_cast <Evas_Event_Key_Down*>(pEventInfo);
 996         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 997
 998         SetLastResult(E_SUCCESS);
 999 }
1000
1001 void
1002 OnEvasKeyReleased(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1003 {
1004         Evas_Event_Key_Up* pEv = static_cast <Evas_Event_Key_Up*>(pEventInfo);
1005         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1006
1007         SetLastResult(E_SUCCESS);
1008 }
1009
1010 void
1011 OnEvasTouchPressed(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1012 {
1013         Evas_Event_Mouse_Down* pEv = static_cast <Evas_Event_Mouse_Down*>(pEventInfo);
1014         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1015
1016         _Control* pControl = static_cast<_Control*>(pData);
1017         SysTryReturnVoidResult(NID_UI, pControl, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1018
1019         _TouchEvent event(0, _TOUCH_PRESSED, pEv->canvas.x, pEv->canvas.y, pEv->timestamp, pControl);
1020
1021         result r = GetLastResult();
1022         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1023
1024         event.Send();
1025
1026         SetLastResult(E_SUCCESS);
1027 }
1028
1029 void
1030 OnEvasTouchReleased(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1031 {
1032         Evas_Event_Mouse_Up* pEv = static_cast <Evas_Event_Mouse_Up*>(pEventInfo);
1033         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1034
1035         _Control* pControl = static_cast<_Control*>(pData);
1036         SysTryReturnVoidResult(NID_UI, pControl, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1037
1038         _TouchEvent event(0, _TOUCH_RELEASED, pEv->canvas.x, pEv->canvas.y, pEv->timestamp, pControl);
1039
1040         result r = GetLastResult();
1041         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1042
1043         event.Send();
1044
1045         SetLastResult(E_SUCCESS);
1046 }
1047
1048 void
1049 OnEvasTouchMoved(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1050 {
1051         Evas_Event_Mouse_Move* pEv = static_cast <Evas_Event_Mouse_Move*>(pEventInfo);
1052         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1053
1054         _Control* pControl = static_cast<_Control*>(pData);
1055         SysTryReturnVoidResult(NID_UI, pControl, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1056
1057         _TouchEvent event(0, _TOUCH_MOVED, pEv->cur.canvas.x, pEv->cur.canvas.y, pEv->timestamp, pControl);
1058
1059         result r = GetLastResult();
1060         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1061
1062         event.Send();
1063
1064         SetLastResult(E_SUCCESS);
1065 }
1066
1067 void
1068 OnEvasMultiTouchPressed(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1069 {
1070         Evas_Event_Multi_Down* pEv = static_cast <Evas_Event_Multi_Down*>(pEventInfo);
1071         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1072
1073         SetLastResult(E_SUCCESS);
1074 }
1075
1076 void
1077 OnEvasMultiTouchReleased(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1078 {
1079         Evas_Event_Multi_Up* pEv = static_cast <Evas_Event_Multi_Up*>(pEventInfo);
1080         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1081
1082         SetLastResult(E_SUCCESS);
1083 }
1084
1085 void
1086 OnEvasMultiTouchMoved(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1087 {
1088         Evas_Event_Multi_Move* pEv = static_cast <Evas_Event_Multi_Move*>(pEventInfo);
1089         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1090
1091         SetLastResult(E_SUCCESS);
1092 }
1093
1094 }; // Anonymous
1095
1096 namespace Tizen { namespace Ui
1097 {
1098
1099 _EflUiEventManager::_EflUiEventManager(void)
1100         : __notificaitonEventType(-1)
1101 {
1102         unique_ptr<LinkedListT<Ecore_Event_Handler*> > pEventHandlers(new (std::nothrow) LinkedListT<Ecore_Event_Handler*>);
1103         SysTryReturnVoidResult(NID_UI, pEventHandlers, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1104
1105         // Noti
1106         __notificaitonEventType = ecore_event_type_new();
1107         SysTryReturnVoidResult(NID_UI, __notificaitonEventType >= 1, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1108
1109         Ecore_Event_Handler* pEventHandler = ecore_event_handler_add(__notificaitonEventType, OnNotified, null);
1110         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1111
1112         pEventHandlers->Add(pEventHandler);
1113
1114         // Key
1115         pEventHandler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, OnKeyPressed, null);
1116         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1117
1118         pEventHandlers->Add(pEventHandler);
1119
1120         pEventHandler = ecore_event_handler_add(ECORE_EVENT_KEY_UP, OnKeyReleased, null);
1121         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1122
1123         pEventHandlers->Add(pEventHandler);
1124
1125         // Touch
1126         pEventHandler = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, OnTouchPressed, null);
1127         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1128
1129         pEventHandlers->Add(pEventHandler);
1130
1131         pEventHandler = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP, OnTouchReleased, null);
1132         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1133
1134         pEventHandlers->Add(pEventHandler);
1135
1136         pEventHandler = ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE, OnTouchMoved, null);
1137         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1138
1139         pEventHandlers->Add(pEventHandler);
1140
1141         // WIndow property
1142         pEventHandler = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_PROPERTY, OnKeyboardInserted, null);
1143         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1144
1145         pEventHandlers->Add(pEventHandler);
1146
1147         // WIndo focus
1148         pEventHandler = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_IN, OnWindowFocusIn, null);
1149         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1150
1151         pEventHandlers->Add(pEventHandler);
1152
1153         pEventHandler = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT, OnWindowFocusOut, null);
1154         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1155
1156         pEventHandlers->Add(pEventHandler);
1157
1158         __pEventHandlers = move(pEventHandlers);
1159
1160         keyboardExist = XInternAtom(static_cast<Display*>(ecore_x_display_get()), "X External Keyboard Exist", 0);
1161
1162         SetLastResult(E_SUCCESS);
1163 }
1164
1165 _EflUiEventManager::~_EflUiEventManager(void)
1166 {
1167         Tizen::Base::Collection::IEnumeratorT<Ecore_Event_Handler*>* pEnumerator = __pEventHandlers->GetEnumeratorN();
1168         SysTryReturnVoidResult(NID_UI, pEnumerator, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
1169
1170         while (pEnumerator->MoveNext() == E_SUCCESS)
1171         {
1172                 Ecore_Event_Handler* pEventHandler = null;
1173                 pEnumerator->GetCurrent(pEventHandler);
1174                 if (pEventHandler)
1175                 {
1176                         ecore_event_handler_del(pEventHandler);
1177                 }
1178         }
1179
1180         delete pEnumerator;
1181 }
1182
1183 result
1184 _EflUiEventManager::RegisterKeyEventHandler(const _Control& control)
1185 {
1186         result r = E_SUCCESS;
1187
1188         Evas_Object* pEvasObject = GetEvasObject(control);
1189         SysTryReturn(NID_UI, pEvasObject, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1190
1191         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_KEY_UP, OnEvasKeyReleased, &control);
1192         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_KEY_DOWN, OnEvasKeyPressed, &control);
1193
1194         return r;
1195 }
1196
1197 result
1198 _EflUiEventManager::RegisterTouchEventHandler(const _Control& control)
1199 {
1200         result r = E_SUCCESS;
1201
1202         Evas_Object* pEvasObject = GetEvasObject(control);
1203         SysTryReturn(NID_UI, pEvasObject, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1204
1205         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MOUSE_UP, OnEvasTouchReleased, &control);
1206         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MOUSE_DOWN, OnEvasTouchPressed, &control);
1207         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MOUSE_MOVE, OnEvasTouchMoved, &control);
1208
1209         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MULTI_UP, OnEvasMultiTouchReleased, &control);
1210         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MULTI_DOWN, OnEvasMultiTouchPressed, &control);
1211         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MULTI_MOVE, OnEvasMultiTouchMoved, &control);
1212
1213         return r;
1214 }
1215
1216 result
1217 _EflUiEventManager::UnregisterKeyEventHandler(const _Control& control)
1218 {
1219         result r = E_SUCCESS;
1220
1221         Evas_Object* pEvasObject = GetEvasObject(control);
1222         SysTryReturn(NID_UI, pEvasObject, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1223
1224         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_KEY_UP, OnEvasKeyReleased);
1225         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_KEY_DOWN, OnEvasKeyPressed);
1226
1227         return r;
1228 }
1229
1230 result
1231 _EflUiEventManager::UnregisterTouchEventHandler(const _Control& control)
1232 {
1233         result r = E_SUCCESS;
1234
1235         Evas_Object* pEvasObject = GetEvasObject(control);
1236         SysTryReturn(NID_UI, pEvasObject, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1237
1238         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MOUSE_UP, OnEvasTouchReleased);
1239         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MOUSE_DOWN, OnEvasTouchPressed);
1240         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MOUSE_MOVE, OnEvasTouchMoved);
1241
1242         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MULTI_UP, OnEvasMultiTouchReleased);
1243         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MULTI_DOWN, OnEvasMultiTouchPressed);
1244         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MULTI_MOVE, OnEvasMultiTouchMoved);
1245
1246         return r;
1247 }
1248
1249 result
1250 _EflUiEventManager::PostEvent(const _UiEvent& event)
1251 {
1252         ClearLastResult();
1253
1254         result r = E_SUCCESS;
1255
1256         _UiEvent* pEvent = event.CloneN();
1257         SysTryReturn(NID_UI, pEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1258
1259         Ecore_Event* pEcoreEvent = ecore_event_add(__notificaitonEventType, pEvent, FreeEvent, null);
1260         SysTryReturn(NID_UI, pEcoreEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1261
1262         return r;
1263 }
1264
1265 void
1266 _EflUiEventManager::SetKeyCapture(const _Control& control, _KeyCode keyCode)
1267 {
1268         Ecore_X_Window win = ecore_evas_software_x11_window_get(ecore_evas_ecore_evas_get(evas_object_evas_get(GetEvasObject(control))));
1269
1270         for (unsigned int i = 0; i < sizeof(keyTable) / sizeof(_EvasConvertKeys); ++i)
1271         {
1272                 if (keyTable[i].code == keyCode)
1273                 {
1274                         if (keyTable[i].pName)
1275                         {
1276                                 utilx_grab_key((Display*)ecore_x_display_get(), win, keyTable[i].pName, TOP_POSITION_GRAB);
1277                                 break;
1278                         }
1279                 }
1280         }
1281 }
1282
1283 void
1284 _EflUiEventManager::ReleaseKeyCapture(const _Control& control, _KeyCode keyCode)
1285 {
1286         Ecore_X_Window win = ecore_evas_software_x11_window_get(ecore_evas_ecore_evas_get(evas_object_evas_get(GetEvasObject(control))));
1287
1288         for (unsigned int i = 0; i < sizeof(keyTable) / sizeof(_EvasConvertKeys); ++i)
1289         {
1290                 if (keyTable[i].code == keyCode)
1291                 {
1292                         if (keyTable[i].pName)
1293                         {
1294                                 utilx_ungrab_key((Display*)ecore_x_display_get(), win,  keyTable[i].pName);
1295                                 break;
1296                         }
1297                 }
1298         }
1299 }
1300 }
1301
1302 } // Tizen::Ui