src/ui/FUi_EflUiEventManager.cpp

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