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