src/ui/FUi_ControlImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 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                FUi_ControlImpl.cpp
  20  * @brief               This is the implementation file for _ControlImpl class.
  21  */
  22
  23 #include <FBaseColArrayListT.h>
  24 #include <FBaseColLinkedListT.h>
  25 #include <FBaseRtIEventListener.h>
  26 #include <FBaseRtITimerEventListener.h>
  27 #include <FUiIDragDropEventListener.h>
  28 #include <FUiAccessibilityContainer.h>
  29 #include <FUiAnimControlAnimator.h>
  30 #include <FUiTouchGestureDetector.h>
  31 #include <FApp_AppInfo.h>
  32 #include <FBaseSysLog.h>
  33 #include <FBase_Log.h>
  34 #include <FUiIPropagatedTouchEventListener.h>
  35 #include <FUiIPropagatedKeyEventListener.h>
  36 #include <FUiKeyEventInfo.h>
  37 #include "FUi_ControlImpl.h"
  38 #include "FUi_ContainerImpl.h"
  39 #include "FUi_Control.h"
  40 #include "FUi_ControlManager.h"
  41 #include "FUi_ControlImplManager.h"
  42 #include "FUi_CoordinateSystemUtils.h"
  43 #include "FUi_UiEventManager.h"
  44 #include "FUi_UiNotificationEvent.h"
  45 #include "FUi_UiTouchEvent.h"
  46 #include "FUi_TouchManager.h"
  47 #include "FUi_TouchEventArg.h"
  48 #include "FUi_ITouchLongPressGestureEventListener.h"
  49 #include "FUi_TouchFlickGestureDetector.h"
  50 #include "FUi_TouchGestureDetectorImpl.h"
  51 #include "FUi_AccessibilityContainerImpl.h"
  52 #include "FUi_ResourceManager.h"
  53 #include "FUi_WindowImpl.h"
  54 #include "FUiAnim_VisualElement.h"
  55 #include "FUiAnim_VisualElementImpl.h"
  56 #include "FUiCtrl_Popup.h"
  57 #include "FUi_Window.h"
  58
  59 //#define _TC_PASS
  60
  61 using namespace Tizen::Base;
  62 using namespace Tizen::Base::Collection;
  63 using namespace Tizen::Base::Runtime;
  64 using namespace Tizen::Graphics;
  65 using namespace Tizen::Ui::Animations;
  66 using namespace Tizen::App;
  67 using namespace Tizen::Base::Utility;
  68 using namespace Tizen::Ui::Controls;
  69
  70 namespace Tizen { namespace Ui {
  71
  72 _ControlImpl::SizeInfo::~SizeInfo(void)
  73 {
  74 }
  75
  76 Dimension
  77 _ControlImpl::SizeInfo::GetDefaultMinimumSize(_ControlOrientation orientation) const
  78 {
  79         return Dimension(0, 0);
  80 }
  81
  82 FloatDimension
  83 _ControlImpl::SizeInfo::GetDefaultMinimumSizeF(_ControlOrientation orientation) const
  84 {
  85         return FloatDimension(0.0f, 0.0f);
  86 }
  87
  88 Dimension
  89 _ControlImpl::SizeInfo::GetDefaultMaximumSize(_ControlOrientation orientation) const
  90 {
  91         return Dimension(_Control::MAX_LENGTH, _Control::MAX_LENGTH);
  92 }
  93
  94 FloatDimension
  95 _ControlImpl::SizeInfo::GetDefaultMaximumSizeF(_ControlOrientation orientation) const
  96 {
  97         return FloatDimension(_Control::MAX_LENGTH, _Control::MAX_LENGTH);
  98 }
  99
 100 Dimension
 101 _ControlImpl::SizeInfo::GetMinimumSizeLimit(_ControlOrientation orientation) const
 102 {
 103         return Dimension(0, 0);
 104 }
 105
 106 FloatDimension
 107 _ControlImpl::SizeInfo::GetMinimumSizeLimitF(_ControlOrientation orientation) const
 108 {
 109         return FloatDimension(0.0f, 0.0f);
 110 }
 111
 112 Dimension
 113 _ControlImpl::SizeInfo::GetMaximumSizeLimit(_ControlOrientation orientation) const
 114 {
 115         return Dimension(_Control::MAX_LENGTH, _Control::MAX_LENGTH);
 116 }
 117
 118 FloatDimension
 119 _ControlImpl::SizeInfo::GetMaximumSizeLimitF(_ControlOrientation orientation) const
 120 {
 121         return FloatDimension(_Control::MAX_LENGTH, _Control::MAX_LENGTH);
 122 }
 123
 124 result
 125 _ControlImpl::SizeInfo::CheckInitialSizeValid(const Dimension& size, _ControlOrientation orientation) const
 126 {
 127         ClearLastResult();
 128
 129         const Dimension minSize = GetDefaultMinimumSize(orientation);
 130         const Dimension maxSize = GetDefaultMaximumSize(orientation);
 131
 132         SysTryReturn(NID_UI,
 133                 (minSize.width <= size.width) && (size.width <= maxSize.width), E_INVALID_ARG,
 134                 E_INVALID_ARG, "[E_INVALID_ARG] The width %d is out of width range(%d ~ %d).",
 135                 size.width, minSize.width, maxSize.width);
 136
 137         SysTryReturn(NID_UI,
 138                 (minSize.height <= size.height) && (size.height <= maxSize.height), E_INVALID_ARG,
 139                 E_INVALID_ARG, "[E_INVALID_ARG] The height %d is out of height range(%d ~ %d).",
 140                 size.height, minSize.height, maxSize.height);
 141
 142         return E_SUCCESS;
 143 }
 144
 145 result
 146 _ControlImpl::SizeInfo::CheckInitialSizeValidF(const FloatDimension& size, _ControlOrientation orientation) const
 147 {
 148         ClearLastResult();
 149
 150         const FloatDimension minSize = GetDefaultMinimumSizeF(orientation);
 151         const FloatDimension maxSize = GetDefaultMaximumSizeF(orientation);
 152
 153         SysTryReturn(NID_UI,
 154                 (minSize.width <= size.width) && (size.width <= maxSize.width), E_INVALID_ARG,
 155                 E_INVALID_ARG, "[E_INVALID_ARG] The width %f is out of width range(%f ~ %f).",
 156                 size.width, minSize.width, maxSize.width);
 157
 158         SysTryReturn(NID_UI,
 159                 (minSize.height <= size.height) && (size.height <= maxSize.height), E_INVALID_ARG,
 160                 E_INVALID_ARG, "[E_INVALID_ARG] The height %f is out of height range(%f ~ %f).",
 161                 size.height, minSize.height, maxSize.height);
 162
 163         return E_SUCCESS;
 164 }
 165
 166 const _ControlImpl::SizeInfo&
 167 _ControlImpl::GetFullScreenSizeInfo(void)
 168 {
 169         class FullScreenSizeInfo : public _ControlImpl::SizeInfo
 170         {
 171         public:
 172                 virtual Dimension GetDefaultMinimumSize(_ControlOrientation orientation) const
 173                 {
 174                         return GetScreenSize();
 175                 }
 176
 177                 virtual FloatDimension GetDefaultMinimumSizeF(_ControlOrientation orientation) const
 178                 {
 179                         return GetScreenSizeF();
 180                 }
 181
 182                 virtual Dimension GetDefaultMaximumSize(_ControlOrientation orientation) const
 183                 {
 184                         return GetScreenSize();
 185                 }
 186
 187                 virtual FloatDimension GetDefaultMaximumSizeF(_ControlOrientation orientation) const
 188                 {
 189                         return GetScreenSizeF();
 190                 }
 191
 192                 virtual Dimension GetMinimumSizeLimit(_ControlOrientation orientation) const
 193                 {
 194                         return GetScreenSize();
 195                 }
 196
 197                 virtual FloatDimension GetMinimumSizeLimitF(_ControlOrientation orientation) const
 198                 {
 199                         return GetScreenSizeF();
 200                 }
 201
 202                 virtual Dimension GetMaximumSizeLimit(_ControlOrientation orientation) const
 203                 {
 204                         return GetScreenSize();
 205                 }
 206
 207                 virtual FloatDimension GetMaximumSizeLimitF(_ControlOrientation orientation) const
 208                 {
 209                         return GetScreenSizeF();
 210                 }
 211
 212         private:
 213                 Dimension GetScreenSize(void) const
 214                 {
 215                         _ControlManager* pMgr = _ControlManager::GetInstance();
 216                         SysTryReturn(NID_UI, pMgr, Dimension(0, 0), E_SYSTEM, "[E_SYSTEM] Failed to get control manager.");
 217                         return pMgr->GetScreenSize();
 218                 }
 219
 220                 FloatDimension GetScreenSizeF(void) const
 221                 {
 222                         _ControlManager* pMgr = _ControlManager::GetInstance();
 223                         SysTryReturn(NID_UI, pMgr, FloatDimension(0.0f, 0.0f), E_SYSTEM, "[E_SYSTEM] Failed to get control manager.");
 224                         return pMgr->GetScreenSizeF();
 225                 }
 226         };
 227
 228         static FullScreenSizeInfo sizeInfo;
 229         return sizeInfo;
 230 }
 231
 232 // [ToDo] How to turn-off callback while initializing: Reset/Set delegate?
 233 result
 234 _ControlImpl::InitializeBoundsProperties(const SizeInfo& sizeInfo, _ControlOrientation orientation)
 235 {
 236         result r = E_SUCCESS;
 237
 238         bool resizable = IsResizable();
 239         SetResizable(true);
 240
 241         r = SetMinimumSize(sizeInfo.GetDefaultMinimumSize(orientation));
 242         SysTryReturn(NID_UI,
 243                 r == E_SUCCESS, E_SYSTEM,
 244                 E_SYSTEM, "[E_SYSTEM] Failed to initialize default minimum size.");
 245
 246         r = SetMaximumSize(sizeInfo.GetDefaultMaximumSize(orientation));
 247         SysTryReturn(NID_UI,
 248                 r == E_SUCCESS, E_SYSTEM,
 249                 E_SYSTEM, "[E_SYSTEM] Failed to initialize default maximum size.");
 250
 251         SetResizable(resizable);
 252
 253         return E_SUCCESS;
 254 }
 255
 256 result
 257 _ControlImpl::InitializeBoundsProperties(const SizeInfo& sizeInfo, const Tizen::Graphics::Rectangle& bounds, _ControlOrientation orientation)
 258 {
 259         result r = InitializeBoundsProperties(sizeInfo, orientation);
 260         if (IsFailed(r))
 261         {
 262                 return r;
 263         }
 264
 265         bool movable = IsMovable();
 266         bool resizable = IsResizable();
 267         SetMovable(true);
 268         SetResizable(true);
 269
 270         r = SetBounds(bounds);
 271
 272         SetMovable(movable);
 273         SetResizable(resizable);
 274
 275         return r;
 276 }
 277
 278 result
 279 _ControlImpl::InitializeBoundsPropertiesF(const SizeInfo& sizeInfo, const Tizen::Graphics::FloatRectangle& bounds, _ControlOrientation orientation)
 280 {
 281         result r = InitializeBoundsProperties(sizeInfo, orientation);
 282         if (IsFailed(r))
 283         {
 284                 return r;
 285         }
 286
 287         bool movable = IsMovable();
 288         bool resizable = IsResizable();
 289         SetMovable(true);
 290         SetResizable(true);
 291
 292         r = SetBounds(bounds);
 293
 294         SetMovable(movable);
 295         SetResizable(resizable);
 296
 297         return r;
 298 }
 299
 300 result
 301 _ControlImpl::InitializeBoundsProperties(const SizeInfo& sizeInfo, const Tizen::Graphics::Dimension& size, _ControlOrientation orientation)
 302 {
 303         return InitializeBoundsProperties(sizeInfo, Rectangle(0, 0, size.width, size.height), orientation);
 304 }
 305
 306 result
 307 _ControlImpl::InitializeBoundsPropertiesF(const SizeInfo& sizeInfo, const Tizen::Graphics::FloatDimension& size, _ControlOrientation orientation)
 308 {
 309         return InitializeBoundsPropertiesF(sizeInfo, FloatRectangle(0.0f, 0.0f, size.width, size.height), orientation);
 310 }
 311
 312 _ControlImpl*
 313 _ControlImpl::CreateControlImplN(Control& control)
 314 {
 315         ClearLastResult();
 316         result r = E_SUCCESS;
 317
 318         _Control* pCore = _Control::CreateControlN();
 319         r = GetLastResult();
 320         SysTryReturn(NID_UI, pCore, null, r, "[%s] Propagating.", GetErrorMessage(r));
 321
 322         _ControlImpl* pImpl = new (std::nothrow) _ControlImpl(&control, pCore);
 323         r = CheckConstruction(pCore, pImpl);
 324         SysTryReturn(NID_UI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 325
 326         return pImpl;
 327 }
 328
 329 result
 330 _ControlImpl::Destroy(void)
 331 {
 332         result r = E_SUCCESS;
 333
 334         _ContainerImpl* pParent = GetParent();
 335         if (pParent)
 336         {
 337                 r = pParent->RemoveChild(this, true);
 338                 SysAssert(r == E_SUCCESS);
 339         }
 340         else
 341         {
 342                 _Control* pParent = GetCore().GetParent();
 343                 if (pParent)
 344                 {
 345                         ControlList& children = pParent->GetChildList();
 346                         r = children.Remove(&GetCore());
 347                 }
 348
 349                 Control* pControl= &GetPublic();
 350                 delete pControl;
 351                 pControl = null;
 352         }
 353
 354         return r;
 355 }
 356
 357 _ControlImpl*
 358 _ControlImpl::GetInstance(Control& control)
 359 {
 360         return static_cast <_ControlImpl*> (control._pControlImpl);
 361 }
 362
 363 const _ControlImpl*
 364 _ControlImpl::GetInstance(const Control& control)
 365 {
 366         return static_cast <const _ControlImpl*> (control._pControlImpl);
 367 }
 368
 369 result
 370 _ControlImpl::CheckConstruction(_Control* pCore, _ControlImpl* pImpl)
 371 {
 372         if (pImpl == null)
 373         {
 374                 delete pCore;
 375                 pCore = null;
 376                 SysLogException(NID_UI, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
 377                 return E_OUT_OF_MEMORY;
 378         }
 379
 380         result r = GetLastResult();
 381         if (IsFailed(r))
 382         {
 383                 delete pImpl;
 384                 pImpl = null;
 385                 SysLogException(NID_UI, r, "[%s] Propagating.", GetErrorMessage(r));
 386                 return r;
 387         }
 388
 389         return E_SUCCESS;
 390 }
 391
 392 const Tizen::Base::String _USER_EVENT = L"UserEvent";
 393 const Tizen::Base::String _REQUEST_REDRAW_EVENT = L"RequestRedrawEvent";
 394 const Tizen::Base::String _KEYBOARD_INSERTED_EVENT = L"KeyboardInsertedEvent";
 395 const int keyPressTimer = 500;
 396 const int doublePressTime = 330;
 397 const int doublePressMoveAllowance = 10;
 398
 399 class _UserEventInfo
 400         : public Tizen::Base::Object
 401 {
 402 public:
 403         _UserEventInfo(RequestId requestId, const IList* pArgs)
 404                 : __requestId(requestId)
 405                 , __pArgs(const_cast <IList*>(pArgs))
 406         {
 407         }
 408         virtual ~_UserEventInfo(void) {}
 409
 410         RequestId GetRequestId(void) const
 411         {
 412                 return __requestId;
 413         }
 414
 415         IList* GetArgs(void)
 416         {
 417                 return __pArgs;
 418         }
 419
 420 private:
 421         _UserEventInfo(const _UserEventInfo& rhs);
 422         _UserEventInfo& operator =(const _UserEventInfo& rhs);
 423
 424 private:
 425         RequestId __requestId;
 426         IList* __pArgs;
 427 };
 428
 429 class _ControlImpl::CoreKeyEvent
 430 {
 431 public:
 432         CoreKeyEvent(_ControlImpl& impl)
 433                 : __impl(impl)
 434                 , __core(impl.GetCore())
 435                 , __public(impl.GetPublic())
 436         {
 437         }
 438
 439         ~CoreKeyEvent(void)
 440         {
 441         }
 442
 443 private:
 444         bool IsPublicKey(_KeyCode keyCode)
 445         {
 446                 bool isPublicKey = false;
 447
 448                 if (keyCode <= _KEY_HARDWARE_MAX)
 449                 {
 450                         isPublicKey = true;
 451                 }
 452
 453                 return isPublicKey;
 454         }
 455
 456         result FirePublicListener(IKeyEventListener& listener, KeyState keyState, KeyCode keyCode)
 457         {
 458                 result r = E_SUCCESS;
 459
 460                 switch (keyState)
 461                 {
 462                         case KEY_PRESSED:
 463                                 listener.OnKeyPressed(__public, keyCode);
 464                                 break;
 465                         case KEY_RELEASED:
 466                                 listener.OnKeyReleased(__public, keyCode);
 467                                 break;
 468                         case KEY_LONGPRESSED:
 469                                 listener.OnKeyLongPressed(__public, keyCode);
 470                                 break;
 471                         default:
 472                                 SysAssert(0);
 473                                 r = E_SYSTEM;
 474                                 break;
 475                 }
 476
 477                 return r;
 478         }
 479
 480 public:
 481         bool ProcessListener(KeyState keyState, _KeyCode keyCode)
 482         {
 483                 bool filterd = false;
 484
 485                 // 1. Public
 486                 if (IsPublicKey(keyCode))
 487                 {
 488                         IEnumeratorT <IEventListener*>* pEnumerator = __impl.__pPublicKeyEventListeners->GetEnumeratorN();
 489                         if (pEnumerator)
 490                         {
 491                                 while (pEnumerator->MoveNext() == E_SUCCESS)
 492                                 {
 493                                         IEventListener* pListener = null;
 494                                         pEnumerator->GetCurrent(pListener);
 495
 496                                         IKeyEventListener* pKeyEventListener = dynamic_cast <IKeyEventListener*>(pListener);
 497                                         if (pKeyEventListener)
 498                                         {
 499                                                 FirePublicListener(*pKeyEventListener, keyState, (KeyCode)keyCode);
 500                                         }
 501                                 }
 502                                 delete pEnumerator;
 503                         }
 504                 }
 505
 506                 if (__impl.IsInputEventConsumed())
 507                 {
 508                         __impl.ResetInputEventConsumed();
 509
 510                         filterd = true;
 511                         return filterd;
 512                 }
 513
 514                 // 2. Default
 515                 if (IsPublicKey(keyCode))
 516                 {
 517                         IKeyEventListener* pDefaultListener = __impl.GetDefaultKeyEventListener();
 518                         if (pDefaultListener)
 519                         {
 520                                 FirePublicListener(*pDefaultListener, keyState, (KeyCode)keyCode);
 521
 522                                 if (__impl.IsInputEventConsumed())
 523                                 {
 524                                         __impl.ResetInputEventConsumed();
 525
 526                                         filterd = true;
 527                                         return filterd;
 528                                 }
 529                         }
 530                 }
 531
 532                 return filterd;
 533         }
 534
 535 private:
 536         CoreKeyEvent(const CoreKeyEvent& rhs);
 537         CoreKeyEvent& operator =(const CoreKeyEvent& rhs);
 538
 539 private:
 540         _ControlImpl& __impl;
 541         _Control& __core;
 542         Control& __public;
 543 };
 544
 545 class _ControlImpl::CoreTouchEvent
 546 {
 547 public:
 548         CoreTouchEvent(_ControlImpl& impl)
 549                 : __impl(impl)
 550                 , __core(impl.GetCore())
 551                 , __public(impl.GetPublic())
 552                 , __oldPreviousPressedTime(0)
 553                 , __previousPressedTime(0)
 554                 , __currentPressedTime(0)
 555                 , __previousPressedPoint(0, 0)
 556                 , __currentPressedPoint(0, 0)
 557
 558         {
 559                 __pTouchManager = _TouchManager::GetInstance();
 560                 SysTryReturnVoidResult(NID_UI, __pTouchManager, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 561         }
 562
 563         ~CoreTouchEvent(void)
 564         {
 565         }
 566
 567
 568 private:
 569         _TouchEventArg* GetTouchEventArgN(const _TouchInfo& touchInfo)
 570         {
 571                 _TouchEventArg* pEventArg = new (std::nothrow) _TouchEventArg(__public, touchInfo.GetTouchStatus());
 572                 SysTryReturn(NID_UI, pEventArg, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 573
 574                 Point startPoint(__pTouchManager->GetStartPoint(touchInfo.GetPointId()).x - __core.GetAbsoluteBounds().x,
 575                                 __pTouchManager->GetStartPoint(touchInfo.GetPointId()).y - __core.GetAbsoluteBounds().y);
 576
 577                 pEventArg->SetTouchPosition(touchInfo.GetPointId(), startPoint.x, startPoint.y,
 578                 touchInfo.GetCurrentPosition().x, touchInfo.GetCurrentPosition().y);
 579
 580                 int xDistance = 0;
 581                 int yDistance = 0;
 582                 __impl.__pFlickGestureDetector->GetDistance(xDistance, yDistance);
 583
 584                 if (xDistance != 0 || yDistance != 0)
 585                 {
 586                         pEventArg->SetFlickedStatus(true);
 587                 }
 588                 else
 589                 {
 590                         pEventArg->SetFlickedStatus(false);
 591                 }
 592
 593                 return pEventArg;
 594         }
 595
 596         result FirePublicListener(ITouchEventListener& listener, const TouchEventInfo& touchEventInfo)
 597         {
 598                 result r = E_SUCCESS;
 599
 600                 switch (touchEventInfo.GetTouchStatus())
 601                 {
 602                         case TOUCH_PRESSED:
 603                                 listener.OnTouchPressed(__public, touchEventInfo.GetCurrentPosition(), touchEventInfo);
 604                                 break;
 605                         case TOUCH_LONG_PRESSED:
 606                                 listener.OnTouchLongPressed(__public, touchEventInfo.GetCurrentPosition(), touchEventInfo);
 607                                 break;
 608                         case TOUCH_RELEASED:
 609                                 listener.OnTouchReleased(__public, touchEventInfo.GetCurrentPosition(), touchEventInfo);
 610                                 break;
 611                         case TOUCH_MOVED:
 612                                 listener.OnTouchMoved(__public, touchEventInfo.GetCurrentPosition(), touchEventInfo);
 613                                 break;
 614                         case TOUCH_DOUBLE_PRESSED:
 615                                 listener.OnTouchDoublePressed(__public, touchEventInfo.GetCurrentPosition(), touchEventInfo);
 616                                 break;
 617                         case TOUCH_FOCUS_IN:
 618                                 listener.OnTouchFocusIn(__public, touchEventInfo.GetCurrentPosition(), touchEventInfo);
 619                                 break;
 620                         case TOUCH_FOCUS_OUT:
 621                                 listener.OnTouchFocusOut(__public, touchEventInfo.GetCurrentPosition(), touchEventInfo);
 622                                 break;
 623                         case TOUCH_CANCELED:
 624                                 listener.OnTouchCanceled(__public, touchEventInfo.GetCurrentPosition(), touchEventInfo);
 625                                 break;
 626                         default:
 627                                 SysAssert(0);
 628                                 r = E_SYSTEM;
 629                                 break;
 630                         }
 631
 632                 return r;
 633         }
 634
 635         result FireFocusListener(ITouchEventListener& listener, const TouchEventInfo& touchEventInfo)
 636         {
 637                 result r = E_SUCCESS;
 638
 639                 _ControlManager* pControlManager = _ControlManager::GetInstance();
 640                 SysTryReturn(NID_UI, pControlManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 641
 642                 _TouchManager* pTouchManager = _TouchManager::GetInstance();
 643                 SysTryReturn(NID_UI, pTouchManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 644
 645                 Point screenPoint(pTouchManager->GetScreenPoint(touchEventInfo.GetPointId()).x, pTouchManager->GetScreenPoint(touchEventInfo.GetPointId()).y);
 646
 647                 _Control* pTouchedControl = pControlManager->GetTopmostTouchedControl(screenPoint);
 648                 SysTryReturn(NID_UI, pTouchedControl, E_INVALID_CONDITION, E_INVALID_CONDITION, "[E_INVALID_CONDITION] pTouchedControl is null.");
 649
 650                 if (__pTouchManager->GetFocusedControlSource() != pTouchedControl)
 651                 {
 652                         if (&(__core) != pTouchedControl)
 653                         {
 654                                 if (__pTouchManager->GetFocusedControlSource() == &(__core))
 655                                 {
 656                                         listener.OnTouchFocusOut(__public, touchEventInfo.GetCurrentPosition(), touchEventInfo);
 657                                 }
 658                         }
 659                         else
 660                         {
 661                                 listener.OnTouchFocusIn(__public, touchEventInfo.GetCurrentPosition(), touchEventInfo);
 662                         }
 663
 664                         __pTouchManager->SetFocusedControlSource(*pTouchedControl);
 665                 }
 666
 667                 return r;
 668         }
 669
 670 public:
 671         result ProcessDragListener(const _TouchInfo& touchInfo)
 672         {
 673                 if (!__core.IsDragEnabled())
 674                 {
 675                         return E_INVALID_CONDITION;
 676                 }
 677
 678                 result r = E_SUCCESS;
 679
 680                 IEnumeratorT <IEventListener*>* pDragEnumerator = __impl.__pPublicDragDropEventListeners->GetEnumeratorN();
 681                 if (pDragEnumerator)
 682                 {
 683                         while (pDragEnumerator->MoveNext() == E_SUCCESS)
 684                         {
 685                                 IEventListener* pDragListener = null;
 686                                 pDragEnumerator->GetCurrent(pDragListener);
 687
 688                                 if (pDragListener != null)
 689                                 {
 690                                         IDragDropEventListener* pDragDropEventListener = dynamic_cast <IDragDropEventListener*>(pDragListener);
 691                                         if (pDragDropEventListener != null)
 692                                         {
 693                                                 pDragDropEventListener->OnTouchDragged(__public, _CoordinateSystemUtils::ConvertToInteger(touchInfo.GetCurrentPosition()), _CoordinateSystemUtils::ConvertToInteger(touchInfo.GetCurrentPosition()));
 694                                         }
 695                                         IDragDropEventListenerF* pDragDropEventListenerF = dynamic_cast <IDragDropEventListenerF*>(pDragListener);
 696                                         if (pDragDropEventListenerF != null)
 697                                         {
 698                                                 pDragDropEventListenerF->OnTouchDraggedF(__public, touchInfo.GetCurrentPosition(), touchInfo.GetCurrentPosition());
 699                                         }
 700                                 }
 701                         }
 702                         delete pDragEnumerator;
 703                 }
 704
 705                 return r;
 706         }
 707
 708         result ProcessDropListener(const _TouchInfo& touchInfo)
 709         {
 710                 if (!__core.IsDropEnabled())
 711                 {
 712                         return E_INVALID_CONDITION;
 713                 }
 714
 715                 result r = E_SUCCESS;
 716
 717                 _Control* pDraggedControl = __pTouchManager->GetTouchControlSource();
 718                 if (pDraggedControl != null)
 719                 {
 720                         IEnumeratorT<IEventListener*>* pDropEnumerator = __impl.__pPublicDragDropEventListeners->GetEnumeratorN();
 721                         if (pDropEnumerator)
 722                         {
 723                                 while (pDropEnumerator->MoveNext() == E_SUCCESS)
 724                                 {
 725                                         IEventListener* pDropListener = null;
 726                                         pDropEnumerator->GetCurrent(pDropListener);
 727
 728                                         if (pDropListener != null)
 729                                         {
 730                                                 IDragDropEventListener* pDropEventListener = dynamic_cast <IDragDropEventListener*>(pDropListener);
 731                                                 if (pDropEventListener != null)
 732                                                 {
 733                                                         pDropEventListener->OnTouchDropped(__public, _CoordinateSystemUtils::ConvertToInteger(__pTouchManager->GetStartPoint(touchInfo.GetPointId())), _CoordinateSystemUtils::ConvertToInteger(touchInfo.GetCurrentPosition()));
 734                                                 }
 735                                         }
 736                                 }
 737
 738                                 delete pDropEnumerator;
 739                         }
 740                 }
 741
 742                 return r;
 743         }
 744
 745         result ProcessDropListenerToTopControl(const _TouchInfo& touchInfo)
 746         {
 747                 result r = E_SUCCESS;
 748                 Point pt(__pTouchManager->GetScreenPoint(touchInfo.GetPointId()).x, __pTouchManager->GetScreenPoint(touchInfo.GetPointId()).y);
 749
 750                 _Control* pCapturedControl = __pTouchManager->GetCapturedControl();
 751                 _Control* pDraggedControl = __pTouchManager->GetTouchControlSource();
 752                 if (!pDraggedControl || pCapturedControl)
 753                 {
 754                         r = E_SUCCESS;
 755                         return r;
 756                 }
 757
 758                 _Control* pTopmostTouchedSource = __core.GetTopmostChildAt(pt);
 759                 if (!pTopmostTouchedSource)
 760                 {
 761                         r = E_SUCCESS;
 762                         return r;
 763                 }
 764
 765                 if (!pTopmostTouchedSource->IsDragEnabled())
 766                 {
 767                         return E_INVALID_CONDITION;
 768                 }
 769
 770                 TouchEventInfo publicTouchInfo;
 771
 772                 _TouchEventArg* pEventArg = GetTouchEventArgN(touchInfo);
 773                 SysTryReturn(NID_UI, pEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 774
 775                 publicTouchInfo.Construct(*pEventArg);
 776
 777                 if (pTopmostTouchedSource != pDraggedControl)
 778                 {
 779                         _ControlImpl* pTopmostTouchedTarget = static_cast <_ControlImpl*>(pTopmostTouchedSource->GetUserData());
 780                         SysTryCatch(NID_UI, pTopmostTouchedTarget, , E_SYSTEM, "[E_SYSTEM] System error occurred.");
 781
 782                         IEnumeratorT <Runtime::IEventListener*>* pDropEnumerator =
 783                                 pTopmostTouchedTarget->GetDragDropEventListener()->GetEnumeratorN();
 784
 785                         if (pDropEnumerator)
 786                         {
 787                                 while (pDropEnumerator->MoveNext() == E_SUCCESS)
 788                                 {
 789                                         IEventListener* pDropListener = null;
 790                                         pDropEnumerator->GetCurrent(pDropListener);
 791
 792                                         if (pDropListener != null)
 793                                         {
 794                                                 IDragDropEventListener* pDropEventListener = dynamic_cast <IDragDropEventListener*>(pDropListener);
 795                                                 if (pDropEventListener != null)
 796                                                 {
 797                                                         pDropEventListener->OnTouchDropped(pTopmostTouchedTarget->GetPublic(),
 798                                                                 publicTouchInfo.GetStartPosition(), _CoordinateSystemUtils::ConvertToInteger(touchInfo.GetCurrentPosition()));
 799                                                 }
 800                                         }
 801                                 }
 802                                 delete pDropEnumerator;
 803                         }
 804
 805                         IEnumeratorT <Runtime::IEventListener*>* pEnumerator =
 806                                 pTopmostTouchedTarget->GetTouchEventListener()->GetEnumeratorN();
 807
 808                         if (pEnumerator)
 809                         {
 810                                 while (pEnumerator->MoveNext() == E_SUCCESS)
 811                                 {
 812                                         Runtime::IEventListener* pListener = null;
 813                                         pEnumerator->GetCurrent(pListener);
 814
 815                                         if (pListener != null)
 816                                         {
 817                                                 ITouchEventListener* pPublicListener = dynamic_cast <ITouchEventListener*>(pListener);
 818                                                 SysAssert(pPublicListener);
 819
 820                                                 pPublicListener->OnTouchReleased(pTopmostTouchedTarget->GetPublic(), _CoordinateSystemUtils::ConvertToInteger(touchInfo.GetCurrentPosition()), publicTouchInfo);
 821                                         }
 822                                 }
 823                                 delete pEnumerator;
 824                         }
 825
 826                         if (pTopmostTouchedTarget->IsInputEventConsumed())
 827                         {
 828                                 pTopmostTouchedTarget->ResetInputEventConsumed();
 829                         }
 830
 831                         // 2. Default
 832                         ITouchEventListener* pDefaultListener = pTopmostTouchedTarget->GetDefaultTouchEventListener();
 833                         if (pDefaultListener)
 834                         {
 835                                 pDefaultListener->OnTouchReleased(pTopmostTouchedTarget->GetPublic(), _CoordinateSystemUtils::ConvertToInteger(touchInfo.GetCurrentPosition()), publicTouchInfo);
 836
 837                                 if (pTopmostTouchedTarget->IsInputEventConsumed())
 838                                 {
 839                                         pTopmostTouchedTarget->ResetInputEventConsumed();
 840                                 }
 841                         }
 842
 843                         // 3. Impl
 844                         if (pTopmostTouchedTarget->OnTouchReleased(*pTopmostTouchedTarget, touchInfo))
 845                         {
 846                                 if (pEventArg)
 847                                 {
 848                                         delete pEventArg;
 849                                         pEventArg = null;
 850                                 }
 851
 852                                 return r;
 853                         }
 854
 855                         // 4. Core
 856                         pTopmostTouchedSource->OnTouchReleased(*pTopmostTouchedSource, touchInfo);
 857                 }
 858
 859                 if (pEventArg)
 860                 {
 861                         delete pEventArg;
 862                         pEventArg = null;
 863                 }
 864
 865                 return r;
 866
 867         CATCH:
 868                 if (pEventArg)
 869                 {
 870                         delete pEventArg;
 871                         pEventArg = null;
 872                 }
 873
 874                 return r;
 875         }
 876
 877         bool ProcessListener(const _TouchInfo& touchInfo)
 878         {
 879                 bool filterd = false;
 880
 881                 TouchEventInfo publicTouchInfo;
 882
 883                 _TouchEventArg* pEventArg = GetTouchEventArgN(touchInfo);
 884                 SysTryReturn(NID_UI, pEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 885
 886                 publicTouchInfo.Construct(*pEventArg);
 887
 888                 _Control* pDraggedControl = __pTouchManager->GetTouchControlSource();
 889
 890                 // 1. Public
 891                 IEnumeratorT<IEventListener*>* pEnumerator = __impl.__pPublicTouchEventListeners->GetEnumeratorN();
 892                 if (pEnumerator)
 893                 {
 894                         while (pEnumerator->MoveNext() == E_SUCCESS)
 895                         {
 896                                 IEventListener* pListener = null;
 897                                 pEnumerator->GetCurrent(pListener);
 898
 899                                 ITouchEventListener* pTouchEventListener = dynamic_cast <ITouchEventListener*>(pListener);
 900                                 if (pTouchEventListener)
 901                                 {
 902                                         FirePublicListener(*pTouchEventListener, publicTouchInfo);
 903
 904                                         if (touchInfo.GetTouchStatus() == _TOUCH_RELEASED)
 905                                         {
 906                                                 if (pDraggedControl == null)    //if exist dragged control, don't send focus event
 907                                                 {
 908                                                         FireFocusListener(*pTouchEventListener, publicTouchInfo);
 909                                                 }
 910                                         }
 911                                         else if (touchInfo.GetTouchStatus() == _TOUCH_MOVED)
 912                                         {
 913                                                 FireFocusListener(*pTouchEventListener, publicTouchInfo);
 914                                         }
 915                                 }
 916                                 else
 917                                 {
 918                                         SysAssert(pTouchEventListener);
 919                                 }
 920                         }
 921                         delete pEnumerator;
 922                 }
 923
 924                 if (__impl.IsInputEventConsumed())
 925                 {
 926                         __impl.ResetInputEventConsumed();
 927
 928                         if (pEventArg)
 929                         {
 930                                 delete pEventArg;
 931                                 pEventArg = null;
 932                         }
 933
 934                         filterd = true;
 935                         return filterd;
 936                 }
 937
 938                 // 2. Default
 939                 ITouchEventListener* pDefaultListener = __impl.GetDefaultTouchEventListener();
 940                 if (pDefaultListener)
 941                 {
 942                         FirePublicListener(*pDefaultListener, publicTouchInfo);
 943
 944                         if (__impl.IsInputEventConsumed())
 945                         {
 946                                 __impl.ResetInputEventConsumed();
 947
 948                                 if (pEventArg)
 949                                 {
 950                                         delete pEventArg;
 951                                         pEventArg = null;
 952                                 }
 953
 954                                 filterd = true;
 955                                 return filterd;
 956                         }
 957                 }
 958
 959                 delete pEventArg;
 960
 961                 return filterd;
 962         }
 963
 964         bool ProcessDoublePress(const _TouchInfo& touchinfo, bool& isFiltered)
 965         {
 966                 if (__pTouchManager->GetPointCount() == 1)
 967                 {
 968                         __oldPreviousPressedTime = __previousPressedTime;
 969                         __previousPressedTime = __currentPressedTime;
 970                         __currentPressedTime = touchinfo.GetTimeStamp();
 971                         __previousPressedPoint.x = __currentPressedPoint.x;
 972                         __previousPressedPoint.y = __currentPressedPoint.y;
 973                         __currentPressedPoint.x = touchinfo.GetCurrentPosition().x;
 974                         __currentPressedPoint.y = touchinfo.GetCurrentPosition().y;
 975
 976                         if (Math::Abs(__previousPressedTime - __currentPressedTime) < doublePressTime)
 977                         {
 978                                 if (Math::Abs(__previousPressedTime - __oldPreviousPressedTime) > doublePressTime)
 979                                 {
 980                                         if (Math::Abs(__previousPressedPoint.x - __currentPressedPoint.x) < doublePressMoveAllowance
 981                                                 && Math::Abs(__previousPressedPoint.y - __currentPressedPoint.y) < doublePressMoveAllowance )
 982                                         {
 983                                                 _TouchInfo touchInfo(0, _TOUCH_DOUBLE_PRESSED, __pTouchManager->GetPosition(0), false, 0);
 984
 985                                                 SysTryReturn(NID_UI, __impl.__pCoreTouchEvent, false, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 986                                                 isFiltered = __impl.__pCoreTouchEvent->ProcessListener(touchInfo);
 987
 988                                                 return false;
 989                                         }
 990                                 }
 991                         }
 992                 }
 993
 994                 return false;
 995         }
 996
 997 private:
 998         CoreTouchEvent(const CoreTouchEvent& rhs);
 999         CoreTouchEvent& operator =(const CoreTouchEvent& rhs);
1000
1001 private:
1002         _ControlImpl& __impl;
1003         _Control& __core;
1004         Control& __public;
1005         _TouchManager* __pTouchManager;
1006         unsigned int __oldPreviousPressedTime;
1007         unsigned int __previousPressedTime;
1008         unsigned int __currentPressedTime;
1009         Point __previousPressedPoint;
1010         Point __currentPressedPoint;
1011 };
1012
1013 class _ControlImpl::CoreFocusEvent
1014 {
1015 public:
1016         CoreFocusEvent(_ControlImpl& impl)
1017                 : __impl(impl)
1018                 , __core(impl.GetCore())
1019                 , __public(impl.GetPublic())
1020         {
1021         }
1022
1023         ~CoreFocusEvent(void)
1024         {
1025         }
1026
1027 private:
1028         result FirePublicListener(IFocusEventListener& listener, FocusStatus focusState)
1029         {
1030                 result r = E_SUCCESS;
1031
1032                 switch (focusState)
1033                 {
1034                         case FOCUS_GAINED:
1035                                 listener.OnFocusGained(__public);
1036                                 break;
1037                         case FOCUS_LOST:
1038                                 listener.OnFocusLost(__public);
1039                                 break;
1040                         default:
1041                                 SysAssert(0);
1042                                 r = E_SYSTEM;
1043                                 break;
1044                 }
1045
1046                 return r;
1047         }
1048
1049 public:
1050         bool ProcessListener(FocusStatus focusState)
1051         {
1052                 bool filterd = false;
1053
1054                 // 1. Public
1055                 IEnumeratorT <IEventListener*>* pEnumerator = __impl.__pPublicFocusEventListeners->GetEnumeratorN();
1056                 if (pEnumerator)
1057                 {
1058                         while (pEnumerator->MoveNext() == E_SUCCESS)
1059                         {
1060                                 Runtime::IEventListener* pListener = null;
1061                                 pEnumerator->GetCurrent(pListener);
1062                                 IFocusEventListener* pFocusEventListener = dynamic_cast <IFocusEventListener*>(pListener);
1063                                 if (pFocusEventListener)
1064                                 {
1065                                         FirePublicListener(*pFocusEventListener, focusState);
1066                                 }
1067                         }
1068
1069                         delete pEnumerator;
1070                 }
1071
1072                 return filterd;
1073         }
1074
1075 private:
1076         CoreFocusEvent(const CoreFocusEvent& rhs);
1077         CoreFocusEvent& operator =(const CoreFocusEvent& rhs);
1078
1079 private:
1080         _ControlImpl& __impl;
1081         _Control& __core;
1082         Control& __public;
1083 };
1084
1085 class _ControlImpl::CoreGestureEvent
1086 {
1087 public:
1088         CoreGestureEvent(_ControlImpl& impl)
1089                 : __impl(impl)
1090                 , __core(impl.GetCore())
1091                 , __public(impl.GetPublic())
1092         {
1093         }
1094
1095         ~CoreGestureEvent(void)
1096         {
1097         }
1098
1099 public:
1100         bool ProcessListener(_TouchGestureDetectorType gestureType)
1101         {
1102                 bool filterd = false;
1103
1104                 _TouchManager* pTouchManager = _TouchManager::GetInstance();
1105                 SysTryReturn(NID_UI, pTouchManager, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1106
1107                 switch (gestureType)
1108                 {
1109                         case _TOUCH_GESTURE_DETECTOR_TYPE_TAP:
1110                         {
1111                                 _TouchInfo touchInfo(0, _TOUCH_DOUBLE_PRESSED, pTouchManager->GetPosition(0), false, 0);
1112
1113                                 SysTryReturn(NID_UI, __impl.__pCoreTouchEvent, false, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1114                                 filterd = __impl.__pCoreTouchEvent->ProcessListener(touchInfo);
1115                         }
1116                         break;
1117                         case _TOUCH_GESTURE_DETECTOR_TYPE_LONG_PRESS:
1118                         {
1119                                 _TouchInfo touchInfo(0, _TOUCH_LONG_PRESSED, pTouchManager->GetPosition(0), false, 0);
1120
1121                                 SysTryReturn(NID_UI, __impl.__pCoreTouchEvent, false, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1122                                 filterd = __impl.__pCoreTouchEvent->ProcessListener(touchInfo);
1123                         }
1124                         break;
1125                         default:
1126                                 SysAssert(0);
1127                                 break;
1128                         }
1129
1130                 return filterd;
1131         }
1132
1133 private:
1134         CoreGestureEvent(const CoreGestureEvent& rhs);
1135         CoreGestureEvent& operator =(const CoreGestureEvent& rhs);
1136
1137 private:
1138         _ControlImpl& __impl;
1139         _Control& __core;
1140         Control& __public;
1141 };
1142
1143 class _ControlImpl::CoreEventListener
1144         : public _IFocusEventListener
1145         , public _INotificationEventListener
1146         , public _ITouchLongPressGestureEventListener
1147         , virtual public Tizen::Base::Runtime::IEventListener
1148         , virtual public _IUiEventListener
1149         , virtual public _ITouchGestureEventListener
1150 {
1151 public:
1152         CoreEventListener(_ControlImpl& impl)
1153                 : __impl(impl)
1154                 , __core(impl.GetCore())
1155                 , __public(impl.GetPublic())
1156                 , __isKeyPressed(false)
1157                 , __pKeyInfo(null)
1158         {
1159                 __pTouchManager = _TouchManager::GetInstance();
1160                 SysTryReturnVoidResult(NID_UI, __pTouchManager, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1161
1162                 return;
1163         }
1164
1165         virtual ~CoreEventListener(void)
1166         {
1167         }
1168
1169         virtual bool OnFocusGained(const _Control& source)
1170         {
1171                 SysTryReturn(NID_UI, __impl.__pCoreFocusEvent, false, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1172
1173                 bool isFiltered = false;
1174
1175                 isFiltered = __impl.__pCoreFocusEvent->ProcessListener(FOCUS_GAINED);
1176                 if (isFiltered)
1177                 {
1178                         return true;
1179                 }
1180
1181                 // 2. Impl
1182                 isFiltered = __impl.OnFocusGained(__impl);
1183                 if (isFiltered)
1184                 {
1185                         return true;
1186                 }
1187
1188                 // 3. Core
1189                 isFiltered = __core.OnFocusGained(source);
1190
1191                 return isFiltered;
1192         }
1193
1194         virtual bool OnFocusLost(const _Control& source)
1195         {
1196                 SysTryReturn(NID_UI, __impl.__pCoreFocusEvent, false, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1197
1198                 bool isFiltered = false;
1199
1200                 isFiltered = __impl.__pCoreFocusEvent->ProcessListener(FOCUS_LOST);
1201                 if (isFiltered)
1202                 {
1203                         return true;
1204                 }
1205
1206                 // 2. Impl
1207                 isFiltered = __impl.OnFocusLost(__impl);
1208                 if (isFiltered)
1209                 {
1210                         return true;
1211                 }
1212
1213                 // 3. Core
1214                 isFiltered = __core.OnFocusLost(source);
1215
1216                 return isFiltered;
1217         }
1218
1219         virtual bool OnNotifiedN(const _Control& source, Tizen::Base::Collection::IList* pArgs)
1220         {
1221                 if (__impl.SendNotification(__impl, pArgs))
1222                 {
1223                         return true;
1224                 }
1225
1226                 if (&source == &__core)
1227                 {
1228                         if (ProcessTouchModeChangedListener(source, pArgs))
1229                         {
1230                                 pArgs->RemoveAll(true);
1231                                 delete pArgs;
1232                                 return true;
1233                         }
1234                 }
1235
1236                 // 1. Impl
1237                 if (__impl.OnNotifiedN(__impl, pArgs))
1238                 {
1239                         return true;
1240                 }
1241
1242                 // 2. Core
1243                 return __core.OnNotifiedN(source, pArgs);
1244         }
1245
1246         virtual bool OnLongPressGestureDetected(_TouchLongPressGestureDetector& gesture)
1247         {
1248                 SysTryReturn(NID_UI, __impl.__pCoreGestureEvent, false, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1249                 bool isFiltered = false;
1250
1251                 isFiltered = __impl.__pCoreGestureEvent->ProcessListener(_TOUCH_GESTURE_DETECTOR_TYPE_LONG_PRESS);
1252
1253                 return isFiltered;
1254         }
1255
1256         virtual bool OnLongPressGestureCanceled(_TouchLongPressGestureDetector& gesture)
1257         {
1258                 return false;
1259         }
1260
1261         bool ProcessTouchModeChangedListener(const _Control& source, Tizen::Base::Collection::IList* pArgs)
1262         {
1263                 IEnumeratorT<IEventListener*>* pEnumerator = __impl.__pPublicTouchModeChangedEventListeners->GetEnumeratorN();
1264                 bool isFiltered = false;
1265
1266                 if (pEnumerator)
1267                 {
1268                         while(pEnumerator->MoveNext() == E_SUCCESS)
1269                         {
1270                                 IEventListener* pEventListener = null;
1271                                 pEnumerator->GetCurrent(pEventListener);
1272
1273                                 if (!pEventListener)
1274                                 {
1275                                         continue;
1276                                 }
1277
1278                                 String* pString = dynamic_cast<String*>(pArgs->GetAt(0));
1279                                 if (pString && (*pString == _KEYBOARD_INSERTED_EVENT))
1280                                 {
1281                                         Boolean* pIsTouchMode = dynamic_cast<Boolean*>(pArgs->GetAt(1));
1282                                         ITouchModeChangedEventListener* pTouchModeListener = dynamic_cast<ITouchModeChangedEventListener*>(pEventListener);
1283                                         if (pTouchModeListener && pIsTouchMode)
1284                                         {
1285                                                 pTouchModeListener->OnTouchModeChanged(__impl.GetPublic(), pIsTouchMode->ToBool()) ;
1286                                                 isFiltered = true;
1287                                         }
1288                                 }
1289                         }
1290                         delete pEnumerator;
1291                 }
1292
1293                 return isFiltered;
1294         }
1295
1296 private:
1297         CoreEventListener(const CoreEventListener& rhs);
1298         CoreEventListener& operator =(const CoreEventListener& rhs);
1299
1300 private:
1301         _ControlImpl& __impl;
1302         _Control& __core;
1303         Control& __public;
1304         _TouchManager* __pTouchManager;
1305         bool __isKeyPressed;
1306         _KeyInfo* __pKeyInfo;
1307 };
1308
1309 class _ControlImpl::_PropagatedTouchEventListener
1310         :       public _IPropagatedTouchEventListener
1311 {
1312 public:
1313         _PropagatedTouchEventListener(_ControlImpl& impl)
1314         : __impl(impl)
1315         , __core(impl.GetCore())
1316         , __public(impl.GetPublic())
1317         {
1318         }
1319
1320         virtual ~_PropagatedTouchEventListener()
1321         {
1322         }
1323
1324         _TouchEventArg* GetTouchEventArgN(const _TouchInfo& touchInfo)
1325         {
1326                 _TouchEventArg* pEventArg = new (std::nothrow) _TouchEventArg(__public, touchInfo.GetTouchStatus());
1327                 SysTryReturn(NID_UI, pEventArg, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1328
1329                 _TouchManager* __pTouchManager = _TouchManager::GetInstance();
1330                 SysTryReturn(NID_UI, __pTouchManager, null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] __pTouchManager == null.");
1331
1332                 Point startPoint(__pTouchManager->GetStartPoint(touchInfo.GetPointId()).x - __core.GetAbsoluteBounds().x,
1333                                 __pTouchManager->GetStartPoint(touchInfo.GetPointId()).y - __core.GetAbsoluteBounds().y);
1334
1335                 pEventArg->SetTouchPosition(touchInfo.GetPointId(), startPoint.x, startPoint.y,
1336                 touchInfo.GetCurrentPosition().x, touchInfo.GetCurrentPosition().y);
1337
1338                 int xDistance = 0;
1339                 int yDistance = 0;
1340                 __impl.__pFlickGestureDetector->GetDistance(xDistance, yDistance);
1341
1342                 if (xDistance != 0 || yDistance != 0)
1343                 {
1344                         pEventArg->SetFlickedStatus(true);
1345                 }
1346                 else
1347                 {
1348                         pEventArg->SetFlickedStatus(false);
1349                 }
1350
1351                 return pEventArg;
1352         }
1353
1354         virtual bool OnTouchPressed(const _Control& source, const _TouchInfo& touchInfo)
1355         {
1356                 bool isFiltered = false;
1357
1358                 if (__impl.__pPublicPropagatedTouchEventListener != null)
1359                 {
1360                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
1361                         SysTryReturn(NID_UI, pControlImpl, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
1362
1363                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
1364
1365                         const _ControlHandle controlHandle = pControlImpl->GetCore().GetHandle();
1366
1367                         TouchEventInfo publicTouchInfo;
1368
1369                         _TouchEventArg* pEventArg = GetTouchEventArgN(touchInfo);
1370                         SysTryReturn(NID_UI, pEventArg, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1371
1372                         publicTouchInfo.Construct(*pEventArg);
1373
1374                         if (pEventArg)
1375                         {
1376                                 delete pEventArg;
1377                                 pEventArg = null;
1378                         }
1379
1380                         isFiltered = __impl.__pPublicPropagatedTouchEventListener->OnTouchPressed(control, publicTouchInfo);
1381                         if (isFiltered)
1382                         {
1383                                 return true;
1384                         }
1385
1386                         _Control* pControl = _ControlManager::GetInstance()->GetObject(controlHandle);
1387                         SysTryReturn(NID_UI, pControl, true, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Target control is deleted.");
1388                 }
1389
1390                 return __impl.CallOnTouchPressed(source, touchInfo);
1391         }
1392
1393         virtual bool OnTouchReleased(const _Control& source, const _TouchInfo& touchInfo)
1394         {
1395                 bool isFiltered = false;
1396
1397                 if (__impl.__pPublicPropagatedTouchEventListener != null)
1398                 {
1399                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
1400                         SysTryReturn(NID_UI, pControlImpl, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
1401
1402                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
1403
1404                         const _ControlHandle controlHandle = pControlImpl->GetCore().GetHandle();
1405
1406                         TouchEventInfo publicTouchInfo;
1407
1408                         _TouchEventArg* pEventArg = GetTouchEventArgN(touchInfo);
1409                         SysTryReturn(NID_UI, pEventArg, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1410
1411                         publicTouchInfo.Construct(*pEventArg);
1412
1413                         if (pEventArg)
1414                         {
1415                                 delete pEventArg;
1416                                 pEventArg = null;
1417                         }
1418
1419                         isFiltered = __impl.__pPublicPropagatedTouchEventListener->OnTouchReleased(control, publicTouchInfo);
1420                         if (isFiltered)
1421                         {
1422                                 return true;
1423                         }
1424
1425                         _Control* pControl = _ControlManager::GetInstance()->GetObject(controlHandle);
1426                         SysTryReturn(NID_UI, pControl, true, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Target control is deleted.");
1427                 }
1428
1429                 return __impl.CallOnTouchReleased(source, touchInfo);
1430         }
1431
1432         virtual bool OnTouchMoved(const _Control& source, const _TouchInfo& touchInfo)
1433         {
1434                 bool isFiltered = false;
1435
1436                 if (__impl.__pPublicPropagatedTouchEventListener != null)
1437                 {
1438                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
1439                         SysTryReturn(NID_UI, pControlImpl, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
1440
1441                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
1442
1443                         const _ControlHandle controlHandle = pControlImpl->GetCore().GetHandle();
1444
1445                                 TouchEventInfo publicTouchInfo;
1446
1447                                 _TouchEventArg* pEventArg = GetTouchEventArgN(touchInfo);
1448                         SysTryReturn(NID_UI, pEventArg, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1449
1450                                 publicTouchInfo.Construct(*pEventArg);
1451
1452                                 if (pEventArg)
1453                                 {
1454                                         delete pEventArg;
1455                                         pEventArg = null;
1456                                 }
1457
1458                         isFiltered = __impl.__pPublicPropagatedTouchEventListener->OnTouchMoved(control, publicTouchInfo);
1459                                 if (isFiltered)
1460                                 {
1461                                         return true;
1462                                 }
1463
1464                         _Control* pControl = _ControlManager::GetInstance()->GetObject(controlHandle);
1465                         SysTryReturn(NID_UI, pControl, true, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Target control is deleted.");
1466                         }
1467
1468                 return __impl.CallOnTouchMoved(source, touchInfo);
1469         }
1470
1471         virtual bool OnTouchCanceled(const _Control& source, const _TouchInfo& touchInfo)
1472         {
1473                 bool isFiltered = false;
1474
1475                 if (__impl.__pPublicPropagatedTouchEventListener != null)
1476                 {
1477                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
1478                         SysTryReturn(NID_UI, pControlImpl, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
1479
1480                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
1481
1482                         const _ControlHandle controlHandle = pControlImpl->GetCore().GetHandle();
1483
1484                                 TouchEventInfo publicTouchInfo;
1485
1486                                 _TouchEventArg* pEventArg = GetTouchEventArgN(touchInfo);
1487                         SysTryReturn(NID_UI, pEventArg, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1488
1489                                 publicTouchInfo.Construct(*pEventArg);
1490
1491                                 if (pEventArg)
1492                                 {
1493                                         delete pEventArg;
1494                                         pEventArg = null;
1495                                 }
1496
1497                         isFiltered = __impl.__pPublicPropagatedTouchEventListener->OnTouchCanceled(control, publicTouchInfo);
1498                                 if (isFiltered)
1499                                 {
1500                                         return true;
1501                                 }
1502
1503                         _Control* pControl = _ControlManager::GetInstance()->GetObject(controlHandle);
1504                         SysTryReturn(NID_UI, pControl, true, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Target control is deleted.");
1505                         }
1506
1507                 return __impl.CallOnTouchCanceled(source, touchInfo);
1508         }
1509
1510         virtual _UiTouchEventDelivery OnPreviewTouchPressed(const _Control& source, const _TouchInfo& touchInfo)
1511         {
1512                 _UiTouchEventDelivery isFiltered = _UI_TOUCH_EVENT_DELIVERY_NO;
1513
1514                 if (__impl.__pPublicPropagatedTouchEventListener != null)
1515                 {
1516                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
1517                         SysTryReturn(NID_UI, pControlImpl, _UI_TOUCH_EVENT_DELIVERY_YES, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
1518
1519                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
1520
1521                         const _ControlHandle controlHandle = pControlImpl->GetCore().GetHandle();
1522
1523                         TouchEventInfo publicTouchInfo;
1524
1525                         _TouchEventArg* pEventArg = GetTouchEventArgN(touchInfo);
1526                         SysTryReturn(NID_UI, pEventArg, _UI_TOUCH_EVENT_DELIVERY_YES, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1527
1528                         publicTouchInfo.Construct(*pEventArg);
1529
1530                         if (pEventArg)
1531                         {
1532                                 delete pEventArg;
1533                                 pEventArg = null;
1534                         }
1535
1536                         if (__impl.__pPublicPropagatedTouchEventListener->OnPreviewTouchPressed(control, publicTouchInfo) == true)
1537                         {
1538                                 return _UI_TOUCH_EVENT_DELIVERY_NO;
1539                         }
1540
1541                         _Control* pControl = _ControlManager::GetInstance()->GetObject(controlHandle);
1542                         SysTryReturn(NID_UI, pControl, _UI_TOUCH_EVENT_DELIVERY_NO, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Target control is deleted.");
1543                 }
1544
1545                 // 3. Impl
1546                 isFiltered = __impl.OnPreviewTouchPressed(__impl, touchInfo);
1547                 if (isFiltered == _UI_TOUCH_EVENT_DELIVERY_NO)
1548                 {
1549                         return _UI_TOUCH_EVENT_DELIVERY_NO;
1550                 }
1551
1552                 // 4. Core
1553                 isFiltered = __core.OnPreviewTouchPressed(source, touchInfo);
1554
1555                 return isFiltered;
1556         }
1557
1558         virtual _UiTouchEventDelivery OnPreviewTouchReleased(const _Control& source, const _TouchInfo& touchInfo)
1559         {
1560                 _UiTouchEventDelivery isFiltered = _UI_TOUCH_EVENT_DELIVERY_NO;
1561
1562                 if (__impl.__pPublicPropagatedTouchEventListener != null)
1563                 {
1564                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
1565                         SysTryReturn(NID_UI, pControlImpl, _UI_TOUCH_EVENT_DELIVERY_YES, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
1566
1567                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
1568
1569                         const _ControlHandle controlHandle = pControlImpl->GetCore().GetHandle();
1570
1571                         TouchEventInfo publicTouchInfo;
1572
1573                         _TouchEventArg* pEventArg = GetTouchEventArgN(touchInfo);
1574                         SysTryReturn(NID_UI, pEventArg, _UI_TOUCH_EVENT_DELIVERY_YES, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1575
1576                         publicTouchInfo.Construct(*pEventArg);
1577
1578                         if (pEventArg)
1579                         {
1580                                 delete pEventArg;
1581                                 pEventArg = null;
1582                         }
1583
1584                         if (__impl.__pPublicPropagatedTouchEventListener->OnPreviewTouchReleased(control, publicTouchInfo) == true)
1585                         {
1586                                 return _UI_TOUCH_EVENT_DELIVERY_NO;
1587                         }
1588
1589                         _Control* pControl = _ControlManager::GetInstance()->GetObject(controlHandle);
1590                         SysTryReturn(NID_UI, pControl, _UI_TOUCH_EVENT_DELIVERY_NO, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Target control is deleted.");
1591                 }
1592
1593                 // 3. Impl
1594                 isFiltered = __impl.OnPreviewTouchReleased(__impl, touchInfo);
1595                 if (isFiltered == _UI_TOUCH_EVENT_DELIVERY_NO)
1596                 {
1597                         return _UI_TOUCH_EVENT_DELIVERY_NO;
1598                 }
1599
1600                 // 4. Core
1601                 isFiltered = __core.OnPreviewTouchReleased(source, touchInfo);
1602
1603                 return isFiltered;
1604         }
1605
1606         virtual _UiTouchEventDelivery OnPreviewTouchMoved(const _Control& source, const _TouchInfo& touchInfo)
1607         {
1608                 _UiTouchEventDelivery isFiltered = _UI_TOUCH_EVENT_DELIVERY_NO;
1609
1610                 if (__impl.__pPublicPropagatedTouchEventListener != null)
1611                 {
1612                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
1613                         SysTryReturn(NID_UI, pControlImpl, _UI_TOUCH_EVENT_DELIVERY_YES, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
1614
1615                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
1616
1617                         const _ControlHandle controlHandle = pControlImpl->GetCore().GetHandle();
1618
1619                         TouchEventInfo publicTouchInfo;
1620
1621                         _TouchEventArg* pEventArg = GetTouchEventArgN(touchInfo);
1622                         SysTryReturn(NID_UI, pEventArg, _UI_TOUCH_EVENT_DELIVERY_YES, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1623
1624                         publicTouchInfo.Construct(*pEventArg);
1625
1626                         if (pEventArg)
1627                         {
1628                                 delete pEventArg;
1629                                 pEventArg = null;
1630                         }
1631
1632                         if (__impl.__pPublicPropagatedTouchEventListener->OnPreviewTouchMoved(control, publicTouchInfo) == true)
1633                         {
1634                                 return _UI_TOUCH_EVENT_DELIVERY_NO;
1635                         }
1636
1637                         _Control* pControl = _ControlManager::GetInstance()->GetObject(controlHandle);
1638                         SysTryReturn(NID_UI, pControl, _UI_TOUCH_EVENT_DELIVERY_NO, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Target control is deleted.");
1639                 }
1640
1641                 // 3. Impl
1642                 isFiltered = __impl.OnPreviewTouchMoved(__impl, touchInfo);
1643                 if (isFiltered == _UI_TOUCH_EVENT_DELIVERY_NO)
1644                 {
1645                         return _UI_TOUCH_EVENT_DELIVERY_NO;
1646                 }
1647
1648                 // 4. Core
1649                 isFiltered = __core.OnPreviewTouchMoved(source, touchInfo);
1650
1651                 return isFiltered;
1652         }
1653
1654         virtual _UiTouchEventDelivery OnPreviewTouchCanceled(const _Control& source, const _TouchInfo& touchInfo)
1655         {
1656                 return _UI_TOUCH_EVENT_DELIVERY_YES;
1657         }
1658
1659         virtual bool OnMousePressed(const _Control& source, const _MouseInfo& mouseInfo)
1660         {
1661                 SysLog(NID_UI, "OnMousePressed, source = 0x%x", &source);
1662                 bool isFiltered = false;
1663
1664                 // 3. Impl
1665                 isFiltered = __impl.OnMousePressed(__impl, mouseInfo);
1666                 if (isFiltered)
1667                 {
1668                         return true;
1669                 }
1670
1671                 // 4. Core
1672                 isFiltered = __core.OnMousePressed(source, mouseInfo);
1673
1674                 return isFiltered;
1675         }
1676
1677         virtual bool OnMouseReleased(const _Control& source, const _MouseInfo& mouseInfo)
1678         {
1679                 SysLog(NID_UI, "OnMouseReleased, source = 0x%x", &source);
1680                 bool isFiltered = false;
1681
1682                 // 3. Impl
1683                 isFiltered = __impl.OnMouseReleased(__impl, mouseInfo);
1684                 if (isFiltered)
1685                 {
1686                         return true;
1687                 }
1688
1689                 // 4. Core
1690                 isFiltered = __core.OnMouseReleased(source, mouseInfo);
1691
1692                 return isFiltered;
1693         }
1694
1695         virtual bool OnMouseMoved(const _Control& source, const _MouseInfo& mouseInfo)
1696         {
1697                 return false;
1698         }
1699
1700         virtual bool OnMouseWheeled(const _Control& source, const _MouseInfo& mouseInfo)
1701         {
1702                 SysLog(NID_UI, "OnWheelMoved, source = 0x%x", &source);
1703                 bool isFiltered = false;
1704
1705                 // 3. Impl
1706                 isFiltered = __impl.OnMouseWheeled(__impl, mouseInfo);
1707                 if (isFiltered)
1708                 {
1709                         return true;
1710                 }
1711
1712                 // 4. Core
1713                 isFiltered = __core.OnMouseWheeled(source, mouseInfo);
1714
1715                 return isFiltered;
1716         }
1717
1718         virtual _UiTouchEventDelivery OnPreviewMousePressed(const _Control& source, const _MouseInfo& mouseInfo)
1719         {
1720                 _UiTouchEventDelivery isFiltered = _UI_TOUCH_EVENT_DELIVERY_NO;
1721
1722                 // 3. Impl
1723                 isFiltered = __impl.OnPreviewMousePressed(__impl, mouseInfo);
1724                 if (isFiltered == _UI_TOUCH_EVENT_DELIVERY_NO)
1725                 {
1726                         return _UI_TOUCH_EVENT_DELIVERY_NO;
1727                 }
1728
1729                 // 4. Core
1730                 isFiltered = __core.OnPreviewMousePressed(source, mouseInfo);
1731
1732                 return isFiltered;
1733         }
1734
1735         virtual _UiTouchEventDelivery OnPreviewMouseReleased(const _Control& source, const _MouseInfo& mouseInfo)
1736         {
1737                 _UiTouchEventDelivery isFiltered = _UI_TOUCH_EVENT_DELIVERY_NO;
1738
1739                 // 3. Impl
1740                 isFiltered = __impl.OnPreviewMouseReleased(__impl, mouseInfo);
1741                 if (isFiltered == _UI_TOUCH_EVENT_DELIVERY_NO)
1742                 {
1743                         return _UI_TOUCH_EVENT_DELIVERY_NO;
1744                 }
1745
1746                 // 4. Core
1747                 isFiltered = __core.OnPreviewMouseReleased(source, mouseInfo);
1748
1749                 return isFiltered;
1750         }
1751
1752         virtual _UiTouchEventDelivery OnPreviewMouseMoved(const _Control& source, const _MouseInfo& mouseInfo)
1753         {
1754                 _UiTouchEventDelivery isFiltered = _UI_TOUCH_EVENT_DELIVERY_NO;
1755
1756                 // 3. Impl
1757                 isFiltered = __impl.OnPreviewMouseMoved(__impl, mouseInfo);
1758                 if (isFiltered == _UI_TOUCH_EVENT_DELIVERY_NO)
1759                 {
1760                         return _UI_TOUCH_EVENT_DELIVERY_NO;
1761                 }
1762
1763                 // 4. Core
1764                 isFiltered = __core.OnPreviewMouseMoved(source, mouseInfo);
1765
1766                 return isFiltered;
1767         }
1768
1769         virtual _UiTouchEventDelivery OnPreviewMouseWheeled(const _Control& source, const _MouseInfo& mouseInfo)
1770         {
1771                 _UiTouchEventDelivery isFiltered = _UI_TOUCH_EVENT_DELIVERY_NO;
1772
1773                 // 3. Impl
1774                 isFiltered = __impl.OnPreviewMouseWheeled(__impl, mouseInfo);
1775                 if (isFiltered == _UI_TOUCH_EVENT_DELIVERY_NO)
1776                 {
1777                         return _UI_TOUCH_EVENT_DELIVERY_NO;
1778                 }
1779
1780                 // 4. Core
1781                 isFiltered = __core.OnPreviewMouseWheeled(source, mouseInfo);
1782
1783                 return isFiltered;
1784         }
1785
1786         virtual void OnTouchPressHandled(const _Control& source)
1787         {
1788                 __impl.OnTouchPressHandled(source);
1789         }
1790
1791         virtual void OnTouchReleaseHandled(const _Control& source)
1792         {
1793                 __impl.OnTouchReleaseHandled(source);
1794         }
1795
1796         virtual void OnTouchMoveHandled(const _Control& source)
1797         {
1798                 __impl.OnTouchMoveHandled(source);
1799         }
1800
1801         virtual void OnTouchCancelHandled(const _Control& source)
1802         {
1803                 __impl.OnTouchCancelHandled(source);
1804         }
1805
1806 private:
1807         _ControlImpl& __impl;
1808         _Control& __core;
1809         Control& __public;
1810 };
1811
1812 class _ControlImpl::_PropagatedKeyEventListener
1813         : public _IPropagatedKeyEventListener
1814         , public ITimerEventListener
1815 {
1816 public:
1817         _PropagatedKeyEventListener(_ControlImpl& impl)
1818         : __impl(impl)
1819         , __core(impl.GetCore())
1820         , __public(impl.GetPublic())
1821         , __pTimer(null)
1822         , __isKeyPressed(false)
1823         , __pKeyInfo(null)
1824         {
1825         }
1826
1827         virtual ~_PropagatedKeyEventListener()
1828         {
1829                 if (__pTimer != null)
1830                 {
1831                         __pTimer->Cancel();
1832
1833                         delete __pTimer;
1834                         __pTimer = null;
1835                 }
1836         }
1837
1838         void OnTimerExpired(Timer& timer)
1839         {
1840                 if (__isKeyPressed)
1841                 {
1842                         SysTryReturnVoidResult(NID_UI, __impl.__pCoreKeyEvent, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1843
1844                         __impl.__pCoreKeyEvent->ProcessListener(KEY_LONGPRESSED, __pKeyInfo->GetKeyCode());
1845                 }
1846         }
1847
1848         virtual bool TranslateKeyEventInfo(const _Control& source, _KeyInfo& keyInfo)
1849         {
1850                 SysTryReturn(NID_UI, __impl.__pCoreKeyEvent, false, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1851
1852                 bool isFiltered = false;
1853
1854                 if (__impl.__pPublicPropagatedKeyEventListener != null)
1855                 {
1856                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
1857                         SysTryReturn(NID_UI, pControlImpl, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
1858
1859                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
1860
1861                         KeyEventInfo* pKeyEventInfo = new (std::nothrow) KeyEventInfo(static_cast<KeyCode>(keyInfo.GetKeyCode()),
1862                                 static_cast<KeyModifier>(keyInfo.GetKeyModifier()));
1863
1864                         isFiltered = __impl.__pPublicPropagatedKeyEventListener->TranslateKeyEventInfo(control, *pKeyEventInfo);
1865                         if (isFiltered)
1866                         {
1867                                 keyInfo.SetKeyCode(static_cast<_KeyCode>(pKeyEventInfo->GetKeyCode()));
1868                                 keyInfo.SetKeyModifier(static_cast<_KeyModifier>(pKeyEventInfo->GetKeyModifier()));
1869                                 return true;
1870                         }
1871                 }
1872
1873                 // 3. Impl
1874                 isFiltered = __impl.TranslateKeyEventInfo(__impl, keyInfo);
1875                 if (isFiltered)
1876                 {
1877                         return true;
1878                 }
1879
1880                 // 4. Core
1881                 isFiltered = __core.TranslateKeyEventInfo(source, keyInfo);
1882
1883                 return isFiltered;
1884         }
1885
1886         virtual bool OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
1887         {
1888                 SysTryReturn(NID_UI, __impl.__pCoreKeyEvent, false, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1889
1890                 bool isFiltered = false;
1891
1892                 //SysLog(NID_UI, ">>> [impl.1] OnKeyPressed(%d, %d)", keyInfo.GetKeyCode(), keyInfo.GetKeyModifier());
1893
1894                 if (__impl.__pPublicPropagatedKeyEventListener != null)
1895                 {
1896                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
1897                         SysTryReturn(NID_UI, pControlImpl, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
1898
1899                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
1900
1901                                 KeyEventInfo* pKeyEventInfo = new (std::nothrow) KeyEventInfo(static_cast<KeyCode>(keyInfo.GetKeyCode()),
1902                                         static_cast<KeyModifier>(keyInfo.GetKeyModifier()));
1903
1904                                 //SysLog(NID_UI, ">>> [impl.2] OnKeyPressed(%d, %d)", keyInfo.GetKeyCode(), keyInfo.GetKeyModifier());
1905
1906                         isFiltered = __impl.__pPublicPropagatedKeyEventListener->OnKeyPressed(control, *pKeyEventInfo);
1907                                 if (isFiltered)
1908                                 {
1909                                         return true;
1910                                 }
1911                         }
1912
1913                 //SysLog(NID_UI, ">>> [impl.3] OnKeyPressed(%d, %d)", keyInfo.GetKeyCode(), keyInfo.GetKeyModifier());
1914
1915                 if (&source == &__core)
1916                 {
1917                         if (!__isKeyPressed)
1918                         {
1919                                 __pTimer = new (std::nothrow) Timer;
1920                                 SysTryReturn(NID_UI, __pTimer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1921
1922                                 result r = __pTimer->Construct(*this);
1923                                 SysTryReturn(NID_UI, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1924
1925                                 r = __pTimer->Start(keyPressTimer);
1926                                 if (r == E_SUCCESS)
1927                                 {
1928                                         __isKeyPressed = true;
1929                                         __pKeyInfo = const_cast<_KeyInfo*>(&keyInfo);
1930                                 }
1931                         }
1932
1933                         isFiltered = __impl.__pCoreKeyEvent->ProcessListener(KEY_PRESSED, keyInfo.GetKeyCode());
1934                         if (isFiltered)
1935                         {
1936                                 return true;
1937                         }
1938                 }
1939
1940                 // 3. Impl
1941                 isFiltered = __impl.OnKeyPressed(__impl, keyInfo);
1942                 if (isFiltered)
1943                 {
1944                         return true;
1945                 }
1946
1947                 // 4. Core
1948                 isFiltered = __core.OnKeyPressed(source, keyInfo);
1949
1950                 return isFiltered;
1951         }
1952
1953         virtual bool OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
1954         {
1955                 SysTryReturn(NID_UI, __impl.__pCoreKeyEvent, false, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1956
1957                 bool isFiltered = false;
1958
1959                 //SysLog(NID_UI, ">>> [impl.1] OnKeyReleased(%d, %d)", keyInfo.GetKeyCode(), keyInfo.GetKeyModifier());
1960
1961                 if (__impl.__pPublicPropagatedKeyEventListener != null)
1962                 {
1963                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
1964                         SysTryReturn(NID_UI, pControlImpl, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
1965
1966                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
1967
1968                                 KeyEventInfo* pKeyEventInfo = new (std::nothrow) KeyEventInfo(static_cast<KeyCode>(keyInfo.GetKeyCode()),
1969                                         static_cast<KeyModifier>(keyInfo.GetKeyModifier()));
1970
1971                                 //SysLog(NID_UI, ">>> [impl.2] OnKeyReleased(%d, %d)", keyInfo.GetKeyCode(), keyInfo.GetKeyModifier());
1972
1973                         isFiltered = __impl.__pPublicPropagatedKeyEventListener->OnKeyReleased(control, *pKeyEventInfo);
1974                                 if (isFiltered)
1975                                 {
1976                                         return true;
1977                                 }
1978                         }
1979
1980                 //SysLog(NID_UI, ">>> [impl.3] OnKeyReleased(%d, %d)", keyInfo.GetKeyCode(), keyInfo.GetKeyModifier());
1981
1982                 if (&source == &__core)
1983                 {
1984                         __isKeyPressed = false;
1985                         __pKeyInfo = null;
1986
1987                         if (__pTimer != null)
1988                         {
1989                                 __pTimer->Cancel();
1990
1991                                 delete __pTimer;
1992                                 __pTimer = null;
1993                         }
1994
1995                         isFiltered = __impl.__pCoreKeyEvent->ProcessListener(KEY_RELEASED, keyInfo.GetKeyCode());
1996                         if (isFiltered)
1997                         {
1998                                 return true;
1999                         }
2000                 }
2001
2002                 // 3. Impl
2003                 isFiltered = __impl.OnKeyReleased(__impl, keyInfo);
2004                 if (isFiltered)
2005                 {
2006                         return true;
2007                 }
2008
2009                 // 4. Core
2010                 isFiltered = __core.OnKeyReleased(source, keyInfo);
2011
2012                 return isFiltered;
2013         }
2014
2015         virtual bool OnPreviewKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
2016         {
2017                 bool isFiltered = false;
2018
2019                 if (__impl.__pPublicPropagatedKeyEventListener != null)
2020                 {
2021                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
2022                         SysTryReturn(NID_UI, pControlImpl, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
2023
2024                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
2025
2026                         KeyEventInfo* pKeyEventInfo = new (std::nothrow) KeyEventInfo(static_cast<KeyCode>(keyInfo.GetKeyCode()),
2027                                 static_cast<KeyModifier>(keyInfo.GetKeyModifier()));
2028
2029                         isFiltered = __impl.__pPublicPropagatedKeyEventListener->OnPreviewKeyPressed(control, *pKeyEventInfo);
2030                         if (isFiltered)
2031                         {
2032                                 return true;
2033                         }
2034                 }
2035
2036                 // 3. Impl
2037                 isFiltered = __impl.OnPreviewKeyPressed(__impl, keyInfo);
2038                 if (isFiltered)
2039                 {
2040                         return true;
2041                 }
2042
2043                 // 4. Core
2044                 isFiltered = __core.OnPreviewKeyPressed(source, keyInfo);
2045
2046                 return isFiltered;
2047         }
2048
2049         virtual bool OnPreviewKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
2050         {
2051                 bool isFiltered = false;
2052
2053                 if (__impl.__pPublicPropagatedKeyEventListener != null)
2054                 {
2055                         _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(source.GetUserData());
2056                         SysTryReturn(NID_UI, pControlImpl, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pControlImpl == null.");
2057
2058                         Control& control = static_cast<Control&>(pControlImpl->GetPublic());
2059
2060                         KeyEventInfo* pKeyEventInfo = new (std::nothrow) KeyEventInfo(static_cast<KeyCode>(keyInfo.GetKeyCode()),
2061                                 static_cast<KeyModifier>(keyInfo.GetKeyModifier()));
2062
2063                         isFiltered = __impl.__pPublicPropagatedKeyEventListener->OnPreviewKeyReleased(control, *pKeyEventInfo);
2064                         if (isFiltered)
2065                         {
2066                                 return true;
2067                         }
2068                 }
2069
2070                 // 3. Impl
2071                 isFiltered = __impl.OnPreviewKeyReleased(__impl, keyInfo);
2072                 if (isFiltered)
2073                 {
2074                         return true;
2075                 }
2076
2077                 // 4. Core
2078                 isFiltered = __core.OnPreviewKeyReleased(source, keyInfo);
2079
2080                 return isFiltered;
2081         }
2082 private:
2083         _ControlImpl& __impl;
2084         _Control& __core;
2085         Control& __public;
2086
2087         Tizen::Base::Runtime::Timer* __pTimer;
2088         bool __isKeyPressed;
2089         _KeyInfo* __pKeyInfo;
2090 };
2091
2092 Rectangle
2093 _ControlImpl::GetErrorBounds(void)
2094 {
2095         return Rectangle(0, 0, -1, -1);
2096 }
2097
2098 FloatRectangle
2099 _ControlImpl::GetErrorBoundsF(void)
2100 {
2101         return FloatRectangle(0.0f, 0.0f, -1.0f, -1.0f);
2102 }
2103
2104 CompositeMode
2105 _ControlImpl::GetErrorCompositeMode(void)
2106 {
2107         return COMPOSITE_MODE_ALPHA_BLENDING;
2108 }
2109
2110 Color
2111 _ControlImpl::GetErrorChromaKeyColor(void)
2112 {
2113         return Color::GetColor(COLOR_ID_MAGENTA);
2114 }
2115
2116 Dimension
2117 _ControlImpl::GetErrorMinimumSize(void)
2118 {
2119         return Dimension(-1, -1);
2120 }
2121
2122 FloatDimension
2123 _ControlImpl::GetErrorMinimumSizeF(void)
2124 {
2125         return FloatDimension(-1.0f, -1.0f);
2126 }
2127
2128 Dimension
2129 _ControlImpl::GetErrorMaximumSize(void)
2130 {
2131         return Dimension(-1, -1);
2132 }
2133
2134 FloatDimension
2135 _ControlImpl::GetErrorMaximumSizeF(void)
2136 {
2137         return FloatDimension(-1.0f, -1.0f);
2138 }
2139
2140 const char*
2141 _ControlImpl::GetPublicClassName(void) const
2142 {
2143         return "Tizen::Ui::Control";
2144 }
2145
2146 const Control&
2147 _ControlImpl::GetPublic(void) const
2148 {
2149         return *__pControlPublic;
2150 }
2151
2152 Control&
2153 _ControlImpl::GetPublic(void)
2154 {
2155         return *__pControlPublic;
2156 }
2157
2158 const _Control&
2159 _ControlImpl::GetCore(void) const
2160 {
2161         return *__pControlCore;
2162 }
2163
2164 _Control&
2165 _ControlImpl::GetCore(void)
2166 {
2167         return *__pControlCore;
2168 }
2169
2170 result
2171 _ControlImpl::AddFocusEventListener(IFocusEventListener& listener)
2172 {
2173         OnFocusEventListenerAdded(listener);
2174         return E_SUCCESS;
2175 }
2176
2177 result
2178 _ControlImpl::AddKeyEventListener(IKeyEventListener& listener)
2179 {
2180         ClearLastResult();
2181         SysTryReturn(NID_UI,
2182                                 __pPublicKeyEventListeners->Add(const_cast <IKeyEventListener*>(&listener)) == E_SUCCESS, E_SYSTEM,
2183                                 E_SYSTEM, "[E_SYSTEM] System error occurred.");
2184
2185         return E_SUCCESS;
2186 }
2187
2188 result
2189 _ControlImpl::AddTouchEventListener(ITouchEventListener& listener)
2190 {
2191         SysAssert(__pControlCore && __pCoreEventListener && __pLongPressGestureDetector && __pFlickGestureDetector);
2192
2193         ClearLastResult();
2194         SysTryReturn(NID_UI,
2195                                 __pPublicTouchEventListeners->Add(const_cast <ITouchEventListener*>(&listener)) == E_SUCCESS, E_SYSTEM,
2196                                 E_SYSTEM, "[E_SYSTEM] System error occurred.");
2197
2198         OnTouchEventListenerAdded();
2199
2200         return E_SUCCESS;
2201 }
2202
2203 Tizen::Base::Collection::LinkedListT <Tizen::Base::Runtime::IEventListener*>*
2204 _ControlImpl::GetTouchEventListener(void) const
2205 {
2206         return __pPublicTouchEventListeners;
2207 }
2208
2209 Tizen::Base::Collection::LinkedListT <Tizen::Base::Runtime::IEventListener*>*
2210 _ControlImpl::GetKeyEventListener(void) const
2211 {
2212         return __pPublicKeyEventListeners;
2213 }
2214
2215 result
2216 _ControlImpl::AddDragDropEventListener(IDragDropEventListener& listener)
2217 {
2218         ClearLastResult();
2219         SysTryReturn(NID_UI,
2220                                 __pPublicDragDropEventListeners->Add(const_cast <IDragDropEventListener*>(&listener)) == E_SUCCESS, E_SYSTEM,
2221                                 E_SYSTEM, "[E_SYSTEM] System error occurred.");
2222
2223         return E_SUCCESS;
2224 }
2225
2226 result
2227 _ControlImpl::AddDragDropEventListener(IDragDropEventListenerF& listener)
2228 {
2229         ClearLastResult();
2230         SysTryReturn(NID_UI,
2231                                 __pPublicDragDropEventListeners->Add(const_cast <IDragDropEventListenerF*>(&listener)) == E_SUCCESS, E_SYSTEM,
2232                                 E_SYSTEM, "[E_SYSTEM] System error occurred.");
2233
2234         return E_SUCCESS;
2235 }
2236
2237 Tizen::Base::Collection::LinkedListT <Tizen::Base::Runtime::IEventListener*>*
2238 _ControlImpl::GetDragDropEventListener(void) const
2239 {
2240         return __pPublicDragDropEventListeners;
2241 }
2242
2243 result
2244 _ControlImpl::AddTouchModeChangedEventListener(ITouchModeChangedEventListener& listener)
2245 {
2246         ClearLastResult();
2247         SysTryReturn(NID_UI,
2248                                 __pPublicTouchModeChangedEventListeners->Add(
2249                                         const_cast <ITouchModeChangedEventListener*>(&listener)) == E_SUCCESS, E_SYSTEM,
2250                                 E_SYSTEM, "[E_SYSTEM] System error occurred.");
2251
2252         return E_SUCCESS;
2253 }
2254
2255 result
2256 _ControlImpl::RemoveFocusEventListener(IFocusEventListener& listener)
2257 {
2258         OnFocusEventListenerRemoved(listener);
2259         return E_SUCCESS;
2260 }
2261
2262 result
2263 _ControlImpl::RemoveKeyEventListener(IKeyEventListener& listener)
2264 {
2265         ClearLastResult();
2266         SysTryReturn(NID_UI,
2267                                 __pPublicKeyEventListeners->Remove(&listener) == E_SUCCESS, E_SYSTEM,
2268                                 E_SYSTEM, "[E_SYSTEM] System error occurred.");
2269
2270         return E_SUCCESS;
2271 }
2272
2273 result
2274 _ControlImpl::RemoveTouchEventListener(ITouchEventListener& listener)
2275 {
2276         ClearLastResult();
2277         SysTryReturn(NID_UI,
2278                                 __pPublicTouchEventListeners->Remove(&listener) == E_SUCCESS, E_SYSTEM,
2279                                 E_SYSTEM, "[E_SYSTEM] System error occurred.");
2280
2281         // [ToDo] if the number of touch event listers becomes 0, disable gesture recognition.
2282
2283         OnTouchEventListenerRemoved();
2284
2285         return E_SUCCESS;
2286 }
2287
2288 result
2289 _ControlImpl::RemoveDragDropEventListener(IDragDropEventListener& listener)
2290 {
2291         ClearLastResult();
2292         SysTryReturn(NID_UI,
2293                                 __pPublicDragDropEventListeners->Remove(&listener) == E_SUCCESS, E_SYSTEM,
2294                                 E_SYSTEM, "[E_SYSTEM] System error occurred.");
2295
2296         return E_SUCCESS;
2297 }
2298
2299 result
2300 _ControlImpl::RemoveDragDropEventListenerF(IDragDropEventListenerF& listener)
2301 {
2302         ClearLastResult();
2303         SysTryReturn(NID_UI,
2304                                 __pPublicDragDropEventListeners->Remove(&listener) == E_SUCCESS, E_SYSTEM,
2305                                 E_SYSTEM, "[E_SYSTEM] System error occurred.");
2306
2307         return E_SUCCESS;
2308 }
2309
2310 result
2311 _ControlImpl::RemoveTouchModeChangedEventListener(ITouchModeChangedEventListener& listener)
2312 {
2313         ClearLastResult();
2314         SysTryReturn(NID_UI,
2315                                 __pPublicTouchModeChangedEventListeners->Remove(&listener) == E_SUCCESS, E_SYSTEM,
2316                                 E_SYSTEM, "[E_SYSTEM] System error occurred.");
2317
2318         return E_SUCCESS;
2319 }
2320
2321 result
2322 _ControlImpl::AddGestureDetector(const TouchGestureDetector& gestureDetector)
2323 {
2324         SysTryReturn(NID_UI,
2325                                 __pPublicGestureDetectors->Add(
2326                                                 const_cast <TouchGestureDetector*>(&gestureDetector)) == E_SUCCESS, E_SYSTEM,
2327                                         E_SYSTEM, "[E_SYSTEM] System error occurred.");
2328
2329         const _TouchGestureDetectorImpl* pImpl = _TouchGestureDetectorImpl::GetInstance(gestureDetector);
2330         SysTryReturn(NID_UI, pImpl, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
2331
2332         result r = GetCore().AddGestureDetector(pImpl->GetCore());
2333         SysTryReturn(NID_UI, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
2334
2335         return E_SUCCESS;
2336 }
2337
2338 result
2339 _ControlImpl::RemoveGestureDetector(const TouchGestureDetector& gestureDetector)
2340 {
2341         SysTryReturn(NID_UI,
2342                                 __pPublicGestureDetectors->Remove(
2343                                                 const_cast <TouchGestureDetector*>(&gestureDetector)) == E_SUCCESS, E_SYSTEM,
2344                                         E_SYSTEM, "[E_SYSTEM] System error occurred.");
2345
2346         const _TouchGestureDetectorImpl* pImpl = _TouchGestureDetectorImpl::GetInstance(gestureDetector);
2347         SysTryReturn(NID_UI, pImpl, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
2348
2349         result r = GetCore().RemoveGestureDetector(pImpl->GetCore());
2350         SysTryReturn(NID_UI, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
2351
2352         return r;
2353 }
2354
2355 IListT<TouchGestureDetector*>*
2356 _ControlImpl::GetGestureDetectorList(void) const
2357 {
2358         return __pPublicGestureDetectors;
2359 }
2360
2361 bool
2362 _ControlImpl::IsMovable(void) const
2363 {
2364         return GetCore().IsMovable();
2365 }
2366
2367 bool
2368 _ControlImpl::IsResizable(void) const
2369 {
2370         return GetCore().IsResizable();
2371 }
2372
2373 Dimension
2374 _ControlImpl::GetContentSize(void) const
2375 {
2376         return GetCore().GetContentSize();
2377 }
2378
2379 FloatDimension
2380 _ControlImpl::GetContentSizeF(bool horizontalMode, bool verticalMode) const
2381 {
2382         return GetCore().GetContentSizeF(horizontalMode, verticalMode);
2383 }
2384
2385 HitTestResult
2386 _ControlImpl::HitTest(const Tizen::Graphics::FloatPoint& point)
2387 {
2388         return GetCore().HitTest(point);
2389 }
2390
2391 String
2392 _ControlImpl::GetDescription(void) const
2393 {
2394         String description(L"");
2395
2396         description.Format(LOG_LEN_MAX, L"0x%x(0x%x, %s) fgColor(0x%x) fontSize(%d) ", this, __pControlPublic, GetPublicClassName(), __foregroundColor.GetRGB32(), __fontSize);
2397
2398         if (__pControlAnimator)
2399         {
2400                 description.Append(L"ControlAnimator(");
2401                 description.Append((int)__pControlAnimator);
2402                 description.Append(L") ");
2403         }
2404
2405         if (__pCustomVisualElement)
2406         {
2407                 description.Append(L"CustomVisualElement(");
2408                 description.Append((int)__pCustomVisualElement);
2409                 description.Append(L") ");
2410         }
2411
2412         if (__pBuilderPortraitBounds)
2413         {
2414                 description.Append(L"PortraitBounds(");
2415                 description.Append(__pBuilderPortraitBounds->x);
2416                 description.Append(L" ");
2417                 description.Append(__pBuilderPortraitBounds->y);
2418                 description.Append(L" ");
2419                 description.Append(__pBuilderPortraitBounds->width);
2420                 description.Append(L" ");
2421                 description.Append(__pBuilderPortraitBounds->height);
2422                 description.Append(L") ");
2423         }
2424
2425         if (__pBuilderLandscapeBounds)
2426         {
2427                 description.Append(L"LandscapeBounds(");
2428                 description.Append(__pBuilderLandscapeBounds->x);
2429                 description.Append(L" ");
2430                 description.Append(__pBuilderLandscapeBounds->y);
2431                 description.Append(L" ");
2432                 description.Append(__pBuilderLandscapeBounds->width);
2433                 description.Append(L" ");
2434                 description.Append(__pBuilderLandscapeBounds->height);
2435                 description.Append(L") ");
2436         }
2437
2438         if (__pPublicGestureDetectors->GetCount() > 0 )
2439         {
2440                 IEnumeratorT<TouchGestureDetector*>* pEnumerator = __pPublicGestureDetectors->GetEnumeratorN();
2441                 if (pEnumerator)
2442                 {
2443                         description.Append(L"TouchGestureDetector(");
2444
2445                         while (pEnumerator->MoveNext() == E_SUCCESS)
2446                         {
2447                                 TouchGestureDetector* pTouchGestureDetector = null;
2448                                 pEnumerator->GetCurrent(pTouchGestureDetector);
2449                                 if (pTouchGestureDetector)
2450                                 {
2451                                         description.Append((int)pTouchGestureDetector);
2452                                         description.Append(L" ");
2453                                 }
2454                         }
2455
2456                         description.Append(L") ");
2457
2458                         delete pEnumerator;
2459                 }
2460         }
2461
2462         if (__pPublicFocusEventListeners->GetCount() > 0 )
2463         {
2464                 IEnumeratorT<IEventListener*>* pEnumerator = __pPublicFocusEventListeners->GetEnumeratorN();
2465                 if (pEnumerator)
2466                 {
2467                         description.Append(L"FocusListener(");
2468
2469                         while (pEnumerator->MoveNext() == E_SUCCESS)
2470                         {
2471                                 IEventListener* pListener = null;
2472                                 pEnumerator->GetCurrent(pListener);
2473                                 if (pListener)
2474                                 {
2475                                         description.Append((int)pListener);
2476                                         description.Append(L" ");
2477                                 }
2478                         }
2479
2480                         description.Append(L") ");
2481
2482                         delete pEnumerator;
2483                 }
2484         }
2485
2486         if (__pPublicKeyEventListeners->GetCount() > 0 )
2487         {
2488                 IEnumeratorT<IEventListener*>* pEnumerator = __pPublicKeyEventListeners->GetEnumeratorN();
2489                 if (pEnumerator)
2490                 {
2491                         description.Append(L"KeyListener(");
2492
2493                         while (pEnumerator->MoveNext() == E_SUCCESS)
2494                         {
2495                                 IEventListener* pListener = null;
2496                                 pEnumerator->GetCurrent(pListener);
2497                                 if (pListener)
2498                                 {
2499                                         description.Append((int)pListener);
2500                                         description.Append(L" ");
2501                                 }
2502                         }
2503
2504                         description.Append(L") ");
2505
2506                         delete pEnumerator;
2507                 }
2508         }
2509
2510         if (__pPublicTouchEventListeners->GetCount() > 0 )
2511         {
2512                 IEnumeratorT<IEventListener*>* pEnumerator = __pPublicTouchEventListeners->GetEnumeratorN();
2513                 if (pEnumerator)
2514                 {
2515                         description.Append(L"TouchListener(");
2516
2517                         while (pEnumerator->MoveNext() == E_SUCCESS)
2518                         {
2519                                 IEventListener* pListener = null;
2520                                 pEnumerator->GetCurrent(pListener);
2521                                 if (pListener)
2522                                 {
2523                                         description.Append((int)pListener);
2524                                         description.Append(L" ");
2525                                 }
2526                         }
2527
2528                         description.Append(L") ");
2529
2530                         delete pEnumerator;
2531                 }
2532         }
2533
2534         if (__pPublicDragDropEventListeners->GetCount() > 0 )
2535         {
2536                 IEnumeratorT<IEventListener*>* pEnumerator = __pPublicDragDropEventListeners->GetEnumeratorN();
2537                 if (pEnumerator)
2538                 {
2539                         description.Append(L"DragDropListener(");
2540
2541                         while (pEnumerator->MoveNext() == E_SUCCESS)
2542                         {
2543                                 IEventListener* pListener = null;
2544                                 pEnumerator->GetCurrent(pListener);
2545                                 if (pListener)
2546                                 {
2547                                         description.Append((int)pListener);
2548                                         description.Append(L" ");
2549                                 }
2550                         }
2551
2552                         description.Append(L") ");
2553
2554                         delete pEnumerator;
2555                 }
2556         }
2557
2558         if (__pPublicTouchModeChangedEventListeners->GetCount() > 0 )
2559         {
2560                 IEnumeratorT<IEventListener*>* pEnumerator = __pPublicTouchModeChangedEventListeners->GetEnumeratorN();
2561                 if (pEnumerator)
2562                 {
2563                         description.Append(L"TouchModeListener(");
2564
2565                         while (pEnumerator->MoveNext() == E_SUCCESS)
2566                         {
2567                                 IEventListener* pListener = null;
2568                                 pEnumerator->GetCurrent(pListener);
2569                                 if (pListener)
2570                                 {
2571                                         description.Append((int)pListener);
2572                                         description.Append(L" ");
2573                                 }
2574                         }
2575
2576                         description.Append(L") ");
2577
2578                         delete pEnumerator;
2579                 }
2580         }
2581
2582         return description;
2583 }
2584
2585 void
2586 _ControlImpl::OnDraw(void)
2587 {
2588         GetCore().OnDraw();
2589 }
2590
2591 Tizen::Graphics::Canvas*
2592 _ControlImpl::OnCanvasRequestedN(const Tizen::Graphics::FloatRectangle& bounds)
2593 {
2594         return GetCore().OnCanvasRequestedN(bounds);
2595 }
2596
2597 Tizen::Graphics::Bitmap*
2598 _ControlImpl::OnCapturedBitmapRequestedN(void)
2599 {
2600
2601         return GetCore().OnCapturedBitmapRequestedN();
2602 }
2603
2604 result
2605 _ControlImpl::OnAttaching(const _Control* pParent)
2606 {
2607         return GetCore().OnAttaching(pParent);
2608 }
2609
2610 result
2611 _ControlImpl::OnAttached(void)
2612 {
2613         return GetCore().OnAttached();
2614 }
2615
2616 result
2617 _ControlImpl::OnAttachingToMainTree(const _Control* pParent)
2618 {
2619         return GetCore().OnAttachingToMainTree(pParent);
2620 }
2621
2622 result
2623 _ControlImpl::OnPreAttachedToMainTree(void)
2624 {
2625         return E_SUCCESS;
2626 }
2627
2628 result
2629 _ControlImpl::OnAttachedToMainTree(void)
2630 {
2631         result r = E_SUCCESS;
2632         result returnResultPublic = E_SUCCESS;
2633         result returnResultCore = E_SUCCESS;
2634
2635         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
2636         {
2637                 GetCore().SetDrawWhenVisible(false);
2638                 GetCore().SetTerminatingOrder(true);
2639         }
2640
2641         returnResultPublic = GetPublic().OnInitializing();
2642         returnResultCore = GetCore().OnAttachedToMainTree();
2643
2644         if (IsFailed(returnResultPublic) || IsFailed(returnResultCore))
2645         {
2646                 _ContainerImpl* pParent = GetParent();
2647                 SysTryReturn(NID_UI, pParent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
2648
2649                 r = pParent->RemoveChild(this, false);
2650                 SysAssert(r == E_SUCCESS);
2651
2652                 SysTryReturn(NID_UI, returnResultPublic == E_SUCCESS, returnResultPublic, returnResultPublic, "[%s] propagated.", GetErrorMessage(returnResultPublic));
2653                 SysTryReturn(NID_UI, returnResultCore == E_SUCCESS, returnResultCore, returnResultCore, "[%s] propagated.", GetErrorMessage(returnResultCore));
2654         }
2655
2656         return returnResultPublic;
2657 }
2658
2659 result
2660 _ControlImpl::OnDetachingFromMainTree(void)
2661 {
2662         GetPublic().OnTerminating();
2663         return GetCore().OnDetachingFromMainTree();
2664 }
2665
2666 void
2667 _ControlImpl::OnAttachingFailed(const _Control& parent)
2668 {
2669         GetCore().OnAttachingFailed(parent);
2670 }
2671
2672 result
2673 _ControlImpl::OnDetaching(void)
2674 {
2675         return E_SUCCESS;
2676 }
2677
2678 result
2679 _ControlImpl::OnBoundsChanging(const Rectangle& bounds)
2680 {
2681         __oldBounds = _CoordinateSystemUtils::ConvertToFloat(GetBounds());
2682
2683         return GetCore().OnBoundsChanging(bounds);
2684 }
2685
2686 result
2687 _ControlImpl::OnBoundsChanging(const FloatRectangle& bounds)
2688 {
2689         __oldBounds = GetBoundsF();
2690
2691         return GetCore().OnBoundsChanging(bounds);
2692 }
2693
2694 void
2695 _ControlImpl::OnBoundsChanged(void)
2696 {
2697         GetCore().OnBoundsChanged();
2698 }
2699
2700 void
2701 _ControlImpl::OnEvaluateSize(Dimension& evaluatedSize)
2702 {
2703         GetCore().OnEvaluateSize(evaluatedSize);
2704 }
2705
2706 bool
2707 _ControlImpl::OnEvaluateSize(FloatDimension& evaluatedSize)
2708 {
2709         return GetCore().OnEvaluateSize(evaluatedSize);
2710 }
2711
2712 void
2713 _ControlImpl::OnParentBoundsChanged(const _Control& parent)
2714 {
2715         GetCore().OnParentBoundsChanged(parent);
2716 }
2717
2718 void
2719 _ControlImpl::OnChildAttached(const _Control& child)
2720 {
2721         GetCore().OnChildAttached(child);
2722 }
2723
2724 void
2725 _ControlImpl::OnChildDetaching(const _Control& child)
2726 {
2727         GetCore().OnChildDetaching(child);
2728 }
2729
2730 void
2731 _ControlImpl::OnChildDetached(const _Control& child)
2732 {
2733         GetCore().OnChildDetached(child);
2734 }
2735
2736 void
2737 _ControlImpl::OnChildBoundsChanged(const _Control& child)
2738 {
2739         GetCore().OnChildBoundsChanged(child);
2740 }
2741
2742 void
2743 _ControlImpl::OnChildVisibleStateChanged(const _Control& child)
2744 {
2745         GetCore().OnChildVisibleStateChanged(child);
2746 }
2747
2748 void
2749 _ControlImpl::OnChangeLayout(_ControlOrientation orientation)
2750 {
2751         result r = E_SUCCESS;
2752
2753         if (IsAttachedToMainTree())
2754         {
2755                 Rectangle builderBounds;
2756                 bool exist = GetBuilderBounds(orientation, builderBounds);
2757                 if (exist)
2758                 {
2759                         bool movable = IsMovable();
2760                         bool resizable = IsResizable();
2761
2762                         SetMovable(true);
2763                         SetResizable(true);
2764
2765                         r = SetBounds(builderBounds);
2766                         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] Failed to set bounds of %s.", GetPublicClassName());
2767                         builderBounds.x = 0;
2768                         builderBounds.y = 0;
2769                         SetClientBounds(builderBounds);
2770
2771                         SetMovable(movable);
2772                         SetResizable(resizable);
2773
2774                 }
2775         }
2776
2777         GetCore().OnChangeLayout(orientation);
2778 }
2779
2780 void
2781 _ControlImpl::OnChangeLayout(_ControlRotation rotation)
2782 {
2783         GetCore().OnChangeLayout(rotation);
2784 }
2785
2786 void
2787 _ControlImpl::OnZOrderChanging(_ControlZOrderUpdate zOrderUpdate)
2788 {
2789         GetCore().OnZOrderChanging(zOrderUpdate);
2790 }
2791
2792 void
2793 _ControlImpl::OnVisibleStateChanging(void)
2794 {
2795         GetCore().OnVisibleStateChanging();
2796 }
2797
2798 void
2799 _ControlImpl::OnVisibleStateChanged(void)
2800 {
2801         GetCore().OnVisibleStateChanged();
2802 }
2803
2804 void
2805 _ControlImpl::OnAncestorVisibleStateChanged(const _Control& control)
2806 {
2807         GetCore().OnAncestorVisibleStateChanged(control);
2808 }
2809
2810 void
2811 _ControlImpl::OnAncestorEnableStateChanged(const _Control& control)
2812 {
2813         GetCore().OnAncestorEnableStateChanged(control);
2814 }
2815
2816 void
2817 _ControlImpl::OnAncestorInputEnableStateChanged(const _Control& control)
2818 {
2819         GetCore().OnAncestorInputEnableStateChanged(control);
2820 }
2821
2822 void
2823 _ControlImpl::OnTouchPressHandled(const _Control& control)
2824 {
2825         GetCore().OnTouchPressHandled(control);
2826 }
2827
2828 void
2829 _ControlImpl::OnTouchReleaseHandled(const _Control& control)
2830 {
2831         GetCore().OnTouchReleaseHandled(control);
2832 }
2833
2834 void
2835 _ControlImpl::OnTouchMoveHandled(const _Control& control)
2836 {
2837         GetCore().OnTouchMoveHandled(control);
2838 }
2839
2840 void
2841 _ControlImpl::OnFontChanged(Font* pFont)
2842 {
2843         GetCore().OnFontChanged(pFont);
2844 }
2845
2846 void
2847 _ControlImpl::OnFontInfoRequested(unsigned long& style, int& size)
2848 {
2849         GetCore().OnFontInfoRequested(style, size);
2850 }
2851
2852 void
2853 _ControlImpl::OnFontInfoRequested(unsigned long& style, float& size)
2854 {
2855         GetCore().OnFontInfoRequested(style, size);
2856 }
2857
2858 void
2859 _ControlImpl::OnBackgroundColorChanged(Color& backgroundColor)
2860 {
2861         GetCore().OnBackgroundColorChanged(backgroundColor);
2862 }
2863
2864 void
2865 _ControlImpl::OnFocusableStateChanged(bool focusalbeState)
2866 {
2867         GetCore().OnFocusableStateChanged(focusalbeState);
2868 }
2869
2870 void
2871 _ControlImpl::OnTouchCancelHandled(const _Control& control)
2872 {
2873         GetCore().OnTouchCancelHandled(control);
2874 }
2875
2876 bool
2877 _ControlImpl::TranslateKeyEventInfo(const _ControlImpl& source, _KeyInfo& keyInfo)
2878 {
2879         return false;
2880 }
2881
2882 bool
2883 _ControlImpl::OnKeyPressed(const _ControlImpl& source, const _KeyInfo& keyInfo)
2884 {
2885         return false;
2886 }
2887
2888 bool
2889 _ControlImpl::OnKeyReleased(const _ControlImpl& source, const _KeyInfo& keyInfo)
2890 {
2891         return false;
2892 }
2893
2894 bool _ControlImpl::OnPreviewKeyPressed(const _ControlImpl& source, const _KeyInfo& keyInfo)
2895 {
2896         return false;
2897 }
2898
2899 bool _ControlImpl::OnPreviewKeyReleased(const _ControlImpl& source, const _KeyInfo& keyInfo)
2900 {
2901         return false;
2902 }
2903
2904 bool
2905 _ControlImpl::CallOnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
2906 {
2907         bool isFiltered = false;
2908
2909         if (source.IsDelayedTouchEventEnabled())
2910         {
2911                 if (&source == &GetCore())
2912                 {
2913                         const_cast<_Control&>(source).AddTouchInfo(touchinfo);
2914                 }
2915
2916                 return false;
2917         }
2918
2919         GetCore().SetEventEnableState(true);
2920
2921         if (&source == &GetCore())
2922         {
2923                 isFiltered = __pCoreTouchEvent->ProcessListener(touchinfo);
2924                 if (isFiltered)
2925                 {
2926                         return true;
2927                 }
2928
2929                 LinkedListT <Tizen::Base::Runtime::IEventListener*>* pList = GetTouchEventListener();
2930                 if (pList && (pList->GetCount() > 0))
2931                 {
2932                         __pCoreTouchEvent->ProcessDoublePress(touchinfo, isFiltered);
2933                 }
2934
2935                 __pCoreTouchEvent->ProcessDragListener(touchinfo);
2936         }
2937
2938         _TouchManager* __pTouchManager =  _TouchManager::GetInstance();
2939         SysTryReturn(NID_UI, __pTouchManager, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] __pTouchManager == null.");
2940
2941         if (!GetCore().IsEventEnabled())
2942         {
2943                 __pTouchManager->ResetTouchInfo();
2944                 isFiltered = true;
2945                 return true;
2946         }
2947
2948         if (!__pTouchManager->IsTouchAllowed())
2949         {
2950                 return true;
2951         }
2952
2953         // 3. Impl
2954         isFiltered = OnTouchPressed(*this, touchinfo);
2955         if (isFiltered)
2956         {
2957                 return true;
2958         }
2959
2960         // 4. Core
2961         isFiltered = GetCore().OnTouchPressed(source, touchinfo);
2962
2963         return isFiltered;
2964
2965 }
2966
2967 bool
2968 _ControlImpl::CallOnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
2969 {
2970         bool isFiltered = false;
2971
2972         if (source.IsDelayedTouchEventEnabled())
2973         {
2974                 if (&source == &GetCore())
2975                 {
2976                         const_cast<_Control&>(source).AddTouchInfo(touchinfo);
2977                 }
2978
2979                 return false;
2980         }
2981
2982         if (&source == &GetCore())
2983         {
2984                 isFiltered = __pCoreTouchEvent->ProcessListener(touchinfo);
2985                 if (isFiltered)
2986                 {
2987                         return true;
2988                 }
2989         }
2990
2991         __pCoreTouchEvent->ProcessDropListener(touchinfo);
2992
2993         _TouchManager* __pTouchManager =  _TouchManager::GetInstance();
2994         SysTryReturn(NID_UI, __pTouchManager, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] __pTouchManager == null.");
2995
2996         if (!__pTouchManager->IsTouchAllowed())
2997         {
2998                 return true;
2999         }
3000
3001         // 3. Impl
3002         isFiltered = OnTouchReleased(*this, touchinfo);
3003         if (isFiltered)
3004         {
3005                 return true;
3006         }
3007
3008         //send drop event to topmost touched control
3009         __pCoreTouchEvent->ProcessDropListenerToTopControl(touchinfo);
3010
3011         // 4. Core
3012         isFiltered = GetCore().OnTouchReleased(source, touchinfo);
3013
3014         return isFiltered;
3015 }
3016
3017 bool
3018 _ControlImpl::CallOnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
3019 {
3020         bool isFiltered = false;
3021
3022         if (source.IsDelayedTouchEventEnabled())
3023         {
3024                 if (&source == &GetCore())
3025                 {
3026                         const_cast<_Control&>(source).AddTouchInfo(touchinfo);
3027                 }
3028
3029                 return false;
3030         }
3031
3032         if (&source == &GetCore())
3033         {
3034                 isFiltered = __pCoreTouchEvent->ProcessListener(touchinfo);
3035                 if (isFiltered)
3036                 {
3037                         return true;
3038                 }
3039
3040                 __pCoreTouchEvent->ProcessDragListener(touchinfo);
3041         }
3042
3043         _TouchManager* __pTouchManager =  _TouchManager::GetInstance();
3044         SysTryReturn(NID_UI, __pTouchManager, false, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] __pTouchManager == null.");
3045
3046         if (!__pTouchManager->IsTouchAllowed())
3047         {
3048                 return true;
3049         }
3050
3051         // 3. Impl
3052         isFiltered = OnTouchMoved(*this, touchinfo);
3053         if (isFiltered)
3054         {
3055                 return true;
3056         }
3057
3058         // 4. Core
3059         isFiltered = GetCore().OnTouchMoved(source, touchinfo);
3060
3061         return isFiltered;
3062 }
3063
3064 bool
3065 _ControlImpl::CallOnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
3066 {
3067         bool isFiltered = false;
3068
3069         __pCoreTouchEvent->ProcessDropListener(touchinfo);
3070         __pCoreTouchEvent->ProcessDropListenerToTopControl(touchinfo);
3071
3072         if (&source == &GetCore())
3073         {
3074                 isFiltered = __pCoreTouchEvent->ProcessListener(touchinfo);
3075                 if (isFiltered)
3076                 {
3077                         return true;
3078                 }
3079         }
3080
3081         // 3. Impl
3082         isFiltered = OnTouchCanceled(*this, touchinfo);
3083         if (isFiltered)
3084         {
3085                 return true;
3086         }
3087
3088         // 4. Core
3089         isFiltered = GetCore().OnTouchCanceled(source, touchinfo);
3090
3091         return isFiltered;
3092 }
3093
3094 result
3095 _ControlImpl::OnTouchEventListenerAdded(void)
3096 {
3097         // First time, enable gesture.
3098         if (__pPublicTouchEventListeners->GetCount() == 1)
3099         {
3100                 result r = E_SUCCESS;
3101
3102                 r = __pControlCore->AddGestureDetector(*__pLongPressGestureDetector);
3103                 SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
3104
3105                 r = __pLongPressGestureDetector->AddGestureListener(*__pCoreEventListener);
3106                 SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
3107
3108                 r = __pControlCore->AddGestureDetector(*__pFlickGestureDetector);
3109                 SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
3110
3111                 r = __pFlickGestureDetector->AddGestureListener(*__pCoreEventListener);
3112                 SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
3113         }
3114         return E_SUCCESS;
3115 }
3116
3117 result
3118 _ControlImpl::OnTouchEventListenerRemoved(void)
3119 {
3120         return E_SUCCESS;
3121 }
3122
3123 void
3124 _ControlImpl::OnFocusEventListenerAdded(IFocusEventListener& listener)
3125 {
3126         ClearLastResult();
3127         SysTryReturnVoidResult(NID_UI,
3128                                 __pPublicFocusEventListeners->Add(const_cast <IFocusEventListener*>(&listener)) == E_SUCCESS, E_SYSTEM,
3129                                 "[E_SYSTEM] System error occurred.");
3130 }
3131
3132 void
3133 _ControlImpl::OnFocusEventListenerRemoved(IFocusEventListener& listener)
3134 {
3135         ClearLastResult();
3136         SysTryReturnVoidResult(NID_UI,
3137                                 __pPublicFocusEventListeners->Remove(&listener) == E_SUCCESS, E_SYSTEM,
3138                                 "[E_SYSTEM] System error occurred.");
3139 }
3140
3141 bool
3142 _ControlImpl::OnTouchPressed(const _ControlImpl& source, const _TouchInfo& touchinfo)
3143 {
3144         return false;
3145 }
3146
3147 bool
3148 _ControlImpl::OnTouchCanceled(const _ControlImpl& source, const _TouchInfo& touchinfo)
3149 {
3150         return false;
3151 }
3152
3153 bool
3154 _ControlImpl::OnTouchReleased(const _ControlImpl& source, const _TouchInfo& touchinfo)
3155 {
3156         return false;
3157 }
3158
3159 bool
3160 _ControlImpl::OnTouchMoved(const _ControlImpl& source, const _TouchInfo& touchinfo)
3161 {
3162         return false;
3163 }
3164
3165 _UiTouchEventDelivery
3166 _ControlImpl::OnPreviewTouchPressed(const _ControlImpl& source, const _TouchInfo& touchInfo)
3167 {
3168         return _UI_TOUCH_EVENT_DELIVERY_YES;
3169 }
3170
3171 _UiTouchEventDelivery
3172 _ControlImpl::OnPreviewTouchReleased(const _ControlImpl& source, const _TouchInfo& touchInfo)
3173 {
3174         return _UI_TOUCH_EVENT_DELIVERY_YES;
3175 }
3176
3177 _UiTouchEventDelivery
3178 _ControlImpl::OnPreviewTouchMoved(const _ControlImpl& source, const _TouchInfo& touchInfo)
3179 {
3180         return _UI_TOUCH_EVENT_DELIVERY_YES;
3181 }
3182
3183 _UiTouchEventDelivery
3184 _ControlImpl::OnPreviewTouchCanceled(const _ControlImpl& source, const _TouchInfo& touchInfo)
3185 {
3186         return _UI_TOUCH_EVENT_DELIVERY_YES;
3187 }
3188
3189 bool
3190 _ControlImpl::OnMousePressed(const _ControlImpl& source, const _MouseInfo& mouseinfo)
3191 {
3192         return false;
3193 }
3194
3195 bool
3196 _ControlImpl::OnMouseReleased(const _ControlImpl& source, const _MouseInfo& mouseinfo)
3197 {
3198         return false;
3199 }
3200
3201 bool
3202 _ControlImpl::OnMouseMoved(const _ControlImpl& source, const _MouseInfo& mouseinfo)
3203 {
3204         return false;
3205 }
3206
3207 bool
3208 _ControlImpl::OnMouseWheeled(const _ControlImpl& source, const _MouseInfo& mouseinfo)
3209 {
3210         return false;
3211 }
3212
3213 _UiTouchEventDelivery
3214 _ControlImpl::OnPreviewMousePressed(const _ControlImpl& source, const _MouseInfo& mouseinfo)
3215 {
3216         return _UI_TOUCH_EVENT_DELIVERY_YES;
3217 }
3218
3219 _UiTouchEventDelivery
3220 _ControlImpl::OnPreviewMouseReleased(const _ControlImpl& source, const _MouseInfo& mouseinfo)
3221 {
3222         return _UI_TOUCH_EVENT_DELIVERY_YES;
3223 }
3224
3225 _UiTouchEventDelivery
3226 _ControlImpl::OnPreviewMouseMoved(const _ControlImpl& source, const _MouseInfo& mouseinfo)
3227 {
3228         return _UI_TOUCH_EVENT_DELIVERY_YES;
3229 }
3230
3231 _UiTouchEventDelivery
3232 _ControlImpl::OnPreviewMouseWheeled(const _ControlImpl& source, const _MouseInfo& mouseinfo)
3233 {
3234         return _UI_TOUCH_EVENT_DELIVERY_YES;
3235 }
3236
3237 bool
3238 _ControlImpl::OnFocusGained(const _ControlImpl& source)
3239 {
3240         return false;
3241 }
3242
3243 bool
3244 _ControlImpl::OnFocusLost(const _ControlImpl& source)
3245 {
3246         return false;
3247 }
3248
3249 bool
3250 _ControlImpl::OnNotifiedN(const _ControlImpl& source, Tizen::Base::Collection::IList* pArgs)
3251 {
3252         return false;
3253 }
3254
3255 void
3256 _ControlImpl::OnUserEventReceivedN(RequestId requestId, Tizen::Base::Collection::IList* pArgs)
3257 {
3258         GetPublic().OnUserEventReceivedN(requestId, pArgs);
3259 }
3260
3261 bool
3262 _ControlImpl::SendNotification(const _ControlImpl& source, Tizen::Base::Collection::IList* pArgs)
3263 {
3264         _ControlImpl& impl = const_cast <_ControlImpl&>(source);
3265
3266         Tizen::Base::String* pString = dynamic_cast <Tizen::Base::String*>(pArgs->GetAt(0));
3267         if (pString)
3268         {
3269                 if (*pString == _USER_EVENT)
3270                 {
3271                         _UserEventInfo* pUserEventInfo = dynamic_cast <_UserEventInfo*>(pArgs->GetAt(1));
3272                         if (pUserEventInfo)
3273                         {
3274                                 impl.OnUserEventReceivedN(pUserEventInfo->GetRequestId(), pUserEventInfo->GetArgs());
3275                         }
3276                         pArgs->RemoveAll(true);
3277                         delete pArgs;
3278
3279                         return true;
3280                 }
3281                 else if (*pString == _REQUEST_REDRAW_EVENT)
3282                 {
3283                         impl.Draw();
3284
3285                         Boolean* pBoolean = dynamic_cast <Boolean*>(pArgs->GetAt(1));
3286                         if (pBoolean && pBoolean->ToBool())
3287                         {
3288                                 impl.Show();
3289                         }
3290                         pArgs->RemoveAll(true);
3291                         delete pArgs;
3292
3293                         return true;
3294                 }
3295         }
3296
3297         return false;
3298 }
3299
3300 result
3301 _ControlImpl::Draw(bool recursive)
3302 {
3303         SysTryReturn(NID_UI,
3304                                 IsAttachedToMainTree(), E_INVALID_OPERATION,
3305                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] The control should be attached to the main tree.");
3306
3307         GetCore().Draw(recursive);
3308
3309         return E_SUCCESS;
3310 }
3311
3312 result
3313 _ControlImpl::Show(void)
3314 {
3315         SysTryReturn(NID_UI,
3316                                 GetParent() || IsAttachedToMainTree(), E_INVALID_OPERATION,
3317                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] This control should have a parent or be attached to the main tree.");
3318
3319         GetCore().Show();
3320
3321         return E_SUCCESS;
3322 }
3323
3324 void
3325 _ControlImpl::Invalidate(bool recursive)
3326 {
3327         SysTryReturnVoidResult(NID_UI,
3328                                 IsAttachedToMainTree(),
3329                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] The control should be attached to the main tree.");
3330
3331         GetCore().Invalidate(recursive);
3332 }
3333
3334 void
3335 _ControlImpl::Invalidate(const Rectangle& rect)
3336 {
3337         SysTryReturnVoidResult(NID_UI,
3338                                 IsAttachedToMainTree(),
3339                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] The control should be attached to the main tree.");
3340
3341         GetCore().Invalidate(rect);
3342 }
3343
3344 void
3345 _ControlImpl::Invalidate(const FloatRectangle& rect)
3346 {
3347         SysTryReturnVoidResult(NID_UI,
3348                                 IsAttachedToMainTree(),
3349                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] The control should be attached to the main tree.");
3350
3351         GetCore().Invalidate(rect);
3352 }
3353
3354 void
3355 _ControlImpl::RequestRedraw(bool show) const
3356 {
3357         ClearLastResult();
3358
3359         ArrayList* pEventArgs = new (std::nothrow) ArrayList;
3360         SysTryReturnVoidResult(NID_UI, pEventArgs, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
3361
3362         pEventArgs->Construct();
3363
3364         Tizen::Base::String* pString = new (std::nothrow) Tizen::Base::String(_REQUEST_REDRAW_EVENT);
3365         SysTryReturnVoidResult(NID_UI, pString, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
3366
3367         // Index 0 : Type
3368         pEventArgs->Add(*pString);
3369
3370         Boolean* pBoolean = new (std::nothrow) Boolean(show);
3371         SysTryReturnVoidResult(NID_UI, pBoolean, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
3372
3373         // Index 1 : User Data
3374         pEventArgs->Add(*pBoolean);
3375
3376         _UiEventManager* pEventManager = _UiEventManager::GetInstance();
3377         SysTryReturnVoidResult(NID_UI, pEventManager, E_SYSTEM, "[E_SYSTEM] System error occurred.");
3378
3379         _UiNotificationEvent event(GetCore().GetHandle(), pEventArgs);
3380
3381         result r = pEventManager->PostEvent(event);
3382         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] System error occurred.");
3383 }
3384
3385 void
3386 _ControlImpl::SendUserEvent(RequestId requestId, const IList* pArgs) const
3387 {
3388         ClearLastResult();
3389
3390         ArrayList* pEventArgs = new (std::nothrow) ArrayList;
3391         SysTryReturnVoidResult(NID_UI, pEventArgs, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
3392
3393         pEventArgs->Construct();
3394
3395         Tizen::Base::String* pString = new (std::nothrow) Tizen::Base::String(_USER_EVENT);
3396         SysTryReturnVoidResult(NID_UI, pString, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
3397
3398         // Index 0 : Type
3399         pEventArgs->Add(*pString);
3400
3401         _UserEventInfo* pUserEventInfo = new (std::nothrow) _UserEventInfo(requestId, pArgs);
3402         SysTryReturnVoidResult(NID_UI, pUserEventInfo, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
3403
3404         // Index 1 : User Data
3405         pEventArgs->Add(*pUserEventInfo);
3406
3407         _UiEventManager* pEventManager = _UiEventManager::GetInstance();
3408         SysTryReturnVoidResult(NID_UI, pEventManager, E_SYSTEM, "[E_SYSTEM] System error occurred.");
3409
3410         _UiNotificationEvent event(GetCore().GetHandle(), pEventArgs);
3411
3412         result r = pEventManager->PostEvent(event);
3413         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] System error occurred.");
3414 }
3415
3416 bool
3417 _ControlImpl::Contains(const Point& point) const
3418 {
3419         return GetCore().Contains(point);
3420 }
3421
3422 bool
3423 _ControlImpl::Contains(const FloatPoint& point) const
3424 {
3425         return GetCore().Contains(point);
3426 }
3427
3428 void
3429 _ControlImpl::ConsumeInputEvent(void)
3430 {
3431         ClearLastResult();
3432         __inputEventConsumed = true;
3433 }
3434
3435 bool
3436 _ControlImpl::IsInputEventConsumed(void) const
3437 {
3438         ClearLastResult();
3439         return __inputEventConsumed;
3440 }
3441
3442 void
3443 _ControlImpl::ResetInputEventConsumed(void)
3444 {
3445         ClearLastResult();
3446         __inputEventConsumed = false;
3447 }
3448
3449 Tizen::Base::String
3450 _ControlImpl::GetName(void) const
3451 {
3452         return GetCore().GetName();
3453 }
3454
3455 void
3456 _ControlImpl::SetName(const Tizen::Base::String& name)
3457 {
3458         GetCore().SetName(name);
3459 }
3460
3461 _ContainerImpl*
3462 _ControlImpl::GetParent(void) const
3463 {
3464         ClearLastResult();
3465
3466         _Control* pParent = GetCore().GetParent();
3467         if (pParent == null)
3468         {
3469                 return null;
3470         }
3471
3472         void* pData = pParent->GetUserData();
3473         if (pData == null)
3474         {
3475                 return null; // This is for the _ControlManager::__pRoot.
3476         }
3477
3478         _ContainerImpl* pParentImpl = static_cast <_ContainerImpl*>(pData);
3479         return pParentImpl;
3480 }
3481
3482 Canvas*
3483 _ControlImpl::GetCanvasN(void) const
3484 {
3485         SysTryReturn(NID_UI,
3486                                 GetParent() || IsAttachedToMainTree(), null,
3487                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] This control should have a parent or be attached to the main tree.");
3488
3489         Canvas* pCanvas = GetCore().GetCanvasN();
3490         result r = GetLastResult();
3491         if (IsFailed(r))
3492         {
3493                 if (r == E_OPERATION_FAILED)
3494                 {
3495                         SetLastResult(E_INVALID_OPERATION);
3496                 }
3497                 SysLog(NID_UI_CTRL, "[%s] Propagated", GetErrorMessage(GetLastResult()));
3498         }
3499         else
3500         {
3501                 if (pCanvas)
3502                 {
3503                         pCanvas->SetBackgroundColor(GetBackgroundColor());
3504                         pCanvas->SetForegroundColor(GetForegroundColor());
3505                 }
3506         }
3507
3508         return pCanvas;
3509 }
3510
3511 Canvas*
3512 _ControlImpl::GetCanvasN(const Rectangle& bounds) const
3513 {
3514         SysTryReturn(NID_UI,
3515                                 GetParent() || IsAttachedToMainTree(), null,
3516                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] This control should have a parent or be attached to the main tree.");
3517
3518         Canvas* pCanvas = GetCore().GetCanvasN(bounds);
3519         result r = GetLastResult();
3520         if (IsFailed(r))
3521         {
3522                 if (r == E_OPERATION_FAILED)
3523                 {
3524                         SetLastResult(E_INVALID_OPERATION);
3525                 }
3526                 SysLog(NID_UI_CTRL, "[%s] Propagated", GetErrorMessage(GetLastResult()));
3527         }
3528         else
3529         {
3530                 if (pCanvas)
3531                 {
3532                         pCanvas->SetBackgroundColor(GetBackgroundColor());
3533                         pCanvas->SetForegroundColor(GetForegroundColor());
3534                 }
3535         }
3536
3537         return pCanvas;
3538 }
3539
3540 Canvas*
3541 _ControlImpl::GetCanvasN(const FloatRectangle& bounds) const
3542 {
3543         SysTryReturn(NID_UI,
3544                                 GetParent() || IsAttachedToMainTree(), null,
3545                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] This control should have a parent or be attached to the main tree.");
3546
3547         Canvas* pCanvas = GetCore().GetCanvasN(bounds);
3548         result r = GetLastResult();
3549         if (IsFailed(r))
3550         {
3551                 if (r == E_OPERATION_FAILED)
3552                 {
3553                         SetLastResult(E_INVALID_OPERATION);
3554                 }
3555                 SysLog(NID_UI_CTRL, "[%s] Propagated", GetErrorMessage(GetLastResult()));
3556         }
3557         else
3558         {
3559                 if (pCanvas)
3560                 {
3561                         pCanvas->SetBackgroundColor(GetBackgroundColor());
3562                         pCanvas->SetForegroundColor(GetForegroundColor());
3563                 }
3564         }
3565
3566         return pCanvas;
3567 }
3568
3569 Canvas*
3570 _ControlImpl::GetClientCanvasN(void) const
3571 {
3572         SysTryReturn(NID_UI,
3573                                 GetParent() || IsAttachedToMainTree(), null,
3574                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] This control should have a parent or be attached to the main tree.");
3575
3576         Canvas* pCanvas = GetCore().GetClientCanvasN();
3577         result r = GetLastResult();
3578         if (IsFailed(r))
3579         {
3580                 if (r == E_OPERATION_FAILED)
3581                 {
3582                         SetLastResult(E_INVALID_OPERATION);
3583                 }
3584                 SysLog(NID_UI_CTRL, "[%s] Propagated", GetErrorMessage(GetLastResult()));
3585         }
3586         else
3587         {
3588                 if (pCanvas)
3589                 {
3590                         pCanvas->SetBackgroundColor(GetBackgroundColor());
3591                         pCanvas->SetForegroundColor(GetForegroundColor());
3592                 }
3593         }
3594
3595         return pCanvas;
3596 }
3597
3598 bool
3599 _ControlImpl::IsAttachedToMainTree(void) const
3600 {
3601         return GetCore().IsAttachedToMainTree();
3602 }
3603
3604 bool
3605 _ControlImpl::IsInTouchMode(void) const
3606 {
3607         ClearLastResult();
3608         // [ToDo]
3609         return true;
3610 }
3611
3612 bool
3613 _ControlImpl::IsFocusable(void) const
3614 {
3615         return GetCore().IsFocusable();
3616 }
3617
3618 result
3619 _ControlImpl::SetFocusable(bool focusable)
3620 {
3621         // [ToDo] Focusable is simple flag. Make this method do not check belows.
3622         SysTryReturn(NID_UI,
3623                                 __focusableChangable, E_INVALID_OPERATION,
3624                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] The control can't chage it's focusable property.");
3625
3626         _Window* pTop =  GetCore().GetRootWindow();
3627         if (pTop)
3628         {
3629                 SysTryReturn(NID_UI,
3630                                         focusable || pTop->GetFocusControl(&this->GetCore()) != &this->GetCore(), E_INVALID_OPERATION,
3631                                         E_INVALID_OPERATION, "[E_INVALID_OPERATION] This already focused control cannot be unfocusable.");
3632         }
3633
3634
3635         GetCore().SetFocusable(focusable);
3636         return E_SUCCESS;
3637 }
3638
3639 bool
3640 _ControlImpl::IsFocused(void) const
3641 {
3642         return GetCore().IsFocused();
3643 }
3644
3645 result
3646 _ControlImpl::SetFocused(void)
3647 {
3648         return GetCore().SetFocused();
3649 }
3650
3651 void
3652 _ControlImpl::SetFocusableChangable(bool focusableChangable)
3653 {
3654         __focusableChangable = focusableChangable;
3655 }
3656
3657 result
3658 _ControlImpl::SetFont(const String& fontName)
3659 {
3660         result r = GetCore().SetFont(fontName);
3661         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
3662         return E_SUCCESS;
3663 }
3664
3665 Tizen::Base::String
3666 _ControlImpl::GetFont(void) const
3667 {
3668         return GetCore().GetFont();
3669 }
3670
3671
3672 bool
3673 _ControlImpl::IsEnabled(void) const
3674 {
3675         return GetCore().IsEnabled();
3676 }
3677
3678 bool
3679 _ControlImpl::GetEnableState(void) const
3680 {
3681         return GetCore().GetEnableState();
3682 }
3683
3684 void
3685 _ControlImpl::SetEnableState(bool enableState)
3686 {
3687         GetCore().SetEnableState(enableState);
3688 }
3689
3690 bool
3691 _ControlImpl::IsInputEventEnabled(void) const
3692 {
3693         return GetCore().IsInputEventEnabled();
3694 }
3695
3696 bool
3697 _ControlImpl::GetInputEnableState(void) const
3698 {
3699         return GetCore().GetInputEnableState();
3700 }
3701
3702 bool
3703 _ControlImpl::IsVisible(void) const
3704 {
3705         // [ToDo] Change the default visible state to false and test.
3706         return GetCore().IsVisible();
3707 }
3708
3709 bool
3710 _ControlImpl::GetVisibleState(void) const
3711 {
3712         return GetCore().GetVisibleState();
3713 }
3714
3715 result
3716 _ControlImpl::SetVisibleState(bool visibleState)
3717 {
3718 #ifdef _TC_PASS
3719         SysTryReturn(NID_UI,
3720                                 GetParent() || IsAttachedToMainTree(), E_INVALID_OPERATION,
3721                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] This control should have a parent or be attached to the main tree.");
3722 #endif
3723         GetCore().SetVisibleState(visibleState);
3724
3725         return E_SUCCESS;
3726 }
3727
3728 bool
3729 _ControlImpl::IsLayoutable(void) const
3730 {
3731         return GetCore().IsLayoutable();
3732 }
3733
3734 bool
3735 _ControlImpl::IsClipToParent(void) const
3736 {
3737         return GetCore().IsClipToParent();
3738 }
3739
3740 result
3741 _ControlImpl::SetClipToParent(bool clipToParent)
3742 {
3743         result r = GetCore().SetClipToParent(clipToParent);
3744         SysTryReturn(NID_UI, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
3745
3746         return E_SUCCESS;
3747 }
3748
3749 bool
3750 _ControlImpl::IsDragEnabled(void) const
3751 {
3752         return GetCore().IsDragEnabled();
3753 }
3754
3755 bool
3756 _ControlImpl::IsDropEnabled(void) const
3757 {
3758         return GetCore().IsDropEnabled();
3759 }
3760
3761 void
3762 _ControlImpl::SetDragEnabled(bool enabled)
3763 {
3764         ClearLastResult();
3765         GetCore().SetDragEnabled(enabled);
3766 }
3767
3768 void
3769 _ControlImpl::SetDropEnabled(bool enabled)
3770 {
3771         ClearLastResult();
3772         GetCore().SetDropEnabled(enabled);
3773 }
3774
3775 Rectangle
3776 _ControlImpl::GetBounds(void) const
3777 {
3778         return GetCore().GetBounds();
3779 }
3780
3781 FloatRectangle
3782 _ControlImpl::GetBoundsF(void) const
3783 {
3784         return GetCore().GetBoundsF();
3785 }
3786
3787 Point
3788 _ControlImpl::GetPosition(void) const
3789 {
3790         return GetCore().GetPosition();
3791 }
3792
3793 FloatPoint
3794 _ControlImpl::GetPositionF(void) const
3795 {
3796         return GetCore().GetPositionF();
3797 }
3798
3799 Dimension
3800 _ControlImpl::GetSize(void) const
3801 {
3802         return GetCore().GetSize();
3803 }
3804
3805 FloatDimension
3806 _ControlImpl::GetSizeF(void) const
3807 {
3808         return GetCore().GetSizeF();
3809 }
3810
3811 _ControlOrientation
3812 _ControlImpl::GetUiBuilderOrientation(void) const
3813 {
3814         _ControlOrientation controlOrientation = _CONTROL_ORIENTATION_PORTRAIT;
3815
3816         _Window* pWindow = GetCore().GetRootWindow();
3817         if (!pWindow)
3818         {
3819                 return controlOrientation;
3820         }
3821
3822         _ControlImplManager* pControlImplManager = _ControlImplManager::GetInstance();
3823         if (!pControlImplManager)
3824         {
3825                 return controlOrientation;
3826         }
3827
3828         if (pWindow->IsOrientationRoot())
3829         {
3830                 // Frame
3831                 OrientationStatus status = pControlImplManager->GetFormOrientationStatus(this);
3832
3833                 if ((status == ORIENTATION_STATUS_LANDSCAPE) || (status == ORIENTATION_STATUS_LANDSCAPE_REVERSE))
3834                 {
3835                         controlOrientation = _CONTROL_ORIENTATION_LANDSCAPE;
3836                 }
3837                 else
3838                 {
3839                         controlOrientation = _CONTROL_ORIENTATION_PORTRAIT;
3840                 }
3841         }
3842         else
3843         {
3844                 // Ownee Window
3845                 bool owner = false;
3846
3847                 Tizen::Ui::Controls::_Popup* pPopup = dynamic_cast<Tizen::Ui::Controls::_Popup*>(pWindow);
3848                 if (pPopup)
3849                 {
3850                         if (pWindow->IsOrientationCallbackModeEnabled() == false)
3851                         {
3852                                 owner = true;
3853                         }
3854                 }
3855
3856                 if (owner)
3857                 {
3858                         _Control* pOwner = pWindow->GetOwner();
3859                         if (pOwner)
3860                         {
3861                                 _ControlImpl* pControlImpl = static_cast<_ControlImpl*>(pOwner->GetUserData());
3862                                 if (pControlImpl)
3863                                 {
3864                                         OrientationStatus status = pControlImplManager->GetFormOrientationStatus(pControlImpl);
3865                                         if ((status == ORIENTATION_STATUS_LANDSCAPE) || (status == ORIENTATION_STATUS_LANDSCAPE_REVERSE))
3866                                         {
3867                                                 controlOrientation = _CONTROL_ORIENTATION_LANDSCAPE;
3868                                         }
3869                                         else
3870                                         {
3871                                                 controlOrientation = _CONTROL_ORIENTATION_PORTRAIT;
3872                                         }
3873                                 }
3874                         }
3875                 }
3876                 else
3877                 {
3878                         controlOrientation = GetCore().GetOrientation();
3879                 }
3880         }
3881
3882         return controlOrientation;
3883 }
3884
3885 void
3886 _ControlImpl::UpdateBuilderBounds(const Tizen::Graphics::FloatRectangle& bounds)
3887 {
3888         FloatRectangle builderBounds;
3889         _ControlOrientation controlOrientation = GetUiBuilderOrientation();
3890         bool exist = GetBuilderBoundsF(controlOrientation, builderBounds);
3891         if (exist)
3892         {
3893                 if (IsAttachedToMainTree())
3894                 {
3895                         SetBuilderBounds(controlOrientation, bounds);
3896                 }
3897                 else
3898                 {
3899                         SetBuilderBounds(_CONTROL_ORIENTATION_PORTRAIT, bounds);
3900                         SetBuilderBounds(_CONTROL_ORIENTATION_LANDSCAPE, bounds);
3901                 }
3902         }
3903 }
3904
3905 void
3906 _ControlImpl::UpdateBuilderSize(const Tizen::Graphics::FloatDimension& dimension)
3907 {
3908         FloatRectangle builderBounds;
3909         _ControlOrientation controlOrientation = GetUiBuilderOrientation();
3910
3911         bool exist = GetBuilderBoundsF(controlOrientation, builderBounds);
3912         if (exist)
3913         {
3914                 builderBounds.width = dimension.width;
3915                 builderBounds.height = dimension.height;
3916                 UpdateBuilderBounds(builderBounds);
3917         }
3918 }
3919
3920 void
3921 _ControlImpl::UpdateBuilderPosition(const FloatPoint& position)
3922 {
3923         FloatRectangle builderBounds;
3924         _ControlOrientation controlOrientation = GetUiBuilderOrientation();
3925
3926         bool exist = GetBuilderBoundsF(controlOrientation, builderBounds);
3927         if (exist)
3928         {
3929                 builderBounds.x = position.x;
3930                 builderBounds.y = position.y;
3931                 UpdateBuilderBounds(builderBounds);
3932         }
3933 }
3934
3935 result
3936 _ControlImpl::SetBounds(const Rectangle& bounds, bool callBoundsChangeCallbacks)
3937 {
3938         UpdateBuilderBounds(_CoordinateSystemUtils::ConvertToFloat(bounds));
3939         return GetCore().SetBounds(bounds, callBoundsChangeCallbacks);
3940 }
3941
3942 result
3943 _ControlImpl::SetBounds(const FloatRectangle& bounds, bool callBoundsChangeCallbacks)
3944 {
3945         UpdateBuilderBounds(bounds);
3946         return GetCore().SetBounds(bounds, callBoundsChangeCallbacks);
3947 }
3948
3949 result
3950 _ControlImpl::SetBoundsAndUpdateLayout(const Tizen::Graphics::Rectangle& bounds)
3951 {
3952         result r = E_SUCCESS;
3953         r = GetCore().SetBounds(bounds);
3954
3955         GetCore().UpdateLayout();
3956
3957         return r;
3958 }
3959
3960 result
3961 _ControlImpl::SetBoundsAndUpdateLayoutF(const Tizen::Graphics::FloatRectangle& bounds)
3962 {
3963         result r = E_SUCCESS;
3964         r = GetCore().SetBounds(bounds);
3965
3966         GetCore().UpdateLayout();
3967
3968         return r;
3969 }
3970
3971 result
3972 _ControlImpl::SetPosition(const Point& position)
3973 {
3974         UpdateBuilderPosition(_CoordinateSystemUtils::ConvertToFloat(position));
3975         return GetCore().SetPosition(position);
3976 }
3977
3978 result
3979 _ControlImpl::SetPosition(const FloatPoint& position)
3980 {
3981         UpdateBuilderPosition(position);
3982         return GetCore().SetPosition(position);
3983 }
3984
3985 result
3986 _ControlImpl::SetSize(const Dimension& size)
3987 {
3988         UpdateBuilderSize(_CoordinateSystemUtils::ConvertToFloat(size));
3989         return GetCore().SetSize(size);
3990 }
3991
3992 result
3993 _ControlImpl::SetSize(const FloatDimension& size)
3994 {
3995         UpdateBuilderSize(size);
3996         return GetCore().SetSize(size);
3997 }
3998
3999 Dimension
4000 _ControlImpl::GetMinimumSize(void) const
4001 {
4002         return GetCore().GetMinimumSize();
4003 }
4004
4005 FloatDimension
4006 _ControlImpl::GetMinimumSizeF(void) const
4007 {
4008         return GetCore().GetMinimumSizeF();
4009 }
4010
4011 Dimension
4012 _ControlImpl::GetMaximumSize(void) const
4013 {
4014         return GetCore().GetMaximumSize();
4015 }
4016
4017 FloatDimension
4018 _ControlImpl::GetMaximumSizeF(void) const
4019 {
4020         return GetCore().GetMaximumSizeF();
4021 }
4022
4023 result
4024 _ControlImpl::SetMinimumSize(const Tizen::Graphics::Dimension& newMinSize)
4025 {
4026         return GetCore().SetMinimumSize(newMinSize);
4027 }
4028
4029 result
4030 _ControlImpl::SetMinimumSize(const Tizen::Graphics::FloatDimension& newMinSize)
4031 {
4032         return GetCore().SetMinimumSize(newMinSize);
4033 }
4034
4035 result
4036 _ControlImpl::SetMaximumSize(const Tizen::Graphics::Dimension& newMaxSize)
4037 {
4038         return GetCore().SetMaximumSize(newMaxSize);
4039 }
4040
4041 result
4042 _ControlImpl::SetMaximumSize(const Tizen::Graphics::FloatDimension& newMaxSize)
4043 {
4044         return GetCore().SetMaximumSize(newMaxSize);
4045 }
4046
4047 Point
4048 _ControlImpl::ConvertToControlPosition(const Point& screenPosition) const
4049 {
4050         return GetCore().ConvertToControlPosition(screenPosition);
4051 }
4052
4053 FloatPoint
4054 _ControlImpl::ConvertToControlPosition(const FloatPoint& screenPosition) const
4055 {
4056         return GetCore().ConvertToControlPosition(screenPosition);
4057 }
4058
4059 Point
4060 _ControlImpl::ConvertToScreenPosition(const Point& controlPosition) const
4061 {
4062         return GetCore().ConvertToScreenPosition(controlPosition);
4063 }
4064
4065 FloatPoint
4066 _ControlImpl::ConvertToScreenPosition(const FloatPoint& controlPosition) const
4067 {
4068         return GetCore().ConvertToScreenPosition(controlPosition);
4069 }
4070
4071 // [ToDo] Must provide a static method.
4072 Dimension
4073 _ControlImpl::GetMinimumSizeLimit(void) const
4074 {
4075         ClearLastResult();
4076         return Dimension(0, 0);
4077 }
4078
4079 FloatDimension
4080 _ControlImpl::GetMinimumSizeLimitF(void) const
4081 {
4082         ClearLastResult();
4083         return FloatDimension(0.0f, 0.0f);
4084 }
4085
4086 // [ToDo] Must provide a static method.
4087 Dimension
4088 _ControlImpl::GetMaximumSizeLimit(void) const
4089 {
4090         ClearLastResult();
4091         return Dimension(_Control::MAX_LENGTH, _Control::MAX_LENGTH);
4092 }
4093
4094 FloatDimension
4095 _ControlImpl::GetMaximumSizeLimitF(void) const
4096 {
4097         ClearLastResult();
4098         return FloatDimension(_Control::MAX_LENGTH, _Control::MAX_LENGTH);
4099 }
4100
4101
4102 Rectangle
4103 _ControlImpl::GetClientBounds(void) const
4104 {
4105         return GetCore().GetClientBounds();
4106 }
4107
4108 FloatRectangle
4109 _ControlImpl::GetClientBoundsF(void) const
4110 {
4111         return GetCore().GetClientBoundsF();
4112 }
4113
4114 Rectangle
4115 _ControlImpl::GetAbsoluteBounds(void) const
4116 {
4117         return GetCore().GetAbsoluteBounds();
4118 }
4119
4120 FloatRectangle
4121 _ControlImpl::GetAbsoluteBoundsF(void) const
4122 {
4123         return GetCore().GetAbsoluteBoundsF();
4124 }
4125
4126 result
4127 _ControlImpl::SetClientBounds(const Rectangle& bounds)
4128 {
4129         return GetCore().SetClientBounds(bounds);
4130 }
4131
4132 result
4133 _ControlImpl::SetClientBounds(const FloatRectangle& bounds)
4134 {
4135         return GetCore().SetClientBounds(bounds);
4136 }
4137
4138 Color
4139 _ControlImpl::GetBackgroundColor(void) const
4140 {
4141         return GetCore().GetBackgroundColor();
4142 }
4143
4144 bool
4145 _ControlImpl::IsOpaque(void) const
4146 {
4147         return false;
4148 }
4149
4150 void
4151 _ControlImpl::SetBackgroundColor(const Color& color)
4152 {
4153         if (!IsOpaque())
4154         {
4155                 GetCore().SetBackgroundColor(color);
4156         }
4157         else
4158         {
4159                 byte r, g, b, a;
4160                 color.GetColorComponents(r, g, b, a);
4161                 GetCore().SetBackgroundColor(Color(r*a/ 255, g*a/255, b*a/ 255, 255));
4162         }
4163 }
4164
4165 Color
4166 _ControlImpl::GetForegroundColor(void) const
4167 {
4168         ClearLastResult();
4169         return __foregroundColor;
4170 }
4171
4172 void
4173 _ControlImpl::SetForegroundColor(const Color& color)
4174 {
4175         ClearLastResult();
4176         __foregroundColor = color;
4177 }
4178
4179 int
4180 _ControlImpl::GetFontSize(void) const
4181 {
4182         ClearLastResult();
4183         return __fontSize;
4184 }
4185
4186 void
4187 _ControlImpl::SetFontSize(int fontSize)
4188 {
4189         ClearLastResult();
4190         __fontSize = fontSize;
4191 }
4192
4193 ITouchEventListener*
4194 _ControlImpl::GetDefaultTouchEventListener(void) const
4195 {
4196         ClearLastResult();
4197         return __pDefaultTouchEventListener;
4198 }
4199
4200 IKeyEventListener*
4201 _ControlImpl::GetDefaultKeyEventListener(void) const
4202 {
4203         ClearLastResult();
4204         return __pDefaultKeyEventListener;
4205 }
4206
4207 void
4208 _ControlImpl::SetDefaultKeyEventListener(IKeyEventListener* pDefaultListener)
4209 {
4210         ClearLastResult();
4211         __pDefaultKeyEventListener = pDefaultListener;
4212 }
4213
4214 void
4215 _ControlImpl::SetDefaultTouchEventListener(ITouchEventListener* pDefaultListener)
4216 {
4217         ClearLastResult();
4218         __pDefaultTouchEventListener = pDefaultListener;
4219 }
4220
4221 CompositeMode
4222 _ControlImpl::GetCompositeMode(void) const
4223 {
4224         ClearLastResult();
4225         return COMPOSITE_MODE_ALPHA_BLENDING;
4226 }
4227
4228 result
4229 _ControlImpl::SetCompositeMode(CompositeMode compositeMode)
4230 {
4231         ClearLastResult();
4232
4233         if (compositeMode == COMPOSITE_MODE_ALPHA_BLENDING)
4234         {
4235                 return E_SUCCESS;
4236         }
4237
4238         SysLogException(NID_UI, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] This operation is not supported.");
4239         return E_UNSUPPORTED_OPERATION;
4240 }
4241
4242 result
4243 _ControlImpl::SetChromaKeyColor(Color chromaKeyColor)
4244 {
4245         SysLogException(NID_UI, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] This operation is not supported.");
4246         return E_UNSUPPORTED_OPERATION;
4247 }
4248
4249 Color
4250 _ControlImpl::GetChromaKeyColor(void) const
4251 {
4252         static const Color errorColor(0, 0, 0, 0);
4253         SysLogException(NID_UI, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] This operation is not supported.");
4254         return errorColor;
4255 }
4256
4257 Animations::ControlAnimator*
4258 _ControlImpl::GetControlAnimator(void) const
4259 {
4260         ClearLastResult();
4261
4262         if ((IsMovable() == false) && (IsResizable() == false))
4263         {
4264                 SysLog(NID_UI, "Control is not animatable.\n");
4265                 return null;
4266         }
4267
4268         if (__pControlAnimator == null)
4269         {
4270                 ControlAnimator* pControlAnimator = new (std::nothrow) ControlAnimator();
4271                 SysTryReturn(NID_UI, (pControlAnimator != null), null, E_OUT_OF_MEMORY, "Unable to create ControlAnimator instance.\n");
4272
4273                 // [ToDo] Check if the Open API can return E_SYSTEM.
4274                 result r = pControlAnimator->Construct(*__pControlPublic);
4275                 if (IsFailed(r))
4276                 {
4277                         delete pControlAnimator;
4278                         SysLogException(NID_UI, E_SYSTEM, "[E_SYSTEM] Failed to create control animator.");
4279                         return null;
4280                 }
4281
4282                 (const_cast <_ControlImpl*>(this))->__pControlAnimator = pControlAnimator;
4283         }
4284
4285         return __pControlAnimator;
4286 }
4287
4288 VisualElement*
4289 _ControlImpl::GetVisualElement(void) const
4290 {
4291         return GetCore().GetVisualElement();
4292 }
4293
4294 void
4295 _ControlImpl::SetMultiTouchEnabled(bool enabled)
4296 {
4297         GetCore().SetMultiTouchEnabled(enabled);
4298 }
4299
4300 bool
4301 _ControlImpl::IsMultiTouchEnabled(void) const
4302 {
4303         return GetCore().IsMultiTouchEnabled();
4304 }
4305
4306 _ControlImpl::PublicEventListenerList*
4307 _ControlImpl::CreatePublicEventListenerListN(void) const
4308 {
4309         PublicEventListenerList* pListenerList = new (std::nothrow) PublicEventListenerList;
4310         SysTryReturn(NID_UI, pListenerList, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4311
4312         return pListenerList;
4313 }
4314
4315 bool
4316 _ControlImpl::HasCore(void) const
4317 {
4318         return __pControlCore != null;
4319 }
4320
4321 result
4322 _ControlImpl::SetCore(_Control& core)
4323 {
4324         result r = E_SUCCESS;
4325
4326         __pControlCore = &core;
4327         __pControlCore->SetControlDelegate(*this);
4328         __pControlCore->SetUserData(this);
4329
4330         __pCoreEventListener = new (std::nothrow) CoreEventListener(*this);
4331         SysTryCatch(NID_UI, __pCoreEventListener, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4332
4333         __pControlCore->SetEventListener<_UI_EVENT_FOCUS>(__pCoreEventListener);
4334         __pControlCore->SetEventListener<_UI_EVENT_NOTIFICAITON>(__pCoreEventListener);
4335
4336         __pPropagatedTouchEventListener = new (std::nothrow) _PropagatedTouchEventListener(*this);
4337         SysTryCatch(NID_UI, __pPropagatedTouchEventListener, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4338
4339         __pControlCore->SetPropagatedTouchEventListener(__pPropagatedTouchEventListener);
4340
4341         __pPropagatedKeyEventListener = new (std::nothrow) _PropagatedKeyEventListener(*this);
4342         SysTryCatch(NID_UI, __pPropagatedKeyEventListener, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4343
4344         __pControlCore->SetPropagatedKeyEventListener(__pPropagatedKeyEventListener);
4345
4346         return E_SUCCESS;
4347
4348 CATCH:
4349         ResetCore();
4350         SysLogException(NID_UI, r, "[%s] Propagating.", GetErrorMessage(r));
4351         return r;
4352 }
4353
4354 void
4355 _ControlImpl::ResetCore(bool deallocate)
4356 {
4357         if (__pControlCore == null)
4358         {
4359                 return;
4360         }
4361
4362         __pControlCore->ResetEventListeners();
4363         __pControlCore->SetUserData(null);
4364         __pControlCore->ResetControlDelegate();
4365
4366         __pFlickGestureDetector->RemoveGestureListener(*__pCoreEventListener);
4367         __pControlCore->RemoveGestureDetector(*__pFlickGestureDetector);
4368
4369         __pLongPressGestureDetector->RemoveGestureListener(*__pCoreEventListener);
4370         __pControlCore->RemoveGestureDetector(*__pLongPressGestureDetector);
4371
4372         __pControlCore->SetPropagatedTouchEventListener(null);
4373         __pControlCore->SetPropagatedKeyEventListener(null);
4374
4375         if (deallocate)
4376         {
4377                 delete __pControlCore;
4378         }
4379         __pControlCore = null;
4380
4381         delete __pCoreEventListener;
4382         __pCoreEventListener = null;
4383
4384         delete __pPropagatedTouchEventListener;
4385         __pPropagatedTouchEventListener = null;
4386
4387         delete __pPropagatedKeyEventListener;
4388         __pPropagatedKeyEventListener = null;
4389 }
4390
4391 void
4392 _ControlImpl::Dispose(bool deallocateCore)
4393 {
4394         if(GetVisualElement() && __pCustomVisualElement)
4395         {
4396                 GetVisualElement()->DetachChild( *__pCustomVisualElement);
4397         }
4398         __pCustomVisualElement = null;
4399         // Reset core
4400         ResetCore(deallocateCore);
4401
4402         // Release core events
4403         delete __pCoreKeyEvent;
4404         __pCoreKeyEvent = null;
4405         delete __pCoreTouchEvent;
4406         __pCoreTouchEvent = null;
4407         delete __pCoreFocusEvent;
4408         __pCoreFocusEvent = null;
4409         delete __pCoreGestureEvent;
4410         __pCoreGestureEvent = null;
4411
4412         // Relese public event listeners
4413         delete __pPublicFocusEventListeners;
4414         __pPublicFocusEventListeners = null;
4415         delete __pPublicKeyEventListeners;
4416         __pPublicKeyEventListeners = null;
4417         delete __pPublicTouchEventListeners;
4418         __pPublicTouchEventListeners = null;
4419         delete __pPublicDragDropEventListeners;
4420         __pPublicDragDropEventListeners = null;
4421         delete __pPublicTouchModeChangedEventListeners;
4422         __pPublicTouchModeChangedEventListeners = null;
4423
4424         // Release builder bounds
4425         delete __pBuilderPortraitBounds;
4426         __pBuilderPortraitBounds = null;
4427         delete __pBuilderLandscapeBounds;
4428         __pBuilderLandscapeBounds = null;
4429
4430         // Release aninator
4431         delete __pControlAnimator;
4432         __pControlAnimator = null;
4433
4434         delete __pPublicGestureDetectors;
4435         __pPublicGestureDetectors = null;
4436
4437         delete __pFlickGestureDetector;
4438         __pFlickGestureDetector = null;
4439
4440         delete __pLongPressGestureDetector;
4441         __pLongPressGestureDetector = null;
4442
4443         delete __pAccessibilityContainerImpl;
4444         __pAccessibilityContainerImpl = null;
4445
4446         __pPublicPropagatedTouchEventListener = null;
4447         __pPublicPropagatedKeyEventListener = null;
4448 }
4449
4450 _ControlImpl::~_ControlImpl(void)
4451 {
4452         Dispose(true);
4453 }
4454
4455 _ControlImpl::_ControlImpl(Control* pPublic, _Control* pCore)
4456         : __pControlPublic(pPublic)
4457         , __pControlCore(null)
4458         , __pControlAnimator(null)
4459         , __pCustomVisualElement(null)
4460         , __pPublicFocusEventListeners(null)
4461         , __pPublicKeyEventListeners(null)
4462         , __pPublicTouchEventListeners(null)
4463         , __pPublicDragDropEventListeners(null)
4464         , __pPublicTouchModeChangedEventListeners(null)
4465         , __pDefaultKeyEventListener(null)
4466         , __pDefaultTouchEventListener(null)
4467         , __foregroundColor(Color(0, 0, 0, 0))
4468         , __fontSize(0)
4469         , __inputEventConsumed(false)
4470         , __focusableChangable(true)
4471         , __pCoreEventListener(null)
4472         , __pCoreKeyEvent(null)
4473         , __pCoreTouchEvent(null)
4474         , __pCoreFocusEvent(null)
4475         , __pCoreGestureEvent(null)
4476         , __pBuilderPortraitBounds(null)
4477         , __pBuilderLandscapeBounds(null)
4478         , __pFlickGestureDetector(null)
4479         , __pLongPressGestureDetector(null)
4480         , __pPublicGestureDetectors(null)
4481         , __pAccessibilityContainerImpl(null)
4482         , __pPublicPropagatedTouchEventListener(null)
4483         , __pPublicPropagatedKeyEventListener(null)
4484 {
4485         ClearLastResult();
4486         result r = E_SUCCESS;
4487
4488         SysAssert(__pControlPublic);
4489         SysAssert(pCore);
4490
4491         // Set core
4492         r = SetCore(*pCore);
4493         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
4494
4495         // Core event listeners: [ToDo: mklove.kang] Check exceptions because the constructors can fail.
4496         __pCoreKeyEvent = new (std::nothrow) CoreKeyEvent(*this);
4497         SysTryCatch(NID_UI, __pCoreKeyEvent, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4498
4499         __pCoreTouchEvent = new (std::nothrow) CoreTouchEvent(*this);
4500         SysTryCatch(NID_UI, __pCoreTouchEvent, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4501
4502         __pCoreFocusEvent = new (std::nothrow) CoreFocusEvent(*this);
4503         SysTryCatch(NID_UI, __pCoreFocusEvent, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4504
4505         __pCoreGestureEvent = new (std::nothrow) CoreGestureEvent(*this);
4506         SysTryCatch(NID_UI, __pCoreGestureEvent, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4507
4508         __pFlickGestureDetector = new (std::nothrow) _TouchFlickGestureDetector;
4509         SysTryCatch(NID_UI, __pFlickGestureDetector, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4510
4511         __pLongPressGestureDetector = new (std::nothrow) _TouchLongPressGestureDetector;
4512         SysTryCatch(NID_UI, __pLongPressGestureDetector, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4513
4514         // Public listeners
4515         __pPublicFocusEventListeners = CreatePublicEventListenerListN();
4516         r = GetLastResult();
4517         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4518
4519         __pPublicKeyEventListeners = CreatePublicEventListenerListN();
4520         r = GetLastResult();
4521         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4522
4523         __pPublicTouchEventListeners = CreatePublicEventListenerListN();
4524         r = GetLastResult();
4525         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4526
4527         __pPublicDragDropEventListeners = CreatePublicEventListenerListN();
4528         r = GetLastResult();
4529         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4530
4531         __pPublicTouchModeChangedEventListeners = CreatePublicEventListenerListN();
4532         r = GetLastResult();
4533         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4534
4535         __pPublicGestureDetectors = new (std::nothrow) LinkedListT<TouchGestureDetector*>;
4536         r = GetLastResult();
4537         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4538
4539         r = GET_COLOR_CONFIG(BASIC::foreground, __foregroundColor);
4540         SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
4541
4542         // Check
4543         SysAssert(r == E_SUCCESS);
4544
4545         return;
4546
4547 CATCH:
4548         Dispose(true); // [ToDo] Is it OK?
4549 }
4550
4551 void
4552 _ControlImpl::SetEffectSoundEnabled(bool enable)
4553 {
4554         GetCore().SetEffectSoundEnabled(enable);
4555 }
4556
4557 bool
4558 _ControlImpl::IsEffectSoundEnabled(void) const
4559 {
4560         return GetCore().IsEffectSoundEnabled();
4561 }
4562
4563 _Layout::LayoutContainer&
4564 _ControlImpl::GetLayoutContainer(void) const
4565 {
4566         return GetCore().GetLayoutContainer();
4567 }
4568
4569 result
4570 _ControlImpl::SetBuilderBounds(_ControlOrientation orientation, const Rectangle& bounds)
4571 {
4572         ClearLastResult();
4573
4574         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
4575         {
4576                 if (__pBuilderPortraitBounds == null)
4577                 {
4578                         __pBuilderPortraitBounds = new (std::nothrow) FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f);
4579
4580                         SysTryReturn(NID_UI,
4581                                                 __pBuilderPortraitBounds, E_OUT_OF_MEMORY,
4582                                                 E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4583                 }
4584
4585                 *__pBuilderPortraitBounds = _CoordinateSystemUtils::ConvertToFloat(bounds);
4586                 return E_SUCCESS;
4587         }
4588         else if (orientation == _CONTROL_ORIENTATION_LANDSCAPE)
4589         {
4590                 if (__pBuilderLandscapeBounds == null)
4591                 {
4592                         __pBuilderLandscapeBounds = new (std::nothrow) FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f);
4593
4594                         SysTryReturn(NID_UI,
4595                                                 __pBuilderLandscapeBounds, E_OUT_OF_MEMORY,
4596                                                 E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4597                 }
4598
4599                 *__pBuilderLandscapeBounds = _CoordinateSystemUtils::ConvertToFloat(bounds);
4600                 return E_SUCCESS;
4601         }
4602
4603         SysAssert(false);
4604         return E_SYSTEM;
4605 }
4606
4607 result
4608 _ControlImpl::SetBuilderBounds(_ControlOrientation orientation, const FloatRectangle& bounds)
4609 {
4610         ClearLastResult();
4611
4612         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
4613         {
4614                 if (__pBuilderPortraitBounds == null)
4615                 {
4616                         __pBuilderPortraitBounds = new (std::nothrow) FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f);
4617
4618                         SysTryReturn(NID_UI,
4619                                                 __pBuilderPortraitBounds, E_OUT_OF_MEMORY,
4620                                                 E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4621                 }
4622
4623                 *__pBuilderPortraitBounds = bounds;
4624                 return E_SUCCESS;
4625         }
4626         else if (orientation == _CONTROL_ORIENTATION_LANDSCAPE)
4627         {
4628                 if (__pBuilderLandscapeBounds == null)
4629                 {
4630                         __pBuilderLandscapeBounds = new (std::nothrow) FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f);
4631
4632                         SysTryReturn(NID_UI,
4633                                                 __pBuilderLandscapeBounds, E_OUT_OF_MEMORY,
4634                                                 E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
4635                 }
4636
4637                 *__pBuilderLandscapeBounds = bounds;
4638                 return E_SUCCESS;
4639         }
4640
4641         SysAssert(false);
4642         return E_SYSTEM;
4643 }
4644
4645 bool
4646 _ControlImpl::GetBuilderBounds(_ControlOrientation orientation, Rectangle& bounds) const
4647 {
4648         ClearLastResult();
4649
4650         if (orientation == _CONTROL_ORIENTATION_PORTRAIT && __pBuilderPortraitBounds)
4651         {
4652                 bounds = _CoordinateSystemUtils::ConvertToInteger(*__pBuilderPortraitBounds);
4653                 return true;
4654         }
4655         else if (orientation == _CONTROL_ORIENTATION_LANDSCAPE && __pBuilderLandscapeBounds)
4656         {
4657                 bounds = _CoordinateSystemUtils::ConvertToInteger(*__pBuilderLandscapeBounds);
4658                 return true;
4659         }
4660
4661         return false;
4662 }
4663
4664 bool
4665 _ControlImpl::GetBuilderBoundsF(_ControlOrientation orientation, FloatRectangle& bounds) const
4666 {
4667         ClearLastResult();
4668
4669         if (orientation == _CONTROL_ORIENTATION_PORTRAIT && __pBuilderPortraitBounds)
4670         {
4671                 bounds = *__pBuilderPortraitBounds;
4672                 return true;
4673         }
4674         else if (orientation == _CONTROL_ORIENTATION_LANDSCAPE && __pBuilderLandscapeBounds)
4675         {
4676                 bounds = *__pBuilderLandscapeBounds;
4677                 return true;
4678         }
4679
4680         return false;
4681 }
4682
4683 void
4684 _ControlImpl::SetContentAreaBounds(const Rectangle& rect)
4685 {
4686         GetCore().SetContentAreaBounds(rect);
4687 }
4688
4689 void
4690 _ControlImpl::SetContentAreaBounds(const FloatRectangle& rect)
4691 {
4692         GetCore().SetContentAreaBounds(rect);
4693 }
4694
4695 Rectangle
4696 _ControlImpl::GetContentAreaBounds(void) const
4697 {
4698         return GetCore().GetContentAreaBounds();
4699 }
4700
4701 FloatRectangle
4702 _ControlImpl::GetContentAreaBoundsF(void) const
4703 {
4704         return GetCore().GetContentAreaBoundsF();
4705 }
4706
4707 Bitmap*
4708 _ControlImpl::GetCapturedBitmapN(void) const
4709 {
4710         return GetCore().GetCapturedBitmapN(true);
4711 }
4712
4713 Rectangle
4714 _ControlImpl::GetInvalidatedBounds(void) const
4715 {
4716         return GetCore().GetInvalidatedBounds();
4717 }
4718
4719 FloatRectangle
4720 _ControlImpl::GetInvalidatedBoundsF(void) const
4721 {
4722         return GetCore().GetInvalidatedBoundsF();
4723 }
4724
4725 result
4726 _ControlImpl::GenerateKeyEvent(KeyState keyState, _KeyCode keyCode)
4727 {
4728         result r = E_SUCCESS;
4729
4730         SysTryReturn(NID_UI, keyState == KEY_LONGPRESSED,
4731                 E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] keyState is invalid.\n");
4732
4733         SysTryReturn(NID_UI, __pCoreKeyEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
4734
4735         __pCoreKeyEvent->ProcessListener(keyState, keyCode);
4736
4737         return r;
4738 }
4739
4740 result
4741 _ControlImpl::GenerateTouchEvent(const _TouchInfo& touchInfo)
4742 {
4743         result r = E_SUCCESS;
4744
4745         _TouchStatus touchStatus = touchInfo.GetTouchStatus();
4746
4747         SysTryReturn(NID_UI, (touchStatus == _TOUCH_LONG_PRESSED) || (touchStatus == _TOUCH_DOUBLE_PRESSED),
4748                 E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] touchStatus is invalid.\n");
4749
4750         SysTryReturn(NID_UI, __pCoreTouchEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
4751
4752         __pCoreTouchEvent->ProcessListener(touchInfo);
4753
4754         return r;
4755 }
4756
4757 void
4758 _ControlImpl::SetMovable(bool movable)
4759 {
4760         GetCore().SetMovable(movable);
4761 }
4762
4763 void
4764 _ControlImpl::SetResizable(bool resizable)
4765 {
4766         GetCore().SetResizable(resizable);
4767 }
4768
4769 AccessibilityContainer*
4770 _ControlImpl::GetAccessibilityContainer(void)
4771 {
4772         if(__pAccessibilityContainerImpl == null)
4773         {
4774                 AccessibilityContainer* pContainer = _AccessibilityContainerImpl::CreateAccessibilityContainerN(*this);
4775                 if(pContainer)
4776                 {
4777                         __pAccessibilityContainerImpl = _AccessibilityContainerImpl::GetInstance(*pContainer);
4778                         return pContainer;
4779                 }
4780                 else
4781                         return null;
4782         }
4783         else
4784         {
4785                 return &(__pAccessibilityContainerImpl->GetPublic());
4786         }
4787 }
4788
4789 result
4790 _ControlImpl::SetPublicPropagatedTouchEventListener(IPropagatedTouchEventListener* pListener)
4791 {
4792         __pPublicPropagatedTouchEventListener = pListener;
4793         return E_SUCCESS;
4794 }
4795
4796 IPropagatedTouchEventListener*
4797 _ControlImpl::GetPublicPropagatedTouchEventListener(void) const
4798 {
4799         return __pPublicPropagatedTouchEventListener;
4800 }
4801
4802 result
4803 _ControlImpl::SetPublicPropagatedKeyEventListener(IPropagatedKeyEventListener* pListener)
4804 {
4805         __pPublicPropagatedKeyEventListener = pListener;
4806         return E_SUCCESS;
4807 }
4808
4809 IPropagatedKeyEventListener*
4810 _ControlImpl::GetPublicPropagatedKeyEventListener(void) const
4811 {
4812         return __pPublicPropagatedKeyEventListener;
4813 }
4814
4815 void
4816 _ControlImpl::SetPreviousFocus(_ControlImpl* pPreviousFocus)
4817 {
4818         if (pPreviousFocus == null)
4819         {
4820                 _Control* pControl  = null;
4821                 return GetCore().SetPreviousFocus(pControl);
4822         }
4823         return GetCore().SetPreviousFocus(&pPreviousFocus->GetCore());
4824 }
4825
4826 void
4827 _ControlImpl::SetNextFocus(_ControlImpl* pNextFocus)
4828 {
4829         if (pNextFocus == null)
4830         {
4831                 _Control* pControl  = null;
4832                 return GetCore().SetPreviousFocus(pControl);
4833         }
4834         return GetCore().SetNextFocus(&pNextFocus->GetCore());
4835 }
4836
4837 _ControlImpl*
4838 _ControlImpl::GetPreviousFocus(void) const
4839 {
4840         if (GetCore().GetPreviousFocus() == null)
4841         {
4842                 return null;
4843         }
4844         return static_cast <_ControlImpl* >(GetCore().GetPreviousFocus()->GetUserData());
4845 }
4846
4847  _ControlImpl*
4848  _ControlImpl::GetNextFocus(void) const
4849  {
4850         if (GetCore().GetNextFocus() == null)
4851         {
4852                 return null;
4853         }
4854         return static_cast <_ControlImpl* >(GetCore().GetNextFocus()->GetUserData());
4855  }
4856
4857 void
4858 _ControlImpl::OnDrawFocus(void)
4859 {
4860         GetCore().OnDrawFocus();
4861 }
4862
4863 void
4864 _ControlImpl::OnChildControlFocusMoved(const _Control& control)
4865 {
4866         GetCore().OnChildControlFocusMoved(control);
4867 }
4868
4869 void
4870 _ControlImpl::OnDescendantControlFocusMoved(const _Control& control)
4871 {
4872         GetCore().OnDescendantControlFocusMoved(control);
4873 }
4874
4875 void
4876 _ControlImpl::OnFocusModeStateChanged(void)
4877 {
4878         GetCore().OnFocusModeStateChanged();
4879 }
4880 bool
4881 _ControlImpl::IsChildControlFocusManage(void) const
4882 {
4883         GetCore().IsChildControlFocusManage();
4884         return false;
4885 }
4886 void
4887 _ControlImpl::SetTouchPressThreshold(float distance)
4888 {
4889         GetCore().SetTouchPressThreshold(distance);
4890 }
4891
4892 float
4893 _ControlImpl::GetTouchPressThreshold(void) const
4894 {
4895         return GetCore().GetTouchPressThreshold();
4896 }
4897
4898 int
4899 _ControlImpl::GetTouchPressThresholdPixel(void) const
4900 {
4901         return GetCore().GetTouchPressThresholdPixel();
4902 }
4903
4904 result
4905 _ControlImpl::SetFontFromFile(const String& fileName)
4906 {
4907         result r = GetCore().SetFontFromFile(fileName);
4908         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
4909         return E_SUCCESS;
4910 }
4911
4912 Tizen::Base::String
4913 _ControlImpl::GetFontFile(void) const
4914 {
4915         return GetCore().GetFontFile();
4916 }
4917 }} // Tizen::Ui