src/controls/FWebCtrl_Web.cpp

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