*
* The file contains the definition of _Web class.
*/
+#include <Elementary.h>
#include <memory>
#include <FBaseByteBuffer.h>
#include <FBaseColLinkedListT.h>
#include <FBaseSysLog.h>
#include <FBaseColIListT.h>
+#include <FGrpFloatPoint.h>
#include <FGrpPoint.h>
#include <FGrpBitmap.h>
#include <FGrpCanvas.h>
+#include <FGrpFloatRectangle.h>
+#include <FSysVibrator.h>
#include <FWebCtrlWebSetting.h>
#include <FGrp_CoordinateSystem.h>
+#include <FSys_VibratorImpl.h>
#include <FUiAnim_EflNode.h>
#include <FUiAnim_VisualElement.h>
+#include <FUiAnim_VisualElementImpl.h>
+#include <FUi_CoordinateSystemUtils.h>
+#include <FUi_AccessibilityContainer.h>
+#include <FUi_AccessibilityElement.h>
+#include <FUi_IAccessibilityFocusHandler.h>
+#include <FUi_IAccessibilityListener.h>
+#include <FUi_Math.h>
#include <FUi_TouchManager.h>
#include "FWebCtrl_EflWebkit.h"
#include "FWebCtrl_GestureState.h"
using namespace Tizen::Ui::Animations;
+namespace
+{
+
+
+class _WebAccessibilityListener
+ : public Tizen::Ui::_IAccessibilityListener
+{
+public:
+ _WebAccessibilityListener(Evas_Object* pView);
+
+ virtual ~_WebAccessibilityListener(void);
+
+ virtual bool OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element);
+
+ virtual bool OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element);
+
+ virtual bool OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element);
+
+ virtual bool OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element);
+
+ virtual bool OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element);
+
+ virtual bool OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element);
+
+ virtual bool OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element);
+
+ virtual bool OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element);
+
+ virtual bool OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element);
+
+private:
+ Evas_Object* __pView;
+};
+
+
+_WebAccessibilityListener::_WebAccessibilityListener(Evas_Object* pView)
+ : __pView(pView)
+{
+}
+
+
+_WebAccessibilityListener::~_WebAccessibilityListener(void)
+{
+}
+
+
+bool
+_WebAccessibilityListener::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
+{
+ return true;
+}
+
+
+bool
+_WebAccessibilityListener::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
+{
+ return true;
+}
+
+
+bool
+_WebAccessibilityListener::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
+{
+ return true;
+}
+
+
+bool
+_WebAccessibilityListener::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
+{
+ return true;
+}
+
+
+bool
+_WebAccessibilityListener::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
+{
+ return true;
+}
+
+
+bool
+_WebAccessibilityListener::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
+{
+ Ewk_View_Smart_Data* pSmartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(__pView));
+ SysAssertf(pSmartData, "Failed to get webkit smart data.");
+
+ Elm_Access_Action_Info* pActionInfo = new Elm_Access_Action_Info();
+ SysTryReturn(NID_WEB_CTRL, pActionInfo, false, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ bool result = false;
+
+ pActionInfo->action_type = ELM_ACCESS_ACTION_UNHIGHLIGHT;
+
+ result = pSmartData->api->screen_reader_action_execute(pSmartData, pActionInfo);
+ delete pActionInfo;
+
+ return result;
+}
+
+
+bool
+_WebAccessibilityListener::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
+{
+ Ewk_View_Smart_Data* pSmartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(__pView));
+ SysAssertf(pSmartData, "Failed to get webkit smart data.");
+
+ Elm_Access_Action_Info* pActionInfo = new Elm_Access_Action_Info();
+ SysTryReturn(NID_WEB_CTRL, pActionInfo, false, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ bool result = false;
+
+ pActionInfo->action_type = ELM_ACCESS_ACTION_ACTIVATE;
+
+ result = pSmartData->api->screen_reader_action_execute(pSmartData, pActionInfo);
+ delete pActionInfo;
+
+ return result;
+}
+
+
+bool
+_WebAccessibilityListener::OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
+{
+ return true;
+}
+
+
+bool
+_WebAccessibilityListener::OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
+{
+ return true;
+}
+
+
+class _WebAccessibilityFocusHandler
+ : public Tizen::Ui::_IAccessibilityFocusHandler
+{
+public:
+ _WebAccessibilityFocusHandler(Evas_Object* pView);
+
+ virtual ~_WebAccessibilityFocusHandler(void);
+
+ virtual bool OnMoveFocus(Tizen::Ui::_AccessibilityFocusDirection direction);
+
+ virtual bool OnMoveFocus(const Tizen::Graphics::Point& point);
+
+private:
+ Evas_Object* __pView;
+};
+
+
+_WebAccessibilityFocusHandler::_WebAccessibilityFocusHandler(Evas_Object* pView)
+ : __pView(pView)
+{
+}
+
+
+_WebAccessibilityFocusHandler::~_WebAccessibilityFocusHandler(void)
+{
+}
+
+
+bool
+_WebAccessibilityFocusHandler::OnMoveFocus(Tizen::Ui::_AccessibilityFocusDirection direction)
+{
+ Ewk_View_Smart_Data* pSmartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(__pView));
+ SysAssertf(pSmartData, "Failed to get webkit smart data.");
+
+ Elm_Access_Action_Info* pActionInfo = new Elm_Access_Action_Info();
+ SysTryReturn(NID_WEB_CTRL, pActionInfo, false, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ bool result = false;
+
+ if (direction == Tizen::Ui::_ACCESSIBILITY_FOCUS_DIRECTION_PREVIOUS)
+ {
+ pActionInfo->action_type = ELM_ACCESS_ACTION_HIGHLIGHT;
+
+ pActionInfo->action_by = ELM_ACCESS_ACTION_HIGHLIGHT_PREV;
+
+ result = pSmartData->api->screen_reader_action_execute(pSmartData, pActionInfo);
+ }
+ else if (direction == Tizen::Ui::_ACCESSIBILITY_FOCUS_DIRECTION_NEXT)
+ {
+ pActionInfo->action_type = ELM_ACCESS_ACTION_HIGHLIGHT;
+
+ pActionInfo->action_by = ELM_ACCESS_ACTION_HIGHLIGHT_NEXT;
+
+ result = pSmartData->api->screen_reader_action_execute(pSmartData, pActionInfo);
+ }
+ delete pActionInfo;
+
+ return result;
+}
+
+
+bool
+_WebAccessibilityFocusHandler::OnMoveFocus(const Tizen::Graphics::Point& point)
+{
+ Ewk_View_Smart_Data* pSmartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(__pView));
+ SysAssertf(pSmartData, "Failed to get webkit smart data.");
+
+ Elm_Access_Action_Info* pActionInfo = new Elm_Access_Action_Info();
+ SysTryReturn(NID_WEB_CTRL, pActionInfo, false, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ bool result = false;
+
+ pActionInfo->action_type = ELM_ACCESS_ACTION_READ;
+ pActionInfo->x = point.x;
+ pActionInfo->y = point.y;
+
+ result = pSmartData->api->screen_reader_action_execute(pSmartData, pActionInfo);
+ delete pActionInfo;
+
+ return result;
+}
+
+
+}
+
+
namespace Tizen { namespace Web { namespace Controls
{
static const char WEB_CTRL[] = "webcontrol";
+void
+OnEdgeLeft(void* pUserData, Evas_Object* pView, void* pEventInfo)
+{
+ _Web* pCore = reinterpret_cast< _Web* >(pUserData);
+ SysAssertf(pCore, "Failed to request");
+
+ pCore->SetEdgeReachedEvent(WEB_EDGE_LEFT);
+}
+
+
+void
+OnEdgeRight(void* pUserData, Evas_Object* pView, void* pEventInfo)
+{
+ _Web* pCore = reinterpret_cast< _Web* >(pUserData);
+ SysAssertf(pCore, "Failed to request");
+
+ pCore->SetEdgeReachedEvent(WEB_EDGE_RIGHT);
+}
+
+
+void
+OnEdgeTop(void* pUserData, Evas_Object* pView, void* pEventInfo)
+{
+ _Web* pCore = reinterpret_cast< _Web* >(pUserData);
+ SysAssertf(pCore, "Failed to request");
+
+ pCore->SetEdgeReachedEvent(WEB_EDGE_TOP);
+}
+
+
+void
+OnEdgeBottom(void* pUserData, Evas_Object* pView, void* pEventInfo)
+{
+ _Web* pCore = reinterpret_cast< _Web* >(pUserData);
+ SysAssertf(pCore, "Failed to request");
+
+ pCore->SetEdgeReachedEvent(WEB_EDGE_BOTTOM);
+}
+
+
_Web::_Web(void)
: __pGestureHandler(null)
, __pEflWebkit(null)
+ , __pWebSetting(null)
, __pGestureFlick(null)
, __pGestureLongPress(null)
+ , __pGesturePinch(null)
, __pGestureDoubleTap(null)
, __pTouchEventInfoList(null)
, __pTapGestureHandler(null)
- , __pDoubleTapGestureHandler(null)
, __pPanningGestureHandler(null)
, __pFlickGestureHandler(null)
, __pPinchGestureHandler(null)
+ , __gestureType(WEB_GESTURE_TYPE_TAP)
+ , __edgeType(WEB_EDGE_NONE)
+ , __pTextElement(null)
+ , __previousTouchedPosition(0.0f, 0.0f)
{
SetBackgroundColor(Color(0, 0, 0, 0));
}
std::unique_ptr<_Web> pWeb(new (std::nothrow) _Web());
SysTryReturn(NID_WEB_CTRL, pWeb.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+ pWeb->__pWebSetting = std::unique_ptr<WebSetting>(new (std::nothrow) WebSetting());
+ SysTryReturn(NID_WEB_CTRL, pWeb->__pWebSetting.get(), null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
pWeb->AcquireHandle();
pWeb->SetMultiTouchEnabled(true);
- pWeb->SetTouchMoveAllowance(TOUCH_MOVE_ALLOWANCE_NORMAL);
+ pWeb->SetTouchPressThreshold(0.08);
r = pWeb->AddGestureListeners();
SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
std::unique_ptr<_EflWebkit> pEflWebkit(new (std::nothrow) _EflWebkit());
SysTryReturnResult(NID_WEB_CTRL, pEflWebkit.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
- r = pEflWebkit->Construct(GetAbsoluteBounds(), *GetVisualElement());
+ _VisualElement* pVe = GetVisualElement();
+ r = pEflWebkit->Construct(GetAbsoluteBounds(), *pVe, this);
SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
+ _VisualElementImpl* pVeImpl = _VisualElementImpl::GetInstance(*pVe);
+ pVeImpl->SetCaptureProvider(this);
+
__pEflWebkit = std::move(pEflWebkit);
+ Evas_Object* pView = GetWebNativeNode();
+ evas_object_smart_callback_add(pView, "edge,left", OnEdgeLeft, this);
+ evas_object_smart_callback_add(pView, "edge,right", OnEdgeRight, this);
+ evas_object_smart_callback_add(pView, "edge,top", OnEdgeTop, this);
+ evas_object_smart_callback_add(pView, "edge,bottom", OnEdgeBottom, this);
+
return E_SUCCESS;
}
__pPinchGestureHandler = std::unique_ptr<_PinchGestureState>(new (std::nothrow) _PinchGestureState(this));
SysTryReturnResult(NID_WEB_CTRL, __pPinchGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
- __pTapGestureHandler = std::unique_ptr<_TapGestureState>(new (std::nothrow) _TapGestureState(this, __pPinchGestureHandler.get()));
+ __pTapGestureHandler = std::unique_ptr<_TapGestureState>(new (std::nothrow) _TapGestureState(this));
SysTryReturnResult(NID_WEB_CTRL, __pTapGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
- __pDoubleTapGestureHandler = std::unique_ptr<_DoubleTapGestureState>(new (std::nothrow) _DoubleTapGestureState(this));
- SysTryReturnResult(NID_WEB_CTRL, __pDoubleTapGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
-
- __pPanningGestureHandler = std::unique_ptr<_PanningGestureState>(new (std::nothrow) _PanningGestureState(this, __pPinchGestureHandler.get()));
+ __pPanningGestureHandler = std::unique_ptr<_PanningGestureState>(new (std::nothrow) _PanningGestureState(this));
SysTryReturnResult(NID_WEB_CTRL, __pPanningGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
__pFlickGestureHandler = std::unique_ptr<_FlickGestureState>(new (std::nothrow) _FlickGestureState(this));
{
result r = E_SUCCESS;
- _ITouchFlickGestureEventListener* pFlickListener = dynamic_cast< _ITouchFlickGestureEventListener* >(this);
- SysAssertf(pFlickListener != null, "Failed to get flick gesture listener");
-
std::unique_ptr<_TouchFlickGestureDetector> pGestureFlick(new (std::nothrow) _TouchFlickGestureDetector());
SysTryReturnResult(NID_WEB_CTRL, pGestureFlick.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
- r = pGestureFlick->AddGestureListener(*pFlickListener);
+ r = pGestureFlick->AddGestureListener(*this);
SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
r = AddGestureDetector(*pGestureFlick.get());
__pGestureFlick = std::move(pGestureFlick);
- _ITouchLongPressGestureEventListener* pLongPressListener = dynamic_cast< _ITouchLongPressGestureEventListener* >(this);
- SysAssertf(pLongPressListener != null, "Failed to get longpress gesture listener");
-
std::unique_ptr<_TouchLongPressGestureDetector> pGestureLongPress(new (std::nothrow) _TouchLongPressGestureDetector());
SysTryReturnResult(NID_WEB_CTRL, pGestureLongPress.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
- r = pGestureLongPress->AddGestureListener(*pLongPressListener);
+ r = pGestureLongPress->AddGestureListener(*this);
SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
r = AddGestureDetector(*pGestureLongPress.get());
__pGestureLongPress = std::move(pGestureLongPress);
- _ITouchTapGestureEventListener* pDoubleTapListener = dynamic_cast< _ITouchTapGestureEventListener* >(this);
- SysAssertf(pDoubleTapListener != null, "Failed to get tap gesture listener");
-
std::unique_ptr<_TouchTapGestureDetector> pGestureDoubleTap(new (std::nothrow) _TouchTapGestureDetector());
SysTryReturnResult(NID_WEB_CTRL, pGestureDoubleTap.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
- r = pGestureDoubleTap->AddGestureListener(*pDoubleTapListener);
+ r = pGestureDoubleTap->AddGestureListener(*this);
SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
r = AddGestureDetector(*pGestureDoubleTap.get());
__pGestureDoubleTap = std::move(pGestureDoubleTap);
+ std::unique_ptr<_TouchPinchGestureDetector> pGesturePinch(new (std::nothrow) _TouchPinchGestureDetector());
+ SysTryReturnResult(NID_WEB_CTRL, pGesturePinch.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ r = pGesturePinch->AddGestureListener(*this);
+ SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
+
+ r = AddGestureDetector(*pGesturePinch.get());
+ SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
+
+ __pGesturePinch = std::move(pGesturePinch);
+
return E_SUCCESS;
}
{
if (__pGestureFlick.get())
{
- _ITouchFlickGestureEventListener* pListener = dynamic_cast< _ITouchFlickGestureEventListener* >(this);
- __pGestureFlick->RemoveGestureListener(*pListener);
+ __pGestureFlick->RemoveGestureListener(*this);
RemoveGestureDetector(*__pGestureFlick);
}
if (__pGestureLongPress.get())
{
- _ITouchLongPressGestureEventListener* pListener = dynamic_cast< _ITouchLongPressGestureEventListener* >(this);
- __pGestureLongPress->RemoveGestureListener(*pListener);
+ __pGestureLongPress->RemoveGestureListener(*this);
RemoveGestureDetector(*__pGestureLongPress);
}
if (__pGestureDoubleTap.get())
{
- _ITouchTapGestureEventListener* pListener = dynamic_cast< _ITouchTapGestureEventListener* >(this);
- __pGestureDoubleTap->RemoveGestureListener(*pListener);
+ __pGestureDoubleTap->RemoveGestureListener(*this);
RemoveGestureDetector(*__pGestureDoubleTap);
}
+
+ if (__pGesturePinch.get())
+ {
+ __pGesturePinch->RemoveGestureListener(*this);
+ RemoveGestureDetector(*__pGesturePinch);
+ }
+
+ Evas_Object* pView = GetWebNativeNode();
+ if (pView)
+ {
+ evas_object_smart_callback_del(pView, "edge,left", OnEdgeLeft);
+ evas_object_smart_callback_del(pView, "edge,right", OnEdgeRight);
+ evas_object_smart_callback_del(pView, "edge,top", OnEdgeTop);
+ evas_object_smart_callback_del(pView, "edge,bottom", OnEdgeBottom);
+ }
}
SetNativeObjectFocusable(false);
+ _AccessibilityContainer* pContainer = GetAccessibilityContainer();
+ SysTryReturn(NID_WEB_CTRL, pContainer, E_SYSTEM, E_SYSTEM, "[%s] Propagating.", GetErrorMessage(E_SYSTEM));
+
+ __pTextElement = new (std::nothrow) _AccessibilityElement(true);
+ SysTryReturn(NID_WEB_CTRL, __pTextElement, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ __pTextElement->SetBounds(FloatRectangle(0.0f, 0.0f, GetBoundsF().width, GetBoundsF().height));
+ __pTextElement->SetLabel(L"Web control");
+
+ pContainer->AddElement(*__pTextElement);
+ pContainer->Activate(true);
+
+ _WebAccessibilityListener* pListener = new (std::nothrow) _WebAccessibilityListener(GetWebNativeNode());
+ SysTryReturn(NID_WEB_CTRL, pListener, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ pContainer->AddListener(*dynamic_cast<_IAccessibilityListener*>(pListener));
+
+ _WebAccessibilityFocusHandler* pFocusHandler = new (std::nothrow) _WebAccessibilityFocusHandler(GetWebNativeNode());
+ SysTryReturn(NID_WEB_CTRL, pFocusHandler, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ pContainer->SetFocusHandler(dynamic_cast<_IAccessibilityFocusHandler*>(pFocusHandler));
+
return E_SUCCESS;
}
Point
_Web::GetAbsoluteCoordinate(Point relativePoint)
{
- _ICoordinateSystemTransformer* pXformer = _CoordinateSystem::GetInstance()->GetTransformer();
- SysAssertf(pXformer, "Failed to get coordinate transformer.");
+ return _CoordinateSystemUtils::Transform(ConvertToScreenPosition(relativePoint));
+}
- int absX = pXformer->TransformHorizontal(relativePoint.x + GetAbsoluteBounds().x);
- int absY = pXformer->TransformVertical(relativePoint.y + GetAbsoluteBounds().y);
- return Point(absX, absY);
+FloatPoint
+_Web::GetAbsoluteCoordinate(FloatPoint relativePoint)
+{
+ return _CoordinateSystemUtils::Transform(ConvertToScreenPosition(relativePoint));
}
Point
_Web::GetRelativeCoordinate(Point absolutePoint)
{
- _ICoordinateSystemTransformer* pXformer = _CoordinateSystem::GetInstance()->GetInverseTransformer();
- SysAssertf(pXformer, "Failed to get coordinate transformer.");
-
- Point bound(GetAbsoluteCoordinate(Point(0, 0)));
+ return ConvertToControlPosition(_CoordinateSystemUtils::InverseTransform(absolutePoint));
+}
- int absX = pXformer->TransformHorizontal(absolutePoint.x - bound.x);
- int absY = pXformer->TransformVertical(absolutePoint.y - bound.y);
- return Point(absX, absY);
+FloatPoint
+_Web::GetRelativeCoordinate(FloatPoint absolutePoint)
+{
+ return ConvertToControlPosition(_CoordinateSystemUtils::InverseTransform(absolutePoint));
}
Evas_Object*
_Web::GetWebNativeNode(void)
{
- SysTryReturn(NID_WEB_CTRL, __pEflWebkit, null, E_INVALID_STATE, "[%s] Native node is in an invalid state.", GetErrorMessage(E_INVALID_STATE));
-
- return __pEflWebkit->GetWebEvasObject();
-}
-
+ if (__pEflWebkit.get())
+ {
+ return __pEflWebkit->GetWebEvasObject();
+ }
-void
-_Web::SetWebSettingImpl(_WebSettingImpl* pWebSettingImpl)
-{
- __pWebSettingImpl = pWebSettingImpl;
+ return null;
}
-_WebSettingImpl*
-_Web::GetWebSettingImpl(void) const
+WebSetting*
+_Web::GetSetting(void) const
{
- return __pWebSettingImpl;
+ return __pWebSetting.get();
}
result
_Web::OnAttaching(const _Control* pParent)
{
- if (__pEflWebkit)
+ if (__pEflWebkit.get())
{
evas_object_show(__pEflWebkit->GetWebEvasObject());
evas_object_focus_set(__pEflWebkit->GetWebEvasObject(), EINA_TRUE);
_ICoordinateSystemTransformer* pXformer = _CoordinateSystem::GetInstance()->GetTransformer();
SysTryReturnResult(NID_WEB_CTRL, pXformer, E_SYSTEM, "[%s] A system error has been occurred. Failed to get coordinate transformer.", GetErrorMessage(E_SYSTEM));
- if (__pEflWebkit)
+ if (__pEflWebkit.get())
{
evas_object_move(__pEflWebkit->GetWebEvasObject(), pXformer->TransformHorizontal(absoluteBounds.x - webBounds.x + bounds.x), pXformer->TransformVertical(absoluteBounds.y - webBounds.y + bounds.y));
evas_object_resize(__pEflWebkit->GetWebEvasObject(), pXformer->TransformHorizontal(bounds.width), pXformer->TransformVertical(bounds.height));
{
case WEB_GESTURE_TYPE_TAP:
__pGestureHandler = __pTapGestureHandler.get();
+ __gestureType = WEB_GESTURE_TYPE_TAP;
break;
- case WEB_GESTURE_TYPE_DOUBLE_TAP:
- __pGestureHandler = __pDoubleTapGestureHandler.get();
- break;
-
case WEB_GESTURE_TYPE_PANNING:
__pGestureHandler = __pPanningGestureHandler.get();
+ __gestureType = WEB_GESTURE_TYPE_PANNING;
break;
case WEB_GESTURE_TYPE_FLICK:
__pGestureHandler = __pFlickGestureHandler.get();
+ __gestureType = WEB_GESTURE_TYPE_FLICK;
break;
case WEB_GESTURE_TYPE_PINCH:
__pGestureHandler = __pPinchGestureHandler.get();
+ __gestureType = WEB_GESTURE_TYPE_PINCH;
+ break;
+
+ default:
+ SysAssert(false);
+ }
+}
+
+
+void
+_Web::SetEdgeReachedEvent(_WebEdgeType type)
+{
+ __edgeType |= type;
+
+ switch(type)
+ {
+ case WEB_EDGE_LEFT:
+ __edgeType &= ~WEB_EDGE_RIGHT;
+ break;
+
+ case WEB_EDGE_RIGHT:
+ __edgeType &= ~WEB_EDGE_LEFT;
+ break;
+
+ case WEB_EDGE_TOP:
+ __edgeType &= ~WEB_EDGE_BOTTOM;
+ break;
+
+ case WEB_EDGE_BOTTOM:
+ __edgeType &= ~WEB_EDGE_TOP;
break;
default:
bool
_Web::OnTouchPressed(const _Control& source, const _TouchInfo& touchInfo)
{
- SendTouchEventForJavaScript(touchInfo);
+ if (__pEflWebkit.get())
+ {
+ __edgeType = WEB_EDGE_NONE;
+ __previousTouchedPosition = touchInfo.GetCurrentPosition();
- __pGestureHandler->OnTouchPressed(source, touchInfo);
+ SendTouchEventForJavaScript(touchInfo);
- return true;
+ return __pGestureHandler->OnTouchPressed(source, touchInfo);
+ }
+
+ return false;
}
bool
_Web::OnTouchMoved(const _Control& source, const _TouchInfo& touchInfo)
{
- SendTouchEventForJavaScript(touchInfo);
+ if (__pEflWebkit.get())
+ {
+ SendTouchEventForJavaScript(touchInfo);
- __pGestureHandler->OnTouchMoved(source, touchInfo);
+ __pGestureHandler->OnTouchMoved(source, touchInfo);
- return true;
+ float scrollDistanceX = __previousTouchedPosition.x - touchInfo.GetCurrentPosition().x;
+ float scrollDistanceY = __previousTouchedPosition.y - touchInfo.GetCurrentPosition().y;
+ __previousTouchedPosition = touchInfo.GetCurrentPosition();
+
+ if (__edgeType != WEB_EDGE_NONE && __gestureType == WEB_GESTURE_TYPE_PANNING)
+ {
+ if (_Abs(scrollDistanceY) < _Abs(scrollDistanceX))
+ {
+ if (__edgeType & WEB_EDGE_LEFT)
+ {
+ if (scrollDistanceX < 0)
+ {
+ __edgeType &= ~WEB_EDGE_RIGHT;
+
+ return false;
+ }
+ else
+ {
+ __edgeType &= ~WEB_EDGE_LEFT;
+ }
+ }
+ else if (__edgeType & WEB_EDGE_RIGHT)
+ {
+ if (scrollDistanceX > 0)
+ {
+ __edgeType &= ~WEB_EDGE_LEFT;
+
+ return false;
+ }
+ else
+ {
+ __edgeType &= ~WEB_EDGE_RIGHT;
+ }
+ }
+ }
+ else if (_Abs(scrollDistanceY) > _Abs(scrollDistanceX))
+ {
+ if (__edgeType & WEB_EDGE_TOP)
+ {
+ if (scrollDistanceY < 0)
+ {
+ __edgeType &= ~WEB_EDGE_BOTTOM;
+
+ return false;
+ }
+ else
+ {
+ __edgeType &= ~WEB_EDGE_TOP;
+ }
+ }
+ else if (__edgeType & WEB_EDGE_BOTTOM)
+ {
+ if (scrollDistanceY > 0)
+ {
+ __edgeType &= ~WEB_EDGE_TOP;
+
+ return false;
+ }
+ else
+ {
+ __edgeType &= ~WEB_EDGE_BOTTOM;
+ }
+ }
+ }
+ }
+
+ return true;
+ }
+
+ return false;
}
bool
_Web::OnTouchReleased(const _Control& source, const _TouchInfo& touchInfo)
{
- SendTouchEventForJavaScript(touchInfo);
+ SetFocused();
+
+ if (__pEflWebkit.get())
+ {
+ SendTouchEventForJavaScript(touchInfo);
+
+ Evas_Object* pView = GetWebNativeNode();
+ _WebImpl* pImpl = reinterpret_cast< _WebImpl* >(evas_object_data_get(pView, WEB_CTRL));
- __pGestureHandler->OnTouchReleased(source, touchInfo);
+ if (pImpl && pImpl->GetTextFromBlock().GetLength() > 0)
+ {
+ evas_object_smart_callback_call(pView, "text,selected", NULL);
+ }
+
+ return __pGestureHandler->OnTouchReleased(source, touchInfo);
+ }
+
+ return false;
+}
- _WebImpl* pWebImpl = reinterpret_cast<_WebImpl*>(evas_object_data_get(GetWebNativeNode(), WEB_CTRL));
- SysAssertf(pWebImpl, "Failed to get Impl");
- if (pWebImpl->GetLoadingListener() && pWebImpl->GetTextFromBlock().GetLength() > 0)
+bool
+_Web::OnTouchCanceled(const _Control& source, const _TouchInfo& touchInfo)
+{
+ if (__pEflWebkit.get())
{
- pWebImpl->FireWebPageBlockSelectedEvent();
+ SendTouchEventForJavaScript(touchInfo);
+
+ return __pGestureHandler->OnTouchCanceled(source, touchInfo);
}
- SetFocused();
+ return false;
+}
+
+
+void
+_Web::OnTouchPressHandled(const _Control& control)
+{
+}
+
+
+void
+_Web::OnTouchReleaseHandled(const _Control& control)
+{
+}
+
+
+void
+_Web::OnTouchMoveHandled(const _Control& control)
+{
+}
+
+
+void
+_Web::OnTouchCancelHandled(const _Control& control)
+{
+}
+
+
+bool
+_Web::OnLongPressGestureDetected(_TouchLongPressGestureDetector& gesture)
+{
+ if (__pEflWebkit.get() && __gestureType == WEB_GESTURE_TYPE_TAP)
+ {
+ return __pTapGestureHandler->OnLongPressGestureDetected(gesture);
+ }
return true;
}
+
bool
-_Web::OnTouchCanceled(const _Control& source, const _TouchInfo& touchInfo)
+_Web::OnLongPressGestureCanceled(_TouchLongPressGestureDetector& gesture)
+{
+ return true;
+}
+
+
+bool
+_Web::OnTapGestureDetected(_TouchTapGestureDetector& gesture)
{
- SendTouchEventForJavaScript(touchInfo);
+ if (__pEflWebkit.get())
+ {
+ return __pTapGestureHandler->OnTapGestureDetected(gesture);
+ }
+
+ return true;
+}
- __pGestureHandler->OnTouchCanceled(source, touchInfo);
+bool
+_Web::OnTapGestureCanceled(_TouchTapGestureDetector& gesture)
+{
return true;
}
bool
_Web::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
{
- if (__pWebSettingImpl->IsScrollEnabled())
+ if (__pEflWebkit.get() && _WebSettingImpl::GetInstance(__pWebSetting.get())->IsScrollEnabled())
{
- ChangeGesture(WEB_GESTURE_TYPE_FLICK);
- static_cast< _FlickGestureState* >(__pGestureHandler)->OnFlickGestureDetected(gesture);
+ return __pFlickGestureHandler->OnFlickGestureDetected(gesture);
}
return true;
bool
-_Web::OnLongPressGestureDetected(_TouchLongPressGestureDetector& gesture)
+_Web::OnPinchGestureStarted(Tizen::Ui::_TouchPinchGestureDetector& gesture)
{
- _TapGestureState* pTapGestureHandler = dynamic_cast< _TapGestureState* >(__pGestureHandler);
- if (pTapGestureHandler)
+ if (__pEflWebkit.get())
{
- pTapGestureHandler->OnLongPressGestureDetected(gesture);
+ return __pPinchGestureHandler->OnPinchGestureStarted(gesture);
}
return true;
bool
-_Web::OnLongPressGestureCanceled(_TouchLongPressGestureDetector& gesture)
+_Web::OnPinchGestureChanged(Tizen::Ui::_TouchPinchGestureDetector& gesture)
{
+ if (__pEflWebkit.get() && __gestureType == WEB_GESTURE_TYPE_PINCH)
+ {
+ return __pPinchGestureHandler->OnPinchGestureChanged(gesture);
+ }
+
return true;
}
bool
-_Web::OnTapGestureDetected(_TouchTapGestureDetector& gesture)
+_Web::OnPinchGestureFinished(Tizen::Ui::_TouchPinchGestureDetector& gesture)
{
- ChangeGesture(WEB_GESTURE_TYPE_DOUBLE_TAP);
+ if (__pEflWebkit.get() && __gestureType == WEB_GESTURE_TYPE_PINCH)
+ {
+ return __pPinchGestureHandler->OnPinchGestureFinished(gesture);
+ }
return true;
}
bool
-_Web::OnTapGestureCanceled(_TouchTapGestureDetector& gesture)
+_Web::OnPinchGestureCanceled(Tizen::Ui::_TouchPinchGestureDetector& gesture)
{
return true;
}
Canvas*
-_Web::OnCanvasRequestedN(const Dimension& size)
+_Web::OnCanvasRequestedN(const FloatRectangle& bounds)
{
- result r = E_SUCCESS;
+ SysTryReturn(NID_WEB_CTRL, bounds.width >= 0.0f && bounds.height >= 0.0f, null, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] Canvas size is out of range. size = (%f, %f)", bounds.width, bounds.height);
+ if (bounds.width == 0.0f || bounds.height == 0.0f)
+ {
+ FloatDimension size(GetSizeF());
+ SysTryReturn(NID_WEB_CTRL, bounds.x >= 0.0f && bounds.y >= 0.0f && bounds.x <= size.width && bounds.y <= size.height, null, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] Bounds is out of range.");
+ }
- Evas_Object* pWebFrame = GetWebNativeNode();
- Eina_Rectangle rect;
- BufferInfo bufferInfo;
+ result r = E_SUCCESS;
- Point absSize = GetAbsoluteCoordinate(Point(size.width, size.height));
+ Rectangle absBounds(_CoordinateSystemUtils::ConvertToInteger(_CoordinateSystemUtils::Transform(bounds)));
- EINA_RECTANGLE_SET(&rect, 0, 0, absSize.x, absSize.y);
+ Eina_Rectangle rect;
+ EINA_RECTANGLE_SET(&rect, absBounds.x, absBounds.y, absBounds.width, absBounds.height);
+ Evas_Object* pWebFrame = GetWebNativeNode();
Evas_Object* pScreenShot = ewk_view_screenshot_contents_get(pWebFrame, rect, 1.0f, evas_object_evas_get(pWebFrame));
- SysTryReturn(NID_WEB_CTRL, pScreenShot, null, E_SYSTEM, "[%s] A system error has been occurred. Failed to get snapshot of Web control", GetErrorMessage(E_SYSTEM));
-
- r = _Utility::GetPixelBufferFromEvasObject(pScreenShot, bufferInfo);
- evas_object_del(pScreenShot);
- SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
std::unique_ptr<Canvas> pCanvas(new (std::nothrow) Canvas());
SysTryReturn(NID_WEB_CTRL, pCanvas.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
- r = pCanvas->Construct(bufferInfo);
- SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
+ if (pScreenShot)
+ {
+ BufferInfo bufferInfo;
+
+ r = _Utility::GetPixelBufferFromEvasObject(pScreenShot, bufferInfo);
+ evas_object_del(pScreenShot);
+ SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
+
+ r = pCanvas->Construct(bufferInfo);
+ SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
+ }
+ else
+ {
+ r = pCanvas->Construct(bounds);
+ SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
+ }
return pCanvas.release();
}
{
result r = E_SUCCESS;
- Evas_Object* pWebFrame = GetWebNativeNode();
- Eina_Rectangle rect;
- ByteBuffer buffer;
BufferInfo bufferInfo;
+ SysTryReturn(NID_WEB_CTRL, OnCaptureAcquire(bufferInfo), null, E_SYSTEM, "[%s] A system error has been occurred. Failed to get snapshot of Web control", GetErrorMessage(E_SYSTEM));
- Dimension size = GetSize();
- Point absSize = GetAbsoluteCoordinate(Point(size.width, size.height));
-
- EINA_RECTANGLE_SET(&rect, 0, 0, absSize.x, absSize.y);
-
- Evas_Object* pScreenShot = ewk_view_screenshot_contents_get(pWebFrame, rect, 1.0f, evas_object_evas_get(pWebFrame));
- SysTryReturn(NID_WEB_CTRL, pScreenShot, null, E_SYSTEM, "[%s] A system error has been occurred. Failed to get snapshot of Web control", GetErrorMessage(E_SYSTEM));
-
- r = _Utility::GetPixelBufferFromEvasObject(pScreenShot, bufferInfo);
- evas_object_del(pScreenShot);
- SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
-
+ ByteBuffer buffer;
int bufferSize = bufferInfo.bitsPerPixel * bufferInfo.width * bufferInfo.height;
+
r = buffer.Construct(reinterpret_cast < byte* >(bufferInfo.pPixels), 0, bufferSize, bufferSize);
SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
}
+bool
+_Web::OnCaptureAcquire(BufferInfo& output)
+{
+ result r = E_SUCCESS;
+
+ FloatPoint position(GetPositionF());
+ FloatDimension size(GetSizeF());
+
+ Dimension absSize(_CoordinateSystemUtils::ConvertToInteger(_CoordinateSystemUtils::Transform(size)));
+
+ Eina_Rectangle rect;
+ EINA_RECTANGLE_SET(&rect, 0, 0, absSize.width, absSize.height);
+
+ Evas_Object* pWebFrame = GetWebNativeNode();
+ Evas_Object* pScreenShot = ewk_view_screenshot_contents_get(pWebFrame, rect, 1.0f, evas_object_evas_get(pWebFrame));
+ SysTryReturn(NID_WEB_CTRL, pScreenShot, false, E_SYSTEM, "[%s] A system error has been occurred. Failed to get snapshot of Web control", GetErrorMessage(E_SYSTEM));
+
+ r = _Utility::GetPixelBufferFromEvasObject(pScreenShot, output);
+ evas_object_del(pScreenShot);
+ SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, false, r, "[%s] propagating", GetErrorMessage(r));
+
+ return true;
+}
+
+
void
_Web::DumpPointList(void* pData)
{
Eina_List* pList = reinterpret_cast< Eina_List* >(pData);
-
+
for(; pList; pList = eina_list_next(pList))
{
Ewk_Touch_Point* pPointDump = static_cast<Ewk_Touch_Point*>(eina_list_data_get(pList));
- SysLog(NID_WEB_CTRL, "The current value of id is %lu, x is %d, y is %d, state is %d", pPointDump->id, pPointDump->x, pPointDump->y, pPointDump->state);
+ SysSecureLog(NID_WEB_CTRL, "The current value of id is %lu, x is %d, y is %d, state is %d", pPointDump->id, pPointDump->x, pPointDump->y, pPointDump->state);
}
}
Eina_List* pPointList = null;
Ewk_Touch_Point* pPoint = null;
-
+
_TouchManager* pTouchManager = _TouchManager::GetInstance();
SysAssertf(pTouchManager, "Failed to get touch manager.");
std::unique_ptr<IBidirectionalEnumeratorT<_FingerInfo*> > pTouchListEnum(pTouchList->GetBidirectionalEnumeratorN());
SysAssertf(pTouchListEnum.get() != null, "Failed to get enumerator of touch list.");
- Point currentPoint;
+ FloatPoint currentPoint;
_FingerInfo* pFingerInfo = null;
while(pTouchListEnum->MoveNext() == E_SUCCESS)
- {
+ {
r = pTouchListEnum->GetCurrent(pFingerInfo);
- SysTryReturnVoidResult(NID_WEB_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
-
+ SysTryReturnVoidResult(NID_WEB_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
+
_TouchStatus state = pFingerInfo->GetStatus();
if(state == _TOUCH_PRESSED || state == _TOUCH_MOVED || state == _TOUCH_RELEASED || state == _TOUCH_CANCELED)
{
currentPoint = GetAbsoluteCoordinate(pFingerInfo->GetPoint());
+ Point integerPoint(_CoordinateSystemUtils::ConvertToInteger(currentPoint));
pPoint = static_cast<Ewk_Touch_Point*>(calloc(1, sizeof(Ewk_Touch_Point)));
-
- pPoint->id = pFingerInfo->GetPointId();
- pPoint->x = currentPoint.x;
- pPoint->y = currentPoint.y;
+
+ pPoint->id = pFingerInfo->GetPointId();
+ pPoint->x = integerPoint.x;
+ pPoint->y = integerPoint.y;
pPoint->state = GetEvasTouchState((TouchStatus)pFingerInfo->GetStatus());
- pPointList = eina_list_append(pPointList, pPoint);
+ pPointList = eina_list_append(pPointList, pPoint);
}
}
DumpPointList(pPointList);
projects / framework / osp / web.git / blobdiff