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