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