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