From b71ef4b077fc55f0c7c44675168647c908f4bc26 Mon Sep 17 00:00:00 2001 From: minkyu kim Date: Mon, 20 May 2013 20:47:36 +0900 Subject: [PATCH] merge mouseEvent, fix retutn value, DCM-1698 : paring touch press/release Change-Id: I1c9181d9169ac823c0eb831bf91036a99a29ee8a --- src/ui/FUi_Control.cpp | 48 +++ src/ui/FUi_ControlImpl.cpp | 175 +++++++++++ src/ui/FUi_ControlManager.cpp | 4 +- src/ui/FUi_EflUiEventManager.cpp | 417 +++++++++++++++++++++++++- src/ui/FUi_SystemUtilImpl.cpp | 4 +- src/ui/FUi_UiTouchEvent.cpp | 530 ++++++++++++++++++++++++++++++++++ src/ui/controls/FUiCtrl_Form.cpp | 53 ++++ src/ui/inc/FUiCtrl_Form.h | 7 + src/ui/inc/FUi_Control.h | 8 + src/ui/inc/FUi_ControlImpl.h | 10 + src/ui/inc/FUi_ITouchEventListener.h | 8 + src/ui/inc/FUi_ITouchEventPreviewer.h | 9 + src/ui/inc/FUi_UiTouchEvent.h | 114 ++++++++ 13 files changed, 1379 insertions(+), 8 deletions(-) diff --git a/src/ui/FUi_Control.cpp b/src/ui/FUi_Control.cpp index 44b5715..50b9501 100644 --- a/src/ui/FUi_Control.cpp +++ b/src/ui/FUi_Control.cpp @@ -640,6 +640,54 @@ _Control::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo) return false; } +_UiTouchEventDelivery +_Control::OnPreviewMousePressed(const _Control& source, const _MouseInfo& mouseinfo) +{ + return _UI_TOUCH_EVENT_DELIVERY_YES; +} + +_UiTouchEventDelivery +_Control::OnPreviewMouseReleased(const _Control& source, const _MouseInfo& mouseinfo) +{ + return _UI_TOUCH_EVENT_DELIVERY_YES; +} + +_UiTouchEventDelivery +_Control::OnPreviewMouseMoved(const _Control& source, const _MouseInfo& mouseinfo) +{ + return _UI_TOUCH_EVENT_DELIVERY_YES; +} + +_UiTouchEventDelivery +_Control::OnPreviewMouseWheeled(const _Control& source, const _MouseInfo& mouseinfo) +{ + return _UI_TOUCH_EVENT_DELIVERY_YES; +} + +bool +_Control::OnMousePressed(const _Control& source, const _MouseInfo& mouseinfo) +{ + return false; +} + +bool +_Control::OnMouseReleased(const _Control& source, const _MouseInfo& mouseinfo) +{ + return false; +} + +bool +_Control::OnMouseMoved(const _Control& source, const _MouseInfo& mouseinfo) +{ + return false; +} + +bool +_Control::OnMouseWheeled(const _Control& source, const _MouseInfo& mouseinfo) +{ + return false; +} + bool _Control::OnFocusGained(const _Control& source) { diff --git a/src/ui/FUi_ControlImpl.cpp b/src/ui/FUi_ControlImpl.cpp index 7368acf..7aa6b7e 100644 --- a/src/ui/FUi_ControlImpl.cpp +++ b/src/ui/FUi_ControlImpl.cpp @@ -1620,6 +1620,133 @@ public: return _UI_TOUCH_EVENT_DELIVERY_YES; } + virtual bool OnMousePressed(const _Control& source, const _MouseInfo& mouseInfo) + { + SysLog(NID_UI, "Minkyu OnMousePressed, source = 0x%x", &source); + bool isFiltered = false; + + // 3. Impl + isFiltered = __impl.OnMousePressed(__impl, mouseInfo); + if (isFiltered) + { + return true; + } + + // 4. Core + isFiltered = __core.OnMousePressed(source, mouseInfo); + + return isFiltered; + } + + virtual bool OnMouseReleased(const _Control& source, const _MouseInfo& mouseInfo) + { + SysLog(NID_UI, "Minkyu OnMouseReleased, source = 0x%x", &source); + bool isFiltered = false; + + // 3. Impl + isFiltered = __impl.OnMouseReleased(__impl, mouseInfo); + if (isFiltered) + { + return true; + } + + // 4. Core + isFiltered = __core.OnMouseReleased(source, mouseInfo); + + return isFiltered; + } + + virtual bool OnMouseMoved(const _Control& source, const _MouseInfo& mouseInfo) + { + return false; + } + + virtual bool OnMouseWheeled(const _Control& source, const _MouseInfo& mouseInfo) + { + SysLog(NID_UI, "OnWheelMoved, source = 0x%x", &source); + bool isFiltered = false; + + // 3. Impl + isFiltered = __impl.OnMouseWheeled(__impl, mouseInfo); + if (isFiltered) + { + return true; + } + + // 4. Core + isFiltered = __core.OnMouseWheeled(source, mouseInfo); + + return isFiltered; + } + + virtual _UiTouchEventDelivery OnPreviewMousePressed(const _Control& source, const _MouseInfo& mouseInfo) + { + _UiTouchEventDelivery isFiltered = _UI_TOUCH_EVENT_DELIVERY_NO; + + // 3. Impl + isFiltered = __impl.OnPreviewMousePressed(__impl, mouseInfo); + if (isFiltered == _UI_TOUCH_EVENT_DELIVERY_NO) + { + return _UI_TOUCH_EVENT_DELIVERY_NO; + } + + // 4. Core + isFiltered = __core.OnPreviewMousePressed(source, mouseInfo); + + return isFiltered; + } + + virtual _UiTouchEventDelivery OnPreviewMouseReleased(const _Control& source, const _MouseInfo& mouseInfo) + { + _UiTouchEventDelivery isFiltered = _UI_TOUCH_EVENT_DELIVERY_NO; + + // 3. Impl + isFiltered = __impl.OnPreviewMouseReleased(__impl, mouseInfo); + if (isFiltered == _UI_TOUCH_EVENT_DELIVERY_NO) + { + return _UI_TOUCH_EVENT_DELIVERY_NO; + } + + // 4. Core + isFiltered = __core.OnPreviewMouseReleased(source, mouseInfo); + + return isFiltered; + } + + virtual _UiTouchEventDelivery OnPreviewMouseMoved(const _Control& source, const _MouseInfo& mouseInfo) + { + _UiTouchEventDelivery isFiltered = _UI_TOUCH_EVENT_DELIVERY_NO; + + // 3. Impl + isFiltered = __impl.OnPreviewMouseMoved(__impl, mouseInfo); + if (isFiltered == _UI_TOUCH_EVENT_DELIVERY_NO) + { + return _UI_TOUCH_EVENT_DELIVERY_NO; + } + + // 4. Core + isFiltered = __core.OnPreviewMouseMoved(source, mouseInfo); + + return isFiltered; + } + + virtual _UiTouchEventDelivery OnPreviewMouseWheeled(const _Control& source, const _MouseInfo& mouseInfo) + { + _UiTouchEventDelivery isFiltered = _UI_TOUCH_EVENT_DELIVERY_NO; + + // 3. Impl + isFiltered = __impl.OnPreviewMouseWheeled(__impl, mouseInfo); + if (isFiltered == _UI_TOUCH_EVENT_DELIVERY_NO) + { + return _UI_TOUCH_EVENT_DELIVERY_NO; + } + + // 4. Core + isFiltered = __core.OnPreviewMouseWheeled(source, mouseInfo); + + return isFiltered; + } + virtual void OnTouchPressHandled(const _Control& source) { __impl.OnTouchPressHandled(source); @@ -3050,6 +3177,54 @@ _ControlImpl::OnPreviewTouchCanceled(const _ControlImpl& source, const _TouchInf } bool +_ControlImpl::OnMousePressed(const _ControlImpl& source, const _MouseInfo& mouseinfo) +{ + return false; +} + +bool +_ControlImpl::OnMouseReleased(const _ControlImpl& source, const _MouseInfo& mouseinfo) +{ + return false; +} + +bool +_ControlImpl::OnMouseMoved(const _ControlImpl& source, const _MouseInfo& mouseinfo) +{ + return false; +} + +bool +_ControlImpl::OnMouseWheeled(const _ControlImpl& source, const _MouseInfo& mouseinfo) +{ + return false; +} + +_UiTouchEventDelivery +_ControlImpl::OnPreviewMousePressed(const _ControlImpl& source, const _MouseInfo& mouseinfo) +{ + return _UI_TOUCH_EVENT_DELIVERY_YES; +} + +_UiTouchEventDelivery +_ControlImpl::OnPreviewMouseReleased(const _ControlImpl& source, const _MouseInfo& mouseinfo) +{ + return _UI_TOUCH_EVENT_DELIVERY_YES; +} + +_UiTouchEventDelivery +_ControlImpl::OnPreviewMouseMoved(const _ControlImpl& source, const _MouseInfo& mouseinfo) +{ + return _UI_TOUCH_EVENT_DELIVERY_YES; +} + +_UiTouchEventDelivery +_ControlImpl::OnPreviewMouseWheeled(const _ControlImpl& source, const _MouseInfo& mouseinfo) +{ + return _UI_TOUCH_EVENT_DELIVERY_YES; +} + +bool _ControlImpl::OnFocusGained(const _ControlImpl& source) { return false; diff --git a/src/ui/FUi_ControlManager.cpp b/src/ui/FUi_ControlManager.cpp index 4be2227..1c899ba 100644 --- a/src/ui/FUi_ControlManager.cpp +++ b/src/ui/FUi_ControlManager.cpp @@ -1296,9 +1296,11 @@ _ControlManager::GetTopmostTouchedControl(const Point& point) } } - + if (pControl != null) + { return pControl; } + } int count = GetWindowCount(); if (count != 0) diff --git a/src/ui/FUi_EflUiEventManager.cpp b/src/ui/FUi_EflUiEventManager.cpp index 9e7890f..7b17204 100644 --- a/src/ui/FUi_EflUiEventManager.cpp +++ b/src/ui/FUi_EflUiEventManager.cpp @@ -59,9 +59,10 @@ namespace { #define __UNUSED__ -bool isPressed = false; Ecore_X_Atom keyboardExist = 0; const wchar_t* KEYBOARD_INSERTED_EVENT = L"KEYBOARD_INSERTED"; +const int DEVICE_COUNT = 999; +bool touchPressed[DEVICE_COUNT] = {false,}; Evas_Object* GetEvasObject(const _Control& control) @@ -828,6 +829,328 @@ private: _TouchEventManager* __pTouchEventManager; }; // _TouchEvent +class _MouseEvent + : public _Event +{ +public: + _MouseEvent(int deviceId, _TouchStatus status, int x, int y, int z, unsigned int buttons, unsigned int timeStamp, const _Control* pRootControl) + : __pTouchEventManager(null) + { + __pTouchEventManager = _TouchEventManager::GetInstance(); + SysTryReturnVoidResult(NID_UI, __pTouchEventManager, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + result r = E_SUCCESS; + Tizen::Graphics::Point current(x, y); + + _TouchManager* pTouchManager = _TouchManager::GetInstance(); + SysTryReturnVoidResult(NID_UI, pTouchManager, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + unsigned int pointId = 0; + + if (status == _TOUCH_PRESSED) + { + IListT<_FingerInfo*>* pFingerInfoList = pTouchManager->GetMultiFingerInfoListN(); + SysTryReturnVoidResult(NID_UI, pFingerInfoList, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed."); + + const int count = pFingerInfoList->GetCount(); + + for (int i = 0; i < count; i++) + { + _FingerInfo* pFingerInfo = null; + pFingerInfoList->GetAt(i, pFingerInfo); + if (pFingerInfo == null) + { + continue; + } + + if (static_cast(pFingerInfo->GetDeviceId()) == deviceId && pFingerInfo->GetStatus() == _TOUCH_PRESSED) + { + pTouchManager->ResetTouchInfo(); + SysSecureLog(NID_UI, "ResetTouchInfo x(%d), y(%d), deviceID(%d), pointID(%d)", current.x, current.y, deviceId, pFingerInfo->GetPointId()); + break; + } + } + delete pFingerInfoList; + + pointId = pTouchManager->GeneratePointId(deviceId); + } + else + { + pointId = pTouchManager->GetPointId(deviceId); + } + + if (pointId == INVALID_POINT_ID) + { + if (status == _TOUCH_RELEASED) + { + _ControlManager* pControlManager = _ControlManager::GetInstance(); + SysTryReturnVoidResult(NID_UI, pControlManager, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + _Window* pWindow = pControlManager->GetTouchedWindow(); + if (pWindow == null) + { + _TouchManager* pTouchManager = _TouchManager::GetInstance(); + if (pTouchManager) + { + pTouchManager->ResetTouchInfo(); + SysLog(NID_UI, "pWindow is null, ResetTouchInfo"); + } + } + } + SetLastResult(E_INVALID_CONDITION); + return; + } + + if (!pRootControl) + { + r = GetPosition(status, x, y, current); + SysTryReturnVoidResult(NID_UI, r != E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] A system error occurred."); + SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + } + else + { + current = _CoordinateSystemUtils::InverseTransform(current); + } + + __mouseInfo.SetTouchInfo(pointId, status, current, z, buttons, false, timeStamp); + + if (status == _TOUCH_PRESSED) + { + _Control* pControl = GetTarget(current.x, current.y, pRootControl); + + if (pControl == null) + { + pTouchManager->ResetTouchInfo(); + SysSecureLog(NID_UI, "ResetTouchInfo x(%d), y(%d), deviceID(%d), pointID(%d)", current.x, current.y, deviceId, pointId); + SysTryReturnVoidResult(NID_UI, false, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + } + else + { + r = __pTouchEventManager->AddControl(pointId, pControl->GetHandle()); + SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + _Control* pParent = pControl->GetParent(); + if (pParent) + { + r = __pTouchEventManager->AddParentControl(pointId, pParent->GetHandle()); + SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + } + } + } + else + { + _Control* pControl = pTouchManager->GetChangedTouchableTarget(); + if (pControl == null) + { + ClearLastResult(); + } + else + { + if (pControl->GetChangingEventTarget() == true && pControl->GetVisibleState() == true) + { + r = __pTouchEventManager->AddControl(pointId, pControl->GetHandle()); + SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + } + } + } + } + + virtual ~_MouseEvent(void) + { + } + +private: + virtual result SendImpl(void) + { + _Control* pTarget = __pTouchEventManager->GetControl(__mouseInfo.GetPointId()); + if (pTarget == null) + { + _TouchManager* pTouchManager = _TouchManager::GetInstance(); + pTouchManager->ResetTouchInfo(); + + SysLog(NID_UI, "ResetTouchInfo"); + return E_SUCCESS; + } + + _UiMouseEvent event(pTarget->GetHandle(), __mouseInfo); + + return _pEventManager->SendEvent(event); + } + +private: + _MouseEvent(const _MouseEvent& rhs); + _MouseEvent& operator =(const _MouseEvent& rhs); + + _Control* GetTarget(int x, int y, const _Control* pRootControl) const + { + ClearLastResult(); + + _TouchManager* pTouchManager = _TouchManager::GetInstance(); + SysTryReturn(NID_UI, pTouchManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + _Control* pCapturedControl = pTouchManager->GetCapturedControl(); + _Control* pControl = null; + + if (pCapturedControl) + { + if (pTouchManager->IsCaptureAllowedOwnerBounds()) + { + if (pTouchManager->IsCaptureAllowedOutOfBounds()) + { + pControl = pCapturedControl; + } + + _Window * pWindow = dynamic_cast<_Window*>(pCapturedControl); + if (pWindow) + { + _Control* pOwner = pWindow->GetOwner(); + if (pOwner) + { + Tizen::Graphics::Rectangle ownerRc(pOwner->GetAbsoluteBounds()); + if ((x >= ownerRc.x) && (x <= (ownerRc.x + ownerRc.width)) && (y >= ownerRc.y) && (y <= (ownerRc.y + ownerRc.height))) + { + pControl = pOwner; + } + } + } + + Tizen::Graphics::Rectangle rc(pCapturedControl->GetAbsoluteBounds()); + if ((x >= rc.x) && (x <= (rc.x + rc.width)) && (y >= rc.y) && (y <= (rc.y + rc.height))) + { + pControl = pCapturedControl; + } + } + else + { + if (pTouchManager->IsCaptureAllowedOutOfBounds()) + { + pControl = pCapturedControl; + } + else + { + Tizen::Graphics::Rectangle rc(pCapturedControl->GetAbsoluteBounds()); + + if ((x < rc.x) || (x > (rc.x + rc.width)) || (y < rc.y) || (y > (rc.y + rc.height))) + { + pControl = pCapturedControl; + } + } + } + + if (pControl != null) + { + return pControl; + } + } + + _ControlManager* pControlManager = _ControlManager::GetInstance(); + SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + Tizen::Graphics::FloatPoint ptf(static_cast(x), static_cast(y)); + + _ControlVisualElement* pRootControlElement = null; + if (pRootControl) + { + pRootControlElement = dynamic_cast<_ControlVisualElement*>(pRootControl->GetVisualElement()); + } + else + { + _Window* pWindow = null; + pWindow = pControlManager->GetTouchedWindow(); + SysTryReturn(NID_UI, pWindow, null, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + Rectangle winBounds = pWindow->GetBounds(); + + ptf.x = static_cast(x - winBounds.x); + ptf.y = static_cast(y - winBounds.y); + + pRootControlElement = dynamic_cast <_ControlVisualElement*>(pWindow->GetVisualElement()); + } + + SysTryReturn(NID_UI, pRootControlElement, null, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + _ControlVisualElement* pControlVisualElement = pRootControlElement->GetControlChildAtPoint(ptf); + SysTryReturn(NID_UI, pControlVisualElement, null, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + pControl = static_cast <_Control*>(pControlVisualElement->GetUserData()); + SysTryReturn(NID_UI, pControl, null, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + return pControl; + } + + result GetPosition(_TouchStatus status, int x, int y, Point& point) const + { + result r = E_SUCCESS; + + _ControlManager* pControlManager = _ControlManager::GetInstance(); + SysTryReturn(NID_UI, pControlManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + _Window* pWindow = pControlManager->GetTouchedWindow(); + if (pWindow == null) + { + _TouchManager* pTouchManager = _TouchManager::GetInstance(); + if (pTouchManager) + { + pTouchManager->ResetTouchInfo(); + SysLog(NID_UI, "pWindow is null, ResetTouchInfo"); + } + } + SysTryReturn(NID_UI, pWindow, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] A system error occurred."); + + _RootVisualElement* pRootVE = pWindow->GetRootVisualElement(); + SysTryReturn(NID_UI, pRootVE, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + _EflLayer* pLayer = static_cast<_EflLayer*>(pRootVE->GetNativeLayer()); + SysTryReturn(NID_UI, pLayer, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + Ecore_Evas* pEE = pLayer->GetEcoreEvas(); + SysTryReturn(NID_UI, pEE, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + + const int PORTRAIT = 0; + const int LANDSCAPE = 270; + const int PORTRAIT_REVERSE = 180; + const int LANDSCAPE_REVERSE = 90; + + Dimension dimension = pControlManager->GetScreenSize(); + Point output(_CoordinateSystemUtils::InverseTransform(point)); + int rotation = ecore_evas_rotation_get(pEE); + + switch (rotation) + { + case PORTRAIT: + point.x = output.x; + point.y = output.y; + break; + + case LANDSCAPE: + point.x = output.y; + point.y = dimension.width - output.x; + break; + + case PORTRAIT_REVERSE: + point.x = dimension.width - output.x; + point.y = dimension.height - output.y; + break; + + case LANDSCAPE_REVERSE: + point.x = dimension.height - output.y; + point.y = output.x; + break; + + default: + SysAssertf(0, "[E_SYSTEM][%d]", rotation); + r = E_SYSTEM; + break; + } + + return r; + } + +private: + _MouseInfo __mouseInfo; + _TouchEventManager* __pTouchEventManager; +}; + Eina_Bool OnNotified(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo) { @@ -929,14 +1252,35 @@ OnTouchPressed(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo) Ecore_Event_Mouse_Button* pEv = static_cast (pEventInfo); SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid."); + SysSecureLog(NID_UI, "OnTouchPressed - x(%d), y(%d), deviceId(%d), buttons(%d)", pEv->root.x, pEv->root.y, pEv->multi.device, pEv->buttons); + _ControlManager* pControlManager = _ControlManager::GetInstance(); SysTryReturn(NID_UI, pControlManager, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] A system error occurred."); pControlManager->SetTouchedWindow((unsigned int)pEv->window); - isPressed = true; + if (touchPressed[pEv->multi.device] == true) + { + _TouchManager* pTouchManager = _TouchManager::GetInstance(); + if (pTouchManager) + { + pTouchManager->SetTouchCanceled(null); + SysLog(NID_UI, "pWindow is null, CancelTouch"); - SysSecureLog(NID_UI, "OnTouchPressed - x(%d), y(%d), deviceId(%d)", pEv->root.x, pEv->root.y, pEv->multi.device); + for(int i=0; imulti.device] = false; + } + + pTouchManager->ResetTouchInfo(); + SysLog(NID_UI, "pWindow is null, ResetTouchInfo"); + } + } + + touchPressed[pEv->multi.device] = true; + + if (pEv->buttons == _MOUSE_BUTTON_LEFT || pEv->buttons == _MOUSE_BUTTON_NONE) + { _TouchEvent event(pEv->multi.device, _TOUCH_PRESSED, pEv->root.x, pEv->root.y, pEv->timestamp, null); result r = GetLastResult(); @@ -947,6 +1291,21 @@ OnTouchPressed(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo) } event.Send(); + } + else + { + //_MouseEvent event(pEv->multi.device, _TOUCH_PRESSED, pEv->root.x, pEv->root.y, 0, pEv->buttons, pEv->timestamp, null); + _MouseEvent event(pEv->multi.device, _TOUCH_PRESSED, pEv->root.x, pEv->root.y, 0, _MOUSE_BUTTON_RIGHT, pEv->timestamp, null); + + result r = GetLastResult(); + if (r != E_SUCCESS) + { + SysLog(NID_UI, "[%s] Propagating.", GetErrorMessage(r)); + return ECORE_CALLBACK_PASS_ON; + } + + event.Send(); + } SetLastResult(E_SUCCESS); @@ -959,12 +1318,15 @@ OnTouchReleased(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo) Ecore_Event_Mouse_Button* pEv = static_cast (pEventInfo); SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid."); - isPressed = false; + SysSecureLog(NID_UI, "OnTouchReleased - x(%d), y(%d), deviceId(%d) buttons(%d)", pEv->root.x, pEv->root.y, pEv->multi.device, pEv->buttons); _TouchManager* pTouchManager = _TouchManager::GetInstance(); SysTryReturn(NID_UI, pTouchManager, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] _TouchManager does not exist."); - SysSecureLog(NID_UI, "OnTouchReleased - x(%d), y(%d), deviceId(%d)", pEv->root.x, pEv->root.y, pEv->multi.device); + touchPressed[pEv->multi.device] = false; + + if (pEv->buttons == _MOUSE_BUTTON_LEFT || pEv->buttons == _MOUSE_BUTTON_NONE) + { _TouchEvent event(pEv->multi.device, _TOUCH_RELEASED, pEv->root.x, pEv->root.y, pEv->timestamp, null); result r = GetLastResult(); @@ -975,6 +1337,29 @@ OnTouchReleased(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo) } event.Send(); + } + else + { + //_MouseEvent event(pEv->multi.device, _TOUCH_RELEASED, pEv->root.x, pEv->root.y, 0, pEv->buttons, pEv->timestamp, null); + _MouseEvent event(pEv->multi.device, _TOUCH_RELEASED, pEv->root.x, pEv->root.y, 0, _MOUSE_BUTTON_RIGHT, pEv->timestamp, null); + + + result r = GetLastResult(); + if (r!= E_SUCCESS) + { + SysLog(NID_UI, "[%s] Propagating.", GetErrorMessage(r)); + return ECORE_CALLBACK_PASS_ON; + } + + event.Send(); + + _TouchManager* pTouchManager = _TouchManager::GetInstance(); + if (pTouchManager) + { + pTouchManager->ResetTouchInfo(); + SysLog(NID_UI, "ResetTouchInfo"); + } + } IListT<_FingerInfo*>* pFingerInfoList = pTouchManager->GetMultiFingerInfoListN(); SysTryReturn(NID_UI, pFingerInfoList, ECORE_CALLBACK_PASS_ON, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed."); @@ -1027,6 +1412,28 @@ OnTouchMoved(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo) } Eina_Bool +OnMouseWheeled(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo) +{ + _Ecore_Event_Mouse_Wheel* pEv = static_cast <_Ecore_Event_Mouse_Wheel*>(pEventInfo); + SysTryReturn(NID_UI, pEv, ECORE_CALLBACK_PASS_ON, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid."); + + SysSecureLog(NID_UI, "OnMouseWheeled - x(%d), y(%d), z(%d)", pEv->root.x, pEv->root.y, pEv->z); + _MouseEvent event(0, _WHEEL_MOVED, pEv->root.x, pEv->root.y, pEv->z, _MOUSE_BUTTON_NONE, pEv->timestamp, null); + + result r = GetLastResult(); + if (r != E_SUCCESS) + { + return ECORE_CALLBACK_PASS_ON; + } + + event.Send(); + + SetLastResult(E_SUCCESS); + + return ECORE_CALLBACK_PASS_ON; +} + +Eina_Bool OnKeyboardInserted(void* pData __UNUSED__, int type __UNUSED__, void* pEventInfo) { Ecore_X_Event_Window_Property *pEv = static_cast (pEventInfo); diff --git a/src/ui/FUi_SystemUtilImpl.cpp b/src/ui/FUi_SystemUtilImpl.cpp index df02b15..b8b9f30 100644 --- a/src/ui/FUi_SystemUtilImpl.cpp +++ b/src/ui/FUi_SystemUtilImpl.cpp @@ -311,12 +311,12 @@ _SystemUtilImpl::SendKeyStopMessage(void) { bool r = false; int num; - Ecore_X_Window *_keygrab_win = NULL; + Ecore_X_Window *_keygrab_win = null; char msg_data[] = "PxXF86Stop"; Ecore_X_Atom type = ecore_x_atom_get("_HWKEY_EMULATION"); - int ret = ecore_x_window_prop_property_get(NULL, type, ECORE_X_ATOM_WINDOW, 32, (unsigned char **)&_keygrab_win, &num); + int ret = ecore_x_window_prop_property_get(null, type, ECORE_X_ATOM_WINDOW, 32, (unsigned char **)&_keygrab_win, &num); if (ret && num) { Ecore_X_Window xWindow = *_keygrab_win; diff --git a/src/ui/FUi_UiTouchEvent.cpp b/src/ui/FUi_UiTouchEvent.cpp index f1fd6b8..2d0cbf0 100644 --- a/src/ui/FUi_UiTouchEvent.cpp +++ b/src/ui/FUi_UiTouchEvent.cpp @@ -151,6 +151,126 @@ _TouchInfo::SetTouchInfo(unsigned long pointId, _TouchStatus status, Tizen::Grap __timeStamp = timeStamp; } +_MouseInfo::_MouseInfo(void) + : __pointId(0) + , __touchStatus(_TOUCH_PRESSED) + , __currentPosition(0, 0) + , __zAxis(0) + , __buttons(0) + , __isFlicked(false) + , __timeStamp(0) +{ +} + +_MouseInfo::_MouseInfo(unsigned long pointId, _TouchStatus status, const Tizen::Graphics::FloatPoint& current, int zAxis, int buttons, const bool isFlick, long long timeStamp) + : __pointId(pointId) + , __touchStatus(status) + , __currentPosition(current) + , __zAxis(zAxis) + , __buttons(buttons) + , __isFlicked(isFlick) + , __timeStamp(timeStamp) +{ +} + +_MouseInfo::_MouseInfo(const _MouseInfo& rhs) + : __pointId(rhs.__pointId) + , __touchStatus(rhs.__touchStatus) + , __currentPosition(rhs.__currentPosition) + , __zAxis(rhs.__zAxis) + , __buttons(rhs.__buttons) + , __isFlicked(rhs.__isFlicked) + , __timeStamp(rhs.__timeStamp) +{ +} + +_MouseInfo& +_MouseInfo::operator =(const _MouseInfo& rhs) +{ + if (this != &rhs) + { + __pointId = rhs.__pointId; + __touchStatus = rhs.__touchStatus; + __currentPosition = rhs.__currentPosition; + __zAxis = rhs.__zAxis; + __buttons = rhs.__buttons; + __isFlicked = rhs.__isFlicked; + __timeStamp = rhs.__timeStamp; + } + + return *this; +} + +_MouseInfo::~_MouseInfo(void) +{ +} + +_TouchStatus +_MouseInfo::GetTouchStatus(void) const +{ + return __touchStatus; +} + +Tizen::Graphics::FloatPoint +_MouseInfo::GetCurrentPosition(void) const +{ + return __currentPosition; +} + +unsigned long +_MouseInfo::GetPointId(void) const +{ + return __pointId; +} + +int +_MouseInfo::GetZAxis(void) const +{ + return __zAxis; +} + +int +_MouseInfo::GetButtons(void) const +{ + return __buttons; +} + +bool +_MouseInfo::IsFlicked(void) const +{ + return __isFlicked; +} + +long long +_MouseInfo::GetTimeStamp(void) const +{ + return __timeStamp; +} + +void +_MouseInfo::SetTouchInfo(unsigned long pointId, _TouchStatus status, Tizen::Graphics::Point& current, int zAxis, int buttons, bool isFlick, long long timeStamp) +{ + __pointId = pointId; + __touchStatus = status; + __currentPosition = _CoordinateSystemUtils::ConvertToFloat(current); + __zAxis = zAxis; + __buttons = buttons; + __isFlicked = isFlick; + __timeStamp = timeStamp; +} + +void +_MouseInfo::SetTouchInfo(unsigned long pointId, _TouchStatus status, Tizen::Graphics::FloatPoint& current, int zAxis, int buttons, bool isFlick, long long timeStamp) +{ + __pointId = pointId; + __touchStatus = status; + __currentPosition = current; + __zAxis = zAxis; + __buttons = buttons; + __isFlicked = isFlick; + __timeStamp = timeStamp; +} + _UiTouchEvent::_UiTouchEvent(const _UiObjectHandle& destination, const _TouchInfo& touchInfo, _UiEventRouteType routeType, const _UiObjectHandle& source) : _UiEvent(destination, source, routeType) , __touchInfo(touchInfo) @@ -592,4 +712,414 @@ _UiTouchEvent::ExistGlobalGesture(void) return exist; } +_UiMouseEvent::_UiMouseEvent(const _UiObjectHandle& destination, const _MouseInfo& mouseInfo, _UiEventRouteType routeType, const _UiObjectHandle& source) + : _UiEvent(destination, source, routeType) + , __mouseInfo(mouseInfo) + , __pForcedControlList(new (std::nothrow) LinkedListT<_Control*>) +{ +} + +_UiMouseEvent::~_UiMouseEvent(void) +{ +} + +_UiMouseEvent::_UiMouseEvent(const _UiMouseEvent& rhs) + : _UiEvent(rhs) + , __mouseInfo(rhs.__mouseInfo) + , __pForcedControlList(rhs.__pForcedControlList) +{ +} + +_UiMouseEvent& +_UiMouseEvent::operator =(const _UiMouseEvent& rhs) +{ + _UiEvent::operator =(rhs); + + if (this != &rhs) + { + __mouseInfo = rhs.__mouseInfo; + __pForcedControlList = rhs.__pForcedControlList; + } + + return *this; +} + +const _MouseInfo* +_UiMouseEvent::GetTouchInfo(void) const +{ + return &__mouseInfo; +} + +_UiMouseEvent* +_UiMouseEvent::CloneN(void) const +{ + return new (std::nothrow) _UiMouseEvent(*this); +} + +_UiEventType +_UiMouseEvent::GetEventType(void) const +{ + return _UI_EVENT_TOUCH; +} + +bool +_UiMouseEvent::IsEventEnabled(const _Control& control) const +{ + if (!_UiEvent::IsEventEnabled(control)) + { + return false; + } + + if (GetTouchInfo()->GetTouchStatus() != _TOUCH_CANCELED) + { + if (!control.IsInputEventEnabled()) + { + return false; + } + } + + return true; +} + +result +_UiMouseEvent::OnPreviewEventProcessing(const _Control& control, bool& isFiltered) +{ + result r = E_SUCCESS; + + const _MouseInfo* pMouseInfo = GetTouchInfo(); + SysTryReturn(NID_UI, pMouseInfo, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + if ((!ExistGlobalGesture() || GetAccessibilityEvent()) && !isFiltered) + { + _ITouchEventPreviewer* pTouchEventPreviewer = control.GetPropagatedTouchEventListener(); + SysTryReturn(NID_UI, pTouchEventPreviewer, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + r = FirePreviewListener(pTouchEventPreviewer, &control, isFiltered); + } + + return r; +} + +result +_UiMouseEvent::OnEventProcessing(const _Control& control, bool& isFiltered) +{ + result r = E_SUCCESS; + + bool doesControlExist = false; + + const _MouseInfo* pMouseInfo = GetTouchInfo(); + SysTryReturn(NID_UI, pMouseInfo, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + if ((!ExistGlobalGesture() || GetAccessibilityEvent()) && !isFiltered) + { + ProcessGesture(control, isFiltered); + } + else if (isFiltered) + { + doesControlExist = __pForcedControlList->Contains(const_cast<_Control*>(&control)); + + if (doesControlExist) + { + bool isForcedFiltered = false; + ProcessGesture(control, isForcedFiltered); + + if (isForcedFiltered) + { + isFiltered = true; + } + } + } + + if (!ExistGlobalGesture() || GetAccessibilityEvent()) + { + if(!isFiltered || doesControlExist) + { + _ITouchEventListener* pTouchEventListener = control.GetPropagatedTouchEventListener(); + SysTryReturn(NID_UI, pTouchEventListener, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + r = FireListener(pTouchEventListener, &control, true, isFiltered); + } + } + + return r; +} + +result +_UiMouseEvent::OnListenerProcessing(const _IUiEventListener& listener, bool& isFiltered) +{ + _ITouchEventListener* pTouchEventListener = dynamic_cast <_ITouchEventListener*>(const_cast <_IUiEventListener*>(&listener)); + SysTryReturn(NID_UI, pTouchEventListener, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + return FireListener(pTouchEventListener, null, true, isFiltered); +} + +result +_UiMouseEvent::OnEventHandled(const _Control& control) +{ + _Control* pTarget = const_cast<_Control*>(GetControl(GetDestination())); + SysTryReturn(NID_UI, pTarget, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + const _MouseInfo* pMouseInfo = GetTouchInfo(); + SysTryReturn(NID_UI, pMouseInfo, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + result r = E_SUCCESS; + + switch (pMouseInfo->GetTouchStatus()) + { + case _TOUCH_PRESSED: + pTarget->GetPropagatedTouchEventListener()->OnTouchPressHandled(control); + break; + + case _TOUCH_MOVED: + pTarget->GetPropagatedTouchEventListener()->OnTouchMoveHandled(control); + break; + + case _TOUCH_RELEASED: + pTarget->GetPropagatedTouchEventListener()->OnTouchReleaseHandled(control); + break; + + case _TOUCH_CANCELED: + pTarget->GetPropagatedTouchEventListener()->OnTouchCancelHandled(control); + break; + + default: + r = E_SYSTEM; + break; + } + + return r; +} + +result +_UiMouseEvent::FireListener(const _ITouchEventListener* pListener, const _Control* pControl, bool isTouchEvent, bool& isFiltered) +{ + _ITouchEventListener* pTouchEventListener = const_cast <_ITouchEventListener*>(pListener); + SysTryReturn(NID_UI, pTouchEventListener, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + result r = E_SUCCESS; + + const _MouseInfo* pMouseInfo = GetTouchInfo(); + SysTryReturn(NID_UI, pMouseInfo, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + const _Control* pTarget = GetControl(GetOriginalDestination()); + if (pTarget == null) + { + SysLog(NID_UI, "pTarget == null, Call ResetTouchInfo."); + _TouchManager* pTouchManager = _TouchManager::GetInstance(); + pTouchManager->ResetTouchInfo(); + + return E_SUCCESS; +} + + if (ResetTouchInfo(pTarget, *pMouseInfo) == E_SUCCESS) + { + isFiltered = true; + return E_SYSTEM; + } + + FloatPoint point(0, 0); + + if (pControl) + { + _TouchManager* pTouchManager = _TouchManager::GetInstance(); + SysAssert(pTouchManager != null) + + point = GetRelativePoint(*pControl, pMouseInfo->GetCurrentPosition()); + } + else + { + point = GetRelativePoint(*pTarget, pMouseInfo->GetCurrentPosition()); + } + + _MouseInfo mouseInfo(pMouseInfo->GetPointId(), pMouseInfo->GetTouchStatus(), point, pMouseInfo->GetZAxis(), pMouseInfo->GetButtons(), false, pMouseInfo->GetTimeStamp()); + + switch (mouseInfo.GetTouchStatus()) + { + case _TOUCH_PRESSED: + isFiltered = pTouchEventListener->OnMousePressed(*pTarget, mouseInfo); + break; + + case _TOUCH_RELEASED: + isFiltered = pTouchEventListener->OnMouseReleased(*pTarget, mouseInfo); + break; + + case _TOUCH_MOVED: + isFiltered = pTouchEventListener->OnMouseMoved(*pTarget, mouseInfo); + break; + + case _WHEEL_MOVED: + isFiltered = pTouchEventListener->OnMouseWheeled(*pTarget, mouseInfo); + break; + + default: + r = E_SYSTEM; + } + + if (isFiltered) + { + if (pControl) + { + SysLog(NID_UI, "Event Consumed : isFiltered is True : pControl %x", pControl); + //_UiPrintControl(*pControl, false); + } + SysLog(NID_UI, "Event Consumed : isFiltered is True : pTarget %x", pTarget); + } + + return r; +} + +result +_UiMouseEvent::FirePreviewListener(const _ITouchEventPreviewer* pListener, const _Control* pControl, bool& isFiltered) +{ + _ITouchEventPreviewer* pTouchEventPreviewer = const_cast <_ITouchEventPreviewer*>(pListener); + SysTryReturn(NID_UI, pTouchEventPreviewer, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + result r = E_SUCCESS; + + const _MouseInfo* pMouseInfo = GetTouchInfo(); + SysTryReturn(NID_UI, pMouseInfo, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + const _Control* pTarget = GetControl(GetDestination()); + + FloatPoint point = GetRelativePoint(*pControl, pMouseInfo->GetCurrentPosition()); + + if (!pControl->IsMultiTouchEnabled() && pMouseInfo->GetPointId() > 0) + { + isFiltered = false; + return E_SUCCESS; + } + + _MouseInfo mouseInfo(pMouseInfo->GetPointId(), pMouseInfo->GetTouchStatus(), point, pMouseInfo->GetZAxis(), pMouseInfo->GetButtons(), false, pMouseInfo->GetTimeStamp()); + + _UiTouchEventDelivery eventDelivery = _UI_TOUCH_EVENT_DELIVERY_NO; + + //condition 1) if target is not enabled multi touch, point id should be 0 + //2) target is enabled multi touch + switch (mouseInfo.GetTouchStatus()) + { + case _TOUCH_PRESSED: + eventDelivery = pTouchEventPreviewer->OnPreviewMousePressed(*pTarget, mouseInfo); + break; + + case _TOUCH_RELEASED: + eventDelivery = pTouchEventPreviewer->OnPreviewMouseReleased(*pTarget, mouseInfo); + break; + + case _TOUCH_MOVED: + eventDelivery = pTouchEventPreviewer->OnPreviewMouseMoved(*pTarget, mouseInfo); + break; + + case _WHEEL_MOVED: + eventDelivery = pTouchEventPreviewer->OnPreviewMouseWheeled(*pTarget, mouseInfo); + break; + + default: + r = E_SYSTEM; + break; + } + + if (eventDelivery != _UI_TOUCH_EVENT_DELIVERY_NO) + { + // isFiltered = (eventDelivery == _UI_TOUCH_EVENT_DELIVERY_FORCED_YES); + + // if (isFiltered) + if (eventDelivery == _UI_TOUCH_EVENT_DELIVERY_FORCED_YES) + { + __pForcedControlList->Add(const_cast<_Control*>(pControl)); + } + } + else + { + isFiltered = true; + } + + return r; +} + +result +_UiMouseEvent::ProcessGesture(const _Control& control, bool& isFiltered) +{ + if (control.IsSendingDelayedEvent()) + { + return E_SUCCESS; + } + + IListT<_TouchGestureDetector*>* pGestureList = control.GetGestureDetectorList(); + if (!pGestureList || (pGestureList && (pGestureList->GetCount() <= 0))) + { + return E_SUCCESS; + } + + IEnumeratorT<_TouchGestureDetector*>* pEnumerator = pGestureList->GetEnumeratorN(); + SysTryReturn(NID_UI, pEnumerator, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + while (pEnumerator->MoveNext() == E_SUCCESS) + { + _TouchGestureDetector* pGestureDetector = null; + pEnumerator->GetCurrent(pGestureDetector); + + if (!pGestureDetector) + { + continue; + } + + _ITouchGestureDelegate* pDelegator = pGestureDetector->GetDelegate(); + if (pDelegator) + { + FireListener(pDelegator, &control, false, isFiltered); + } + } + + delete pEnumerator; + return E_SUCCESS; +} + +FloatPoint +_UiMouseEvent::GetRelativePoint(const _Control& control, const FloatPoint& point) const +{ + FloatPoint relativePoint(point); + FloatRectangle absRect = control.GetAbsoluteBoundsF(); + + relativePoint.x -= absRect.x; + relativePoint.y -= absRect.y; + + return relativePoint; +} + +result +_UiMouseEvent::ResetTouchInfo(const _Control* pControl, const _MouseInfo& mouseInfo) +{ + _TouchManager* pTouchManager = _TouchManager::GetInstance(); + SysTryReturnResult(NID_UI, pTouchManager, E_SYSTEM, "[E_SYSTEM] System error occurred. "); + + if (pControl == null) + { + if (mouseInfo.GetTouchStatus() == _TOUCH_RELEASED) + { + pTouchManager->ResetTouchInfo(); + } + + return E_SUCCESS; + } + + return E_INVALID_CONDITION; +} + +bool +_UiMouseEvent::ExistGlobalGesture(void) +{ + _ControlManager* pControlManager = _ControlManager::GetInstance(); + SysTryReturn(NID_UI, pControlManager, false, E_SYSTEM, "[E_SYSTEM] System error occurred."); + + bool exist = false; + + IListT<_TouchGestureDetector*>* pGestureList = pControlManager->GetGestureDetectorList(); + if (pGestureList && (pGestureList->GetCount() > 0)) + { + exist = true; + } + + return exist; +} + }} // Tizen::Ui diff --git a/src/ui/controls/FUiCtrl_Form.cpp b/src/ui/controls/FUiCtrl_Form.cpp index fb36501..7f29ee4 100644 --- a/src/ui/controls/FUiCtrl_Form.cpp +++ b/src/ui/controls/FUiCtrl_Form.cpp @@ -48,6 +48,7 @@ #include "FUiCtrl_IFormBackEventListener.h" #include "FUiCtrl_Indicator.h" #include "FUi_SystemUtilImpl.h" +#include "FUiCtrl_FormImpl.h" using namespace std; using namespace Tizen::Ui::Animations; @@ -2498,6 +2499,58 @@ _Form::SetFooterBounds(Rectangle& bounds) return r; } +bool +_Form::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo) +{ + return false; +} + +bool +_Form::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo) +{ + return false; +} + +bool +_Form::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo) +{ + return false; +} + +bool +_Form::OnTouchCanceled(const _Control & source, const _TouchInfo & touchinfo) +{ + return false; +} + +bool +_Form::OnMousePressed(const _Control& source, const _MouseInfo& mouseinfo) +{ + return false; +} + +bool +_Form::OnMouseReleased(const _Control& source, const _MouseInfo& mouseinfo) +{ + _Toolbar* pToolbar = GetFooter(); + if (pToolbar == null) + { + return null; + } + + if (pToolbar->IsButtonSet(BACK_BUTTON)) + { + void* pData = GetUserData(); + if (pData) + { + _FormImpl* pDataImpl = static_cast<_FormImpl*>(pData); + pDataImpl->OnFormBackRequested(*this); + } + } + + return true; +} + result _Form::SetFooterBounds(FloatRectangle& bounds) { diff --git a/src/ui/inc/FUiCtrl_Form.h b/src/ui/inc/FUiCtrl_Form.h index dd7909d..8f220ad 100644 --- a/src/ui/inc/FUiCtrl_Form.h +++ b/src/ui/inc/FUiCtrl_Form.h @@ -184,6 +184,13 @@ public: result SetIndicatorShowState(bool state, bool hide = false); result SetIndicatorOpacity(_IndicatorOpacity opacity); + virtual bool OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo); + virtual bool OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo); + virtual bool OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo); + virtual bool OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo); + virtual bool OnMousePressed(const _Control& source, const _MouseInfo& mouseinfo); + virtual bool OnMouseReleased(const _Control& source, const _MouseInfo& mouseinfo); + result AdjustClientBounds(void); result AddActionEventListener(Tizen::Ui::Controls::_IActionEventListener& listener); diff --git a/src/ui/inc/FUi_Control.h b/src/ui/inc/FUi_Control.h index f29c76c..286461e 100644 --- a/src/ui/inc/FUi_Control.h +++ b/src/ui/inc/FUi_Control.h @@ -213,6 +213,14 @@ public: virtual bool OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo); virtual bool OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo); virtual bool OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo); + virtual _UiTouchEventDelivery OnPreviewMousePressed(const _Control& source, const _MouseInfo& mouseinfo); + virtual _UiTouchEventDelivery OnPreviewMouseReleased(const _Control& source, const _MouseInfo& mouseinfo); + virtual _UiTouchEventDelivery OnPreviewMouseMoved(const _Control& source, const _MouseInfo& mouseinfo); + virtual _UiTouchEventDelivery OnPreviewMouseWheeled(const _Control& source, const _MouseInfo& mouseinfo); + virtual bool OnMousePressed(const _Control& source, const _MouseInfo& mouseinfo); + virtual bool OnMouseReleased(const _Control& source, const _MouseInfo& mouseinfo); + virtual bool OnMouseMoved(const _Control& source, const _MouseInfo& mouseinfo); + virtual bool OnMouseWheeled(const _Control& source, const _MouseInfo& mouseinfo); virtual bool OnFocusGained(const _Control& source); virtual bool OnFocusLost(const _Control& source); virtual bool OnPreviewNotifiedN(const _Control& source, Tizen::Base::Collection::IList* pArgs); // [ToDo] Make the notification id as enumeration. diff --git a/src/ui/inc/FUi_ControlImpl.h b/src/ui/inc/FUi_ControlImpl.h index 162d938..3b4454f 100644 --- a/src/ui/inc/FUi_ControlImpl.h +++ b/src/ui/inc/FUi_ControlImpl.h @@ -191,6 +191,16 @@ public: virtual _UiTouchEventDelivery OnPreviewTouchMoved(const _ControlImpl& source, const _TouchInfo& touchInfo); virtual _UiTouchEventDelivery OnPreviewTouchCanceled(const _ControlImpl& source, const _TouchInfo& touchInfo); + virtual _UiTouchEventDelivery OnPreviewMousePressed(const _ControlImpl& source, const _MouseInfo& mouseinfo); + virtual _UiTouchEventDelivery OnPreviewMouseReleased(const _ControlImpl& source, const _MouseInfo& mouseinfo); + virtual _UiTouchEventDelivery OnPreviewMouseMoved(const _ControlImpl& source, const _MouseInfo& mouseinfo); + virtual _UiTouchEventDelivery OnPreviewMouseWheeled(const _ControlImpl& source, const _MouseInfo& mouseinfo); + + virtual bool OnMousePressed(const _ControlImpl& source, const _MouseInfo& mouseinfo); + virtual bool OnMouseReleased(const _ControlImpl& source, const _MouseInfo& mouseinfo); + virtual bool OnMouseMoved(const _ControlImpl& source, const _MouseInfo& mouseinfo); + virtual bool OnMouseWheeled(const _ControlImpl& source, const _MouseInfo& mouseinfo); + virtual bool OnFocusGained(const _ControlImpl& source); virtual bool OnFocusLost(const _ControlImpl& source); virtual bool OnNotifiedN(const _ControlImpl& source, Tizen::Base::Collection::IList* pArgs); diff --git a/src/ui/inc/FUi_ITouchEventListener.h b/src/ui/inc/FUi_ITouchEventListener.h index 0a512be..3ee05b3 100644 --- a/src/ui/inc/FUi_ITouchEventListener.h +++ b/src/ui/inc/FUi_ITouchEventListener.h @@ -95,6 +95,14 @@ public: * @param[in] touchInfo The touch event information */ virtual bool OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo) = 0; + + virtual bool OnMousePressed(const _Control& source, const _MouseInfo& mouseinfo){return false;} + + virtual bool OnMouseReleased(const _Control& source, const _MouseInfo& mouseinfo){return false;} + + virtual bool OnMouseMoved(const _Control& source, const _MouseInfo& mouseinfo){return false;} + + virtual bool OnMouseWheeled(const _Control& source, const _MouseInfo& mouseinfo){return false;} }; // _ITouchEventListener }} // Tizen::Ui diff --git a/src/ui/inc/FUi_ITouchEventPreviewer.h b/src/ui/inc/FUi_ITouchEventPreviewer.h index c5291ae..a1843f0 100644 --- a/src/ui/inc/FUi_ITouchEventPreviewer.h +++ b/src/ui/inc/FUi_ITouchEventPreviewer.h @@ -34,6 +34,7 @@ namespace Tizen { namespace Ui class _Control; class _TouchInfo; +class _MouseInfo; /** * @interface _ITouchEventPreviewer @@ -96,6 +97,14 @@ public: * @param[in] touchInfo The touch event information */ virtual _UiTouchEventDelivery OnPreviewTouchCanceled(const _Control& source, const _TouchInfo& touchinfo) = 0; + + virtual _UiTouchEventDelivery OnPreviewMousePressed(const _Control& source, const _MouseInfo& mouseinfo){return _UI_TOUCH_EVENT_DELIVERY_YES;} + + virtual _UiTouchEventDelivery OnPreviewMouseReleased(const _Control& source, const _MouseInfo& mouseinfo){return _UI_TOUCH_EVENT_DELIVERY_YES;} + + virtual _UiTouchEventDelivery OnPreviewMouseMoved(const _Control& source, const _MouseInfo& mouseinfo){return _UI_TOUCH_EVENT_DELIVERY_YES;} + + virtual _UiTouchEventDelivery OnPreviewMouseWheeled(const _Control& source, const _MouseInfo& mouseinfo){return _UI_TOUCH_EVENT_DELIVERY_YES;} }; // _ITouchEventPreviewer }} // Tizen::Ui diff --git a/src/ui/inc/FUi_UiTouchEvent.h b/src/ui/inc/FUi_UiTouchEvent.h index b738b68..63c9ddf 100644 --- a/src/ui/inc/FUi_UiTouchEvent.h +++ b/src/ui/inc/FUi_UiTouchEvent.h @@ -43,6 +43,15 @@ enum _TouchStatus _TOUCH_FOCUS_IN = TOUCH_FOCUS_IN, /**< Touch focus-in event type */ _TOUCH_FOCUS_OUT = TOUCH_FOCUS_OUT, /**< Touch focus-out event type */ _TOUCH_CANCELED = TOUCH_CANCELED, /**< Touch canceled event type */ + _WHEEL_MOVED = TOUCH_CANCELED+1, /**< Touch moved event type */ +}; + +enum _MouseButtons +{ + _MOUSE_BUTTON_NONE = 0, + _MOUSE_BUTTON_LEFT, + _MOUSE_BUTTON_WHEEL, + _MOUSE_BUTTON_RIGHT }; class _OSP_EXPORT_ _TouchInfo @@ -93,6 +102,59 @@ private: long long __timeStamp; }; // _TouchInfo +class _OSP_EXPORT_ _MouseInfo +{ +public: + _MouseInfo(void); + _MouseInfo(unsigned long pointId, _TouchStatus status, const Tizen::Graphics::FloatPoint& current, int zAxis, int buttons, const bool isFlick, long long timeStamp); + _MouseInfo(const _MouseInfo& rhs); + _MouseInfo& operator =(const _MouseInfo& rhs); + ~_MouseInfo(void); + +public: + /** + * This method returns the touch status. + * + * @since 2.0 + * @return The touch status + */ + _TouchStatus GetTouchStatus(void) const; + + /** + * This method returns the current position of the touch event. + * + * @since 2.0 + * @return The current position of the touch event + */ + Tizen::Graphics::FloatPoint GetCurrentPosition(void) const; + + /** + * This method returns the touch pointId. + * + * @since 2.0 + * @return The touch pointId + */ + unsigned long GetPointId(void) const; + + int GetZAxis(void) const; + + int GetButtons(void) const; + + bool IsFlicked(void) const; + long long GetTimeStamp(void) const; + void SetTouchInfo(unsigned long pointId, _TouchStatus status, Tizen::Graphics::Point& current, int zAxis, int buttons, bool isFlick, long long timeStamp); + void SetTouchInfo(unsigned long pointId, _TouchStatus status, Tizen::Graphics::FloatPoint& current, int zAxis, int buttons, bool isFlick, long long timeStamp); + +private: + unsigned long __pointId; + _TouchStatus __touchStatus; + Tizen::Graphics::FloatPoint __currentPosition; + int __zAxis; + int __buttons; + bool __isFlicked; + long long __timeStamp; +}; // _TouchInfo + class _ITouchEventListener; class _Control; @@ -148,6 +210,58 @@ private: std::tr1::shared_ptr > __pForcedControlList; }; // _UiTouchEvent +/** +* This is internal. If used in an application, the application can get rejected during the certification process. +* @class _UiMouseEvent +* @brief This class impliments _UiMouseEvent and +* fire the Window Event object of a Ui Control. +*/ +class _OSP_EXPORT_ _UiMouseEvent + : public _UiEvent +{ +// Lifecycle +public: + /** + * This is the default class constructor. + * + */ + _UiMouseEvent(const _UiObjectHandle& destination, const _MouseInfo& mouseInfo, _UiEventRouteType routeType = _UI_EVENT_ROUTE_TUNNEL_BUBBLE, const _UiObjectHandle& source = _UiObjectHandle()); + _UiMouseEvent(const _UiMouseEvent& rhs); + + /** + * This is the default class destructor. + * + */ + virtual ~_UiMouseEvent(void); + +public: + _UiMouseEvent& operator =(const _UiMouseEvent& rhs); + +public: + const _MouseInfo* GetTouchInfo(void) const; + +private: + virtual _UiMouseEvent* CloneN(void) const; + virtual _UiEventType GetEventType(void) const; + virtual bool IsEventEnabled(const _Control& control) const; + virtual result OnPreviewEventProcessing(const _Control& control, bool& isFiltered); + virtual result OnEventProcessing(const _Control& control, bool& isFiltered); + virtual result OnListenerProcessing(const _IUiEventListener& listener, bool& isFiltered); + virtual result OnEventHandled(const _Control& control); + +private: + result ProcessGesture(const _Control& control, bool& isFiltered); + result FireListener(const _ITouchEventListener* pListener, const _Control* pControl, bool isTouchEvent, bool& isFiltered); + result FirePreviewListener(const _ITouchEventPreviewer* pListener, const _Control* pControl, bool& isFiltered); + Tizen::Graphics::FloatPoint GetRelativePoint(const _Control& control, const Tizen::Graphics::FloatPoint& point) const; + result ResetTouchInfo(const _Control* pControl, const _MouseInfo& mouseInfo); + bool ExistGlobalGesture(void); + +private: + _MouseInfo __mouseInfo; + std::tr1::shared_ptr > __pForcedControlList; +}; + }} // Tizen::Ui #endif //_FUI_INTERNAL_UI_TOUCH_EVENT_H_ -- 2.7.4