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