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)
{
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);
}
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;
}
}
-
+ if (pControl != null)
+ {
return pControl;
}
+ }
int count = GetWindowCount();
if (count != 0)
{
#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)
_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<int>(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<float>(x), static_cast<float>(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<float>(x - winBounds.x);
+ ptf.y = static_cast<float>(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)
{
Ecore_Event_Mouse_Button* pEv = static_cast <Ecore_Event_Mouse_Button*>(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; i<DEVICE_COUNT; i++)
+ {
+ touchPressed[pEv->multi.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();
}
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);
Ecore_Event_Mouse_Button* pEv = static_cast <Ecore_Event_Mouse_Button*>(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();
}
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.");
}
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 <Ecore_X_Event_Window_Property*>(pEventInfo);
{
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;
__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)
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
#include "FUiCtrl_IFormBackEventListener.h"
#include "FUiCtrl_Indicator.h"
#include "FUi_SystemUtilImpl.h"
+#include "FUiCtrl_FormImpl.h"
using namespace std;
using namespace Tizen::Ui::Animations;
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)
{
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);
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.
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);
* @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
class _Control;
class _TouchInfo;
+class _MouseInfo;
/**
* @interface _ITouchEventPreviewer
* @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
_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
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;
std::tr1::shared_ptr<Tizen::Base::Collection::IListT<_Control*> > __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<Tizen::Base::Collection::IListT<_Control*> > __pForcedControlList;
+};
+
}} // Tizen::Ui
#endif //_FUI_INTERNAL_UI_TOUCH_EVENT_H_
projects / platform / framework / native / uifw.git / commitdiff