src/controls/FWebCtrl_Web.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FWebCtrl_Web.cpp
  20  * @brief               The file contains the definition of _Web class.
  21  *
  22  * The file contains the definition of _Web class.
  23  */
  24 #include <Elementary.h>
  25 #include <memory>
  26 #include <FBaseByteBuffer.h>
  27 #include <FBaseColLinkedListT.h>
  28 #include <FBaseSysLog.h>
  29 #include <FBaseColIListT.h>
  30 #include <FGrpFloatPoint.h>
  31 #include <FGrpPoint.h>
  32 #include <FGrpBitmap.h>
  33 #include <FGrpCanvas.h>
  34 #include <FGrpFloatRectangle.h>
  35 #include <FSysVibrator.h>
  36 #include <FWebCtrlWebSetting.h>
  37 #include <FGrp_CoordinateSystem.h>
  38 #include <FSys_VibratorImpl.h>
  39 #include <FUiAnim_EflNode.h>
  40 #include <FUiAnim_VisualElement.h>
  41 #include <FUi_CoordinateSystemUtils.h>
  42 #include <FUi_AccessibilityContainer.h>
  43 #include <FUi_AccessibilityElement.h>
  44 #include <FUi_IAccessibilityFocusHandler.h>
  45 #include <FUi_IAccessibilityListener.h>
  46 #include <FUi_Math.h>
  47 #include <FUi_TouchManager.h>
  48 #include "FWebCtrl_EflWebkit.h"
  49 #include "FWebCtrl_GestureState.h"
  50 #include "FWebCtrl_Web.h"
  51 #include "FWebCtrl_WebImpl.h"
  52 #include "FWebCtrl_WebSettingImpl.h"
  53 #include "FWebCtrl_Utility.h"
  54
  55
  56 using namespace Tizen::Base;
  57 using namespace Tizen::Base::Collection;
  58 using namespace Tizen::Graphics;
  59 using namespace Tizen::Ui;
  60 using namespace Tizen::Ui::Animations;
  61
  62
  63 namespace
  64 {
  65
  66
  67 class _WebAccessibilityListener
  68         : public Tizen::Ui::_IAccessibilityListener
  69 {
  70 public:
  71         _WebAccessibilityListener(Evas_Object* pView);
  72
  73         virtual ~_WebAccessibilityListener(void);
  74
  75         virtual bool OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  76
  77         virtual bool OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  78
  79         virtual bool OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  80
  81         virtual bool OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  82
  83         virtual bool OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  84
  85         virtual bool OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  86
  87         virtual bool OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  88
  89         virtual bool OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  90
  91         virtual bool OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  92
  93 private:
  94         Evas_Object* __pView;
  95 };
  96
  97
  98 _WebAccessibilityListener::_WebAccessibilityListener(Evas_Object* pView)
  99         : __pView(pView)
 100 {
 101 }
 102
 103
 104 _WebAccessibilityListener::~_WebAccessibilityListener(void)
 105 {
 106 }
 107
 108
 109 bool
 110 _WebAccessibilityListener::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 111 {
 112         return true;
 113 }
 114
 115
 116 bool
 117 _WebAccessibilityListener::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 118 {
 119         return true;
 120 }
 121
 122
 123 bool
 124 _WebAccessibilityListener::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 125 {
 126         return true;
 127 }
 128
 129
 130 bool
 131 _WebAccessibilityListener::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 132 {
 133         return true;
 134 }
 135
 136
 137 bool
 138 _WebAccessibilityListener::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 139 {
 140         return true;
 141 }
 142
 143
 144 bool
 145 _WebAccessibilityListener::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 146 {
 147         return true;
 148 }
 149
 150
 151 bool
 152 _WebAccessibilityListener::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 153 {
 154         const Ewk_View_Smart_Data* pSmartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(__pView));
 155         SysAssertf(pSmartData, "Failed to get webkit smart data.");
 156
 157         Elm_Access_Action_Info* pActionInfo = new Elm_Access_Action_Info();
 158         SysTryReturn(NID_WEB_CTRL, pActionInfo, false, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 159
 160         bool result = false;
 161
 162         pActionInfo->action_type = ELM_ACCESS_ACTION_ACTIVATE;
 163
 164         result = pSmartData->api->screen_reader_action_execute(const_cast<Ewk_View_Smart_Data*>(pSmartData), pActionInfo);
 165         delete pActionInfo;
 166
 167         return result;
 168 }
 169
 170
 171 bool
 172 _WebAccessibilityListener::OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 173 {
 174         return true;
 175 }
 176
 177
 178 bool
 179 _WebAccessibilityListener::OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 180 {
 181         return true;
 182 }
 183
 184
 185 class _WebAccessibilityFocusHandler
 186         : public Tizen::Ui::_IAccessibilityFocusHandler
 187 {
 188 public:
 189         _WebAccessibilityFocusHandler(Evas_Object* pView);
 190
 191         virtual ~_WebAccessibilityFocusHandler(void);
 192
 193         virtual bool OnMoveFocus(Tizen::Ui::_AccessibilityFocusDirection direction);
 194
 195         virtual bool OnMoveFocus(const Tizen::Graphics::Point& point);
 196
 197 private:
 198         Evas_Object* __pView;
 199 };
 200
 201
 202 _WebAccessibilityFocusHandler::_WebAccessibilityFocusHandler(Evas_Object* pView)
 203         : __pView(pView)
 204 {
 205 }
 206
 207
 208 _WebAccessibilityFocusHandler::~_WebAccessibilityFocusHandler(void)
 209 {
 210 }
 211
 212
 213 bool
 214 _WebAccessibilityFocusHandler::OnMoveFocus(Tizen::Ui::_AccessibilityFocusDirection direction)
 215 {
 216         const Ewk_View_Smart_Data* pSmartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(__pView));
 217         SysAssertf(pSmartData, "Failed to get webkit smart data.");
 218
 219         Elm_Access_Action_Info* pActionInfo = new Elm_Access_Action_Info();
 220         SysTryReturn(NID_WEB_CTRL, pActionInfo, false, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 221
 222         bool result = false;
 223
 224         if (direction == Tizen::Ui::_ACCESSIBILITY_FOCUS_DIRECTION_PREVIOUS)
 225         {
 226                 pActionInfo->action_type = ELM_ACCESS_ACTION_HIGHLIGHT_PREV;
 227
 228                 result = pSmartData->api->screen_reader_action_execute(const_cast<Ewk_View_Smart_Data*>(pSmartData), pActionInfo);
 229         }
 230         else if (direction == Tizen::Ui::_ACCESSIBILITY_FOCUS_DIRECTION_NEXT)
 231         {
 232                 pActionInfo->action_type = ELM_ACCESS_ACTION_HIGHLIGHT_NEXT;
 233
 234                 result = pSmartData->api->screen_reader_action_execute(const_cast<Ewk_View_Smart_Data*>(pSmartData), pActionInfo);
 235         }
 236         delete pActionInfo;
 237
 238         return result;
 239 }
 240
 241
 242 bool
 243 _WebAccessibilityFocusHandler::OnMoveFocus(const Tizen::Graphics::Point& point)
 244 {
 245         const Ewk_View_Smart_Data* pSmartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(__pView));
 246         SysAssertf(pSmartData, "Failed to get webkit smart data.");
 247
 248         Elm_Access_Action_Info* pActionInfo = new Elm_Access_Action_Info();
 249         SysTryReturn(NID_WEB_CTRL, pActionInfo, false, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 250
 251         bool result = false;
 252
 253         pActionInfo->action_type = ELM_ACCESS_ACTION_READ;
 254         pActionInfo->x = point.x;
 255         pActionInfo->y = point.y;
 256
 257         result = pSmartData->api->screen_reader_action_execute(const_cast<Ewk_View_Smart_Data*>(pSmartData), pActionInfo);
 258         delete pActionInfo;
 259
 260         return result;
 261 }
 262
 263
 264 }
 265
 266
 267 namespace Tizen { namespace Web { namespace Controls
 268 {
 269
 270
 271 static const char WEB_CTRL[] = "webcontrol";
 272
 273
 274 void
 275 OnEdgeLeft(void* pUserData, Evas_Object* pView, void* pEventInfo)
 276 {
 277         _Web* pCore = reinterpret_cast< _Web* >(pUserData);
 278         SysAssertf(pCore, "Failed to request");
 279
 280         pCore->SetEdgeReachedEvent(WEB_EDGE_LEFT);
 281 }
 282
 283
 284 void
 285 OnEdgeRight(void* pUserData, Evas_Object* pView, void* pEventInfo)
 286 {
 287         _Web* pCore = reinterpret_cast< _Web* >(pUserData);
 288         SysAssertf(pCore, "Failed to request");
 289
 290         pCore->SetEdgeReachedEvent(WEB_EDGE_RIGHT);
 291 }
 292
 293
 294 void
 295 OnEdgeTop(void* pUserData, Evas_Object* pView, void* pEventInfo)
 296 {
 297         _Web* pCore = reinterpret_cast< _Web* >(pUserData);
 298         SysAssertf(pCore, "Failed to request");
 299
 300         pCore->SetEdgeReachedEvent(WEB_EDGE_TOP);
 301 }
 302
 303
 304 void
 305 OnEdgeBottom(void* pUserData, Evas_Object* pView, void* pEventInfo)
 306 {
 307         _Web* pCore = reinterpret_cast< _Web* >(pUserData);
 308         SysAssertf(pCore, "Failed to request");
 309
 310         pCore->SetEdgeReachedEvent(WEB_EDGE_BOTTOM);
 311 }
 312
 313
 314 _Web::_Web(void)
 315         : __pGestureHandler(null)
 316         , __pEflWebkit(null)
 317         , __pWebSetting(null)
 318         , __pGestureFlick(null)
 319         , __pGestureLongPress(null)
 320         , __pGesturePinch(null)
 321         , __pGestureDoubleTap(null)
 322         , __pTouchEventInfoList(null)
 323         , __pTapGestureHandler(null)
 324         , __pPanningGestureHandler(null)
 325         , __pFlickGestureHandler(null)
 326         , __pPinchGestureHandler(null)
 327         , __gestureType(WEB_GESTURE_TYPE_TAP)
 328         , __edgeType(WEB_EDGE_NONE)
 329         , __pTextElement(null)
 330         , __previousTouchedPosition(0.0f, 0.0f)
 331 {
 332         SetBackgroundColor(Color(0, 0, 0, 0));
 333 }
 334
 335
 336 _Web::~_Web(void)
 337 {
 338         RemoveGestureListener();
 339 }
 340
 341
 342 _Web*
 343 _Web::CreateWebN(void)
 344 {
 345         result r = E_SUCCESS;
 346
 347         std::unique_ptr<_Web> pWeb(new (std::nothrow) _Web());
 348         SysTryReturn(NID_WEB_CTRL, pWeb.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 349
 350         pWeb->__pWebSetting = std::unique_ptr<WebSetting>(new (std::nothrow) WebSetting());
 351         SysTryReturn(NID_WEB_CTRL, pWeb->__pWebSetting.get(), null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 352
 353         pWeb->AcquireHandle();
 354         pWeb->SetMultiTouchEnabled(true);
 355         pWeb->SetTouchPressThreshold(0.08);
 356
 357         r = pWeb->AddGestureListeners();
 358         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 359
 360         r = pWeb->InitializeGestureStates();
 361         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 362
 363         return pWeb.release();
 364 }
 365
 366
 367 result
 368 _Web::CreateWebkitEvasObject(void)
 369 {
 370         result r = E_SUCCESS;
 371
 372         std::unique_ptr<_EflWebkit> pEflWebkit(new (std::nothrow) _EflWebkit());
 373         SysTryReturnResult(NID_WEB_CTRL, pEflWebkit.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 374
 375         r = pEflWebkit->Construct(GetAbsoluteBounds(), *GetVisualElement(), this);
 376         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 377
 378         __pEflWebkit = std::move(pEflWebkit);
 379
 380         Evas_Object* pView = GetWebNativeNode();
 381         evas_object_smart_callback_add(pView, "edge,left", OnEdgeLeft, this);
 382         evas_object_smart_callback_add(pView, "edge,right", OnEdgeRight, this);
 383         evas_object_smart_callback_add(pView, "edge,top", OnEdgeTop, this);
 384         evas_object_smart_callback_add(pView, "edge,bottom", OnEdgeBottom, this);
 385
 386         return E_SUCCESS;
 387 }
 388
 389
 390 result
 391 _Web::InitializeGestureStates(void)
 392 {
 393         __pPinchGestureHandler = std::unique_ptr<_PinchGestureState>(new (std::nothrow) _PinchGestureState(this));
 394         SysTryReturnResult(NID_WEB_CTRL, __pPinchGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 395
 396         __pTapGestureHandler = std::unique_ptr<_TapGestureState>(new (std::nothrow) _TapGestureState(this));
 397         SysTryReturnResult(NID_WEB_CTRL, __pTapGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 398
 399         __pPanningGestureHandler = std::unique_ptr<_PanningGestureState>(new (std::nothrow) _PanningGestureState(this));
 400         SysTryReturnResult(NID_WEB_CTRL, __pPanningGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 401
 402         __pFlickGestureHandler = std::unique_ptr<_FlickGestureState>(new (std::nothrow) _FlickGestureState(this));
 403         SysTryReturnResult(NID_WEB_CTRL, __pFlickGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 404
 405         __pGestureHandler = __pTapGestureHandler.get();
 406
 407         return E_SUCCESS;
 408 }
 409
 410
 411 result
 412 _Web::AddGestureListeners(void)
 413 {
 414         result r = E_SUCCESS;
 415
 416         std::unique_ptr<_TouchFlickGestureDetector> pGestureFlick(new (std::nothrow) _TouchFlickGestureDetector());
 417         SysTryReturnResult(NID_WEB_CTRL, pGestureFlick.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 418
 419         r = pGestureFlick->AddGestureListener(*this);
 420         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 421
 422         r = AddGestureDetector(*pGestureFlick.get());
 423         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 424
 425         __pGestureFlick = std::move(pGestureFlick);
 426
 427         std::unique_ptr<_TouchLongPressGestureDetector> pGestureLongPress(new (std::nothrow) _TouchLongPressGestureDetector());
 428         SysTryReturnResult(NID_WEB_CTRL, pGestureLongPress.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 429
 430         r = pGestureLongPress->AddGestureListener(*this);
 431         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 432
 433         r = AddGestureDetector(*pGestureLongPress.get());
 434         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 435
 436         __pGestureLongPress = std::move(pGestureLongPress);
 437
 438         std::unique_ptr<_TouchTapGestureDetector> pGestureDoubleTap(new (std::nothrow) _TouchTapGestureDetector());
 439         SysTryReturnResult(NID_WEB_CTRL, pGestureDoubleTap.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 440
 441         r = pGestureDoubleTap->AddGestureListener(*this);
 442         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 443
 444         r = AddGestureDetector(*pGestureDoubleTap.get());
 445         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 446
 447         __pGestureDoubleTap = std::move(pGestureDoubleTap);
 448
 449         std::unique_ptr<_TouchPinchGestureDetector> pGesturePinch(new (std::nothrow) _TouchPinchGestureDetector());
 450         SysTryReturnResult(NID_WEB_CTRL, pGesturePinch.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 451
 452         r = pGesturePinch->AddGestureListener(*this);
 453         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 454
 455         r = AddGestureDetector(*pGesturePinch.get());
 456         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 457
 458         __pGesturePinch = std::move(pGesturePinch);
 459
 460         return E_SUCCESS;
 461 }
 462
 463
 464 void
 465 _Web::RemoveGestureListener(void)
 466 {
 467         if (__pGestureFlick.get())
 468         {
 469                 __pGestureFlick->RemoveGestureListener(*this);
 470                 RemoveGestureDetector(*__pGestureFlick);
 471         }
 472
 473         if (__pGestureLongPress.get())
 474         {
 475                 __pGestureLongPress->RemoveGestureListener(*this);
 476                 RemoveGestureDetector(*__pGestureLongPress);
 477         }
 478
 479         if (__pGestureDoubleTap.get())
 480         {
 481                 __pGestureDoubleTap->RemoveGestureListener(*this);
 482                 RemoveGestureDetector(*__pGestureDoubleTap);
 483         }
 484
 485         if (__pGesturePinch.get())
 486         {
 487                 __pGesturePinch->RemoveGestureListener(*this);
 488                 RemoveGestureDetector(*__pGesturePinch);
 489         }
 490
 491         Evas_Object* pView = GetWebNativeNode();
 492         if (pView)
 493         {
 494                 evas_object_smart_callback_del(pView, "edge,left", OnEdgeLeft);
 495                 evas_object_smart_callback_del(pView, "edge,right", OnEdgeRight);
 496                 evas_object_smart_callback_del(pView, "edge,top", OnEdgeTop);
 497                 evas_object_smart_callback_del(pView, "edge,bottom", OnEdgeBottom);
 498         }
 499 }
 500
 501
 502 result
 503 _Web::InitializeWebNativeNode(void)
 504 {
 505         result r = E_SUCCESS;
 506
 507         r = CreateWebkitEvasObject();
 508         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 509
 510         SetNativeObjectFocusable(false);
 511
 512         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 513         SysTryReturn(NID_WEB_CTRL, pContainer, E_SYSTEM, E_SYSTEM, "[%s] Propagating.", GetErrorMessage(E_SYSTEM));
 514
 515         __pTextElement = new (std::nothrow) _AccessibilityElement(true);
 516         SysTryReturn(NID_WEB_CTRL, __pTextElement, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 517
 518         __pTextElement->SetBounds(FloatRectangle(0.0f, 0.0f, GetBoundsF().width, GetBoundsF().height));
 519         __pTextElement->SetLabel(L"Web control");
 520
 521         pContainer->AddElement(*__pTextElement);
 522         pContainer->Activate(true);
 523
 524         _WebAccessibilityListener* pListener = new (std::nothrow) _WebAccessibilityListener(GetWebNativeNode());
 525         SysTryReturn(NID_WEB_CTRL, pListener, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 526
 527         pContainer->AddListener(*dynamic_cast<_IAccessibilityListener*>(pListener));
 528
 529         _WebAccessibilityFocusHandler* pFocusHandler = new (std::nothrow) _WebAccessibilityFocusHandler(GetWebNativeNode());
 530         SysTryReturn(NID_WEB_CTRL, pFocusHandler, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 531
 532         pContainer->SetFocusHandler(dynamic_cast<_IAccessibilityFocusHandler*>(pFocusHandler));
 533
 534         return E_SUCCESS;
 535 }
 536
 537
 538 Point
 539 _Web::GetAbsoluteCoordinate(Point relativePoint)
 540 {
 541         return _CoordinateSystemUtils::Transform(ConvertToScreenPosition(relativePoint));
 542 }
 543
 544
 545 FloatPoint
 546 _Web::GetAbsoluteCoordinate(FloatPoint relativePoint)
 547 {
 548         return _CoordinateSystemUtils::Transform(ConvertToScreenPosition(relativePoint));
 549 }
 550
 551
 552 Point
 553 _Web::GetRelativeCoordinate(Point absolutePoint)
 554 {
 555         return ConvertToControlPosition(_CoordinateSystemUtils::InverseTransform(absolutePoint));
 556 }
 557
 558
 559 FloatPoint
 560 _Web::GetRelativeCoordinate(FloatPoint absolutePoint)
 561 {
 562         return ConvertToControlPosition(_CoordinateSystemUtils::InverseTransform(absolutePoint));
 563 }
 564
 565
 566 Evas_Object*
 567 _Web::GetWebNativeNode(void)
 568 {
 569         SysTryReturn(NID_WEB_CTRL, __pEflWebkit.get(), null, E_INVALID_STATE, "[%s] Native node is in an invalid state.", GetErrorMessage(E_INVALID_STATE));
 570
 571         return __pEflWebkit->GetWebEvasObject();
 572 }
 573
 574
 575 WebSetting*
 576 _Web::GetSetting(void) const
 577 {
 578         return __pWebSetting.get();
 579 }
 580
 581
 582 result
 583 _Web::OnAttaching(const _Control* pParent)
 584 {
 585         if (__pEflWebkit.get())
 586         {
 587                 evas_object_show(__pEflWebkit->GetWebEvasObject());
 588                 evas_object_focus_set(__pEflWebkit->GetWebEvasObject(), EINA_TRUE);
 589         }
 590
 591         return E_SUCCESS;
 592 }
 593
 594
 595 result
 596 _Web::OnBoundsChanging(const Rectangle& bounds)
 597 {
 598         Rectangle absoluteBounds = GetAbsoluteBounds();
 599         Rectangle webBounds = GetBounds();
 600         _ICoordinateSystemTransformer* pXformer = _CoordinateSystem::GetInstance()->GetTransformer();
 601         SysTryReturnResult(NID_WEB_CTRL, pXformer, E_SYSTEM, "[%s] A system error has been occurred. Failed to get coordinate transformer.", GetErrorMessage(E_SYSTEM));
 602
 603         if (__pEflWebkit.get())
 604         {
 605                 evas_object_move(__pEflWebkit->GetWebEvasObject(), pXformer->TransformHorizontal(absoluteBounds.x - webBounds.x + bounds.x), pXformer->TransformVertical(absoluteBounds.y - webBounds.y + bounds.y));
 606                 evas_object_resize(__pEflWebkit->GetWebEvasObject(), pXformer->TransformHorizontal(bounds.width), pXformer->TransformVertical(bounds.height));
 607         }
 608
 609         return E_SUCCESS;
 610 }
 611
 612
 613 void
 614 _Web::ChangeGesture(_WebGestureType type)
 615 {
 616         switch (type)
 617         {
 618         case WEB_GESTURE_TYPE_TAP:
 619                 __pGestureHandler = __pTapGestureHandler.get();
 620                 __gestureType = WEB_GESTURE_TYPE_TAP;
 621                 break;
 622
 623         case WEB_GESTURE_TYPE_PANNING:
 624                 __pGestureHandler = __pPanningGestureHandler.get();
 625                 __gestureType = WEB_GESTURE_TYPE_PANNING;
 626                 break;
 627
 628         case WEB_GESTURE_TYPE_FLICK:
 629                 __pGestureHandler = __pFlickGestureHandler.get();
 630                 __gestureType = WEB_GESTURE_TYPE_FLICK;
 631                 break;
 632
 633         case WEB_GESTURE_TYPE_PINCH:
 634                 __pGestureHandler = __pPinchGestureHandler.get();
 635                 __gestureType = WEB_GESTURE_TYPE_PINCH;
 636                 break;
 637
 638         default:
 639                 SysAssert(false);
 640         }
 641 }
 642
 643
 644 void
 645 _Web::SetEdgeReachedEvent(_WebEdgeType type)
 646 {
 647         __edgeType |= type;
 648
 649         switch(type)
 650         {
 651         case WEB_EDGE_LEFT:
 652                 __edgeType &= ~WEB_EDGE_RIGHT;
 653                 break;
 654
 655         case WEB_EDGE_RIGHT:
 656                 __edgeType &= ~WEB_EDGE_LEFT;
 657                 break;
 658
 659         case WEB_EDGE_TOP:
 660                 __edgeType &= ~WEB_EDGE_BOTTOM;
 661                 break;
 662
 663         case WEB_EDGE_BOTTOM:
 664                 __edgeType &= ~WEB_EDGE_TOP;
 665                 break;
 666
 667         default:
 668                 SysAssert(false);
 669         }
 670 }
 671
 672
 673 bool
 674 _Web::OnTouchPressed(const _Control& source, const _TouchInfo& touchInfo)
 675 {
 676         if (__pEflWebkit.get())
 677         {
 678                 __edgeType = WEB_EDGE_NONE;
 679                 __previousTouchedPosition = touchInfo.GetCurrentPosition();
 680
 681                 SendTouchEventForJavaScript(touchInfo);
 682
 683                 return __pGestureHandler->OnTouchPressed(source, touchInfo);
 684         }
 685
 686         return false;
 687 }
 688
 689
 690 bool
 691 _Web::OnTouchMoved(const _Control& source, const _TouchInfo& touchInfo)
 692 {
 693         if (__pEflWebkit.get())
 694         {
 695                 SendTouchEventForJavaScript(touchInfo);
 696
 697                 __pGestureHandler->OnTouchMoved(source, touchInfo);
 698
 699                 float scrollDistanceX = __previousTouchedPosition.x - touchInfo.GetCurrentPosition().x;
 700                 float scrollDistanceY = __previousTouchedPosition.y - touchInfo.GetCurrentPosition().y;
 701                 __previousTouchedPosition = touchInfo.GetCurrentPosition();
 702
 703                 if (__edgeType !=  WEB_EDGE_NONE && __gestureType == WEB_GESTURE_TYPE_PANNING)
 704                 {
 705                         if (_Abs(scrollDistanceY) < _Abs(scrollDistanceX))
 706                         {
 707                                 if  (__edgeType & WEB_EDGE_LEFT)
 708                                 {
 709                                         if (scrollDistanceX < 0)
 710                                         {
 711                                                 __edgeType &= ~WEB_EDGE_RIGHT;
 712
 713                                                 return false;
 714                                         }
 715                                         else
 716                                         {
 717                                                 __edgeType &= ~WEB_EDGE_LEFT;
 718                                         }
 719                                 }
 720                                 else if  (__edgeType & WEB_EDGE_RIGHT)
 721                                 {
 722                                         if (scrollDistanceX > 0)
 723                                         {
 724                                                 __edgeType &= ~WEB_EDGE_LEFT;
 725
 726                                                 return false;
 727                                         }
 728                                         else
 729                                         {
 730                                                 __edgeType &= ~WEB_EDGE_RIGHT;
 731                                         }
 732                                 }
 733                         }
 734                         else if (_Abs(scrollDistanceY) > _Abs(scrollDistanceX))
 735                         {
 736                                 if  (__edgeType & WEB_EDGE_TOP)
 737                                 {
 738                                         if (scrollDistanceY < 0)
 739                                         {
 740                                                 __edgeType &= ~WEB_EDGE_BOTTOM;
 741
 742                                                 return false;
 743                                         }
 744                                         else
 745                                         {
 746                                                 __edgeType &= ~WEB_EDGE_TOP;
 747                                         }
 748                                 }
 749                                 else if  (__edgeType & WEB_EDGE_BOTTOM)
 750                                 {
 751                                         if (scrollDistanceY > 0)
 752                                         {
 753                                                 __edgeType &= ~WEB_EDGE_TOP;
 754
 755                                                 return false;
 756                                         }
 757                                         else
 758                                         {
 759                                                 __edgeType &= ~WEB_EDGE_BOTTOM;
 760                                         }
 761                                 }
 762                         }
 763                 }
 764
 765                 return true;
 766         }
 767
 768         return false;
 769 }
 770
 771
 772 bool
 773 _Web::OnTouchReleased(const _Control& source, const _TouchInfo& touchInfo)
 774 {
 775         SetFocused();
 776
 777         if (__pEflWebkit.get())
 778         {
 779                 SendTouchEventForJavaScript(touchInfo);
 780
 781                 return __pGestureHandler->OnTouchReleased(source, touchInfo);
 782         }
 783
 784         return false;
 785 }
 786
 787
 788 bool
 789 _Web::OnTouchCanceled(const _Control& source, const _TouchInfo& touchInfo)
 790 {
 791         if (__pEflWebkit.get())
 792         {
 793                 SendTouchEventForJavaScript(touchInfo);
 794
 795                 return __pGestureHandler->OnTouchCanceled(source, touchInfo);
 796         }
 797
 798         return false;
 799 }
 800
 801
 802 void
 803 _Web::OnTouchPressHandled(const _Control& control)
 804 {
 805 }
 806
 807
 808 void
 809 _Web::OnTouchReleaseHandled(const _Control& control)
 810 {
 811 }
 812
 813
 814 void
 815 _Web::OnTouchMoveHandled(const _Control& control)
 816 {
 817 }
 818
 819
 820 void
 821 _Web::OnTouchCancelHandled(const _Control& control)
 822 {
 823 }
 824
 825
 826 bool
 827 _Web::OnLongPressGestureDetected(_TouchLongPressGestureDetector& gesture)
 828 {
 829         if (__pEflWebkit.get() && __gestureType == WEB_GESTURE_TYPE_TAP)
 830         {
 831                 return __pTapGestureHandler->OnLongPressGestureDetected(gesture);
 832         }
 833
 834         return true;
 835 }
 836
 837
 838 bool
 839 _Web::OnLongPressGestureCanceled(_TouchLongPressGestureDetector& gesture)
 840 {
 841         return true;
 842 }
 843
 844
 845 bool
 846 _Web::OnTapGestureDetected(_TouchTapGestureDetector& gesture)
 847 {
 848         if (__pEflWebkit.get())
 849         {
 850                 return __pTapGestureHandler->OnTapGestureDetected(gesture);
 851         }
 852
 853         return true;
 854 }
 855
 856
 857 bool
 858 _Web::OnTapGestureCanceled(_TouchTapGestureDetector& gesture)
 859 {
 860         return true;
 861 }
 862
 863
 864 bool
 865 _Web::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
 866 {
 867         if (__pEflWebkit.get() && _WebSettingImpl::GetInstance(__pWebSetting.get())->IsScrollEnabled())
 868         {
 869                 return __pFlickGestureHandler->OnFlickGestureDetected(gesture);
 870         }
 871
 872         return true;
 873 }
 874
 875
 876 bool
 877 _Web::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
 878 {
 879         return true;
 880 }
 881
 882
 883 bool
 884 _Web::OnPinchGestureStarted(Tizen::Ui::_TouchPinchGestureDetector& gesture)
 885 {
 886         if (__pEflWebkit.get())
 887         {
 888                 return __pPinchGestureHandler->OnPinchGestureStarted(gesture);
 889         }
 890
 891         return true;
 892 }
 893
 894
 895 bool
 896 _Web::OnPinchGestureChanged(Tizen::Ui::_TouchPinchGestureDetector& gesture)
 897 {
 898         if (__pEflWebkit.get() && __gestureType == WEB_GESTURE_TYPE_PINCH)
 899         {
 900                 return __pPinchGestureHandler->OnPinchGestureChanged(gesture);
 901         }
 902
 903         return true;
 904 }
 905
 906
 907 bool
 908 _Web::OnPinchGestureFinished(Tizen::Ui::_TouchPinchGestureDetector& gesture)
 909 {
 910         if (__pEflWebkit.get() && __gestureType == WEB_GESTURE_TYPE_PINCH)
 911         {
 912                 return __pPinchGestureHandler->OnPinchGestureFinished(gesture);
 913         }
 914
 915         return true;
 916 }
 917
 918
 919 bool
 920 _Web::OnPinchGestureCanceled(Tizen::Ui::_TouchPinchGestureDetector& gesture)
 921 {
 922         return true;
 923 }
 924
 925
 926 Canvas*
 927 _Web::OnCanvasRequestedN(const FloatRectangle& bounds)
 928 {
 929         result r = E_SUCCESS;
 930
 931         Evas_Object* pWebFrame = GetWebNativeNode();
 932         Eina_Rectangle rect;
 933         BufferInfo bufferInfo;
 934
 935         Point absPoint(_CoordinateSystemUtils::ConvertToInteger(GetAbsoluteCoordinate(FloatPoint(bounds.x, bounds.y))));
 936         Dimension absSize(_CoordinateSystemUtils::ConvertToInteger(_CoordinateSystemUtils::HorizontalTransform(bounds.width)),
 937                 _CoordinateSystemUtils::ConvertToInteger(_CoordinateSystemUtils::VerticalTransform(bounds.height)));
 938
 939         EINA_RECTANGLE_SET(&rect, absPoint.x, absPoint.y, absSize.width, absSize.height);
 940
 941         Evas_Object* pScreenShot = ewk_view_screenshot_contents_get(pWebFrame, rect, 1.0f, evas_object_evas_get(pWebFrame));
 942
 943         std::unique_ptr<Canvas> pCanvas(new (std::nothrow) Canvas());
 944         SysTryReturn(NID_WEB_CTRL, pCanvas.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 945
 946         if (pScreenShot)
 947         {
 948                 r = _Utility::GetPixelBufferFromEvasObject(pScreenShot, bufferInfo);
 949                 evas_object_del(pScreenShot);
 950                 SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 951
 952                 r = pCanvas->Construct(bufferInfo);
 953                 SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 954         }
 955         else
 956         {
 957                 r = pCanvas->Construct(bounds);
 958                 SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 959         }
 960
 961         return pCanvas.release();
 962 }
 963
 964
 965 Bitmap*
 966 _Web::OnCapturedBitmapRequestedN(void)
 967 {
 968         result r = E_SUCCESS;
 969
 970         Evas_Object* pWebFrame = GetWebNativeNode();
 971         Eina_Rectangle rect;
 972         ByteBuffer buffer;
 973         BufferInfo bufferInfo;
 974
 975         Dimension size(GetSize());
 976         Point absSize(GetAbsoluteCoordinate(Point(size.width, size.height)));
 977
 978         EINA_RECTANGLE_SET(&rect, 0, 0, absSize.x, absSize.y);
 979
 980         Evas_Object* pScreenShot = ewk_view_screenshot_contents_get(pWebFrame, rect, 1.0f, evas_object_evas_get(pWebFrame));
 981         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));
 982
 983         r = _Utility::GetPixelBufferFromEvasObject(pScreenShot, bufferInfo);
 984         evas_object_del(pScreenShot);
 985         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 986
 987         int bufferSize = bufferInfo.bitsPerPixel * bufferInfo.width * bufferInfo.height;
 988         r = buffer.Construct(reinterpret_cast < byte* >(bufferInfo.pPixels), 0, bufferSize, bufferSize);
 989         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 990
 991         std::unique_ptr<Bitmap> pBitmap(new (std::nothrow) Bitmap());
 992         SysTryReturn(NID_WEB_CTRL, pBitmap.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 993
 994         r = pBitmap->Construct(buffer, Dimension(bufferInfo.width, bufferInfo.height), BITMAP_PIXEL_FORMAT_ARGB8888);
 995         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 996
 997         return pBitmap.release();
 998 }
 999
1000
1001 void
1002 _Web::DumpPointList(void* pData)
1003 {
1004         Eina_List* pList = reinterpret_cast< Eina_List* >(pData);
1005
1006         for(; pList; pList = eina_list_next(pList))
1007         {
1008                 Ewk_Touch_Point* pPointDump = static_cast<Ewk_Touch_Point*>(eina_list_data_get(pList));
1009                 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);
1010         }
1011 }
1012
1013
1014 void
1015 _Web::SendTouchEventForJavaScript(const _TouchInfo& touchInfo)
1016 {
1017         result r = E_SUCCESS;
1018
1019         Eina_List* pPointList = null;
1020         Ewk_Touch_Point* pPoint = null;
1021
1022         _TouchManager* pTouchManager = _TouchManager::GetInstance();
1023         SysAssertf(pTouchManager, "Failed to get touch manager.");
1024
1025         std::unique_ptr<IListT<_FingerInfo*> > pTouchList(pTouchManager->GetMultiFingerInfoListN());
1026         SysTryReturnVoidResult(NID_WEB_CTRL, pTouchList.get(), GetLastResult(), "[%s] Failed to get touch list.", GetErrorMessage(GetLastResult()));
1027
1028         std::unique_ptr<IBidirectionalEnumeratorT<_FingerInfo*> > pTouchListEnum(pTouchList->GetBidirectionalEnumeratorN());
1029         SysAssertf(pTouchListEnum.get() != null, "Failed to get enumerator of touch list.");
1030
1031         FloatPoint currentPoint;
1032         _FingerInfo* pFingerInfo = null;
1033         while(pTouchListEnum->MoveNext() == E_SUCCESS)
1034         {
1035                 r = pTouchListEnum->GetCurrent(pFingerInfo);
1036                 SysTryReturnVoidResult(NID_WEB_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1037
1038                 _TouchStatus state = pFingerInfo->GetStatus();
1039                 if(state == _TOUCH_PRESSED || state == _TOUCH_MOVED || state == _TOUCH_RELEASED || state == _TOUCH_CANCELED)
1040                 {
1041                         currentPoint = GetAbsoluteCoordinate(pFingerInfo->GetPoint());
1042                         Point integerPoint(_CoordinateSystemUtils::ConvertToInteger(currentPoint));
1043
1044                         pPoint = static_cast<Ewk_Touch_Point*>(calloc(1, sizeof(Ewk_Touch_Point)));
1045
1046                         pPoint->id = pFingerInfo->GetPointId();
1047                         pPoint->x = integerPoint.x;
1048                         pPoint->y = integerPoint.y;
1049                         pPoint->state = GetEvasTouchState((TouchStatus)pFingerInfo->GetStatus());
1050
1051                         pPointList = eina_list_append(pPointList, pPoint);
1052                 }
1053         }
1054         DumpPointList(pPointList);
1055
1056         Eina_Bool ret = ewk_view_feed_touch_event(__pEflWebkit->GetWebEvasObject(), GetEwkTouchEvent(touchInfo.GetTouchStatus()), pPointList, null);
1057         SysTryReturnVoidResult(NID_WEB_CTRL, ret == EINA_TRUE, E_SYSTEM, "[%s] A system error has been occurred. Failed to deliver touch event to javascript.", GetErrorMessage(E_SYSTEM));
1058
1059         void* pData = null;
1060
1061         EINA_LIST_FREE(pPointList, pData)
1062         free(pData);
1063 }
1064
1065
1066 Ewk_Touch_Event_Type
1067 _Web::GetEwkTouchEvent(_TouchStatus touchStatus)
1068 {
1069         Ewk_Touch_Event_Type ewkTouchEvent = EWK_TOUCH_CANCEL;
1070
1071         switch (touchStatus)
1072         {
1073         case _TOUCH_PRESSED :
1074                 ewkTouchEvent = EWK_TOUCH_START;
1075                 break;
1076         case _TOUCH_MOVED :
1077                 ewkTouchEvent = EWK_TOUCH_MOVE;
1078                 break;
1079         case _TOUCH_RELEASED :
1080                 ewkTouchEvent = EWK_TOUCH_END;
1081                 break;
1082         case _TOUCH_CANCELED :
1083                 //fall through
1084         default :
1085                 ewkTouchEvent = EWK_TOUCH_CANCEL;
1086                 break;
1087         }
1088
1089         return ewkTouchEvent;
1090 }
1091
1092
1093 Evas_Touch_Point_State
1094 _Web::GetEvasTouchState(TouchStatus touchStatus)
1095 {
1096         Evas_Touch_Point_State evasTouchState = EVAS_TOUCH_POINT_CANCEL;
1097
1098         switch (touchStatus)
1099         {
1100         case TOUCH_PRESSED :
1101                 evasTouchState = EVAS_TOUCH_POINT_DOWN;
1102                 break;
1103         case TOUCH_MOVED :
1104                 evasTouchState = EVAS_TOUCH_POINT_MOVE;
1105                 break;
1106         case TOUCH_RELEASED :
1107                 evasTouchState = EVAS_TOUCH_POINT_UP;
1108                 break;
1109         case TOUCH_CANCELED :
1110                 //fall through
1111         default :
1112                 evasTouchState = EVAS_TOUCH_POINT_CANCEL;
1113                 //todo : mapping    EVAS_TOUCH_POINT_STILL, /**< Touch point is not moved af
1114                 break;
1115         }
1116
1117         return evasTouchState;
1118 }
1119
1120
1121 }}} // Tizen::Web::Controls