src/ui/FUi_EflUiEventManager.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_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 #include "FUiAnim_RootVisualElement.h"
  48 #include "FUiAnim_EflLayer.h"
  49 #include "FUi_AccessibilityManager.h"
  50
  51 using namespace std;
  52 using namespace Tizen::Ui;
  53 using namespace Tizen::Ui::Animations;
  54 using namespace Tizen::Graphics;
  55 using namespace Tizen::Base::Collection;
  56 using namespace Tizen::Base;
  57 using namespace Tizen::Ui::Controls;
  58
  59 namespace
  60 {
  61 #define __UNUSED__
  62
  63 Ecore_X_Atom keyboardExist = 0;
  64 const wchar_t* KEYBOARD_INSERTED_EVENT = L"KEYBOARD_INSERTED";
  65 const int DEVICE_COUNT = 999;
  66 bool touchPressed[DEVICE_COUNT] = {false,};
  67
  68 Evas_Object*
  69 GetEvasObject(const _Control& control)
  70 {
  71         _VisualElement* pVisualElement = control.GetVisualElement();
  72         SysTryReturn(NID_UI, pVisualElement, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
  73
  74         _EflNode* pEflNode = dynamic_cast<_EflNode*>(pVisualElement->GetNativeNode());
  75         SysTryReturn(NID_UI, pEflNode, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
  76
  77         return (Evas_Object*)pEflNode->GetGroupContainer();
  78 }
  79
  80 Evas*
  81 GetEvas(const _Control& control)
  82 {
  83         Evas* pEvas = null;
  84         Evas_Object* pEvasObject = GetEvasObject(control);
  85         if (pEvasObject)
  86         {
  87                 pEvas = evas_object_evas_get(pEvasObject);
  88                 SysTryReturn(NID_UI, pEvas, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
  89         }
  90
  91         return pEvas;
  92 }
  93
  94 class _Event
  95 {
  96 public:
  97         _Event(void)
  98                 : _pEventManager(null)
  99         {
 100                 _pEventManager = _UiEventManager::GetInstance();
 101                 SysTryReturnVoidResult(NID_UI, _pEventManager, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 102
 103                 SetLastResult(E_SUCCESS);
 104         }
 105
 106         virtual ~_Event(void)
 107         {
 108         }
 109
 110 private:
 111         _Event(const _Event& rhs);
 112         _Event& operator =(const _Event& rhs);
 113
 114         virtual result SendImpl(void) = 0;
 115
 116 public:
 117         result Send(void)
 118         {
 119                 return SendImpl();
 120         }
 121
 122 protected:
 123         _UiEventManager* _pEventManager;
 124 }; // _Event
 125
 126 struct _EvasConvertKeys
 127 {
 128         _KeyCode code;
 129         const char* pName;
 130 };
 131
 132 const _EvasConvertKeys keyTable[] =
 133 {
 134         { _KEY_ESC, "Escape" },
 135         { _KEY_GRAVE, "grave" },
 136         { _KEY_1, "1" },
 137         { _KEY_2, "2" },
 138         { _KEY_3, "3" },
 139         { _KEY_4, "4" },
 140         { _KEY_5, "5" },
 141         { _KEY_6, "6" },
 142         { _KEY_7, "7" },
 143         { _KEY_8, "8" },
 144         { _KEY_9, "9" },
 145         { _KEY_0, "0" },
 146         { _KEY_MINUS, "minus" },
 147         { _KEY_EQUAL, "equal" },
 148         { _KEY_BACKSLASH, "backslash" },
 149         { _KEY_BACKSPACE, "BackSpace" },
 150         { _KEY_TAB, "Tab" },
 151         { _KEY_Q, "q" },
 152         { _KEY_W, "w" },
 153         { _KEY_E, "e" },
 154         { _KEY_R, "r" },
 155         { _KEY_T, "t" },
 156         { _KEY_Y, "y" },
 157         { _KEY_U, "u" },
 158         { _KEY_I, "i" },
 159         { _KEY_O, "o" },
 160         { _KEY_P, "p" },
 161         { _KEY_LBRACKET, "bracketleft" },
 162         { _KEY_RBRACKET, "bracketright" },
 163         { _KEY_ENTER, "Return" },
 164         { _KEY_CAPSLOCK, "Caps_Lock" },
 165         { _KEY_A, "a" },
 166         { _KEY_S, "s" },
 167         { _KEY_D, "d" },
 168         { _KEY_F, "f" },
 169         { _KEY_G, "g" },
 170         { _KEY_H, "h" },
 171         { _KEY_J, "j" },
 172         { _KEY_K, "k" },
 173         { _KEY_L, "l" },
 174         { _KEY_SEMICOLON, "semicolon" },
 175         { _KEY_APOSTROPHE, "apostrophe" },
 176         { _KEY_SHIFT_L, "Shift_L" },
 177         { _KEY_Z, "z" },
 178         { _KEY_X, "x" },
 179         { _KEY_C, "c" },
 180         { _KEY_V, "v" },
 181         { _KEY_B, "b" },
 182         { _KEY_N, "n" },
 183         { _KEY_M, "m" },
 184         { _KEY_COMMA, "comma" },
 185         { _KEY_DOT, "period" },
 186         { _KEY_SLASH, "slash" },
 187         { _KEY_SHIFT_R, "Shift_R" },
 188         { _KEY_CTRL_L, "Control_L" },
 189         { _KEY_LALT, "Alt_L" },
 190         { _KEY_SPACE, "space" },
 191         { _KEY_RALT, "Alt_R" },
 192         { _KEY_CTRL_R, "Control_R" },
 193         { _KEY_FN_1, "F1" },
 194         { _KEY_FN_2, "F2" },
 195         { _KEY_FN_3, "F3" },
 196         { _KEY_FN_4, "F4" },
 197         { _KEY_FN_5, "F5" },
 198         { _KEY_FN_6, "F6" },
 199         { _KEY_FN_7, "F7" },
 200         { _KEY_FN_8, "F8" },
 201         { _KEY_FN_9, "F9" },
 202         { _KEY_FN_10, "F10" },
 203         { _KEY_FN_11, "F11" },
 204         { _KEY_FN_12, "F12" },
 205         { _KEY_NUM_LOCK, "Num_Lock" },
 206         { _KEY_NUMPAD_DIVIDE, "KP_Divide" },
 207         { _KEY_NUMPAD_MULTIPLY, "KP_Multiply" },
 208         { _KEY_NUMPAD_SUBTRACT, "KP_Subtract" },
 209         { _KEY_NUMPAD_7, "KP_Home" },
 210         { _KEY_NUMPAD_8, "KP_Up" },
 211         { _KEY_NUMPAD_9, "KP_Prior" },
 212         { _KEY_NUMPAD_4, "KP_Left" },
 213         { _KEY_NUMPAD_5, "KP_Begin" },
 214         { _KEY_NUMPAD_6, "KP_Right" },
 215         { _KEY_NUMPAD_ADD, "KP_Add" },
 216         { _KEY_NUMPAD_1, "KP_End" },
 217         { _KEY_NUMPAD_2, "KP_Down" },
 218         { _KEY_NUMPAD_3, "KP_Next" },
 219         { _KEY_NUMPAD_0, "KP_Insert" },
 220         { _KEY_NUMPAD_DOT, "KP_Delete" },
 221         { _KEY_NUMPAD_ENTER, "KP_Enter" },
 222         { _KEY_PRINT, "Print" },
 223         { _KEY_SCROLL_LOCK, "Scroll_Lock" },
 224         { _KEY_PAUSEBREAK, "Pause" },
 225         { _KEY_INSERT, "Insert" },
 226         { _KEY_HOME_BUTTON, "Home" },
 227         { _KEY_PAGE_UP, "Prior" },
 228         { _KEY_DELETE, "Delete" },
 229         { _KEY_END_BUTTON, "End" },
 230         { _KEY_PAGE_DOWN, "Next" },
 231         { _KEY_UP, "Up" },
 232         { _KEY_LEFT, "Left" },
 233         { _KEY_DOWN, "Down" },
 234         { _KEY_RIGHT, "Right" },
 235         { _KEY_COMMA, "less" }, /*virtual keypad <*/
 236         { _KEY_9, "parenleft" }, /*virtual keypad (*/
 237         { _KEY_0, "parenright" }, /*virtual keypad )*/
 238         { _KEY_CONTEXT_MENU, "Menu" },
 239         { _KEY_CONTEXT_MENU, "XF86Send" },
 240         //{ _KEY_SIDE_UP, "XF86AudioRaiseVolume" },
 241         //{ _KEY_SIDE_DOWN, "XF86AudioLowerVolume" },
 242         //{ _KEY_POWER_HOLD, "XF86PowerOff" },
 243         { _KEY_CLEAR, "XF86Stop" }
 244
 245
 246 };
 247
 248 class _KeyEvent
 249         : public _Event
 250 {
 251 public:
 252         _KeyEvent(KeyState keyState, _KeyCode keyCode, int keyModifier, void* pUserData)
 253                 : __pTarget(null)
 254                 , __keyInfo(keyState, keyCode, keyModifier, pUserData)
 255         {
 256                 __pTarget = GetTarget(keyCode);
 257         }
 258
 259         virtual ~_KeyEvent(void)
 260         {
 261         }
 262
 263         static _KeyCode GetKeyCode(const char* pKeyName)
 264         {
 265                 ClearLastResult();
 266
 267                 SysTryReturn(NID_UI, pKeyName, _KEY_INVALID, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 268
 269                 for (unsigned int i = 0; i < sizeof(keyTable) / sizeof(_EvasConvertKeys); ++i)
 270                 {
 271                         if (strcmp(keyTable[i].pName, pKeyName) == 0)
 272                         {
 273                                 return keyTable[i].code;
 274                         }
 275                 }
 276
 277                 return _KEY_INVALID;
 278         }
 279
 280         static int GetKeyModifier(const int keyModifier)
 281         {
 282                 ClearLastResult();
 283                 unsigned int modifier = _KEY_MODIFIER_NONE;
 284
 285                 if(ECORE_EVENT_MODIFIER_SHIFT & keyModifier)
 286                 {
 287                         modifier |= _KEY_MODIFIER_SHIFT;
 288                 }
 289                 if(ECORE_EVENT_MODIFIER_CTRL & keyModifier)
 290                 {
 291                         modifier |= _KEY_MODIFIER_CTRL;
 292                 }
 293                 if(ECORE_EVENT_MODIFIER_ALT & keyModifier)
 294                 {
 295                         modifier |= _KEY_MODIFIER_ALT;
 296                 }
 297                 if(ECORE_EVENT_MODIFIER_WIN & keyModifier)
 298                 {
 299                         modifier |= _KEY_MODIFIER_WIN;
 300                 }
 301                 if(ECORE_EVENT_MODIFIER_SCROLL & keyModifier)
 302                 {
 303                         modifier |= _KEY_MODIFIER_SCROLL;
 304                 }
 305                 if(ECORE_EVENT_MODIFIER_NUM & keyModifier)
 306                 {
 307                         modifier |= _KEY_MODIFIER_NUM;
 308                 }
 309                 if(ECORE_EVENT_MODIFIER_CAPS & keyModifier)
 310                 {
 311                         modifier |= _KEY_MODIFIER_CAPS;
 312                 }
 313                 if(ECORE_EVENT_LOCK_SCROLL & keyModifier)
 314                 {
 315                         modifier |= _KEY_LOCK_SCROLL;
 316                 }
 317                 if(ECORE_EVENT_LOCK_NUM & keyModifier)
 318                 {
 319                         modifier |= _KEY_LOCK_NUM;
 320                 }
 321                 if(ECORE_EVENT_LOCK_CAPS & keyModifier)
 322                 {
 323                         modifier |= _KEY_LOCK_CAPS;
 324                 }
 325                 if(ECORE_EVENT_LOCK_SHIFT & keyModifier)
 326                 {
 327                         modifier |= _KEY_LOCK_SHIFT;
 328                 }
 329                 if(ECORE_EVENT_MODIFIER_ALTGR & keyModifier)
 330                 {
 331                         modifier |= _KEY_MODIFIER_ALTGR;
 332                 }
 333
 334                 return modifier;
 335         }
 336
 337 private:
 338         _KeyEvent(const _KeyEvent& rhs);
 339         _KeyEvent& operator =(const _KeyEvent& rhs);
 340
 341         virtual result SendImpl(void)
 342         {
 343                 SysTryReturn(NID_UI, __pTarget, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 344
 345                 _UiKeyEvent event(__pTarget->GetHandle(), __keyInfo);
 346
 347                 return _pEventManager->SendEvent(event);
 348         }
 349
 350         _Control* GetTarget(_KeyCode keyCode) const
 351         {
 352                 _KeyEventManager* pKeyEventManager = _KeyEventManager::GetInstance();
 353                 SysTryReturn(NID_UI, pKeyEventManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 354
 355                 _Control* pControl = pKeyEventManager->GetCapturingControl(keyCode);
 356
 357                 if (pControl == null)
 358                 {
 359                         _ControlManager* pControlManager = _ControlManager::GetInstance();
 360                         SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 361
 362                         pControl = pControlManager->GetFocusControl();
 363
 364                         if (!pControl)
 365                         {
 366                                 pControl = pControlManager->GetCurrentFrame();
 367                         }
 368                         SysTryReturn(NID_UI, pControl, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 369                 }
 370
 371                 _ControlManager* pControlManager = _ControlManager::GetInstance();
 372                 SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 373
 374                 pControl = pControlManager->GetFocusControl();
 375                 if (!pControl)
 376                 {
 377                         pControl = pControlManager->GetCurrentFrame();
 378                 }
 379                 SysTryReturn(NID_UI, pControl, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 380
 381                 SetLastResult(E_SUCCESS);
 382
 383                 return pControl;
 384         }
 385
 386 private:
 387         _Control* __pTarget;
 388         _KeyInfo __keyInfo;
 389 }; // _KeyEvent
 390
 391 class _TouchEventManager
 392 {
 393 public:
 394         static _TouchEventManager* GetInstance(void)
 395         {
 396                 if (__pInstance == null)
 397                 {
 398                         __pInstance = new (std::nothrow) _TouchEventManager;
 399                         SysTryReturn(NID_UI, __pInstance, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 400                 }
 401
 402                 SetLastResult(E_SUCCESS);
 403
 404                 return __pInstance;
 405         }
 406
 407         result AddControl(int pointId, const _ControlHandle& controlHandle)
 408         {
 409                 bool exist = false;
 410                 result r = E_SUCCESS;
 411
 412                 __pTargetMap->ContainsKey(pointId, exist);
 413
 414                 if (exist)
 415                 {
 416                         r = __pTargetMap->Remove(pointId);
 417                         SysTryReturnResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 418                 }
 419
 420                 r = __pTargetMap->Add(pointId, controlHandle);
 421                 SysTryReturnResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 422
 423                 return r;
 424         }
 425
 426         _Control* GetControl(int pointId)
 427         {
 428                 SysTryReturn(NID_UI, __pTargetMap, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 429
 430                 _ControlHandle controlHandle;
 431
 432                 __pTargetMap->GetValue(pointId, controlHandle);
 433
 434                 _ControlManager* pControlManager = _ControlManager::GetInstance();
 435                 result r = GetLastResult();
 436                 SysTryReturn(NID_UI, pControlManager, null, r, "[%s] Propagating.", GetErrorMessage(r));
 437
 438                 return pControlManager->GetObject(controlHandle);
 439         }
 440
 441 private:
 442         _TouchEventManager(void)
 443         {
 444                 result r = E_SUCCESS;
 445                 unique_ptr<HashMapT<int, _ControlHandle> > pTargetMap(new (std::nothrow) HashMapT<int, _ControlHandle>);
 446                 SysTryReturnVoidResult(NID_UI, pTargetMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 447
 448                 r = pTargetMap->Construct();
 449                 SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 450
 451                 __pTargetMap = move(pTargetMap);
 452
 453                 SetLastResult(E_SUCCESS);
 454         }
 455
 456         ~_TouchEventManager(void)
 457         {
 458         }
 459
 460         _TouchEventManager(const _TouchEventManager& rhs);
 461         _TouchEventManager& operator =(const _TouchEventManager& rhs);
 462
 463 private:
 464         static _TouchEventManager* __pInstance;
 465         unique_ptr<HashMapT<int, _ControlHandle> > __pTargetMap;
 466 };
 467
 468 _TouchEventManager* _TouchEventManager::__pInstance = null;
 469
 470 class _TouchEvent
 471         : public _Event
 472 {
 473 public:
 474         _TouchEvent(int deviceId, _TouchStatus status, int x, int y, unsigned int timeStamp, const _Control* pRootControl)
 475                 : __pTouchEventManager(null)
 476         {
 477                 __pTouchEventManager = _TouchEventManager::GetInstance();
 478                 SysTryReturnVoidResult(NID_UI, __pTouchEventManager, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 479
 480                 result r = E_SUCCESS;
 481                 Tizen::Graphics::Point current(x, y);
 482
 483                 _TouchManager* pTouchManager = _TouchManager::GetInstance();
 484                 SysTryReturnVoidResult(NID_UI, pTouchManager, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 485
 486                 unsigned int pointId = 0;
 487
 488                 if (status == _TOUCH_PRESSED)
 489                 {
 490                         IListT<_FingerInfo*>* pFingerInfoList = pTouchManager->GetMultiFingerInfoListN();
 491                         SysTryReturnVoidResult(NID_UI, pFingerInfoList, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 492
 493                         const int count = pFingerInfoList->GetCount();
 494
 495                         for (int i = 0; i < count; i++)
 496                         {
 497                                 _FingerInfo* pFingerInfo = null;
 498                                 pFingerInfoList->GetAt(i, pFingerInfo);
 499                                 if (pFingerInfo == null)
 500                                 {
 501                                         continue;
 502                                 }
 503
 504                                 if (static_cast<int>(pFingerInfo->GetDeviceId()) == deviceId && pFingerInfo->GetStatus() == _TOUCH_PRESSED)
 505                                 {
 506                                         pTouchManager->ResetTouchInfo();
 507                                         SysSecureLog(NID_UI, "ResetTouchInfo x(%d), y(%d), deviceID(%d), pointID(%d)", current.x, current.y, deviceId, pFingerInfo->GetPointId());
 508                                         break;
 509                                 }
 510                         }
 511                         delete pFingerInfoList;
 512
 513                         pointId = pTouchManager->GeneratePointId(deviceId);
 514                         SysSecureLog(NID_UI, "OnTouchPressed GeneratePointId = pointId %d", pointId);
 515                 }
 516                 else
 517                 {
 518                         pointId = pTouchManager->GetPointId(deviceId);
 519                 }
 520
 521                 if (status == _TOUCH_RELEASED)
 522                 {
 523                         SysSecureLog(NID_UI, "OnTouchReleased GetPointId = pointId %d", pointId);
 524                 }
 525
 526                 if (pointId == INVALID_POINT_ID)
 527                 {
 528                         if (status == _TOUCH_RELEASED)
 529                         {
 530                                 _ControlManager* pControlManager = _ControlManager::GetInstance();
 531                                 SysTryReturnVoidResult(NID_UI, pControlManager, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 532
 533                                 _Window* pWindow = pControlManager->GetTouchedWindow();
 534                                 if (pWindow == null)
 535                                 {
 536                                         _TouchManager* pTouchManager = _TouchManager::GetInstance();
 537                                         if (pTouchManager)
 538                                         {
 539                                                 pTouchManager->ResetTouchInfo();
 540                                                 SysLog(NID_UI, "pWindow is null, ResetTouchInfo");
 541                                         }
 542                                 }
 543                         }
 544                         SetLastResult(E_INVALID_CONDITION);
 545                         return;
 546                 }
 547
 548                 if (!pRootControl)
 549                 {
 550                         r = GetPosition(status, x, y, current);
 551                         SysTryReturnVoidResult(NID_UI, r != E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] A system error occurred.");
 552                         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 553                 }
 554                 else
 555                 {
 556                         current = _CoordinateSystemUtils::InverseTransform(current);
 557                 }
 558
 559                 __touchInfo.SetTouchInfo(pointId, status, current, false, timeStamp);
 560
 561                 if (status == _TOUCH_PRESSED)
 562                 {
 563                         _Control* pControl = GetTarget(current.x, current.y, pRootControl);
 564
 565                         if (pControl == null)
 566                         {
 567                                 pTouchManager->ResetTouchInfo();
 568                                 SysSecureLog(NID_UI, "ResetTouchInfo x(%d), y(%d), deviceID(%d), pointID(%d)", current.x, current.y, deviceId, pointId);
 569                                 SysTryReturnVoidResult(NID_UI, false, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 570                         }
 571                         else
 572                         {
 573                                 r = __pTouchEventManager->AddControl(pointId, pControl->GetHandle());
 574                                 SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 575                                 SysSecureLog(NID_UI, "touch_pressed : pointId = %d, AddControl = 0x%x", pointId, pControl);
 576                         }
 577                 }
 578                 else
 579                 {
 580                         _Control* pControl = pTouchManager->GetChangedTouchableTarget();
 581                         if (pControl == null)
 582                         {
 583                                 ClearLastResult();
 584                         }
 585                         else
 586                         {
 587                                 if (pControl->GetChangingEventTarget() == true && pControl->GetVisibleState() == true)
 588                                 {
 589                                         r = __pTouchEventManager->AddControl(pointId, pControl->GetHandle());
 590                                         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 591                                         SysSecureLog(NID_UI, "touch_moved, touch_released : pointId = %d, AddControl = 0x%x", pointId, pControl);
 592                                 }
 593                         }
 594                 }
 595         }
 596
 597         virtual ~_TouchEvent(void)
 598         {
 599         }
 600
 601 private:
 602         virtual result SendImpl(void)
 603         {
 604                 _Control* pTarget = __pTouchEventManager->GetControl(__touchInfo.GetPointId());
 605                 if (pTarget == null)
 606                 {
 607                         if (__touchInfo.GetTouchStatus() == _TOUCH_MOVED)
 608                         {
 609                                 SysLog(NID_UI, "Target is null for the move event, skip sendImpl");
 610                                 return E_SUCCESS;
 611                         }
 612
 613                         _TouchManager* pTouchManager = _TouchManager::GetInstance();
 614                         pTouchManager->SetTouchCanceled(null);
 615                         pTouchManager->ResetTouchInfo();
 616
 617                         SysLog(NID_UI, "ResetTouchInfo");
 618                         return E_SUCCESS;
 619                 }
 620
 621                 _UiTouchEvent event(pTarget->GetHandle(), __touchInfo);
 622
 623                 return _pEventManager->SendEvent(event);
 624         }
 625
 626 private:
 627         _TouchEvent(const _TouchEvent& rhs);
 628         _TouchEvent& operator =(const _TouchEvent& rhs);
 629
 630         _Control* GetTarget(int x, int y, const _Control* pRootControl) const
 631         {
 632                 ClearLastResult();
 633
 634                 _TouchManager* pTouchManager = _TouchManager::GetInstance();
 635                 SysTryReturn(NID_UI, pTouchManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 636
 637                 _Control* pCapturedControl = pTouchManager->GetCapturedControl();
 638                 _Control* pControl = null;
 639
 640                 if (pCapturedControl)
 641                 {
 642                         if (pTouchManager->IsCaptureAllowedOwnerBounds())
 643                         {
 644                                 if (pTouchManager->IsCaptureAllowedOutOfBounds())
 645                                 {
 646                                         pControl = pCapturedControl;
 647                                 }
 648
 649                                 _Window * pWindow = dynamic_cast<_Window*>(pCapturedControl);
 650                                 if (pWindow)
 651                                 {
 652                                         _Control* pOwner = pWindow->GetOwner();
 653                                         if (pOwner)
 654                                         {
 655                                                 Tizen::Graphics::Rectangle ownerRc(pOwner->GetAbsoluteBounds());
 656                                                 if ((x >= ownerRc.x) && (x <= (ownerRc.x + ownerRc.width)) && (y >= ownerRc.y) && (y <= (ownerRc.y + ownerRc.height)))
 657                                                 {
 658                                                         pControl = pOwner;
 659                                                 }
 660                                         }
 661                                 }
 662
 663                                 Tizen::Graphics::Rectangle rc(pCapturedControl->GetAbsoluteBounds());
 664                                 if ((x >= rc.x) && (x <= (rc.x + rc.width)) && (y >= rc.y) && (y <= (rc.y + rc.height)))
 665                                 {
 666                                         pControl = pCapturedControl;
 667                                 }
 668                         }
 669                         else
 670                         {
 671                                 if (pTouchManager->IsCaptureAllowedOutOfBounds())
 672                                 {
 673                                         pControl = pCapturedControl;
 674                                 }
 675                                 else
 676                                 {
 677                                         Tizen::Graphics::Rectangle rc(pCapturedControl->GetAbsoluteBounds());
 678
 679                                         if ((x < rc.x) || (x > (rc.x + rc.width)) || (y < rc.y) || (y > (rc.y + rc.height)))
 680                                         {
 681                                                 pControl = pCapturedControl;
 682                                         }
 683                                 }
 684                         }
 685
 686                         if (pControl != null)
 687                         {
 688                                 return pControl;
 689                         }
 690                 }
 691
 692                 _ControlManager* pControlManager = _ControlManager::GetInstance();
 693                 SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 694
 695                 Tizen::Graphics::FloatPoint ptf(static_cast<float>(x), static_cast<float>(y));
 696
 697                 _ControlVisualElement* pRootControlElement = null;
 698                 if (pRootControl)
 699                 {
 700                         pRootControlElement = dynamic_cast<_ControlVisualElement*>(pRootControl->GetVisualElement());
 701                 }
 702                 else
 703                 {
 704                         _Window* pWindow = null;
 705                         pWindow = pControlManager->GetTouchedWindow();
 706                         SysTryReturn(NID_UI, pWindow, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 707
 708                         Rectangle winBounds = pWindow->GetBounds();
 709
 710                         ptf.x = static_cast<float>(x - winBounds.x);
 711                         ptf.y = static_cast<float>(y - winBounds.y);
 712
 713                         pRootControlElement = dynamic_cast <_ControlVisualElement*>(pWindow->GetVisualElement());
 714                 }
 715
 716                 SysTryReturn(NID_UI, pRootControlElement, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 717
 718                 _ControlVisualElement* pControlVisualElement = pRootControlElement->GetControlChildAtPoint(ptf);
 719                 SysTryReturn(NID_UI, pControlVisualElement, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 720
 721                 pControl = static_cast <_Control*>(pControlVisualElement->GetUserData());
 722                 SysTryReturn(NID_UI, pControl, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 723
 724                 return pControl;
 725         }
 726
 727         result GetPosition(_TouchStatus status, int x, int y, Point& point) const
 728         {
 729                 result r = E_SUCCESS;
 730
 731                 _ControlManager* pControlManager = _ControlManager::GetInstance();
 732                 SysTryReturn(NID_UI, pControlManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 733
 734                 _Window* pWindow = pControlManager->GetTouchedWindow();
 735                 if (pWindow == null)
 736                 {
 737                         _TouchManager* pTouchManager = _TouchManager::GetInstance();
 738                         if (pTouchManager)
 739                         {
 740                                 pTouchManager->ResetTouchInfo();
 741                                 SysLog(NID_UI, "pWindow is null, ResetTouchInfo");
 742                         }
 743                 }
 744                 SysTryReturn(NID_UI, pWindow, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] A system error occurred.");
 745
 746                 _RootVisualElement* pRootVE = pWindow->GetRootVisualElement();
 747                 SysTryReturn(NID_UI, pRootVE, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 748
 749                 _EflLayer* pLayer = static_cast<_EflLayer*>(pRootVE->GetNativeLayer());
 750                 SysTryReturn(NID_UI, pLayer, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 751
 752                 Ecore_Evas* pEE = pLayer->GetEcoreEvas();
 753                 SysTryReturn(NID_UI, pEE, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 754
 755                 const int PORTRAIT = 0;
 756                 const int LANDSCAPE = 270;
 757                 const int PORTRAIT_REVERSE = 180;
 758                 const int LANDSCAPE_REVERSE = 90;
 759
 760                 Dimension dimension = pControlManager->GetScreenSize();
 761                 Point output(_CoordinateSystemUtils::InverseTransform(point));
 762                 int rotation = ecore_evas_rotation_get(pEE);
 763
 764                 switch (rotation)
 765                 {
 766                 case PORTRAIT:
 767                         point.x = output.x;
 768                         point.y = output.y;
 769                         break;
 770
 771                 case LANDSCAPE:
 772                         point.x = output.y;
 773                         point.y = dimension.width - output.x;
 774                         break;
 775
 776                 case PORTRAIT_REVERSE:
 777                         point.x = dimension.width - output.x;
 778                         point.y = dimension.height - output.y;
 779                         break;
 780
 781                 case LANDSCAPE_REVERSE:
 782                         point.x = dimension.height - output.y;
 783                         point.y = output.x;
 784                         break;
 785
 786                 default:
 787                         SysAssertf(0, "[E_SYSTEM][%d]", rotation);
 788                         r = E_SYSTEM;
 789                         break;
 790                 }
 791
 792                 return r;
 793         }
 794
 795 private:
 796         _TouchInfo __touchInfo;
 797         _TouchEventManager* __pTouchEventManager;
 798 }; // _TouchEvent
 799
 800 class _MouseEvent
 801         : public _Event
 802 {
 803 public:
 804         _MouseEvent(int deviceId, _TouchStatus status, int x, int y, int z, unsigned int buttons, unsigned int timeStamp, const _Control* pRootControl)
 805                 : __pTouchEventManager(null)
 806         {
 807                 __pTouchEventManager = _TouchEventManager::GetInstance();
 808                 SysTryReturnVoidResult(NID_UI, __pTouchEventManager, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 809
 810                 result r = E_SUCCESS;
 811                 Tizen::Graphics::Point current(x, y);
 812
 813                 _TouchManager* pTouchManager = _TouchManager::GetInstance();
 814                 SysTryReturnVoidResult(NID_UI, pTouchManager, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 815
 816                 unsigned int pointId = 0;
 817
 818                 if (status == _TOUCH_PRESSED)
 819                 {
 820                         IListT<_FingerInfo*>* pFingerInfoList = pTouchManager->GetMultiFingerInfoListN();
 821                         SysTryReturnVoidResult(NID_UI, pFingerInfoList, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 822
 823                         const int count = pFingerInfoList->GetCount();
 824
 825                         for (int i = 0; i < count; i++)
 826                         {
 827                                 _FingerInfo* pFingerInfo = null;
 828                                 pFingerInfoList->GetAt(i, pFingerInfo);
 829                                 if (pFingerInfo == null)
 830                                 {
 831                                         continue;
 832                                 }
 833
 834                                 if (static_cast<int>(pFingerInfo->GetDeviceId()) == deviceId && pFingerInfo->GetStatus() == _TOUCH_PRESSED)
 835                                 {
 836                                         pTouchManager->ResetTouchInfo();
 837                                         SysSecureLog(NID_UI, "ResetTouchInfo x(%d), y(%d), deviceID(%d), pointID(%d)", current.x, current.y, deviceId, pFingerInfo->GetPointId());
 838                                         break;
 839                                 }
 840                         }
 841                         delete pFingerInfoList;
 842
 843                         pointId = pTouchManager->GeneratePointId(deviceId);
 844                 }
 845                 else
 846                 {
 847                         pointId = pTouchManager->GetPointId(deviceId);
 848                 }
 849
 850                 if (pointId == INVALID_POINT_ID)
 851                 {
 852                         if (status == _TOUCH_RELEASED)
 853                         {
 854                                 _ControlManager* pControlManager = _ControlManager::GetInstance();
 855                                 SysTryReturnVoidResult(NID_UI, pControlManager, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 856
 857                                 _Window* pWindow = pControlManager->GetTouchedWindow();
 858                                 if (pWindow == null)
 859                                 {
 860                                         _TouchManager* pTouchManager = _TouchManager::GetInstance();
 861                                         if (pTouchManager)
 862                                         {
 863                                                 pTouchManager->ResetTouchInfo();
 864                                                 SysLog(NID_UI, "pWindow is null, ResetTouchInfo");
 865                                         }
 866                                 }
 867                         }
 868                         SetLastResult(E_INVALID_CONDITION);
 869                         return;
 870                 }
 871
 872                 if (!pRootControl)
 873                 {
 874                         r = GetPosition(status, x, y, current);
 875                         SysTryReturnVoidResult(NID_UI, r != E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] A system error occurred.");
 876                         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 877                 }
 878                 else
 879                 {
 880                         current = _CoordinateSystemUtils::InverseTransform(current);
 881                 }
 882
 883                 __mouseInfo.SetTouchInfo(pointId, status, current, z, buttons, false, timeStamp);
 884
 885                 if (status == _TOUCH_PRESSED)
 886                 {
 887                         _Control* pControl = GetTarget(current.x, current.y, pRootControl);
 888
 889                         if (pControl == null)
 890                         {
 891                                 pTouchManager->ResetTouchInfo();
 892                                 SysSecureLog(NID_UI, "ResetTouchInfo x(%d), y(%d), deviceID(%d), pointID(%d)", current.x, current.y, deviceId, pointId);
 893                                 SysTryReturnVoidResult(NID_UI, false, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 894                         }
 895                         else
 896                         {
 897                                 r = __pTouchEventManager->AddControl(pointId, pControl->GetHandle());
 898                                 SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 899                         }
 900                 }
 901                 else
 902                 {
 903                         _Control* pControl = pTouchManager->GetChangedTouchableTarget();
 904                         if (pControl == null)
 905                         {
 906                                 ClearLastResult();
 907                         }
 908                         else
 909                         {
 910                                 if (pControl->GetChangingEventTarget() == true && pControl->GetVisibleState() == true)
 911                                 {
 912                                         r = __pTouchEventManager->AddControl(pointId, pControl->GetHandle());
 913                                         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 914                                 }
 915                         }
 916                 }
 917         }
 918
 919         virtual ~_MouseEvent(void)
 920         {
 921         }
 922
 923 private:
 924         virtual result SendImpl(void)
 925         {
 926                 _Control* pTarget = __pTouchEventManager->GetControl(__mouseInfo.GetPointId());
 927                 if (pTarget == null)
 928                 {
 929                         _TouchManager* pTouchManager = _TouchManager::GetInstance();
 930                         pTouchManager->ResetTouchInfo();
 931
 932                         SysLog(NID_UI, "ResetTouchInfo");
 933                         return E_SUCCESS;
 934                 }
 935
 936                 _UiMouseEvent event(pTarget->GetHandle(), __mouseInfo);
 937
 938                 return _pEventManager->SendEvent(event);
 939         }
 940
 941 private:
 942         _MouseEvent(const _MouseEvent& rhs);
 943         _MouseEvent& operator =(const _MouseEvent& rhs);
 944
 945         _Control* GetTarget(int x, int y, const _Control* pRootControl) const
 946         {
 947                 ClearLastResult();
 948
 949                 _TouchManager* pTouchManager = _TouchManager::GetInstance();
 950                 SysTryReturn(NID_UI, pTouchManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 951
 952                 _Control* pCapturedControl = pTouchManager->GetCapturedControl();
 953                 _Control* pControl = null;
 954
 955                 if (pCapturedControl)
 956                 {
 957                         if (pTouchManager->IsCaptureAllowedOwnerBounds())
 958                         {
 959                                 if (pTouchManager->IsCaptureAllowedOutOfBounds())
 960                                 {
 961                                         pControl = pCapturedControl;
 962                                 }
 963
 964                                 _Window * pWindow = dynamic_cast<_Window*>(pCapturedControl);
 965                                 if (pWindow)
 966                                 {
 967                                         _Control* pOwner = pWindow->GetOwner();
 968                                         if (pOwner)
 969                                         {
 970                                                 Tizen::Graphics::Rectangle ownerRc(pOwner->GetAbsoluteBounds());
 971                                                 if ((x >= ownerRc.x) && (x <= (ownerRc.x + ownerRc.width)) && (y >= ownerRc.y) && (y <= (ownerRc.y + ownerRc.height)))
 972                                                 {
 973                                                         pControl = pOwner;
 974                                                 }
 975                                         }
 976                                 }
 977
 978                                 Tizen::Graphics::Rectangle rc(pCapturedControl->GetAbsoluteBounds());
 979                                 if ((x >= rc.x) && (x <= (rc.x + rc.width)) && (y >= rc.y) && (y <= (rc.y + rc.height)))
 980                                 {
 981                                         pControl = pCapturedControl;
 982                                 }
 983                         }
 984                         else
 985                         {
 986                                 if (pTouchManager->IsCaptureAllowedOutOfBounds())
 987                                 {
 988                                         pControl = pCapturedControl;
 989                                 }
 990                                 else
 991                                 {
 992                                         Tizen::Graphics::Rectangle rc(pCapturedControl->GetAbsoluteBounds());
 993
 994                                         if ((x < rc.x) || (x > (rc.x + rc.width)) || (y < rc.y) || (y > (rc.y + rc.height)))
 995                                         {
 996                                                 pControl = pCapturedControl;
 997                                         }
 998                                 }
 999                         }
1000
1001                         if (pControl != null)
1002                         {
1003                                 return pControl;
1004                         }
1005                 }
1006
1007                 _ControlManager* pControlManager = _ControlManager::GetInstance();
1008                 SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1009
1010                 Tizen::Graphics::FloatPoint ptf(static_cast<float>(x), static_cast<float>(y));
1011
1012                 _ControlVisualElement* pRootControlElement = null;
1013                 if (pRootControl)
1014                 {
1015                         pRootControlElement = dynamic_cast<_ControlVisualElement*>(pRootControl->GetVisualElement());
1016                 }
1017                 else
1018                 {
1019                         _Window* pWindow = null;
1020                         pWindow = pControlManager->GetTouchedWindow();
1021                         SysTryReturn(NID_UI, pWindow, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1022
1023                         Rectangle winBounds = pWindow->GetBounds();
1024
1025                         ptf.x = static_cast<float>(x - winBounds.x);
1026                         ptf.y = static_cast<float>(y - winBounds.y);
1027
1028                         pRootControlElement = dynamic_cast <_ControlVisualElement*>(pWindow->GetVisualElement());
1029                 }
1030
1031                 SysTryReturn(NID_UI, pRootControlElement, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1032
1033                 _ControlVisualElement* pControlVisualElement = pRootControlElement->GetControlChildAtPoint(ptf);
1034                 SysTryReturn(NID_UI, pControlVisualElement, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1035
1036                 pControl = static_cast <_Control*>(pControlVisualElement->GetUserData());
1037                 SysTryReturn(NID_UI, pControl, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1038
1039                 return pControl;
1040         }
1041
1042         result GetPosition(_TouchStatus status, int x, int y, Point& point) const
1043         {
1044                 result r = E_SUCCESS;
1045
1046                 _ControlManager* pControlManager = _ControlManager::GetInstance();
1047                 SysTryReturn(NID_UI, pControlManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1048
1049                 _Window* pWindow = pControlManager->GetTouchedWindow();
1050                 if (pWindow == null)
1051                 {
1052                         _TouchManager* pTouchManager = _TouchManager::GetInstance();
1053                         if (pTouchManager)
1054                         {
1055                                 pTouchManager->ResetTouchInfo();
1056                                 SysLog(NID_UI, "pWindow is null, ResetTouchInfo");
1057                         }
1058                 }
1059                 SysTryReturn(NID_UI, pWindow, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] A system error occurred.");
1060
1061                 _RootVisualElement* pRootVE = pWindow->GetRootVisualElement();
1062                 SysTryReturn(NID_UI, pRootVE, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1063
1064                 _EflLayer* pLayer = static_cast<_EflLayer*>(pRootVE->GetNativeLayer());
1065                 SysTryReturn(NID_UI, pLayer, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1066
1067                 Ecore_Evas* pEE = pLayer->GetEcoreEvas();
1068                 SysTryReturn(NID_UI, pEE, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1069
1070                 const int PORTRAIT = 0;
1071                 const int LANDSCAPE = 270;
1072                 const int PORTRAIT_REVERSE = 180;
1073                 const int LANDSCAPE_REVERSE = 90;
1074
1075                 Dimension dimension = pControlManager->GetScreenSize();
1076                 Point output(_CoordinateSystemUtils::InverseTransform(point));
1077                 int rotation = ecore_evas_rotation_get(pEE);
1078
1079                 switch (rotation)
1080                 {
1081                 case PORTRAIT:
1082                         point.x = output.x;
1083                         point.y = output.y;
1084                         break;
1085
1086                 case LANDSCAPE:
1087                         point.x = output.y;
1088                         point.y = dimension.width - output.x;
1089                         break;
1090
1091                 case PORTRAIT_REVERSE:
1092                         point.x = dimension.width - output.x;
1093                         point.y = dimension.height - output.y;
1094                         break;
1095
1096                 case LANDSCAPE_REVERSE:
1097                         point.x = dimension.height - output.y;
1098                         point.y = output.x;
1099                         break;
1100
1101                 default:
1102                         SysAssertf(0, "[E_SYSTEM][%d]", rotation);
1103                         r = E_SYSTEM;
1104                         break;
1105                 }
1106
1107                 return r;
1108         }
1109
1110 private:
1111         _MouseInfo __mouseInfo;
1112         _TouchEventManager* __pTouchEventManager;
1113 };
1114
1115 Eina_Bool
1116 OnNotified(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
1117 {
1118         if (pEventInfo)
1119         {
1120                 _UiEvent* pUiEvent = static_cast <_UiEvent*>(pEventInfo);
1121                 SysTryReturn(NID_UI, pUiEvent, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1122
1123                 _UiEventManager* pEventManager = _UiEventManager::GetInstance();
1124                 SysTryReturn(NID_UI, pEventManager, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1125
1126                 result r = pEventManager->SendEvent(*pUiEvent);
1127                 SysTryReturn(NID_UI, r == E_SUCCESS, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1128         }
1129
1130         SetLastResult(E_SUCCESS);
1131
1132         return ECORE_CALLBACK_PASS_ON;
1133 }
1134
1135 void
1136 FreeEvent(void* pData __UNUSED__, void* pEventInfo)
1137 {
1138         _UiEvent* pUiEvent = static_cast <_UiEvent*>(pEventInfo);
1139         if (pUiEvent)
1140         {
1141                 delete pUiEvent;
1142         }
1143 }
1144
1145 Eina_Bool
1146 OnKeyPressed(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
1147 {
1148         Ecore_Event_Key* pEv = static_cast <Ecore_Event_Key*>(pEventInfo);
1149         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1150
1151         if (_KeyEvent::GetKeyCode(pEv->keyname) == _KEY_INVALID)
1152         {
1153                 SysLog(NID_UI, "KeyCode is Invalid");
1154                 return ECORE_CALLBACK_PASS_ON;
1155         }
1156
1157         _KeyEvent event(KEY_PRESSED, _KeyEvent::GetKeyCode(pEv->keyname), _KeyEvent::GetKeyModifier(pEv->modifiers), pEv);
1158         SysSecureLog(NID_UI, "KeyName = %s, KeyCode = %d, KeyModifier = %x", pEv->keyname, _KeyEvent::GetKeyCode(pEv->keyname), _KeyEvent::GetKeyModifier(pEv->modifiers));
1159         event.Send();
1160
1161         SetLastResult(E_SUCCESS);
1162
1163         return ECORE_CALLBACK_PASS_ON;
1164 }
1165
1166 Eina_Bool
1167 OnKeyReleased(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
1168 {
1169         Ecore_Event_Key* pEv = static_cast <Ecore_Event_Key*>(pEventInfo);
1170         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1171
1172         if (_KeyEvent::GetKeyCode(pEv->keyname) == _KEY_INVALID)
1173         {
1174                 SysLog(NID_UI, "KeyCode is Invalid");
1175                 return ECORE_CALLBACK_PASS_ON;
1176         }
1177
1178         _KeyEvent event(KEY_RELEASED, _KeyEvent::GetKeyCode(pEv->keyname), _KeyEvent::GetKeyModifier(pEv->modifiers), pEv);
1179         SysSecureLog(NID_UI, "KeyName = %s, KeyCode = %d, KeyModifier = %x", pEv->keyname, _KeyEvent::GetKeyCode(pEv->keyname), _KeyEvent::GetKeyModifier(pEv->modifiers));
1180         event.Send();
1181
1182         SetLastResult(E_SUCCESS);
1183
1184         return ECORE_CALLBACK_PASS_ON;
1185 }
1186
1187 Eina_Bool
1188 OnClipboardMessageReceived(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
1189 {
1190         Ecore_X_Event_Client_Message *pEv = static_cast<Ecore_X_Event_Client_Message*>(pEventInfo);
1191
1192         if (pEv->message_type != ecore_x_atom_get("CBHM_MSG"))
1193         {
1194                 return ECORE_CALLBACK_PASS_ON;
1195         }
1196
1197         if (!strcmp("SET_OWNER", pEv->data.b))
1198         {
1199                 _KeyEvent event(KEY_PRESSED, _KEY_OEM_1, 0, pEv);
1200                 SysSecureLog(NID_UI, "KeyName = clipboard, KeyCode = _KEY_OEM_1, KeyModifier = 0");
1201                 event.Send();
1202
1203                 SetLastResult(E_SUCCESS);
1204         }
1205
1206         return ECORE_CALLBACK_PASS_ON;
1207 }
1208
1209
1210 Eina_Bool
1211 OnTouchPressed(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
1212 {
1213         Ecore_Event_Mouse_Button* pEv = static_cast <Ecore_Event_Mouse_Button*>(pEventInfo);
1214         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1215
1216         SysSecureLog(NID_UI, "OnTouchPressed - x(%d), y(%d), deviceId(%d), buttons(%d)", pEv->root.x, pEv->root.y, pEv->multi.device, pEv->buttons);
1217
1218         _ControlManager* pControlManager = _ControlManager::GetInstance();
1219         SysTryReturn(NID_UI, pControlManager, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1220
1221         pControlManager->SetTouchedWindow((unsigned int)pEv->window);
1222
1223         if (touchPressed[pEv->multi.device] == true)
1224         {
1225                 _TouchManager* pTouchManager = _TouchManager::GetInstance();
1226                 if (pTouchManager)
1227                 {
1228                         pTouchManager->SetTouchCanceled(null);
1229                         SysLog(NID_UI, "pWindow is null, CancelTouch");
1230
1231                         for(int i=0; i<DEVICE_COUNT; i++)
1232                         {
1233                                 touchPressed[pEv->multi.device] = false;
1234                         }
1235
1236                         pTouchManager->ResetTouchInfo();
1237                         SysLog(NID_UI, "pWindow is null, ResetTouchInfo");
1238                 }
1239         }
1240
1241         touchPressed[pEv->multi.device] = true;
1242
1243         if (pEv->buttons == _MOUSE_BUTTON_LEFT || pEv->buttons == _MOUSE_BUTTON_NONE)
1244         {
1245         _TouchEvent event(pEv->multi.device, _TOUCH_PRESSED, pEv->root.x, pEv->root.y, pEv->timestamp, null);
1246
1247         result r = GetLastResult();
1248         if (r != E_SUCCESS)
1249         {
1250                 SysLog(NID_UI, "[%s] Propagating.", GetErrorMessage(r));
1251                 return ECORE_CALLBACK_PASS_ON;
1252         }
1253
1254         event.Send();
1255         }
1256         else
1257         {
1258                 //_MouseEvent event(pEv->multi.device, _TOUCH_PRESSED, pEv->root.x, pEv->root.y, 0, pEv->buttons, pEv->timestamp, null);
1259                 _MouseEvent event(pEv->multi.device, _TOUCH_PRESSED, pEv->root.x, pEv->root.y, 0, _MOUSE_BUTTON_RIGHT, pEv->timestamp, null);
1260
1261         result r = GetLastResult();
1262         if (r != E_SUCCESS)
1263         {
1264                 SysLog(NID_UI, "[%s] Propagating.", GetErrorMessage(r));
1265                 return ECORE_CALLBACK_PASS_ON;
1266         }
1267
1268         event.Send();
1269
1270                 _UiEventManager* pEventManager = _UiEventManager::GetInstance();
1271                 SysTryReturn(NID_UI, pEventManager, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1272
1273                 pEventManager->GenerateKeyEvent(KEY_PRESSED, _KEY_OEM_2, _KEY_MODIFIER_NONE, false);
1274                 pEventManager->GenerateKeyEvent(KEY_RELEASED, _KEY_OEM_2, _KEY_MODIFIER_NONE, false);
1275         }
1276
1277         SetLastResult(E_SUCCESS);
1278
1279         return ECORE_CALLBACK_PASS_ON;
1280 }
1281
1282 Eina_Bool
1283 OnTouchReleased(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
1284 {
1285         Ecore_Event_Mouse_Button* pEv = static_cast <Ecore_Event_Mouse_Button*>(pEventInfo);
1286         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1287
1288         SysSecureLog(NID_UI, "OnTouchReleased - x(%d), y(%d), deviceId(%d) buttons(%d)", pEv->root.x, pEv->root.y, pEv->multi.device, pEv->buttons);
1289
1290         _TouchManager* pTouchManager = _TouchManager::GetInstance();
1291         SysTryReturn(NID_UI, pTouchManager, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] _TouchManager does not exist.");
1292
1293         touchPressed[pEv->multi.device] = false;
1294
1295         if (pEv->buttons == _MOUSE_BUTTON_LEFT || pEv->buttons == _MOUSE_BUTTON_NONE)
1296         {
1297                 _TouchEvent event(pEv->multi.device, _TOUCH_RELEASED, pEv->root.x, pEv->root.y, pEv->timestamp, null);
1298
1299                 result r = GetLastResult();
1300                 if (r!= E_SUCCESS)
1301                 {
1302                         SysLog(NID_UI, "[%s] Propagating.", GetErrorMessage(r));
1303                         return ECORE_CALLBACK_PASS_ON;
1304                 }
1305
1306                 event.Send();
1307         }
1308         else
1309         {
1310                 //_MouseEvent event(pEv->multi.device, _TOUCH_RELEASED, pEv->root.x, pEv->root.y, 0, pEv->buttons, pEv->timestamp, null);
1311                 _MouseEvent event(pEv->multi.device, _TOUCH_RELEASED, pEv->root.x, pEv->root.y, 0, _MOUSE_BUTTON_RIGHT, pEv->timestamp, null);
1312
1313
1314                 result r = GetLastResult();
1315                 if (r!= E_SUCCESS)
1316                 {
1317                         SysLog(NID_UI, "[%s] Propagating.", GetErrorMessage(r));
1318                         return ECORE_CALLBACK_PASS_ON;
1319                 }
1320
1321                 event.Send();
1322
1323                 _TouchManager* pTouchManager = _TouchManager::GetInstance();
1324                 if (pTouchManager)
1325                 {
1326                         pTouchManager->ResetTouchInfo();
1327                         SysLog(NID_UI, "ResetTouchInfo");
1328                 }
1329         }
1330
1331         IListT<_FingerInfo*>* pFingerInfoList = pTouchManager->GetMultiFingerInfoListN();
1332         SysTryReturn(NID_UI, pFingerInfoList, ECORE_CALLBACK_PASS_ON, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1333
1334         int count = pFingerInfoList->GetCount();
1335
1336         for (int i = 0; i < count; i++)
1337         {
1338                 _FingerInfo* pFingerInfo = null;
1339                 pFingerInfoList->GetAt(i, pFingerInfo);
1340                 if (pFingerInfo == null)
1341                 {
1342                         continue;
1343                 }
1344
1345                 if (static_cast<int>(pFingerInfo->GetDeviceId()) == pEv->multi.device)
1346                 {
1347                         pFingerInfo->SetPointId(INVALID_POINT_ID);
1348                         break;
1349                 }
1350         }
1351         delete pFingerInfoList;
1352
1353         pTouchManager->SetChangedTouchableTarget(null);
1354
1355         SetLastResult(E_SUCCESS);
1356         return ECORE_CALLBACK_PASS_ON;
1357 }
1358
1359 Eina_Bool
1360 OnTouchMoved(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
1361 {
1362         Ecore_Event_Mouse_Move* pEv = static_cast <Ecore_Event_Mouse_Move*>(pEventInfo);
1363         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1364
1365         //SysSecureLog(NID_UI, "OnTouchMoved - x(%d), y(%d), deviceId(%d)", pEv->root.x, pEv->root.y, pEv->multi.device);
1366         _TouchEvent event(pEv->multi.device, _TOUCH_MOVED, pEv->root.x, pEv->root.y, pEv->timestamp, null);
1367
1368         result r = GetLastResult();
1369         if (r != E_SUCCESS)
1370         {
1371                 return ECORE_CALLBACK_PASS_ON;
1372         }
1373
1374         event.Send();
1375
1376         SetLastResult(E_SUCCESS);
1377
1378         return ECORE_CALLBACK_PASS_ON;
1379 }
1380
1381 Eina_Bool
1382 OnMouseWheeled(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
1383 {
1384         _Ecore_Event_Mouse_Wheel* pEv = static_cast <_Ecore_Event_Mouse_Wheel*>(pEventInfo);
1385         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1386
1387         SysSecureLog(NID_UI, "OnMouseWheeled - x(%d), y(%d), z(%d)", pEv->root.x, pEv->root.y, pEv->z);
1388         _MouseEvent event(0, _WHEEL_MOVED, pEv->root.x, pEv->root.y, pEv->z, _MOUSE_BUTTON_NONE, pEv->timestamp, null);
1389
1390         result r = GetLastResult();
1391         if (r != E_SUCCESS)
1392         {
1393                 return ECORE_CALLBACK_PASS_ON;
1394         }
1395
1396         event.Send();
1397
1398         SetLastResult(E_SUCCESS);
1399
1400         return ECORE_CALLBACK_PASS_ON;
1401 }
1402
1403 Eina_Bool
1404 OnKeyboardInserted(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
1405 {
1406         Ecore_X_Event_Window_Property *pEv = static_cast <Ecore_X_Event_Window_Property*>(pEventInfo);
1407         if ( pEv->atom != keyboardExist)
1408         {
1409 //              SysLog(NID_UI, "OnKeyboardInserted - atom of event(%d), keyboardExist(%d)", pEv->atom, keyboardExist);
1410                 return ECORE_CALLBACK_PASS_ON;
1411         }
1412
1413         ArrayList* pArgs = null;
1414         result r = E_SUCCESS;
1415         Boolean* pIsKeyboardOn = null;
1416         _UiEventManager* pEventManager = _UiEventManager::GetInstance();
1417         SysTryReturn(NID_UI, pEventManager, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1418
1419         _Control* pControl = _ControlManager::GetInstance()->GetFocusControl();
1420         SysTryReturn(NID_UI, pControl, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1421
1422         bool isKeyboardOn = false;
1423         unsigned int value = 0;
1424         int returnResult = -1;
1425
1426         returnResult = ecore_x_window_prop_card32_get(pEv->win, keyboardExist, &value, 1);
1427         if (returnResult)
1428         {
1429                 if (value > 0)
1430                 {
1431                         isKeyboardOn = true;
1432                 }
1433
1434                 pArgs = new (std::nothrow) ArrayList;
1435                 SysTryReturn(NID_UI, pArgs, ECORE_CALLBACK_PASS_ON, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1436
1437                 r = pArgs->Construct();
1438                 SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1439
1440                 String* pString = new (std::nothrow) String(KEYBOARD_INSERTED_EVENT);
1441                 r = pArgs->Add(*pString);
1442                 SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1443
1444                 pIsKeyboardOn = new (std::nothrow) Boolean(isKeyboardOn);
1445                 r = pArgs->Add(*pIsKeyboardOn);
1446                 SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1447
1448                 _UiNotificationEvent event(pControl->GetHandle(), pArgs);
1449                 r = pEventManager->SendEvent(event);
1450 //              SysLog(NID_UI, "OnKeyboardInserted - sent keyboard inserted noti");
1451         }
1452
1453         SetLastResult(r);
1454
1455         return ECORE_CALLBACK_PASS_ON;
1456
1457 CATCH:
1458         if (pArgs)
1459         {
1460                 delete pArgs;
1461         }
1462
1463         if (pIsKeyboardOn)
1464         {
1465                 delete pIsKeyboardOn;
1466         }
1467
1468         return ECORE_CALLBACK_PASS_ON;
1469 }
1470
1471 Eina_Bool
1472 OnWindowFocusIn(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
1473 {
1474         SysLog(NID_UI, "Enter");
1475
1476         Ecore_X_Event_Window_Focus_In* pEv = static_cast<Ecore_X_Event_Window_Focus_In*>(pEventInfo);
1477         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1478
1479         _ControlManager* pControlManager = _ControlManager::GetInstance();
1480         SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1481
1482         int count = pControlManager->GetWindowCount();
1483
1484         _Control* pFocusedControl = null;
1485         for (int i = count - 1; i >= 0; --i)
1486         {
1487                 _Window* pWindow = pControlManager->GetWindow(i);
1488                 if (pWindow)
1489                 {
1490                         NativeWindowHandle nativeWindowHandle = pWindow->GetNativeHandle();
1491                         if (pEv->win == nativeWindowHandle)
1492                         {
1493                                 pFocusedControl = pWindow->GetFocusControl();
1494
1495                                 if (pFocusedControl)
1496                                 {
1497                                         pFocusedControl->SetFocused();
1498                                         break;
1499                                 }
1500                         }
1501                 }
1502         }
1503         _AccessibilityManager::GetInstance()->RequestAutoReading(_ACCESSIBILITY_AUTO_READING_MODE_FIRST_ITEM);
1504         return ECORE_CALLBACK_PASS_ON;
1505 }
1506
1507 Eina_Bool
1508 OnWindowFocusOut(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo)
1509 {
1510         SysLog(NID_UI, "Enter");
1511
1512         Ecore_X_Event_Window_Focus_Out* pEv = static_cast<Ecore_X_Event_Window_Focus_Out*>(pEventInfo);
1513         SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1514
1515         _ControlManager* pControlManager = _ControlManager::GetInstance();
1516         SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1517
1518         _Control* pFocusedControl = pControlManager->GetFocusControl();
1519         if (pFocusedControl)
1520         {
1521                 _Window* pRootWindow = pFocusedControl->GetRootWindow();
1522                 if (pRootWindow)
1523                 {
1524                         NativeWindowHandle nativeWindowHandle = pRootWindow->GetNativeHandle();
1525                         if (pEv->win == nativeWindowHandle)
1526                         {
1527                                 pControlManager->TakeFocusFromControl(*pFocusedControl);
1528                         }
1529                 }
1530         }
1531         _AccessibilityManager::GetInstance()->RequestAutoReading(_ACCESSIBILITY_AUTO_READING_MODE_RESET);
1532         return ECORE_CALLBACK_PASS_ON;
1533 }
1534
1535 // Evas Callbacks
1536 void
1537 OnEvasKeyPressed(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1538 {
1539         Evas_Event_Key_Down* pEv = static_cast <Evas_Event_Key_Down*>(pEventInfo);
1540         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1541
1542         SetLastResult(E_SUCCESS);
1543 }
1544
1545 void
1546 OnEvasKeyReleased(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1547 {
1548         Evas_Event_Key_Up* pEv = static_cast <Evas_Event_Key_Up*>(pEventInfo);
1549         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1550
1551         SetLastResult(E_SUCCESS);
1552 }
1553
1554 void
1555 OnEvasTouchPressed(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1556 {
1557         Evas_Event_Mouse_Down* pEv = static_cast <Evas_Event_Mouse_Down*>(pEventInfo);
1558         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1559
1560         _Control* pControl = static_cast<_Control*>(pData);
1561         SysTryReturnVoidResult(NID_UI, pControl, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1562
1563         SysSecureLog(NID_UI, "OnEvasTouchPressed - x(%d), y(%d)", pEv->canvas.x, pEv->canvas.y);
1564         _TouchEvent event(0, _TOUCH_PRESSED, pEv->canvas.x, pEv->canvas.y, pEv->timestamp, pControl);
1565
1566         result r = GetLastResult();
1567         if (r != E_SUCCESS)
1568         {
1569                 SysLog(NID_UI, "[%s] Propagating.", GetErrorMessage(r));
1570                 return;
1571         }
1572
1573         event.Send();
1574
1575         SetLastResult(E_SUCCESS);
1576 }
1577
1578 void
1579 OnEvasTouchReleased(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1580 {
1581         Evas_Event_Mouse_Up* pEv = static_cast <Evas_Event_Mouse_Up*>(pEventInfo);
1582         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1583
1584         _Control* pControl = static_cast<_Control*>(pData);
1585         SysTryReturnVoidResult(NID_UI, pControl, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1586
1587         SysSecureLog(NID_UI, "OnEvasTouchReleased - x(%d), y(%d)", pEv->canvas.x, pEv->canvas.y);
1588         _TouchEvent event(0, _TOUCH_RELEASED, pEv->canvas.x, pEv->canvas.y, pEv->timestamp, pControl);
1589
1590         result r = GetLastResult();
1591         if (r != E_SUCCESS)
1592         {
1593                 SysLog(NID_UI, "[%s] Propagating.", GetErrorMessage(r));
1594                 return;
1595         }
1596
1597         event.Send();
1598
1599         SetLastResult(E_SUCCESS);
1600 }
1601
1602 void
1603 OnEvasTouchMoved(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1604 {
1605         Evas_Event_Mouse_Move* pEv = static_cast <Evas_Event_Mouse_Move*>(pEventInfo);
1606         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1607
1608         _Control* pControl = static_cast<_Control*>(pData);
1609         SysTryReturnVoidResult(NID_UI, pControl, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1610
1611         SysSecureLog(NID_UI, "OnEvasTouchMoved - x(%d), y(%d)", pEv->cur.canvas.x, pEv->cur.canvas.x);
1612         _TouchEvent event(0, _TOUCH_MOVED, pEv->cur.canvas.x, pEv->cur.canvas.y, pEv->timestamp, pControl);
1613
1614         result r = GetLastResult();
1615         if (r != E_SUCCESS)
1616         {
1617                 SysLog(NID_UI, "[%s] Propagating.", GetErrorMessage(r));
1618                 return;
1619         }
1620
1621         event.Send();
1622
1623         SetLastResult(E_SUCCESS);
1624 }
1625
1626 void
1627 OnEvasMultiTouchPressed(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1628 {
1629         Evas_Event_Multi_Down* pEv = static_cast <Evas_Event_Multi_Down*>(pEventInfo);
1630         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1631
1632         SetLastResult(E_SUCCESS);
1633 }
1634
1635 void
1636 OnEvasMultiTouchReleased(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1637 {
1638         Evas_Event_Multi_Up* pEv = static_cast <Evas_Event_Multi_Up*>(pEventInfo);
1639         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1640
1641         SetLastResult(E_SUCCESS);
1642 }
1643
1644 void
1645 OnEvasMultiTouchMoved(void* pData, Evas* pEvas, Evas_Object* pEvasObject, void* pEventInfo)
1646 {
1647         Evas_Event_Multi_Move* pEv = static_cast <Evas_Event_Multi_Move*>(pEventInfo);
1648         SysTryReturnVoidResult(NID_UI, pEv, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1649
1650         SetLastResult(E_SUCCESS);
1651 }
1652
1653 }; // Anonymous
1654
1655 namespace Tizen { namespace Ui
1656 {
1657
1658 _EflUiEventManager::_EflUiEventManager(void)
1659         : __notificaitonEventType(-1)
1660 {
1661         unique_ptr<LinkedListT<Ecore_Event_Handler*> > pEventHandlers(new (std::nothrow) LinkedListT<Ecore_Event_Handler*>);
1662         SysTryReturnVoidResult(NID_UI, pEventHandlers, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1663
1664         // Noti
1665         __notificaitonEventType = ecore_event_type_new();
1666         SysTryReturnVoidResult(NID_UI, __notificaitonEventType >= 1, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1667
1668         Ecore_Event_Handler* pEventHandler = ecore_event_handler_add(__notificaitonEventType, OnNotified, null);
1669         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1670
1671         pEventHandlers->Add(pEventHandler);
1672
1673         // Key
1674         pEventHandler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, OnKeyPressed, null);
1675         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1676
1677         pEventHandlers->Add(pEventHandler);
1678
1679         pEventHandler = ecore_event_handler_add(ECORE_EVENT_KEY_UP, OnKeyReleased, null);
1680         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1681
1682         pEventHandlers->Add(pEventHandler);
1683
1684         // clipboard key
1685         pEventHandler = ecore_event_handler_add(ECORE_X_EVENT_CLIENT_MESSAGE, OnClipboardMessageReceived, null);
1686         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1687
1688         pEventHandlers->Add(pEventHandler);
1689
1690         // Touch
1691         pEventHandler = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, OnTouchPressed, null);
1692         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1693
1694         pEventHandlers->Add(pEventHandler);
1695
1696         pEventHandler = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP, OnTouchReleased, null);
1697         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1698
1699         pEventHandlers->Add(pEventHandler);
1700
1701         pEventHandler = ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE, OnTouchMoved, null);
1702         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1703
1704         pEventHandlers->Add(pEventHandler);
1705
1706         // WIndow property
1707         pEventHandler = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_PROPERTY, OnKeyboardInserted, null);
1708         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1709
1710         pEventHandlers->Add(pEventHandler);
1711
1712         // WIndo focus
1713         pEventHandler = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_IN, OnWindowFocusIn, null);
1714         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1715
1716         pEventHandlers->Add(pEventHandler);
1717
1718         pEventHandler = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT, OnWindowFocusOut, null);
1719         SysTryReturnVoidResult(NID_UI, pEventHandler, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1720
1721         pEventHandlers->Add(pEventHandler);
1722
1723         __pEventHandlers = move(pEventHandlers);
1724
1725         keyboardExist = XInternAtom(static_cast<Display*>(ecore_x_display_get()), "X External Keyboard Exist", 0);
1726
1727         SetLastResult(E_SUCCESS);
1728 }
1729
1730 _EflUiEventManager::~_EflUiEventManager(void)
1731 {
1732         Tizen::Base::Collection::IEnumeratorT<Ecore_Event_Handler*>* pEnumerator = __pEventHandlers->GetEnumeratorN();
1733         SysTryReturnVoidResult(NID_UI, pEnumerator, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
1734
1735         while (pEnumerator->MoveNext() == E_SUCCESS)
1736         {
1737                 Ecore_Event_Handler* pEventHandler = null;
1738                 pEnumerator->GetCurrent(pEventHandler);
1739                 if (pEventHandler)
1740                 {
1741                         ecore_event_handler_del(pEventHandler);
1742                 }
1743         }
1744
1745         delete pEnumerator;
1746 }
1747
1748 result
1749 _EflUiEventManager::RegisterKeyEventHandler(const _Control& control)
1750 {
1751         result r = E_SUCCESS;
1752
1753         Evas_Object* pEvasObject = GetEvasObject(control);
1754         SysTryReturn(NID_UI, pEvasObject, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1755
1756         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_KEY_UP, OnEvasKeyReleased, &control);
1757         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_KEY_DOWN, OnEvasKeyPressed, &control);
1758
1759         return r;
1760 }
1761
1762 result
1763 _EflUiEventManager::RegisterTouchEventHandler(const _Control& control)
1764 {
1765         result r = E_SUCCESS;
1766
1767         Evas_Object* pEvasObject = GetEvasObject(control);
1768         SysTryReturn(NID_UI, pEvasObject, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1769
1770         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MOUSE_UP, OnEvasTouchReleased, &control);
1771         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MOUSE_DOWN, OnEvasTouchPressed, &control);
1772         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MOUSE_MOVE, OnEvasTouchMoved, &control);
1773
1774         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MULTI_UP, OnEvasMultiTouchReleased, &control);
1775         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MULTI_DOWN, OnEvasMultiTouchPressed, &control);
1776         evas_object_event_callback_add(pEvasObject, EVAS_CALLBACK_MULTI_MOVE, OnEvasMultiTouchMoved, &control);
1777
1778         return r;
1779 }
1780
1781 result
1782 _EflUiEventManager::UnregisterKeyEventHandler(const _Control& control)
1783 {
1784         result r = E_SUCCESS;
1785
1786         Evas_Object* pEvasObject = GetEvasObject(control);
1787         SysTryReturn(NID_UI, pEvasObject, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1788
1789         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_KEY_UP, OnEvasKeyReleased);
1790         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_KEY_DOWN, OnEvasKeyPressed);
1791
1792         return r;
1793 }
1794
1795 result
1796 _EflUiEventManager::UnregisterTouchEventHandler(const _Control& control)
1797 {
1798         result r = E_SUCCESS;
1799
1800         Evas_Object* pEvasObject = GetEvasObject(control);
1801         SysTryReturn(NID_UI, pEvasObject, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1802
1803         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MOUSE_UP, OnEvasTouchReleased);
1804         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MOUSE_DOWN, OnEvasTouchPressed);
1805         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MOUSE_MOVE, OnEvasTouchMoved);
1806
1807         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MULTI_UP, OnEvasMultiTouchReleased);
1808         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MULTI_DOWN, OnEvasMultiTouchPressed);
1809         evas_object_event_callback_del(pEvasObject, EVAS_CALLBACK_MULTI_MOVE, OnEvasMultiTouchMoved);
1810
1811         return r;
1812 }
1813
1814 result
1815 _EflUiEventManager::PostEvent(const _UiEvent& event)
1816 {
1817         ClearLastResult();
1818
1819         result r = E_SUCCESS;
1820
1821         _UiEvent* pEvent = event.CloneN();
1822         SysTryReturn(NID_UI, pEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1823
1824         Ecore_Event* pEcoreEvent = ecore_event_add(__notificaitonEventType, pEvent, FreeEvent, null);
1825         SysTryReturn(NID_UI, pEcoreEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1826
1827         return r;
1828 }
1829
1830 void
1831 _EflUiEventManager::SetKeyCapture(const _Control& control, _KeyCode keyCode)
1832 {
1833         Ecore_X_Window win = ecore_evas_software_x11_window_get(ecore_evas_ecore_evas_get(evas_object_evas_get(GetEvasObject(control))));
1834
1835         for (unsigned int i = 0; i < sizeof(keyTable) / sizeof(_EvasConvertKeys); ++i)
1836         {
1837                 if (keyTable[i].code == keyCode)
1838                 {
1839                         if (keyTable[i].pName)
1840                         {
1841                                 utilx_grab_key((Display*)ecore_x_display_get(), win, keyTable[i].pName, TOP_POSITION_GRAB);
1842                                 break;
1843                         }
1844                 }
1845         }
1846 }
1847
1848 void
1849 _EflUiEventManager::ReleaseKeyCapture(const _Control& control, _KeyCode keyCode)
1850 {
1851         Ecore_X_Window win = ecore_evas_software_x11_window_get(ecore_evas_ecore_evas_get(evas_object_evas_get(GetEvasObject(control))));
1852
1853         for (unsigned int i = 0; i < sizeof(keyTable) / sizeof(_EvasConvertKeys); ++i)
1854         {
1855                 if (keyTable[i].code == keyCode)
1856                 {
1857                         if (keyTable[i].pName)
1858                         {
1859                                 utilx_ungrab_key((Display*)ecore_x_display_get(), win,  keyTable[i].pName);
1860                                 break;
1861                         }
1862                 }
1863         }
1864 }
1865 }
1866
1867 } // Tizen::Ui