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