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