src/controls/FWebCtrl_Web.cpp

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