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 <FGrpPoint.h>
  30 #include <FGrpBitmap.h>
  31 #include <FGrpCanvas.h>
  32 #include <FWebCtrlWebSetting.h>
  33 #include <FGrp_CoordinateSystem.h>
  34 #include <FUiAnim_EflNode.h>
  35 #include <FUiAnim_VisualElement.h>
  36 #include <FUi_TouchManager.h>
  37 #include "FWebCtrl_EflWebkit.h"
  38 #include "FWebCtrl_GestureState.h"
  39 #include "FWebCtrl_Web.h"
  40 #include "FWebCtrl_WebImpl.h"
  41 #include "FWebCtrl_WebSettingImpl.h"
  42 #include "FWebCtrl_Utility.h"
  43
  44
  45 using namespace Tizen::Base;
  46 using namespace Tizen::Base::Collection;
  47 using namespace Tizen::Graphics;
  48 using namespace Tizen::Ui;
  49 using namespace Tizen::Ui::Animations;
  50
  51
  52 namespace Tizen { namespace Web { namespace Controls
  53 {
  54
  55
  56 static const char WEB_CTRL[] = "webcontrol";
  57
  58
  59 _Web::_Web(void)
  60         : __pGestureHandler(null)
  61         , __pEflWebkit(null)
  62         , __pGestureFlick(null)
  63         , __pGestureLongPress(null)
  64         , __pGestureDoubleTap(null)
  65         , __pTouchEventInfoList(null)
  66         , __pTapGestureHandler(null)
  67         , __pDoubleTapGestureHandler(null)
  68         , __pPanningGestureHandler(null)
  69         , __pFlickGestureHandler(null)
  70         , __pPinchGestureHandler(null)
  71 {
  72         SetBackgroundColor(Color(0, 0, 0, 0));
  73 }
  74
  75
  76 _Web::~_Web(void)
  77 {
  78         RemoveGestureListener();
  79 }
  80
  81
  82 _Web*
  83 _Web::CreateWebN(void)
  84 {
  85         result r = E_SUCCESS;
  86
  87         std::unique_ptr<_Web> pWeb(new (std::nothrow) _Web());
  88         SysTryReturn(NID_WEB_CTRL, pWeb.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
  89
  90         pWeb->AcquireHandle();
  91         pWeb->SetMultiTouchEnabled(true);
  92         pWeb->SetTouchMoveAllowance(TOUCH_MOVE_ALLOWANCE_NORMAL);
  93
  94         r = pWeb->AddGestureListeners();
  95         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  96
  97         r = pWeb->InitializeGestureStates();
  98         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  99
 100         return pWeb.release();
 101 }
 102
 103
 104 result
 105 _Web::CreateWebkitEvasObject(void)
 106 {
 107         result r = E_SUCCESS;
 108
 109         std::unique_ptr<_EflWebkit> pEflWebkit(new (std::nothrow) _EflWebkit());
 110         SysTryReturnResult(NID_WEB_CTRL, pEflWebkit.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 111
 112         r = pEflWebkit->Construct(GetAbsoluteBounds(), *GetVisualElement());
 113         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 114
 115         __pEflWebkit = std::move(pEflWebkit);
 116
 117         return E_SUCCESS;
 118 }
 119
 120
 121 result
 122 _Web::InitializeGestureStates(void)
 123 {
 124         __pPinchGestureHandler = std::unique_ptr<_PinchGestureState>(new (std::nothrow) _PinchGestureState(this));
 125         SysTryReturnResult(NID_WEB_CTRL, __pPinchGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 126
 127         __pTapGestureHandler = std::unique_ptr<_TapGestureState>(new (std::nothrow) _TapGestureState(this, __pPinchGestureHandler.get()));
 128         SysTryReturnResult(NID_WEB_CTRL, __pTapGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 129
 130         __pDoubleTapGestureHandler = std::unique_ptr<_DoubleTapGestureState>(new (std::nothrow) _DoubleTapGestureState(this));
 131         SysTryReturnResult(NID_WEB_CTRL, __pDoubleTapGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 132
 133         __pPanningGestureHandler = std::unique_ptr<_PanningGestureState>(new (std::nothrow) _PanningGestureState(this, __pPinchGestureHandler.get()));
 134         SysTryReturnResult(NID_WEB_CTRL, __pPanningGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 135
 136         __pFlickGestureHandler = std::unique_ptr<_FlickGestureState>(new (std::nothrow) _FlickGestureState(this));
 137         SysTryReturnResult(NID_WEB_CTRL, __pFlickGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 138
 139         __pGestureHandler = __pTapGestureHandler.get();
 140
 141         return E_SUCCESS;
 142 }
 143
 144
 145 result
 146 _Web::AddGestureListeners(void)
 147 {
 148         result r = E_SUCCESS;
 149
 150         _ITouchFlickGestureEventListener* pFlickListener = dynamic_cast< _ITouchFlickGestureEventListener* >(this);
 151         SysAssertf(pFlickListener != null, "Failed to get flick gesture listener");
 152
 153         std::unique_ptr<_TouchFlickGestureDetector> pGestureFlick(new (std::nothrow) _TouchFlickGestureDetector());
 154         SysTryReturnResult(NID_WEB_CTRL, pGestureFlick.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 155
 156         r = pGestureFlick->AddGestureListener(*pFlickListener);
 157         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 158
 159         r = AddGestureDetector(*pGestureFlick.get());
 160         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 161
 162         __pGestureFlick = std::move(pGestureFlick);
 163
 164         _ITouchLongPressGestureEventListener* pLongPressListener = dynamic_cast< _ITouchLongPressGestureEventListener* >(this);
 165         SysAssertf(pLongPressListener != null, "Failed to get longpress gesture listener");
 166
 167         std::unique_ptr<_TouchLongPressGestureDetector> pGestureLongPress(new (std::nothrow) _TouchLongPressGestureDetector());
 168         SysTryReturnResult(NID_WEB_CTRL, pGestureLongPress.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 169
 170         r = pGestureLongPress->AddGestureListener(*pLongPressListener);
 171         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 172
 173         r = AddGestureDetector(*pGestureLongPress.get());
 174         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 175
 176         __pGestureLongPress = std::move(pGestureLongPress);
 177
 178         _ITouchTapGestureEventListener* pDoubleTapListener = dynamic_cast< _ITouchTapGestureEventListener* >(this);
 179         SysAssertf(pDoubleTapListener != null, "Failed to get tap gesture listener");
 180
 181         std::unique_ptr<_TouchTapGestureDetector> pGestureDoubleTap(new (std::nothrow) _TouchTapGestureDetector());
 182         SysTryReturnResult(NID_WEB_CTRL, pGestureDoubleTap.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 183
 184         r = pGestureDoubleTap->AddGestureListener(*pDoubleTapListener);
 185         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 186
 187         r = AddGestureDetector(*pGestureDoubleTap.get());
 188         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 189
 190         __pGestureDoubleTap = std::move(pGestureDoubleTap);
 191
 192         return E_SUCCESS;
 193 }
 194
 195
 196 void
 197 _Web::RemoveGestureListener(void)
 198 {
 199         if (__pGestureFlick.get())
 200         {
 201                 _ITouchFlickGestureEventListener* pListener = dynamic_cast< _ITouchFlickGestureEventListener* >(this);
 202                 __pGestureFlick->RemoveGestureListener(*pListener);
 203                 RemoveGestureDetector(*__pGestureFlick);
 204         }
 205
 206         if (__pGestureLongPress.get())
 207         {
 208                 _ITouchLongPressGestureEventListener* pListener = dynamic_cast< _ITouchLongPressGestureEventListener* >(this);
 209                 __pGestureLongPress->RemoveGestureListener(*pListener);
 210                 RemoveGestureDetector(*__pGestureLongPress);
 211         }
 212
 213         if (__pGestureDoubleTap.get())
 214         {
 215                 _ITouchTapGestureEventListener* pListener = dynamic_cast< _ITouchTapGestureEventListener* >(this);
 216                 __pGestureDoubleTap->RemoveGestureListener(*pListener);
 217                 RemoveGestureDetector(*__pGestureDoubleTap);
 218         }
 219 }
 220
 221
 222 result
 223 _Web::InitializeWebNativeNode(void)
 224 {
 225         result r = E_SUCCESS;
 226
 227         r = CreateWebkitEvasObject();
 228         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 229
 230         SetNativeObjectFocusable(false);
 231
 232         return E_SUCCESS;
 233 }
 234
 235
 236 Point
 237 _Web::GetAbsoluteCoordinate(Point relativePoint)
 238 {
 239         _ICoordinateSystemTransformer* pXformer = _CoordinateSystem::GetInstance()->GetTransformer();
 240         SysAssertf(pXformer, "Failed to get coordinate transformer.");
 241
 242         int absX = pXformer->TransformHorizontal(relativePoint.x + GetAbsoluteBounds().x);
 243         int absY = pXformer->TransformVertical(relativePoint.y + GetAbsoluteBounds().y);
 244
 245         return Point(absX, absY);
 246 }
 247
 248
 249 Point
 250 _Web::GetRelativeCoordinate(Point absolutePoint)
 251 {
 252         _ICoordinateSystemTransformer* pXformer = _CoordinateSystem::GetInstance()->GetInverseTransformer();
 253         SysAssertf(pXformer, "Failed to get coordinate transformer.");
 254
 255         Point bound(GetAbsoluteCoordinate(Point(0, 0)));
 256
 257         int absX = pXformer->TransformHorizontal(absolutePoint.x - bound.x);
 258         int absY = pXformer->TransformVertical(absolutePoint.y - bound.y);
 259
 260         return Point(absX, absY);
 261 }
 262
 263
 264 Evas_Object*
 265 _Web::GetWebNativeNode(void)
 266 {
 267         SysTryReturn(NID_WEB_CTRL, __pEflWebkit, null, E_INVALID_STATE, "[%s] Native node is in an invalid state.", GetErrorMessage(E_INVALID_STATE));
 268
 269         return __pEflWebkit->GetWebEvasObject();
 270 }
 271
 272
 273 void
 274 _Web::SetWebSettingImpl(_WebSettingImpl* pWebSettingImpl)
 275 {
 276         __pWebSettingImpl = pWebSettingImpl;
 277 }
 278
 279
 280 _WebSettingImpl*
 281 _Web::GetWebSettingImpl(void) const
 282 {
 283         return __pWebSettingImpl;
 284 }
 285
 286
 287 result
 288 _Web::OnAttaching(const _Control* pParent)
 289 {
 290         if (__pEflWebkit)
 291         {
 292                 evas_object_show(__pEflWebkit->GetWebEvasObject());
 293                 evas_object_focus_set(__pEflWebkit->GetWebEvasObject(), EINA_TRUE);
 294         }
 295
 296         return E_SUCCESS;
 297 }
 298
 299
 300 result
 301 _Web::OnBoundsChanging(const Rectangle& bounds)
 302 {
 303         Rectangle absoluteBounds = GetAbsoluteBounds();
 304         Rectangle webBounds = GetBounds();
 305         _ICoordinateSystemTransformer* pXformer = _CoordinateSystem::GetInstance()->GetTransformer();
 306         SysTryReturnResult(NID_WEB_CTRL, pXformer, E_SYSTEM, "[%s] A system error has been occurred. Failed to get coordinate transformer.", GetErrorMessage(E_SYSTEM));
 307
 308         if (__pEflWebkit)
 309         {
 310                 evas_object_move(__pEflWebkit->GetWebEvasObject(), pXformer->TransformHorizontal(absoluteBounds.x - webBounds.x + bounds.x), pXformer->TransformVertical(absoluteBounds.y - webBounds.y + bounds.y));
 311                 evas_object_resize(__pEflWebkit->GetWebEvasObject(), pXformer->TransformHorizontal(bounds.width), pXformer->TransformVertical(bounds.height));
 312         }
 313
 314         return E_SUCCESS;
 315 }
 316
 317
 318 void
 319 _Web::ChangeGesture(_WebGestureType type)
 320 {
 321         switch (type)
 322         {
 323         case WEB_GESTURE_TYPE_TAP:
 324                 __pGestureHandler = __pTapGestureHandler.get();
 325                 break;
 326
 327         case WEB_GESTURE_TYPE_DOUBLE_TAP:
 328                 __pGestureHandler = __pDoubleTapGestureHandler.get();
 329                 break;
 330
 331         case WEB_GESTURE_TYPE_PANNING:
 332                 __pGestureHandler = __pPanningGestureHandler.get();
 333                 break;
 334
 335         case WEB_GESTURE_TYPE_FLICK:
 336                 __pGestureHandler = __pFlickGestureHandler.get();
 337                 break;
 338
 339         case WEB_GESTURE_TYPE_PINCH:
 340                 __pGestureHandler = __pPinchGestureHandler.get();
 341                 break;
 342
 343         default:
 344                 SysAssert(false);
 345         }
 346 }
 347
 348
 349 bool
 350 _Web::OnTouchPressed(const _Control& source, const _TouchInfo& touchInfo)
 351 {
 352         SendTouchEventForJavaScript(touchInfo);
 353
 354         __pGestureHandler->OnTouchPressed(source, touchInfo);
 355
 356         return true;
 357 }
 358
 359
 360 bool
 361 _Web::OnTouchMoved(const _Control& source, const _TouchInfo& touchInfo)
 362 {
 363         SendTouchEventForJavaScript(touchInfo);
 364
 365         __pGestureHandler->OnTouchMoved(source, touchInfo);
 366
 367         return true;
 368 }
 369
 370
 371 bool
 372 _Web::OnTouchReleased(const _Control& source, const _TouchInfo& touchInfo)
 373 {
 374         SendTouchEventForJavaScript(touchInfo);
 375
 376         __pGestureHandler->OnTouchReleased(source, touchInfo);
 377
 378         _WebImpl* pWebImpl = reinterpret_cast<_WebImpl*>(evas_object_data_get(GetWebNativeNode(), WEB_CTRL));
 379         SysAssertf(pWebImpl, "Failed to get Impl");
 380
 381         if (pWebImpl->GetLoadingListener() && pWebImpl->GetTextFromBlock().GetLength() > 0)
 382         {
 383                 pWebImpl->FireWebPageBlockSelectedEvent();
 384         }
 385
 386         SetFocused();
 387
 388         return true;
 389 }
 390
 391 bool
 392 _Web::OnTouchCanceled(const _Control& source, const _TouchInfo& touchInfo)
 393 {
 394         SendTouchEventForJavaScript(touchInfo);
 395
 396         __pGestureHandler->OnTouchCanceled(source, touchInfo);
 397
 398         return true;
 399 }
 400
 401
 402 bool
 403 _Web::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
 404 {
 405         if (__pWebSettingImpl->IsScrollEnabled())
 406         {
 407                 ChangeGesture(WEB_GESTURE_TYPE_FLICK);
 408                 static_cast< _FlickGestureState* >(__pGestureHandler)->OnFlickGestureDetected(gesture);
 409         }
 410
 411         return true;
 412 }
 413
 414
 415 bool
 416 _Web::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
 417 {
 418         return true;
 419 }
 420
 421
 422 bool
 423 _Web::OnLongPressGestureDetected(_TouchLongPressGestureDetector& gesture)
 424 {
 425         _TapGestureState* pTapGestureHandler = dynamic_cast< _TapGestureState* >(__pGestureHandler);
 426         if (pTapGestureHandler)
 427         {
 428                 pTapGestureHandler->OnLongPressGestureDetected(gesture);
 429         }
 430
 431         return true;
 432 }
 433
 434
 435 bool
 436 _Web::OnLongPressGestureCanceled(_TouchLongPressGestureDetector& gesture)
 437 {
 438         return true;
 439 }
 440
 441
 442 bool
 443 _Web::OnTapGestureDetected(_TouchTapGestureDetector& gesture)
 444 {
 445         ChangeGesture(WEB_GESTURE_TYPE_DOUBLE_TAP);
 446
 447         return true;
 448 }
 449
 450
 451 bool
 452 _Web::OnTapGestureCanceled(_TouchTapGestureDetector& gesture)
 453 {
 454         return true;
 455 }
 456
 457
 458 Canvas*
 459 _Web::OnCanvasRequestedN(const Dimension& size)
 460 {
 461         result r = E_SUCCESS;
 462
 463         Evas_Object* pWebFrame = GetWebNativeNode();
 464         Eina_Rectangle rect;
 465         BufferInfo bufferInfo;
 466
 467         Point absSize = GetAbsoluteCoordinate(Point(size.width, size.height));
 468
 469         EINA_RECTANGLE_SET(&rect, 0, 0, absSize.x, absSize.y);
 470
 471         Evas_Object* pScreenShot = ewk_view_screenshot_contents_get(pWebFrame, rect, 1.0f, evas_object_evas_get(pWebFrame));
 472         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));
 473
 474         r = _Utility::GetPixelBufferFromEvasObject(pScreenShot, bufferInfo);
 475         evas_object_del(pScreenShot);
 476         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 477
 478         std::unique_ptr<Canvas> pCanvas(new (std::nothrow) Canvas());
 479         SysTryReturn(NID_WEB_CTRL, pCanvas.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 480
 481         r = pCanvas->Construct(bufferInfo);
 482         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 483
 484         return pCanvas.release();
 485 }
 486
 487
 488 Bitmap*
 489 _Web::OnCapturedBitmapRequestedN(void)
 490 {
 491         result r = E_SUCCESS;
 492
 493         Evas_Object* pWebFrame = GetWebNativeNode();
 494         Eina_Rectangle rect;
 495         ByteBuffer buffer;
 496         BufferInfo bufferInfo;
 497
 498         Dimension size = GetSize();
 499         Point absSize = GetAbsoluteCoordinate(Point(size.width, size.height));
 500
 501         EINA_RECTANGLE_SET(&rect, 0, 0, absSize.x, absSize.y);
 502
 503         Evas_Object* pScreenShot = ewk_view_screenshot_contents_get(pWebFrame, rect, 1.0f, evas_object_evas_get(pWebFrame));
 504         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));
 505
 506         r = _Utility::GetPixelBufferFromEvasObject(pScreenShot, bufferInfo);
 507         evas_object_del(pScreenShot);
 508         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 509
 510         int bufferSize = bufferInfo.bitsPerPixel * bufferInfo.width * bufferInfo.height;
 511         r = buffer.Construct(reinterpret_cast < byte* >(bufferInfo.pPixels), 0, bufferSize, bufferSize);
 512         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 513
 514         std::unique_ptr<Bitmap> pBitmap(new (std::nothrow) Bitmap());
 515         SysTryReturn(NID_WEB_CTRL, pBitmap.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 516
 517         r = pBitmap->Construct(buffer, Dimension(bufferInfo.width, bufferInfo.height), BITMAP_PIXEL_FORMAT_ARGB8888);
 518         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 519
 520         return pBitmap.release();
 521 }
 522
 523
 524 void
 525 _Web::DumpPointList(void* pData)
 526 {
 527         Eina_List* pList = reinterpret_cast< Eina_List* >(pData);
 528
 529         for(; pList; pList = eina_list_next(pList))
 530         {
 531                 Ewk_Touch_Point* pPointDump = static_cast<Ewk_Touch_Point*>(eina_list_data_get(pList));
 532                 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);
 533         }
 534 }
 535
 536
 537 void
 538 _Web::SendTouchEventForJavaScript(const _TouchInfo& touchInfo)
 539 {
 540         result r = E_SUCCESS;
 541
 542         Eina_List* pPointList = null;
 543         Ewk_Touch_Point* pPoint = null;
 544
 545         _TouchManager* pTouchManager = _TouchManager::GetInstance();
 546         SysAssertf(pTouchManager, "Failed to get touch manager.");
 547
 548         std::unique_ptr<IListT<_FingerInfo*> > pTouchList(pTouchManager->GetMultiFingerInfoListN());
 549         SysTryReturnVoidResult(NID_WEB_CTRL, pTouchList.get(), GetLastResult(), "[%s] Failed to get touch list.", GetErrorMessage(GetLastResult()));
 550
 551         std::unique_ptr<IBidirectionalEnumeratorT<_FingerInfo*> > pTouchListEnum(pTouchList->GetBidirectionalEnumeratorN());
 552         SysAssertf(pTouchListEnum.get() != null, "Failed to get enumerator of touch list.");
 553
 554         Point currentPoint;
 555         _FingerInfo* pFingerInfo = null;
 556         while(pTouchListEnum->MoveNext() == E_SUCCESS)
 557         {
 558                 r = pTouchListEnum->GetCurrent(pFingerInfo);
 559                 SysTryReturnVoidResult(NID_WEB_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 560
 561                 _TouchStatus state = pFingerInfo->GetStatus();
 562                 if(state == _TOUCH_PRESSED || state == _TOUCH_MOVED || state == _TOUCH_RELEASED || state == _TOUCH_CANCELED)
 563                 {
 564                         currentPoint = GetAbsoluteCoordinate(pFingerInfo->GetPoint());
 565
 566                         pPoint = static_cast<Ewk_Touch_Point*>(calloc(1, sizeof(Ewk_Touch_Point)));
 567
 568                         pPoint->id = pFingerInfo->GetPointId();
 569                         pPoint->x = currentPoint.x;
 570                         pPoint->y = currentPoint.y;
 571                         pPoint->state = GetEvasTouchState((TouchStatus)pFingerInfo->GetStatus());
 572
 573                         pPointList = eina_list_append(pPointList, pPoint);
 574                 }
 575         }
 576         DumpPointList(pPointList);
 577
 578         Eina_Bool ret = ewk_view_feed_touch_event(__pEflWebkit->GetWebEvasObject(), GetEwkTouchEvent(touchInfo.GetTouchStatus()), pPointList, null);
 579         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));
 580
 581         void* pData = null;
 582
 583         EINA_LIST_FREE(pPointList, pData)
 584         free(pData);
 585 }
 586
 587
 588 Ewk_Touch_Event_Type
 589 _Web::GetEwkTouchEvent(_TouchStatus touchStatus)
 590 {
 591         Ewk_Touch_Event_Type ewkTouchEvent = EWK_TOUCH_CANCEL;
 592
 593         switch (touchStatus)
 594         {
 595         case _TOUCH_PRESSED :
 596                 ewkTouchEvent = EWK_TOUCH_START;
 597                 break;
 598         case _TOUCH_MOVED :
 599                 ewkTouchEvent = EWK_TOUCH_MOVE;
 600                 break;
 601         case _TOUCH_RELEASED :
 602                 ewkTouchEvent = EWK_TOUCH_END;
 603                 break;
 604         case _TOUCH_CANCELED :
 605                 //fall through
 606         default :
 607                 ewkTouchEvent = EWK_TOUCH_CANCEL;
 608                 break;
 609         }
 610
 611         return ewkTouchEvent;
 612 }
 613
 614
 615 Evas_Touch_Point_State
 616 _Web::GetEvasTouchState(TouchStatus touchStatus)
 617 {
 618         Evas_Touch_Point_State evasTouchState = EVAS_TOUCH_POINT_CANCEL;
 619
 620         switch (touchStatus)
 621         {
 622         case TOUCH_PRESSED :
 623                 evasTouchState = EVAS_TOUCH_POINT_DOWN;
 624                 break;
 625         case TOUCH_MOVED :
 626                 evasTouchState = EVAS_TOUCH_POINT_MOVE;
 627                 break;
 628         case TOUCH_RELEASED :
 629                 evasTouchState = EVAS_TOUCH_POINT_UP;
 630                 break;
 631         case TOUCH_CANCELED :
 632                 //fall through
 633         default :
 634                 evasTouchState = EVAS_TOUCH_POINT_CANCEL;
 635                 //todo : mapping    EVAS_TOUCH_POINT_STILL, /**< Touch point is not moved af
 636                 break;
 637         }
 638
 639         return evasTouchState;
 640 }
 641
 642
 643 }}} // Tizen::Web::Controls