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