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 <Elementary.h>
  25 #include <memory>
  26 #include <FBaseByteBuffer.h>
  27 #include <FBaseColLinkedListT.h>
  28 #include <FBaseSysLog.h>
  29 #include <FBaseColIListT.h>
  30 #include <FGrpFloatPoint.h>
  31 #include <FGrpPoint.h>
  32 #include <FGrpBitmap.h>
  33 #include <FGrpCanvas.h>
  34 #include <FGrpFloatRectangle.h>
  35 #include <FSysVibrator.h>
  36 #include <FWebCtrlWebSetting.h>
  37 #include <FGrp_CoordinateSystem.h>
  38 #include <FSys_VibratorImpl.h>
  39 #include <FUiAnim_EflNode.h>
  40 #include <FUiAnim_VisualElement.h>
  41 #include <FUiAnim_VisualElementImpl.h>
  42 #include <FUi_CoordinateSystemUtils.h>
  43 #include <FUi_AccessibilityContainer.h>
  44 #include <FUi_AccessibilityElement.h>
  45 #include <FUi_UiEventManager.h>
  46 #include <FUi_IAccessibilityFocusHandler.h>
  47 #include <FUi_IAccessibilityListener.h>
  48 #include <FUi_Math.h>
  49 #include <FUi_TouchManager.h>
  50 #include "FWebCtrl_EflWebkit.h"
  51 #include "FWebCtrl_GestureState.h"
  52 #include "FWebCtrl_Web.h"
  53 #include "FWebCtrl_WebSettingImpl.h"
  54 #include "FWebCtrl_Utility.h"
  55
  56
  57 using namespace Tizen::Base;
  58 using namespace Tizen::Base::Collection;
  59 using namespace Tizen::Graphics;
  60 using namespace Tizen::Ui;
  61 using namespace Tizen::Ui::Animations;
  62
  63
  64 namespace
  65 {
  66
  67
  68 class _WebAccessibilityListener
  69         : public Tizen::Ui::_IAccessibilityListener
  70 {
  71 public:
  72         _WebAccessibilityListener(Evas_Object* pView);
  73
  74         virtual ~_WebAccessibilityListener(void);
  75
  76         virtual bool OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  77
  78         virtual bool OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  79
  80         virtual bool OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  81
  82         virtual bool OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  83
  84         virtual bool OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  85
  86         virtual bool OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  87
  88         virtual bool OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  89
  90         virtual bool OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  91
  92         virtual bool OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element);
  93
  94 private:
  95         Evas_Object* __pView;
  96 };
  97
  98
  99 _WebAccessibilityListener::_WebAccessibilityListener(Evas_Object* pView)
 100         : __pView(pView)
 101 {
 102 }
 103
 104
 105 _WebAccessibilityListener::~_WebAccessibilityListener(void)
 106 {
 107 }
 108
 109
 110 bool
 111 _WebAccessibilityListener::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 112 {
 113         return true;
 114 }
 115
 116
 117 bool
 118 _WebAccessibilityListener::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 119 {
 120         return true;
 121 }
 122
 123
 124 bool
 125 _WebAccessibilityListener::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 126 {
 127         return true;
 128 }
 129
 130
 131 bool
 132 _WebAccessibilityListener::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 133 {
 134         return true;
 135 }
 136
 137
 138 bool
 139 _WebAccessibilityListener::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 140 {
 141         return true;
 142 }
 143
 144
 145 bool
 146 _WebAccessibilityListener::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 147 {
 148         Ewk_View_Smart_Data* pSmartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(__pView));
 149         SysAssertf(pSmartData, "Failed to get webkit smart data.");
 150
 151         Elm_Access_Action_Info* pActionInfo = new Elm_Access_Action_Info();
 152         SysTryReturn(NID_WEB_CTRL, pActionInfo, false, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 153
 154         bool result = false;
 155
 156         pActionInfo->action_type = ELM_ACCESS_ACTION_UNHIGHLIGHT;
 157
 158         result = pSmartData->api->screen_reader_action_execute(pSmartData, pActionInfo);
 159         delete pActionInfo;
 160
 161         return result;
 162 }
 163
 164
 165 bool
 166 _WebAccessibilityListener::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 167 {
 168         Ewk_View_Smart_Data* pSmartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(__pView));
 169         SysAssertf(pSmartData, "Failed to get webkit smart data.");
 170
 171         Elm_Access_Action_Info* pActionInfo = new Elm_Access_Action_Info();
 172         SysTryReturn(NID_WEB_CTRL, pActionInfo, false, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 173
 174         bool result = false;
 175
 176         pActionInfo->action_type = ELM_ACCESS_ACTION_ACTIVATE;
 177
 178         result = pSmartData->api->screen_reader_action_execute(pSmartData, pActionInfo);
 179         delete pActionInfo;
 180
 181         return result;
 182 }
 183
 184
 185 bool
 186 _WebAccessibilityListener::OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 187 {
 188         return true;
 189 }
 190
 191
 192 bool
 193 _WebAccessibilityListener::OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 194 {
 195         return true;
 196 }
 197
 198
 199 class _WebAccessibilityFocusHandler
 200         : public Tizen::Ui::_IAccessibilityFocusHandler
 201 {
 202 public:
 203         _WebAccessibilityFocusHandler(Evas_Object* pView);
 204
 205         virtual ~_WebAccessibilityFocusHandler(void);
 206
 207         virtual bool OnMoveFocus(Tizen::Ui::_AccessibilityFocusDirection direction);
 208
 209         virtual bool OnMoveFocus(const Tizen::Graphics::Point& point);
 210
 211 private:
 212         Evas_Object* __pView;
 213 };
 214
 215
 216 _WebAccessibilityFocusHandler::_WebAccessibilityFocusHandler(Evas_Object* pView)
 217         : __pView(pView)
 218 {
 219 }
 220
 221
 222 _WebAccessibilityFocusHandler::~_WebAccessibilityFocusHandler(void)
 223 {
 224 }
 225
 226
 227 bool
 228 _WebAccessibilityFocusHandler::OnMoveFocus(Tizen::Ui::_AccessibilityFocusDirection direction)
 229 {
 230         Ewk_View_Smart_Data* pSmartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(__pView));
 231         SysAssertf(pSmartData, "Failed to get webkit smart data.");
 232
 233         Elm_Access_Action_Info* pActionInfo = new Elm_Access_Action_Info();
 234         SysTryReturn(NID_WEB_CTRL, pActionInfo, false, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 235
 236         bool result = false;
 237
 238         if (direction == Tizen::Ui::_ACCESSIBILITY_FOCUS_DIRECTION_PREVIOUS)
 239         {
 240                 pActionInfo->action_type = ELM_ACCESS_ACTION_HIGHLIGHT;
 241
 242                 pActionInfo->action_by = ELM_ACCESS_ACTION_HIGHLIGHT_PREV;
 243
 244                 result = pSmartData->api->screen_reader_action_execute(pSmartData, pActionInfo);
 245         }
 246         else if (direction == Tizen::Ui::_ACCESSIBILITY_FOCUS_DIRECTION_NEXT)
 247         {
 248                 pActionInfo->action_type = ELM_ACCESS_ACTION_HIGHLIGHT;
 249
 250                 pActionInfo->action_by = ELM_ACCESS_ACTION_HIGHLIGHT_NEXT;
 251
 252                 result = pSmartData->api->screen_reader_action_execute(pSmartData, pActionInfo);
 253         }
 254         delete pActionInfo;
 255
 256         return result;
 257 }
 258
 259
 260 bool
 261 _WebAccessibilityFocusHandler::OnMoveFocus(const Tizen::Graphics::Point& point)
 262 {
 263         Ewk_View_Smart_Data* pSmartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(__pView));
 264         SysAssertf(pSmartData, "Failed to get webkit smart data.");
 265
 266         Elm_Access_Action_Info* pActionInfo = new Elm_Access_Action_Info();
 267         SysTryReturn(NID_WEB_CTRL, pActionInfo, false, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 268
 269         bool result = false;
 270
 271         pActionInfo->action_type = ELM_ACCESS_ACTION_READ;
 272         pActionInfo->x = point.x;
 273         pActionInfo->y = point.y;
 274
 275         result = pSmartData->api->screen_reader_action_execute(pSmartData, pActionInfo);
 276         delete pActionInfo;
 277
 278         return result;
 279 }
 280
 281
 282 }
 283
 284
 285 namespace Tizen { namespace Web { namespace Controls
 286 {
 287
 288
 289 void
 290 OnEdgeLeft(void* pUserData, Evas_Object* pView, void* pEventInfo)
 291 {
 292         _Web* pCore = reinterpret_cast< _Web* >(pUserData);
 293         SysAssertf(pCore, "Failed to request");
 294
 295         pCore->SetEdgeReachedEvent(WEB_EDGE_LEFT);
 296 }
 297
 298
 299 void
 300 OnEdgeRight(void* pUserData, Evas_Object* pView, void* pEventInfo)
 301 {
 302         _Web* pCore = reinterpret_cast< _Web* >(pUserData);
 303         SysAssertf(pCore, "Failed to request");
 304
 305         pCore->SetEdgeReachedEvent(WEB_EDGE_RIGHT);
 306 }
 307
 308
 309 void
 310 OnEdgeTop(void* pUserData, Evas_Object* pView, void* pEventInfo)
 311 {
 312         _Web* pCore = reinterpret_cast< _Web* >(pUserData);
 313         SysAssertf(pCore, "Failed to request");
 314
 315         pCore->SetEdgeReachedEvent(WEB_EDGE_TOP);
 316 }
 317
 318
 319 void
 320 OnEdgeBottom(void* pUserData, Evas_Object* pView, void* pEventInfo)
 321 {
 322         _Web* pCore = reinterpret_cast< _Web* >(pUserData);
 323         SysAssertf(pCore, "Failed to request");
 324
 325         pCore->SetEdgeReachedEvent(WEB_EDGE_BOTTOM);
 326 }
 327
 328
 329 _Web::_Web(void)
 330         : __pGestureHandler(null)
 331         , __pEflWebkit(null)
 332         , __pWebSetting(null)
 333         , __pGestureFlick(null)
 334         , __pGestureLongPress(null)
 335         , __pGesturePinch(null)
 336         , __pGestureDoubleTap(null)
 337         , __pTouchEventInfoList(null)
 338         , __pTapGestureHandler(null)
 339         , __pPanningGestureHandler(null)
 340         , __pFlickGestureHandler(null)
 341         , __pPinchGestureHandler(null)
 342         , __gestureType(WEB_GESTURE_TYPE_TAP)
 343         , __edgeType(WEB_EDGE_NONE)
 344         , __pTextElement(null)
 345         , __previousTouchedPosition(0.0f, 0.0f)
 346         , __isFullScreenEntered(false)
 347 {
 348         SetBackgroundColor(Color(0, 0, 0, 0));
 349 }
 350
 351
 352 _Web::~_Web(void)
 353 {
 354         _UiEventManager* pManager = _UiEventManager::GetInstance();
 355         SysAssertf(pManager, "Failed to get ui evnet manager.");
 356
 357         pManager->RemoveKeyEventListener(*this);
 358
 359         RemoveGestureListener();
 360 }
 361
 362
 363 _Web*
 364 _Web::CreateWebN(void)
 365 {
 366         result r = E_SUCCESS;
 367
 368         std::unique_ptr<_Web> pWeb(new (std::nothrow) _Web());
 369         SysTryReturn(NID_WEB_CTRL, pWeb.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 370
 371         pWeb->__pWebSetting = std::unique_ptr<WebSetting>(new (std::nothrow) WebSetting());
 372         SysTryReturn(NID_WEB_CTRL, pWeb->__pWebSetting.get(), null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 373
 374         pWeb->AcquireHandle();
 375         pWeb->SetMultiTouchEnabled(true);
 376         pWeb->SetTouchPressThreshold(0.08);
 377
 378         r = pWeb->AddGestureListeners();
 379         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 380
 381         r = pWeb->InitializeGestureStates();
 382         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 383
 384         _UiEventManager* pManager = _UiEventManager::GetInstance();
 385         SysAssertf(pManager, "Failed to get ui evnet manager.");
 386
 387         pManager->AddKeyEventListener(*pWeb.get());
 388
 389         return pWeb.release();
 390 }
 391
 392
 393 result
 394 _Web::CreateWebkitEvasObject(void)
 395 {
 396         result r = E_SUCCESS;
 397
 398         std::unique_ptr<_EflWebkit> pEflWebkit(new (std::nothrow) _EflWebkit());
 399         SysTryReturnResult(NID_WEB_CTRL, pEflWebkit.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 400
 401         _VisualElement* pVe = GetVisualElement();
 402         r = pEflWebkit->Construct(GetAbsoluteBounds(), *pVe, this);
 403         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 404
 405         _VisualElementImpl* pVeImpl = _VisualElementImpl::GetInstance(*pVe);
 406         pVeImpl->SetCaptureProvider(this);
 407
 408         __pEflWebkit = std::move(pEflWebkit);
 409
 410         Evas_Object* pView = GetWebNativeNode();
 411         evas_object_smart_callback_add(pView, "edge,left", OnEdgeLeft, this);
 412         evas_object_smart_callback_add(pView, "edge,right", OnEdgeRight, this);
 413         evas_object_smart_callback_add(pView, "edge,top", OnEdgeTop, this);
 414         evas_object_smart_callback_add(pView, "edge,bottom", OnEdgeBottom, this);
 415
 416         return E_SUCCESS;
 417 }
 418
 419
 420 result
 421 _Web::InitializeGestureStates(void)
 422 {
 423         __pPinchGestureHandler = std::unique_ptr<_PinchGestureState>(new (std::nothrow) _PinchGestureState(this));
 424         SysTryReturnResult(NID_WEB_CTRL, __pPinchGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 425
 426         __pTapGestureHandler = std::unique_ptr<_TapGestureState>(new (std::nothrow) _TapGestureState(this));
 427         SysTryReturnResult(NID_WEB_CTRL, __pTapGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 428
 429         __pPanningGestureHandler = std::unique_ptr<_PanningGestureState>(new (std::nothrow) _PanningGestureState(this));
 430         SysTryReturnResult(NID_WEB_CTRL, __pPanningGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 431
 432         __pFlickGestureHandler = std::unique_ptr<_FlickGestureState>(new (std::nothrow) _FlickGestureState(this));
 433         SysTryReturnResult(NID_WEB_CTRL, __pFlickGestureHandler.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 434
 435         __pGestureHandler = __pTapGestureHandler.get();
 436
 437         return E_SUCCESS;
 438 }
 439
 440
 441 result
 442 _Web::AddGestureListeners(void)
 443 {
 444         result r = E_SUCCESS;
 445
 446         std::unique_ptr<_TouchFlickGestureDetector> pGestureFlick(new (std::nothrow) _TouchFlickGestureDetector());
 447         SysTryReturnResult(NID_WEB_CTRL, pGestureFlick.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 448
 449         r = pGestureFlick->AddGestureListener(*this);
 450         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 451
 452         r = AddGestureDetector(*pGestureFlick.get());
 453         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 454
 455         __pGestureFlick = std::move(pGestureFlick);
 456
 457         std::unique_ptr<_TouchLongPressGestureDetector> pGestureLongPress(new (std::nothrow) _TouchLongPressGestureDetector());
 458         SysTryReturnResult(NID_WEB_CTRL, pGestureLongPress.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 459
 460         r = pGestureLongPress->AddGestureListener(*this);
 461         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 462
 463         r = AddGestureDetector(*pGestureLongPress.get());
 464         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 465
 466         __pGestureLongPress = std::move(pGestureLongPress);
 467
 468         std::unique_ptr<_TouchTapGestureDetector> pGestureDoubleTap(new (std::nothrow) _TouchTapGestureDetector());
 469         SysTryReturnResult(NID_WEB_CTRL, pGestureDoubleTap.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 470
 471         r = pGestureDoubleTap->AddGestureListener(*this);
 472         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 473
 474         r = AddGestureDetector(*pGestureDoubleTap.get());
 475         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 476
 477         __pGestureDoubleTap = std::move(pGestureDoubleTap);
 478
 479         std::unique_ptr<_TouchPinchGestureDetector> pGesturePinch(new (std::nothrow) _TouchPinchGestureDetector());
 480         SysTryReturnResult(NID_WEB_CTRL, pGesturePinch.get(), E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 481
 482         r = pGesturePinch->AddGestureListener(*this);
 483         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 484
 485         r = AddGestureDetector(*pGesturePinch.get());
 486         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 487
 488         __pGesturePinch = std::move(pGesturePinch);
 489
 490         return E_SUCCESS;
 491 }
 492
 493
 494 void
 495 _Web::RemoveGestureListener(void)
 496 {
 497         if (__pGestureFlick.get())
 498         {
 499                 __pGestureFlick->RemoveGestureListener(*this);
 500                 RemoveGestureDetector(*__pGestureFlick);
 501         }
 502
 503         if (__pGestureLongPress.get())
 504         {
 505                 __pGestureLongPress->RemoveGestureListener(*this);
 506                 RemoveGestureDetector(*__pGestureLongPress);
 507         }
 508
 509         if (__pGestureDoubleTap.get())
 510         {
 511                 __pGestureDoubleTap->RemoveGestureListener(*this);
 512                 RemoveGestureDetector(*__pGestureDoubleTap);
 513         }
 514
 515         if (__pGesturePinch.get())
 516         {
 517                 __pGesturePinch->RemoveGestureListener(*this);
 518                 RemoveGestureDetector(*__pGesturePinch);
 519         }
 520
 521         Evas_Object* pView = GetWebNativeNode();
 522         if (pView)
 523         {
 524                 evas_object_smart_callback_del(pView, "edge,left", OnEdgeLeft);
 525                 evas_object_smart_callback_del(pView, "edge,right", OnEdgeRight);
 526                 evas_object_smart_callback_del(pView, "edge,top", OnEdgeTop);
 527                 evas_object_smart_callback_del(pView, "edge,bottom", OnEdgeBottom);
 528         }
 529 }
 530
 531
 532 result
 533 _Web::InitializeWebNativeNode(void)
 534 {
 535         result r = E_SUCCESS;
 536
 537         r = CreateWebkitEvasObject();
 538         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 539
 540         SetNativeObjectFocusable(false);
 541
 542         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 543         SysTryReturn(NID_WEB_CTRL, pContainer, E_SYSTEM, E_SYSTEM, "[%s] Propagating.", GetErrorMessage(E_SYSTEM));
 544
 545         __pTextElement = new (std::nothrow) _AccessibilityElement(true);
 546         SysTryReturn(NID_WEB_CTRL, __pTextElement, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 547
 548         __pTextElement->SetBounds(FloatRectangle(0.0f, 0.0f, GetBoundsF().width, GetBoundsF().height));
 549         __pTextElement->SetLabel(L"Web control");
 550
 551         pContainer->AddElement(*__pTextElement);
 552         pContainer->Activate(true);
 553
 554         _WebAccessibilityListener* pListener = new (std::nothrow) _WebAccessibilityListener(GetWebNativeNode());
 555         SysTryReturn(NID_WEB_CTRL, pListener, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 556
 557         pContainer->AddListener(*dynamic_cast<_IAccessibilityListener*>(pListener));
 558
 559         _WebAccessibilityFocusHandler* pFocusHandler = new (std::nothrow) _WebAccessibilityFocusHandler(GetWebNativeNode());
 560         SysTryReturn(NID_WEB_CTRL, pFocusHandler, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 561
 562         pContainer->SetFocusHandler(dynamic_cast<_IAccessibilityFocusHandler*>(pFocusHandler));
 563
 564         return E_SUCCESS;
 565 }
 566
 567
 568 Point
 569 _Web::GetAbsoluteCoordinate(Point relativePoint)
 570 {
 571         return _CoordinateSystemUtils::Transform(ConvertToScreenPosition(relativePoint));
 572 }
 573
 574
 575 FloatPoint
 576 _Web::GetAbsoluteCoordinate(FloatPoint relativePoint)
 577 {
 578         return _CoordinateSystemUtils::Transform(ConvertToScreenPosition(relativePoint));
 579 }
 580
 581
 582 Point
 583 _Web::GetRelativeCoordinate(Point absolutePoint)
 584 {
 585         return ConvertToControlPosition(_CoordinateSystemUtils::InverseTransform(absolutePoint));
 586 }
 587
 588
 589 FloatPoint
 590 _Web::GetRelativeCoordinate(FloatPoint absolutePoint)
 591 {
 592         return ConvertToControlPosition(_CoordinateSystemUtils::InverseTransform(absolutePoint));
 593 }
 594
 595
 596 Evas_Object*
 597 _Web::GetWebNativeNode(void)
 598 {
 599         if (__pEflWebkit.get())
 600         {
 601                 return __pEflWebkit->GetWebEvasObject();
 602         }
 603
 604         return null;
 605 }
 606
 607
 608 WebSetting*
 609 _Web::GetSetting(void) const
 610 {
 611         return __pWebSetting.get();
 612 }
 613
 614
 615 result
 616 _Web::OnAttaching(const _Control* pParent)
 617 {
 618         if (__pEflWebkit.get())
 619         {
 620                 evas_object_show(__pEflWebkit->GetWebEvasObject());
 621                 evas_object_focus_set(__pEflWebkit->GetWebEvasObject(), EINA_TRUE);
 622         }
 623
 624         return E_SUCCESS;
 625 }
 626
 627
 628 result
 629 _Web::OnBoundsChanging(const Rectangle& bounds)
 630 {
 631         Rectangle absoluteBounds = GetAbsoluteBounds();
 632         Rectangle webBounds = GetBounds();
 633         _ICoordinateSystemTransformer* pXformer = _CoordinateSystem::GetInstance()->GetTransformer();
 634         SysTryReturnResult(NID_WEB_CTRL, pXformer, E_SYSTEM, "[%s] A system error has been occurred. Failed to get coordinate transformer.", GetErrorMessage(E_SYSTEM));
 635
 636         if (__pEflWebkit.get())
 637         {
 638                 evas_object_move(__pEflWebkit->GetWebEvasObject(), pXformer->TransformHorizontal(absoluteBounds.x - webBounds.x + bounds.x), pXformer->TransformVertical(absoluteBounds.y - webBounds.y + bounds.y));
 639                 evas_object_resize(__pEflWebkit->GetWebEvasObject(), pXformer->TransformHorizontal(bounds.width), pXformer->TransformVertical(bounds.height));
 640         }
 641
 642         return E_SUCCESS;
 643 }
 644
 645
 646 void
 647 _Web::ChangeGesture(_WebGestureType type)
 648 {
 649         switch (type)
 650         {
 651         case WEB_GESTURE_TYPE_TAP:
 652                 __pGestureHandler = __pTapGestureHandler.get();
 653                 __gestureType = WEB_GESTURE_TYPE_TAP;
 654                 break;
 655
 656         case WEB_GESTURE_TYPE_PANNING:
 657                 __pGestureHandler = __pPanningGestureHandler.get();
 658                 __gestureType = WEB_GESTURE_TYPE_PANNING;
 659                 break;
 660
 661         case WEB_GESTURE_TYPE_FLICK:
 662                 __pGestureHandler = __pFlickGestureHandler.get();
 663                 __gestureType = WEB_GESTURE_TYPE_FLICK;
 664                 break;
 665
 666         case WEB_GESTURE_TYPE_PINCH:
 667                 __pGestureHandler = __pPinchGestureHandler.get();
 668                 __gestureType = WEB_GESTURE_TYPE_PINCH;
 669                 break;
 670
 671         default:
 672                 SysAssert(false);
 673         }
 674 }
 675
 676
 677 void
 678 _Web::SetEdgeReachedEvent(_WebEdgeType type)
 679 {
 680         __edgeType |= type;
 681
 682         switch(type)
 683         {
 684         case WEB_EDGE_LEFT:
 685                 __edgeType &= ~WEB_EDGE_RIGHT;
 686                 break;
 687
 688         case WEB_EDGE_RIGHT:
 689                 __edgeType &= ~WEB_EDGE_LEFT;
 690                 break;
 691
 692         case WEB_EDGE_TOP:
 693                 __edgeType &= ~WEB_EDGE_BOTTOM;
 694                 break;
 695
 696         case WEB_EDGE_BOTTOM:
 697                 __edgeType &= ~WEB_EDGE_TOP;
 698                 break;
 699
 700         default:
 701                 SysAssert(false);
 702         }
 703 }
 704
 705
 706 bool
 707 _Web::OnTouchPressed(const _Control& source, const _TouchInfo& touchInfo)
 708 {
 709         evas_object_focus_set(GetWebNativeNode(), EINA_TRUE);
 710
 711         if (__pEflWebkit.get())
 712         {
 713                 __edgeType = WEB_EDGE_NONE;
 714                 __previousTouchedPosition = touchInfo.GetCurrentPosition();
 715
 716                 SendTouchEventForJavaScript(touchInfo);
 717
 718                 return __pGestureHandler->OnTouchPressed(source, touchInfo);
 719         }
 720
 721         return false;
 722 }
 723
 724
 725 bool
 726 _Web::OnTouchMoved(const _Control& source, const _TouchInfo& touchInfo)
 727 {
 728         if (__pEflWebkit.get())
 729         {
 730                 if (__gestureType == WEB_GESTURE_TYPE_TAP)
 731                 {
 732                         __pPanningGestureHandler->InitializeTextSelectionStatus();
 733                 }
 734
 735                 SendTouchEventForJavaScript(touchInfo);
 736
 737                 __pGestureHandler->OnTouchMoved(source, touchInfo);
 738
 739                 float scrollDistanceX = __previousTouchedPosition.x - touchInfo.GetCurrentPosition().x;
 740                 float scrollDistanceY = __previousTouchedPosition.y - touchInfo.GetCurrentPosition().y;
 741                 __previousTouchedPosition = touchInfo.GetCurrentPosition();
 742
 743                 if (__edgeType !=  WEB_EDGE_NONE && __gestureType == WEB_GESTURE_TYPE_PANNING)
 744                 {
 745                         if (_Abs(scrollDistanceY) < _Abs(scrollDistanceX))
 746                         {
 747                                 if  (__edgeType & WEB_EDGE_LEFT)
 748                                 {
 749                                         if (scrollDistanceX < 0)
 750                                         {
 751                                                 __edgeType &= ~WEB_EDGE_RIGHT;
 752
 753                                                 return false;
 754                                         }
 755                                         else
 756                                         {
 757                                                 __edgeType &= ~WEB_EDGE_LEFT;
 758                                         }
 759                                 }
 760                                 else if  (__edgeType & WEB_EDGE_RIGHT)
 761                                 {
 762                                         if (scrollDistanceX > 0)
 763                                         {
 764                                                 __edgeType &= ~WEB_EDGE_LEFT;
 765
 766                                                 return false;
 767                                         }
 768                                         else
 769                                         {
 770                                                 __edgeType &= ~WEB_EDGE_RIGHT;
 771                                         }
 772                                 }
 773                         }
 774                         else if (_Abs(scrollDistanceY) > _Abs(scrollDistanceX))
 775                         {
 776                                 if  (__edgeType & WEB_EDGE_TOP)
 777                                 {
 778                                         if (scrollDistanceY < 0)
 779                                         {
 780                                                 __edgeType &= ~WEB_EDGE_BOTTOM;
 781
 782                                                 return false;
 783                                         }
 784                                         else
 785                                         {
 786                                                 __edgeType &= ~WEB_EDGE_TOP;
 787                                         }
 788                                 }
 789                                 else if  (__edgeType & WEB_EDGE_BOTTOM)
 790                                 {
 791                                         if (scrollDistanceY > 0)
 792                                         {
 793                                                 __edgeType &= ~WEB_EDGE_TOP;
 794
 795                                                 return false;
 796                                         }
 797                                         else
 798                                         {
 799                                                 __edgeType &= ~WEB_EDGE_BOTTOM;
 800                                         }
 801                                 }
 802                         }
 803                 }
 804
 805                 return true;
 806         }
 807
 808         return false;
 809 }
 810
 811
 812 bool
 813 _Web::OnTouchReleased(const _Control& source, const _TouchInfo& touchInfo)
 814 {
 815         SetFocused();
 816
 817         if (__pEflWebkit.get())
 818         {
 819                 SendTouchEventForJavaScript(touchInfo);
 820
 821                 return __pGestureHandler->OnTouchReleased(source, touchInfo);
 822         }
 823
 824         return false;
 825 }
 826
 827
 828 bool
 829 _Web::OnTouchCanceled(const _Control& source, const _TouchInfo& touchInfo)
 830 {
 831         if (__pEflWebkit.get())
 832         {
 833                 SendTouchEventForJavaScript(touchInfo);
 834
 835                 return __pGestureHandler->OnTouchCanceled(source, touchInfo);
 836         }
 837
 838         return false;
 839 }
 840
 841
 842 void
 843 _Web::OnTouchPressHandled(const _Control& control)
 844 {
 845 }
 846
 847
 848 void
 849 _Web::OnTouchReleaseHandled(const _Control& control)
 850 {
 851 }
 852
 853
 854 void
 855 _Web::OnTouchMoveHandled(const _Control& control)
 856 {
 857 }
 858
 859
 860 void
 861 _Web::OnTouchCancelHandled(const _Control& control)
 862 {
 863 }
 864
 865
 866 bool
 867 _Web::OnLongPressGestureDetected(_TouchLongPressGestureDetector& gesture)
 868 {
 869         if (__pEflWebkit.get() && __gestureType == WEB_GESTURE_TYPE_TAP)
 870         {
 871                 return __pTapGestureHandler->OnLongPressGestureDetected(gesture);
 872         }
 873
 874         return true;
 875 }
 876
 877
 878 bool
 879 _Web::OnLongPressGestureCanceled(_TouchLongPressGestureDetector& gesture)
 880 {
 881         return true;
 882 }
 883
 884
 885 bool
 886 _Web::OnTapGestureDetected(_TouchTapGestureDetector& gesture)
 887 {
 888         if (__pEflWebkit.get())
 889         {
 890                 return __pTapGestureHandler->OnTapGestureDetected(gesture);
 891         }
 892
 893         return true;
 894 }
 895
 896
 897 bool
 898 _Web::OnTapGestureCanceled(_TouchTapGestureDetector& gesture)
 899 {
 900         return true;
 901 }
 902
 903
 904 bool
 905 _Web::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
 906 {
 907         if (__pEflWebkit.get() && _WebSettingImpl::GetInstance(__pWebSetting.get())->IsScrollEnabled())
 908         {
 909                 return __pFlickGestureHandler->OnFlickGestureDetected(gesture);
 910         }
 911
 912         return true;
 913 }
 914
 915
 916 bool
 917 _Web::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
 918 {
 919         return true;
 920 }
 921
 922
 923 bool
 924 _Web::OnPinchGestureStarted(Tizen::Ui::_TouchPinchGestureDetector& gesture)
 925 {
 926         if (__pEflWebkit.get())
 927         {
 928                 return __pPinchGestureHandler->OnPinchGestureStarted(gesture);
 929         }
 930
 931         return true;
 932 }
 933
 934
 935 bool
 936 _Web::OnPinchGestureChanged(Tizen::Ui::_TouchPinchGestureDetector& gesture)
 937 {
 938         if (__pEflWebkit.get() && __gestureType == WEB_GESTURE_TYPE_PINCH)
 939         {
 940                 return __pPinchGestureHandler->OnPinchGestureChanged(gesture);
 941         }
 942
 943         return true;
 944 }
 945
 946
 947 bool
 948 _Web::OnPinchGestureFinished(Tizen::Ui::_TouchPinchGestureDetector& gesture)
 949 {
 950         if (__pEflWebkit.get() && __gestureType == WEB_GESTURE_TYPE_PINCH)
 951         {
 952                 return __pPinchGestureHandler->OnPinchGestureFinished(gesture);
 953         }
 954
 955         return true;
 956 }
 957
 958
 959 bool
 960 _Web::OnPinchGestureCanceled(Tizen::Ui::_TouchPinchGestureDetector& gesture)
 961 {
 962         return true;
 963 }
 964
 965
 966 Canvas*
 967 _Web::OnCanvasRequestedN(const FloatRectangle& bounds)
 968 {
 969         SysTryReturn(NID_WEB_CTRL, bounds.width >= 0.0f && bounds.height >= 0.0f, null, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] Canvas size is out of range. size = (%f, %f)", bounds.width, bounds.height);
 970         if (bounds.width == 0.0f || bounds.height == 0.0f)
 971         {
 972                 FloatDimension size(GetSizeF());
 973                 SysTryReturn(NID_WEB_CTRL, bounds.x >= 0.0f && bounds.y >= 0.0f && bounds.x <= size.width && bounds.y <= size.height, null, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] Bounds is out of range.");
 974         }
 975
 976         result r = E_SUCCESS;
 977
 978         Rectangle absBounds(_CoordinateSystemUtils::ConvertToInteger(_CoordinateSystemUtils::Transform(bounds)));
 979
 980         Eina_Rectangle rect;
 981         EINA_RECTANGLE_SET(&rect, absBounds.x, absBounds.y, absBounds.width, absBounds.height);
 982
 983         Evas_Object* pWebFrame = GetWebNativeNode();
 984         Evas_Object* pScreenShot = ewk_view_screenshot_contents_get(pWebFrame, rect, 1.0f, evas_object_evas_get(pWebFrame));
 985
 986         std::unique_ptr<Canvas> pCanvas(new (std::nothrow) Canvas());
 987         SysTryReturn(NID_WEB_CTRL, pCanvas.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 988
 989         if (pScreenShot)
 990         {
 991                 BufferInfo bufferInfo;
 992
 993                 r = _Utility::GetPixelBufferFromEvasObject(pScreenShot, bufferInfo);
 994                 evas_object_del(pScreenShot);
 995                 SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 996
 997                 r = pCanvas->Construct(bufferInfo);
 998                 SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
 999         }
1000         else
1001         {
1002                 r = pCanvas->Construct(bounds);
1003                 SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
1004         }
1005
1006         return pCanvas.release();
1007 }
1008
1009
1010 Bitmap*
1011 _Web::OnCapturedBitmapRequestedN(void)
1012 {
1013         result r = E_SUCCESS;
1014
1015         BufferInfo bufferInfo;
1016         SysTryReturn(NID_WEB_CTRL, OnCaptureAcquire(bufferInfo), null, E_SYSTEM, "[%s] A system error has been occurred. Failed to get snapshot of Web control", GetErrorMessage(E_SYSTEM));
1017
1018         ByteBuffer buffer;
1019         int bufferSize = bufferInfo.bitsPerPixel * bufferInfo.width * bufferInfo.height;
1020
1021         r = buffer.Construct(reinterpret_cast < byte* >(bufferInfo.pPixels), 0, bufferSize, bufferSize);
1022         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
1023
1024         std::unique_ptr<Bitmap> pBitmap(new (std::nothrow) Bitmap());
1025         SysTryReturn(NID_WEB_CTRL, pBitmap.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1026
1027         r = pBitmap->Construct(buffer, Dimension(bufferInfo.width, bufferInfo.height), BITMAP_PIXEL_FORMAT_ARGB8888);
1028         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] propagating", GetErrorMessage(r));
1029
1030         return pBitmap.release();
1031 }
1032
1033
1034 bool
1035 _Web::OnCaptureAcquire(BufferInfo& output)
1036 {
1037         result r = E_SUCCESS;
1038
1039         FloatPoint position(GetPositionF());
1040         FloatDimension size(GetSizeF());
1041
1042         Dimension absSize(_CoordinateSystemUtils::ConvertToInteger(_CoordinateSystemUtils::Transform(size)));
1043
1044         Eina_Rectangle rect;
1045         EINA_RECTANGLE_SET(&rect, 0, 0, absSize.width, absSize.height);
1046
1047         Evas_Object* pWebFrame = GetWebNativeNode();
1048         Evas_Object* pScreenShot = ewk_view_screenshot_contents_get(pWebFrame, rect, 1.0f, evas_object_evas_get(pWebFrame));
1049         SysTryReturn(NID_WEB_CTRL, pScreenShot, false, E_SYSTEM, "[%s] A system error has been occurred. Failed to get snapshot of Web control", GetErrorMessage(E_SYSTEM));
1050
1051         r = _Utility::GetPixelBufferFromEvasObject(pScreenShot, output);
1052         evas_object_del(pScreenShot);
1053         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, false, r, "[%s] propagating", GetErrorMessage(r));
1054
1055         return true;
1056 }
1057
1058
1059 void
1060 _Web::SendTouchEventForJavaScript(const _TouchInfo& touchInfo)
1061 {
1062         result r = E_SUCCESS;
1063
1064         _TouchManager* pTouchManager = _TouchManager::GetInstance();
1065         SysAssertf(pTouchManager, "Failed to get touch manager.");
1066
1067         std::unique_ptr<IListT<_FingerInfo*> > pTouchList(pTouchManager->GetMultiFingerInfoListN());
1068         SysTryReturnVoidResult(NID_WEB_CTRL, pTouchList.get(), GetLastResult(), "[%s] Failed to get touch list.", GetErrorMessage(GetLastResult()));
1069
1070         std::unique_ptr<IBidirectionalEnumeratorT<_FingerInfo*> > pTouchListEnum(pTouchList->GetBidirectionalEnumeratorN());
1071         SysAssertf(pTouchListEnum.get() != null, "Failed to get enumerator of touch list.");
1072
1073         Eina_List* pPointList = null;
1074         _FingerInfo* pFingerInfo = null;
1075         while(pTouchListEnum->MoveNext() == E_SUCCESS)
1076         {
1077                 r = pTouchListEnum->GetCurrent(pFingerInfo);
1078                 SysTryReturnVoidResult(NID_WEB_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1079
1080                 _TouchStatus state = pFingerInfo->GetStatus();
1081                 if(state == _TOUCH_PRESSED || state == _TOUCH_MOVED || state == _TOUCH_RELEASED || state == _TOUCH_CANCELED)
1082                 {
1083                         Point integerPoint(_CoordinateSystemUtils::ConvertToInteger(GetAbsoluteCoordinate(pFingerInfo->GetPoint())));
1084
1085                         Ewk_Touch_Point* pPoint = static_cast<Ewk_Touch_Point*>(calloc(1, sizeof(Ewk_Touch_Point)));
1086                         pPoint->id = pFingerInfo->GetPointId();
1087                         pPoint->x = integerPoint.x;
1088                         pPoint->y = integerPoint.y;
1089                         pPoint->state = GetEvasTouchState((TouchStatus)pFingerInfo->GetStatus());
1090                         SysSecureLog(NID_WEB_CTRL, "The current value of id is %lu, x is %d, y is %d, state is %d", pPoint->id, pPoint->x, pPoint->y, pPoint->state);
1091
1092                         pPointList = eina_list_append(pPointList, pPoint);
1093                 }
1094         }
1095
1096         ewk_view_feed_touch_event(__pEflWebkit->GetWebEvasObject(), GetEwkTouchEvent(touchInfo.GetTouchStatus()), pPointList, null);
1097
1098         void* pData = null;
1099         EINA_LIST_FREE(pPointList, pData)
1100         free(pData);
1101 }
1102
1103
1104 Ewk_Touch_Event_Type
1105 _Web::GetEwkTouchEvent(_TouchStatus touchStatus)
1106 {
1107         Ewk_Touch_Event_Type ewkTouchEvent = EWK_TOUCH_CANCEL;
1108
1109         switch (touchStatus)
1110         {
1111         case _TOUCH_PRESSED :
1112                 ewkTouchEvent = EWK_TOUCH_START;
1113                 break;
1114         case _TOUCH_MOVED :
1115                 ewkTouchEvent = EWK_TOUCH_MOVE;
1116                 break;
1117         case _TOUCH_RELEASED :
1118                 ewkTouchEvent = EWK_TOUCH_END;
1119                 break;
1120         case _TOUCH_CANCELED :
1121                 //fall through
1122         default :
1123                 ewkTouchEvent = EWK_TOUCH_CANCEL;
1124                 break;
1125         }
1126
1127         return ewkTouchEvent;
1128 }
1129
1130
1131 Evas_Touch_Point_State
1132 _Web::GetEvasTouchState(TouchStatus touchStatus)
1133 {
1134         Evas_Touch_Point_State evasTouchState = EVAS_TOUCH_POINT_CANCEL;
1135
1136         switch (touchStatus)
1137         {
1138         case TOUCH_PRESSED :
1139                 evasTouchState = EVAS_TOUCH_POINT_DOWN;
1140                 break;
1141         case TOUCH_MOVED :
1142                 evasTouchState = EVAS_TOUCH_POINT_MOVE;
1143                 break;
1144         case TOUCH_RELEASED :
1145                 evasTouchState = EVAS_TOUCH_POINT_UP;
1146                 break;
1147         case TOUCH_CANCELED :
1148                 //fall through
1149         default :
1150                 evasTouchState = EVAS_TOUCH_POINT_CANCEL;
1151                 //todo : mapping    EVAS_TOUCH_POINT_STILL, /**< Touch point is not moved af
1152                 break;
1153         }
1154
1155         return evasTouchState;
1156 }
1157
1158
1159 void
1160 _Web::SetFullScreenEntered(bool isFullScreenEntered)
1161 {
1162         __isFullScreenEntered = isFullScreenEntered;
1163 }
1164
1165
1166 bool
1167 _Web::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
1168 {
1169         if (__isFullScreenEntered)
1170         {
1171                 if (keyInfo.GetKeyCode() == _KEY_ESC || keyInfo.GetKeyCode() == _KEY_BACK)
1172                 {
1173                         __isFullScreenEntered = false;
1174
1175                         ewk_view_fullscreen_exit(GetWebNativeNode());
1176
1177                         return true;
1178                 }
1179         }
1180
1181         return false;
1182 }
1183
1184
1185 }}} // Tizen::Web::Controls