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