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