src/ui/FUi_TouchGestureDetector.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  * @file                FUi_TouchGestureDetector.cpp
  19  * @brief               This is the implementation file for %_TouchGestureDetector class
  20  * @version             2.0
  21  *
  22  * This file contains the implementation of %_TouchGestureDetector class.
  23  *
  24  */
  25
  26 #include <FBaseSysLog.h>
  27 #include <FBase_Log.h>
  28 #include <FUiITouchFlickGestureEventListener.h>
  29 #include <FUiITouchLongPressGestureEventListener.h>
  30 #include <FUiITouchTapGestureEventListener.h>
  31 #include <FUiITouchPinchGestureEventListener.h>
  32 #include <FUiITouchPanningGestureEventListener.h>
  33 #include <FUiITouchRotationGestureEventListener.h>
  34 #include <FUiITouchCustomGestureEventListener.h>
  35 #include "FUi_TouchManager.h"
  36 #include "FUi_ITouchFlickGestureEventListener.h"
  37 #include "FUi_ITouchLongPressGestureEventListener.h"
  38 #include "FUi_ITouchTapGestureEventListener.h"
  39 #include "FUi_ITouchPinchGestureEventListener.h"
  40 #include "FUi_ITouchPanningGestureEventListener.h"
  41 #include "FUi_ITouchRotationGestureEventListener.h"
  42 #include "FUi_ITouchCustomGestureEventListener.h"
  43 #include "FUi_TouchFlickGestureDetectorImpl.h"
  44 #include "FUi_TouchLongPressGestureDetectorImpl.h"
  45 #include "FUi_TouchTapGestureDetectorImpl.h"
  46 #include "FUi_TouchPinchGestureDetectorImpl.h"
  47 #include "FUi_TouchPanningGestureDetectorImpl.h"
  48 #include "FUi_TouchRotationGestureDetectorImpl.h"
  49 #include "FUi_ControlManager.h"
  50
  51 using namespace Tizen::Base;
  52 using namespace Tizen::Base::Collection;
  53 using namespace Tizen::Graphics;
  54
  55 namespace Tizen { namespace Ui
  56 {
  57
  58 _TouchGestureDetector::_TouchGestureDetector(void)
  59         : __isTouchEventDelayed(false)
  60         , __isTouchCanceledOnSuccess(false)
  61         , __isDetectionStarted(false)
  62         , __currentState(_TOUCH_GESTURE_DETECTOR_STATE_READY)
  63         , __type(_TOUCH_GESTURE_DETECTOR_TYPE_CUSTOM)
  64         , __pUserData(null)
  65         , __pDelegator(null)
  66         , __pWantToFailList(null)
  67         , __pCurrentWantToFailList(null)
  68         , __pEventListenerList(null)
  69 {
  70         ClearLastResult();
  71
  72         __pEventListenerList = new (std::nothrow) LinkedListT<_ITouchGestureEventListener*>;
  73         SysTryReturnVoidResult(NID_UI, __pEventListenerList,
  74                 E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  75
  76         __pWantToFailList = new (std::nothrow) LinkedListT<_TouchGestureDetector*>;
  77         SysTryCatch(NID_UI, __pWantToFailList, ,
  78                 E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  79
  80         __pCurrentWantToFailList = new (std::nothrow) LinkedListT<_TouchGestureDetector*>;
  81                 SysTryCatch(NID_UI, __pCurrentWantToFailList, ,
  82                 E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  83
  84         __pDelegator = this;
  85
  86         return;
  87
  88 CATCH:
  89         if (__pEventListenerList)
  90         {
  91                 delete __pEventListenerList;
  92                 __pEventListenerList = null;
  93         }
  94
  95         if (__pWantToFailList)
  96         {
  97                 delete __pWantToFailList;
  98                 __pWantToFailList = null;
  99         }
 100
 101         if (__pCurrentWantToFailList)
 102         {
 103                 delete __pCurrentWantToFailList;
 104                 __pCurrentWantToFailList = null;
 105         }
 106 }
 107
 108 _TouchGestureDetector::~_TouchGestureDetector(void)
 109 {
 110         delete __pEventListenerList;
 111         __pEventListenerList = null;
 112
 113         delete __pWantToFailList;
 114         __pWantToFailList = null;
 115
 116         delete __pCurrentWantToFailList;
 117         __pCurrentWantToFailList = null;
 118
 119         __pDelegator = null;
 120 }
 121
 122 result
 123 _TouchGestureDetector::AddGestureListener(const _ITouchGestureEventListener& listener)
 124 {
 125         bool exist = __pEventListenerList->Contains(const_cast <_ITouchGestureEventListener*>(&listener));
 126         if (!exist)
 127         {
 128                 SysTryReturnResult(NID_UI,
 129                                                 __pEventListenerList->Add(const_cast <_ITouchGestureEventListener*>(&listener)) == E_SUCCESS, E_SYSTEM,
 130                                                 "[E_SYSTEM] System error occurred.");
 131         }
 132
 133         return E_SUCCESS;
 134 }
 135
 136 result
 137 _TouchGestureDetector::RemoveGestureListener(const _ITouchGestureEventListener& listener)
 138 {
 139         if (__pEventListenerList->GetCount() == 0)
 140         {
 141                 return E_INVALID_CONDITION;
 142         }
 143
 144         SysTryReturnResult(NID_UI,
 145                                 __pEventListenerList->Remove(const_cast <_ITouchGestureEventListener*>(&listener)) == E_SUCCESS, E_SYSTEM,
 146                                 "[E_SYSTEM] System error occurred.");
 147
 148         return E_SUCCESS;
 149 }
 150
 151 IListT <_ITouchGestureEventListener*>*
 152 _TouchGestureDetector::GetGestureListenerList(void) const
 153 {
 154         return __pEventListenerList;
 155 }
 156
 157 void
 158 _TouchGestureDetector::SetDelegate(const _ITouchGestureDelegate& delegator)
 159 {
 160         __pDelegator = const_cast<_ITouchGestureDelegate*>(&delegator);
 161 }
 162
 163 _ITouchGestureDelegate*
 164 _TouchGestureDetector::GetDelegate(void) const
 165 {
 166         return __pDelegator;
 167 }
 168
 169 result
 170 _TouchGestureDetector::SetControl(const _Control& control)
 171 {
 172         __gestureContol = control.GetHandle();
 173
 174         return E_SUCCESS;
 175 }
 176
 177 _Control*
 178 _TouchGestureDetector::GetControl(void) const
 179 {
 180         _ControlManager* pControlManager = _ControlManager::GetInstance();
 181         SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] _ControlManager does not exist.");
 182
 183         return pControlManager->GetObject(__gestureContol);
 184 }
 185
 186 _TouchGestureDetectorState
 187 _TouchGestureDetector::GetDetectorState(void) const
 188 {
 189         return __currentState;
 190 }
 191
 192 void
 193 _TouchGestureDetector::SetDetectorType(_TouchGestureDetectorType type)
 194 {
 195         __type = type;
 196 }
 197
 198 _TouchGestureDetectorType
 199 _TouchGestureDetector::GetDetectorType(void) const
 200 {
 201         return __type;
 202 }
 203
 204 void
 205 _TouchGestureDetector::SetDelayTouchEventEnabled(bool enabled)
 206 {
 207         __isTouchEventDelayed = enabled;
 208 }
 209
 210 bool
 211 _TouchGestureDetector::IsDelayTouchEventEnabled(void) const
 212 {
 213         return __isTouchEventDelayed;
 214 }
 215
 216 void
 217 _TouchGestureDetector::SetCancelTouchEventOnSuccessEnabled(bool enabled)
 218 {
 219         __isTouchCanceledOnSuccess = enabled;
 220 }
 221
 222 bool
 223 _TouchGestureDetector::IsCancelTouchEventOnSuccessEnabled(void) const
 224 {
 225         return __isTouchCanceledOnSuccess;
 226 }
 227
 228 void
 229 _TouchGestureDetector::SetUserData(void* pUserData)
 230 {
 231         __pUserData = pUserData;
 232 }
 233
 234 void*
 235 _TouchGestureDetector::GetUserData(void) const
 236 {
 237         return __pUserData;
 238 }
 239
 240 bool
 241 _TouchGestureDetector::ExistWaitingList(void) const
 242 {
 243         bool exist = false;
 244
 245         if (__pCurrentWantToFailList && (__pCurrentWantToFailList->GetCount() > 0))
 246         {
 247                 exist = true;
 248         }
 249
 250         return exist;
 251 }
 252
 253 result
 254 _TouchGestureDetector::StartOnFailureOf(const _TouchGestureDetector& gesture)
 255 {
 256         SysTryReturnResult(NID_UI, IsPossibleToAddFailList(gesture), E_SYSTEM, "[E_SYSTEM] param gesture also waits you to fail.");
 257
 258         _TouchGestureDetector* pGesture = const_cast < _TouchGestureDetector* >(&gesture);
 259         bool exist = __pWantToFailList->Contains(pGesture);
 260         if (!exist)
 261         {
 262                 SysTryReturnResult(NID_UI, __pWantToFailList->Add(pGesture) == E_SUCCESS,
 263                                 E_SYSTEM, "[E_SYSTEM] System error occurred.");
 264         }
 265
 266         return E_SUCCESS;
 267 }
 268
 269 bool
 270 _TouchGestureDetector::IsPossibleToAddFailList(const _TouchGestureDetector& gesture)
 271 {
 272         IListT<_TouchGestureDetector*>* pList = gesture.GetWantToFailList();
 273         if (pList == null)
 274         {
 275                 return true;
 276         }
 277
 278         IEnumeratorT<_TouchGestureDetector*>* pEnumerator = pList->GetEnumeratorN();
 279         if (pEnumerator)
 280         {
 281                 while(pEnumerator->MoveNext() == E_SUCCESS)
 282                 {
 283                         _TouchGestureDetector* pGesture = null;
 284                         pEnumerator->GetCurrent(pGesture);
 285                         if (pGesture == null)
 286                         {
 287                                 continue;
 288                         }
 289
 290                         if (pGesture == this)
 291                         {
 292                                 delete pEnumerator;
 293                                 return false;
 294                         }
 295                 }
 296                 delete pEnumerator;
 297         }
 298         return true;
 299 }
 300
 301 void
 302 _TouchGestureDetector::SetDetectorState(_TouchGestureDetectorState state)
 303 {
 304         __currentState = state;
 305
 306         if (state == _TOUCH_GESTURE_DETECTOR_STATE_READY)
 307         {
 308                 IEnumeratorT<_TouchGestureDetector*>* pEnumerator = __pWantToFailList->GetEnumeratorN();
 309
 310                 if (pEnumerator)
 311                 {
 312                         while(pEnumerator->MoveNext() == E_SUCCESS)
 313                         {
 314                                 _TouchGestureDetector* pGesture = null;
 315                                 pEnumerator->GetCurrent(pGesture);
 316                                 if (pGesture == null)
 317                                 {
 318                                         continue;
 319                                 }
 320
 321                                 bool exist = __pCurrentWantToFailList->Contains(pGesture);
 322                                 if (!exist)
 323                                 {
 324                                         __pCurrentWantToFailList->Add(pGesture);
 325                                 }
 326                         }
 327                         delete pEnumerator;
 328                 }
 329         }
 330
 331         if (state == _TOUCH_GESTURE_DETECTOR_STATE_STARTED || state == _TOUCH_GESTURE_DETECTOR_STATE_CHANGED || state == _TOUCH_GESTURE_DETECTOR_STATE_FINISHED)
 332         {
 333                 if (ExistWaitingList())
 334                 {
 335                         __isDetectionStarted = true;
 336                         __currentState = _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS_AND_WAIT;
 337                         return;
 338                 }
 339
 340                 _Control* pControl = GetControl();
 341                 if (pControl)
 342                 {
 343                         IListT <_TouchGestureDetector*>* pList = pControl->GetStartedGestureDetectorListN();
 344                         if (pList)
 345                         {
 346                                 IEnumeratorT<_TouchGestureDetector*>* pEnumerator = pList->GetEnumeratorN();
 347                                 if (pEnumerator)
 348                                 {
 349                                         while(pEnumerator->MoveNext() == E_SUCCESS)
 350                                         {
 351                                                 _TouchGestureDetector* pStartedGestureDetector = null;
 352                                                 pEnumerator->GetCurrent(pStartedGestureDetector);
 353                                                 if (pStartedGestureDetector && (pStartedGestureDetector == this))
 354                                                 {
 355                                                         _TouchGestureDetectorEventType eventType = pStartedGestureDetector->GetGestureDetectorEventType();
 356                                                         if (eventType == _TOUCH_GESTURE_DETECTOR_EVENT_TYPE_DISCRETE ||
 357                                                                 (eventType == _TOUCH_GESTURE_DETECTOR_EVENT_TYPE_CONTINUOUS && state == _TOUCH_GESTURE_DETECTOR_STATE_FINISHED))
 358                                                         {
 359                                                                 pControl->SetStartedGestureDetector(*this, _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS);
 360                                                         }
 361                                                 }
 362                                         }
 363                                         delete pEnumerator;
 364                                 }
 365                                 delete pList;
 366                         }
 367                 }
 368
 369                 ProcessPublicListener(*this);
 370                 ProcessCoreListener(*this);
 371                 NotifyStateChanged();
 372         }
 373         else if (state == _TOUCH_GESTURE_DETECTOR_STATE_FAILED)
 374         {
 375                 _Control* pControl = GetControl();
 376                 if (pControl)
 377                 {
 378                         IListT <_TouchGestureDetector*>* pList = pControl->GetStartedGestureDetectorListN();
 379                         if (pList)
 380                         {
 381                                 IEnumeratorT<_TouchGestureDetector*>* pEnumerator = pList->GetEnumeratorN();
 382                                 if (pEnumerator)
 383                                 {
 384                                         while(pEnumerator->MoveNext() == E_SUCCESS)
 385                                         {
 386                                                 _TouchGestureDetector* pStartedGestureDetector = null;
 387                                                 pEnumerator->GetCurrent(pStartedGestureDetector);
 388                                                 if (pStartedGestureDetector && (pStartedGestureDetector == this))
 389                                                 {
 390                                                         pControl->SetStartedGestureDetector(*this, _TOUCH_GESTURE_DETECTOR_STATE_FAILED);
 391                                                 }
 392                                         }
 393                                         delete pEnumerator;
 394                                 }
 395                                 delete pList;
 396                         }
 397                 }
 398
 399                 NotifyStateChanged();
 400         }
 401         else if (state == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 402         {
 403                 if (!IsGestureStarted())
 404                 {
 405                         SetToDefaultState();
 406                 }
 407
 408                 SetGestureStart(false);
 409         }
 410
 411         _TouchGestureDetectorState currentState = GetDetectorState();
 412         if (( !__isDetectionStarted && currentState == _TOUCH_GESTURE_DETECTOR_STATE_FINISHED) || currentState == _TOUCH_GESTURE_DETECTOR_STATE_FAILED || currentState == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 413         {
 414                 SetToDefaultState();
 415         }
 416 }
 417
 418 void
 419 _TouchGestureDetector::SetToDefaultState(void)
 420 {
 421         __pCurrentWantToFailList->RemoveAll();
 422         __isDetectionStarted = false;
 423         SetDetectorState(_TOUCH_GESTURE_DETECTOR_STATE_READY);
 424 }
 425
 426 _TouchGestureDetectorEventType
 427 _TouchGestureDetector::GetGestureDetectorEventType(void)
 428 {
 429         _TouchGestureDetectorType type = GetDetectorType();
 430
 431         if (type == _TOUCH_GESTURE_DETECTOR_TYPE_PINCH ||type == _TOUCH_GESTURE_DETECTOR_TYPE_CUSTOM
 432                 ||type == _TOUCH_GESTURE_DETECTOR_TYPE_ROTATION || type == _TOUCH_GESTURE_DETECTOR_TYPE_PANNING)
 433         {
 434                 return _TOUCH_GESTURE_DETECTOR_EVENT_TYPE_CONTINUOUS;
 435         }
 436         else
 437         {
 438                 return _TOUCH_GESTURE_DETECTOR_EVENT_TYPE_DISCRETE;
 439         }
 440 }
 441
 442 String
 443 _TouchGestureDetector::GetDescription(void)
 444 {
 445         String type(L"");
 446
 447         switch (GetDetectorType())
 448         {
 449         case _TOUCH_GESTURE_DETECTOR_TYPE_CUSTOM:
 450                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_CUSTOM";
 451                 break;
 452
 453         case _TOUCH_GESTURE_DETECTOR_TYPE_TAP:
 454                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_TAP";
 455                 break;
 456
 457         case _TOUCH_GESTURE_DETECTOR_TYPE_LONG_PRESS:
 458                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_LONG_PRESS";
 459                 break;
 460
 461         case _TOUCH_GESTURE_DETECTOR_TYPE_PINCH:
 462                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_PINCH";
 463                 break;
 464
 465         case _TOUCH_GESTURE_DETECTOR_TYPE_FLICK:
 466                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_FLICK";
 467                 break;
 468
 469         case _TOUCH_GESTURE_DETECTOR_TYPE_ROTATION:
 470                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_ROTATION";
 471                 break;
 472
 473         case _TOUCH_GESTURE_DETECTOR_TYPE_PANNING:
 474                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_PANNING";
 475                 break;
 476
 477         default:
 478                 break;
 479         }
 480
 481         String description(L"");
 482
 483         description.Format(LOG_LEN_MAX, L"%ls state(%d) delay(%d) cancelonSuccess(%d)",
 484                 type.GetPointer(), GetDetectorState(),
 485                         IsDelayTouchEventEnabled(), IsCancelTouchEventOnSuccessEnabled());
 486
 487         return description;
 488 }
 489
 490 IListT <_TouchGestureDetector*>*
 491 _TouchGestureDetector::GetWantToFailList(void) const
 492 {
 493         return __pWantToFailList;
 494 }
 495
 496 void
 497 _TouchGestureDetector::ProcessPublicListener(_TouchGestureDetector& gesture)
 498 {
 499         _TouchGestureDetectorImpl* pImpl = static_cast<_TouchGestureDetectorImpl*>(gesture.GetUserData());
 500         if (!pImpl)
 501         {
 502                 return;
 503         }
 504
 505         IListT<ITouchGestureEventListener*>* pPublicList = pImpl->GetGestureEventListenerList();
 506         if (!pPublicList)
 507         {
 508                 return;
 509         }
 510
 511         IEnumeratorT<ITouchGestureEventListener*>* pEnumerator = pPublicList->GetEnumeratorN();
 512         SysTryReturnVoidResult(NID_UI, pEnumerator, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 513
 514         while(pEnumerator->MoveNext() == E_SUCCESS)
 515         {
 516                 ITouchGestureEventListener* pListener = null;
 517                 pEnumerator->GetCurrent(pListener);
 518
 519                 if (pListener == null)
 520                 {
 521                         continue;
 522                 }
 523
 524                 switch(gesture.GetDetectorType())
 525                 {
 526                 case _TOUCH_GESTURE_DETECTOR_TYPE_TAP:
 527                 {
 528                         ITouchTapGestureEventListener* pPublicListener = dynamic_cast<ITouchTapGestureEventListener*>(pListener);
 529                         TouchTapGestureDetector* pPublicGestureDetector = dynamic_cast<TouchTapGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 530
 531                         if (pPublicListener && pPublicGestureDetector)
 532                         {
 533                                 if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 534                                 {
 535                                         pPublicListener->OnTapGestureCanceled(*pPublicGestureDetector);
 536                                         gesture.SetToDefaultState();
 537                                 }
 538                                 else if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 539                                 {
 540                                         pPublicListener->OnTapGestureDetected(*pPublicGestureDetector);
 541                                 }
 542                         }
 543                 }
 544                 break;
 545
 546                 case _TOUCH_GESTURE_DETECTOR_TYPE_LONG_PRESS:
 547                 {
 548                         ITouchLongPressGestureEventListener* pPublicListener = dynamic_cast<ITouchLongPressGestureEventListener*>(pListener);
 549                         TouchLongPressGestureDetector* pPublicGestureDetector = dynamic_cast<TouchLongPressGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 550
 551                         if (pPublicListener && pPublicGestureDetector)
 552                         {
 553                                 if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 554                                 {
 555                                         pPublicListener->OnLongPressGestureCanceled(*pPublicGestureDetector);
 556                                         gesture.SetToDefaultState();
 557                                 }
 558                                 else if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 559                                 {
 560                                         pPublicListener->OnLongPressGestureDetected(*pPublicGestureDetector);
 561                                 }
 562                         }
 563                 }
 564                 break;
 565
 566                 case _TOUCH_GESTURE_DETECTOR_TYPE_PINCH:
 567                 {
 568                         ITouchPinchGestureEventListener* pPublicListener = dynamic_cast<ITouchPinchGestureEventListener*>(pListener);
 569                         TouchPinchGestureDetector* pPublicGestureDetector = dynamic_cast<TouchPinchGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 570
 571                         if (pPublicListener && pPublicGestureDetector)
 572                         {
 573                                 switch(gesture.GetDetectorState())
 574                                 {
 575                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 576                                         pPublicListener->OnPinchGestureStarted(*pPublicGestureDetector);
 577                                         break;
 578
 579                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 580                                         pPublicListener->OnPinchGestureChanged(*pPublicGestureDetector);
 581                                         break;
 582
 583                                 case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 584                                         pPublicListener->OnPinchGestureFinished(*pPublicGestureDetector);
 585                                         break;
 586
 587                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 588                                         pPublicListener->OnPinchGestureCanceled(*pPublicGestureDetector);
 589                                         gesture.SetToDefaultState();
 590                                         break;
 591
 592                                 default:
 593                                         break;
 594                                 }
 595                         }
 596                 }
 597                 break;
 598
 599                 case _TOUCH_GESTURE_DETECTOR_TYPE_FLICK:
 600                 {
 601                         ITouchFlickGestureEventListener* pPublicListener = dynamic_cast<ITouchFlickGestureEventListener*>(pListener);
 602                         TouchFlickGestureDetector* pPublicGestureDetector = dynamic_cast<TouchFlickGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 603
 604                         if (pPublicListener && pPublicGestureDetector)
 605                         {
 606                                 if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 607                                 {
 608                                         pPublicListener->OnFlickGestureCanceled(*pPublicGestureDetector);
 609                                         gesture.SetToDefaultState();
 610                                 }
 611                                 else if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 612                                 {
 613                                         pPublicListener->OnFlickGestureDetected(*pPublicGestureDetector);
 614                                 }
 615                         }
 616                 }
 617                 break;
 618
 619                 case _TOUCH_GESTURE_DETECTOR_TYPE_ROTATION:
 620                 {
 621                         ITouchRotationGestureEventListener* pPublicListener = dynamic_cast<ITouchRotationGestureEventListener*>(pListener);
 622                         TouchRotationGestureDetector* pPublicGestureDetector = dynamic_cast<TouchRotationGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 623
 624                         if (pPublicListener && pPublicGestureDetector)
 625                         {
 626                                 switch(gesture.GetDetectorState())
 627                                 {
 628                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 629                                         pPublicListener->OnRotationGestureStarted(*pPublicGestureDetector);
 630                                         break;
 631
 632                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 633                                         pPublicListener->OnRotationGestureChanged(*pPublicGestureDetector);
 634                                         break;
 635
 636                                 case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 637                                         pPublicListener->OnRotationGestureFinished(*pPublicGestureDetector);
 638                                         break;
 639
 640                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 641                                         pPublicListener->OnRotationGestureCanceled(*pPublicGestureDetector);
 642                                         gesture.SetToDefaultState();
 643                                         break;
 644
 645                                 default:
 646                                         break;
 647                                 }
 648                         }
 649                 }
 650                 break;
 651
 652                 case _TOUCH_GESTURE_DETECTOR_TYPE_PANNING:
 653                 {
 654                         ITouchPanningGestureEventListener* pPublicListener = dynamic_cast<ITouchPanningGestureEventListener*>(pListener);
 655                         TouchPanningGestureDetector* pPublicGestureDetector = dynamic_cast<TouchPanningGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 656
 657                         if (pPublicListener && pPublicGestureDetector)
 658                         {
 659                                         switch(gesture.GetDetectorState())
 660                                         {
 661                                         case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 662                                                 pPublicListener->OnPanningGestureStarted(*pPublicGestureDetector);
 663                                                 break;
 664
 665                                         case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 666                                                 pPublicListener->OnPanningGestureChanged(*pPublicGestureDetector);
 667                                                 break;
 668
 669                                         case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 670                                                 pPublicListener->OnPanningGestureFinished(*pPublicGestureDetector);
 671                                                 break;
 672
 673                                         case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 674                                                 pPublicListener->OnPanningGestureCanceled(*pPublicGestureDetector);
 675                                                 gesture.SetToDefaultState();
 676                                                 break;
 677
 678                                         default:
 679                                                 break;
 680                                         }
 681                                 }
 682                 }
 683                 break;
 684
 685                 case _TOUCH_GESTURE_DETECTOR_TYPE_CUSTOM:
 686                 default:
 687                 {
 688                         ITouchCustomGestureEventListener* pPublicListener = dynamic_cast<ITouchCustomGestureEventListener*>(pListener);
 689
 690                         if (pPublicListener)
 691                         {
 692                                 switch(gesture.GetDetectorState())
 693                                 {
 694                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 695                                         pPublicListener->OnCustomGestureStarted(pImpl->GetPublic());
 696                                         break;
 697
 698                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 699                                         pPublicListener->OnCustomGestureChanged(pImpl->GetPublic());
 700                                         break;
 701
 702                                 case _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS:
 703                                         pPublicListener->OnCustomGestureFinished(pImpl->GetPublic());
 704                                         break;
 705
 706                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 707                                         pPublicListener->OnCustomGestureCanceled(pImpl->GetPublic());
 708                                         gesture.SetToDefaultState();
 709                                         break;
 710
 711                                 default:
 712                                         break;
 713                                 }
 714                         }
 715                 }
 716                 break;
 717                 }
 718         }
 719         delete pEnumerator;
 720 }
 721
 722 void
 723 _TouchGestureDetector::ProcessCoreListener(_TouchGestureDetector& gesture)
 724 {
 725         IListT <_ITouchGestureEventListener*>* pList = gesture.GetGestureListenerList();
 726         if (!pList)
 727         {
 728                 return;
 729         }
 730
 731         IEnumeratorT<_ITouchGestureEventListener*>* pEnumerator = pList->GetEnumeratorN();
 732         SysTryReturnVoidResult(NID_UI, pEnumerator, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 733
 734         while(pEnumerator->MoveNext() == E_SUCCESS)
 735         {
 736                 _ITouchGestureEventListener* pListener = null;
 737                 pEnumerator->GetCurrent(pListener);
 738
 739                 if (pListener == null)
 740                 {
 741                         continue;
 742                 }
 743
 744                 switch(gesture.GetDetectorType())
 745                 {
 746                 case _TOUCH_GESTURE_DETECTOR_TYPE_TAP:
 747                 {
 748                         _ITouchTapGestureEventListener* pCoreListener = dynamic_cast<_ITouchTapGestureEventListener*>(pListener);
 749                         _TouchTapGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchTapGestureDetector*>(&gesture);
 750
 751                         if (pCoreListener && pCoreGestureDetector)
 752                         {
 753                                 if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 754                                 {
 755                                         pCoreListener->OnTapGestureCanceled(*pCoreGestureDetector);
 756                                         pCoreGestureDetector->SetToDefaultState();
 757                                 }
 758                                 else if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 759                                 {
 760                                         pCoreListener->OnTapGestureDetected(*pCoreGestureDetector);
 761                                 }
 762                         }
 763                 }
 764                 break;
 765
 766                 case _TOUCH_GESTURE_DETECTOR_TYPE_LONG_PRESS:
 767                 {
 768                         _ITouchLongPressGestureEventListener* pCoreListener = dynamic_cast<_ITouchLongPressGestureEventListener*>(pListener);
 769                         _TouchLongPressGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchLongPressGestureDetector*>(&gesture);
 770
 771                         if (pCoreListener && pCoreGestureDetector)
 772                         {
 773                                 if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 774                                 {
 775                                         pCoreListener->OnLongPressGestureCanceled(*pCoreGestureDetector);
 776                                         pCoreGestureDetector->SetToDefaultState();
 777                                 }
 778                                 else if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 779                                 {
 780                                         pCoreListener->OnLongPressGestureDetected(*pCoreGestureDetector);
 781                                 }
 782                         }
 783                 }
 784                 break;
 785
 786                 case _TOUCH_GESTURE_DETECTOR_TYPE_PINCH:
 787                 {
 788                         _ITouchPinchGestureEventListener* pCoreListener = dynamic_cast<_ITouchPinchGestureEventListener*>(pListener);
 789                         _TouchPinchGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchPinchGestureDetector*>(&gesture);
 790
 791                         if (pCoreListener && pCoreGestureDetector)
 792                         {
 793                                 switch(GetDetectorState())
 794                                 {
 795                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 796                                         pCoreListener->OnPinchGestureStarted(*pCoreGestureDetector);
 797                                         break;
 798
 799                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 800                                         pCoreListener->OnPinchGestureChanged(*pCoreGestureDetector);
 801                                         break;
 802
 803                                 case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 804                                         pCoreListener->OnPinchGestureFinished(*pCoreGestureDetector);
 805                                         break;
 806
 807                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 808                                         pCoreListener->OnPinchGestureCanceled(*pCoreGestureDetector);
 809                                         pCoreGestureDetector->SetToDefaultState();
 810                                         break;
 811
 812                                 default:
 813                                         break;
 814                                 }
 815                         }
 816                 }
 817                 break;
 818
 819                 case _TOUCH_GESTURE_DETECTOR_TYPE_FLICK:
 820                 {
 821                         _ITouchFlickGestureEventListener* pCoreListener = dynamic_cast<_ITouchFlickGestureEventListener*>(pListener);
 822                         _TouchFlickGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchFlickGestureDetector*>(&gesture);
 823
 824                         if (pCoreListener && pCoreGestureDetector)
 825                         {
 826                                 if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 827                                 {
 828                                         pCoreListener->OnFlickGestureCanceled(*pCoreGestureDetector);
 829                                         pCoreGestureDetector->SetToDefaultState();
 830                                 }
 831                                 else if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 832                                 {
 833                                         pCoreListener->OnFlickGestureDetected(*pCoreGestureDetector);
 834                                 }
 835                         }
 836                 }
 837                 break;
 838
 839                 case _TOUCH_GESTURE_DETECTOR_TYPE_ROTATION:
 840                 {
 841                         _ITouchRotationGestureEventListener* pCoreListener = dynamic_cast<_ITouchRotationGestureEventListener*>(pListener);
 842                         _TouchRotationGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchRotationGestureDetector*>(&gesture);
 843
 844                         if (pCoreListener && pCoreGestureDetector)
 845                         {
 846                                 switch(GetDetectorState())
 847                                 {
 848                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 849                                         pCoreListener->OnRotationGestureStarted(*pCoreGestureDetector);
 850                                         break;
 851
 852                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 853                                         pCoreListener->OnRotationGestureChanged(*pCoreGestureDetector);
 854                                         break;
 855
 856                                 case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 857                                         pCoreListener->OnRotationGestureFinished(*pCoreGestureDetector);
 858                                         break;
 859
 860                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 861                                         pCoreListener->OnRotationGestureCanceled(*pCoreGestureDetector);
 862                                         pCoreGestureDetector->SetToDefaultState();
 863                                         break;
 864
 865                                 default:
 866                                         break;
 867                                 }
 868                         }
 869                 }
 870                 break;
 871
 872                 case _TOUCH_GESTURE_DETECTOR_TYPE_PANNING:
 873                 {
 874                         _ITouchPanningGestureEventListener* pCoreListener = dynamic_cast<_ITouchPanningGestureEventListener*>(pListener);
 875                         _TouchPanningGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchPanningGestureDetector*>(&gesture);
 876
 877                         if (pCoreListener && pCoreGestureDetector)
 878                         {
 879                                 switch(GetDetectorState())
 880                                 {
 881                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 882                                         pCoreListener->OnPanningGestureStarted(*pCoreGestureDetector);
 883                                         break;
 884
 885                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 886                                         pCoreListener->OnPanningGestureChanged(*pCoreGestureDetector);
 887                                         break;
 888
 889                                 case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 890                                         pCoreListener->OnPanningGestureFinished(*pCoreGestureDetector);
 891                                         break;
 892
 893                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 894                                         pCoreListener->OnPanningGestureCanceled(*pCoreGestureDetector);
 895                                         pCoreGestureDetector->SetToDefaultState();
 896                                         break;
 897
 898                                 default:
 899                                         break;
 900                                 }
 901                         }
 902                 }
 903                 break;
 904
 905                 case _TOUCH_GESTURE_DETECTOR_TYPE_CUSTOM:
 906                 default:
 907                 {
 908                         _ITouchCustomGestureEventListener* pCoreListener = dynamic_cast<_ITouchCustomGestureEventListener*>(pListener);
 909
 910                         if (pCoreListener)
 911                         {
 912                                 switch(GetDetectorState())
 913                                 {
 914                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 915                                         pCoreListener->OnCustomGestureStarted(gesture);
 916                                         break;
 917
 918                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 919                                         pCoreListener->OnCustomGestureChanged(gesture);
 920                                         break;
 921
 922                                 case _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS:
 923                                         pCoreListener->OnCustomGestureFinished(gesture);
 924                                         break;
 925
 926                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 927                                         pCoreListener->OnCustomGestureCanceled(gesture);
 928                                         gesture.SetToDefaultState();
 929                                         break;
 930
 931                                 default:
 932                                         break;
 933                                 }
 934                         }
 935                 }
 936                 break;
 937                 }
 938         }
 939         delete pEnumerator;
 940 }
 941
 942 void
 943 _TouchGestureDetector::NotifyStateChanged(void)
 944 {
 945         _ControlManager* pControlManager = _ControlManager::GetInstance();
 946         SysTryReturnVoidResult(NID_UI, pControlManager, E_SYSTEM, "[E_SYSTEM] _ControlManager does not exist.");
 947
 948         _Control* pControl = GetControl();
 949         SysTryReturnVoidResult(NID_UI, pControl, E_INVALID_CONDITION, "[E_INVALID_CONDITION] invalid GestureDetectorControl()");
 950
 951         IListT<_TouchGestureDetector*>* pGestureList = pControlManager->GetGestureDetectorList();
 952         if (!pGestureList || (pGestureList && pGestureList->GetCount() == 0))
 953         {
 954                 pGestureList = pControl->GetGestureDetectorList();
 955         }
 956
 957         if (pGestureList)
 958         {
 959                 IEnumeratorT<_TouchGestureDetector*>* pEnumerator = pGestureList->GetEnumeratorN();
 960                 if (pEnumerator)
 961                 {
 962                         while(pEnumerator->MoveNext() == E_SUCCESS)
 963                         {
 964                                 _TouchGestureDetector* pGestureDetector = null;
 965                                 pEnumerator->GetCurrent(pGestureDetector);
 966                                 if (pGestureDetector == null || !pGestureDetector->ExistWaitingList())
 967                                 {
 968                                         continue;
 969                                 }
 970
 971                                 IListT<_TouchGestureDetector*>* pWaitingList = pGestureDetector->GetWantToFailList();
 972                                 if (pWaitingList)
 973                                 {
 974                                         IEnumeratorT<_TouchGestureDetector*>* pWaitingEnumerator = pWaitingList->GetEnumeratorN();
 975                                         if (pWaitingEnumerator)
 976                                         {
 977                                                 while(pWaitingEnumerator->MoveNext() == E_SUCCESS)
 978                                                 {
 979                                                         _TouchGestureDetector* pWaitingGestureDetector = null;
 980                                                         pWaitingEnumerator->GetCurrent(pWaitingGestureDetector);
 981                                                         if (pWaitingGestureDetector == null)
 982                                                         {
 983                                                                 continue;
 984                                                         }
 985
 986                                                         if (pWaitingGestureDetector == this)
 987                                                         {
 988                                                                 pGestureDetector->OnGestureDetectorStateChanged(*this);
 989                                                         }
 990                                                 }
 991                                                 delete pWaitingEnumerator;
 992                                         }
 993                                 }
 994                         }
 995                         delete pEnumerator;
 996                 }
 997         }
 998
 999         ProcessGestureCondition();
1000 }
1001
1002 void
1003 _TouchGestureDetector::ProcessGestureCondition(void)
1004 {
1005         _TouchManager* pTouchManager = _TouchManager::GetInstance();
1006         SysTryReturnVoidResult(NID_UI, pTouchManager, E_SYSTEM, "[E_SYSTEM] _ControlManager does not exist.");
1007
1008         _Control* pControl = GetControl();
1009         SysTryReturnVoidResult(NID_UI, pControl, E_INVALID_CONDITION, "[E_INVALID_CONDITION] invalid GestureDetectorControl()");
1010
1011         //send delayed touch event when all gestures set delayed touch events decided its state(success or failed) and all failed.
1012         if (!pControl->IsDelayedTouchEventEnabled() && pControl->IsPossibleToSendDelayedTouchEvent() && !pControl->IsSentDelayedEvent())
1013         {
1014                 SendDelayedTouchEvent(pControl);
1015         }
1016
1017         if (pControl->IsCancelOnGestureSuccess())
1018         {
1019                 pTouchManager->SetTouchCancelOnGesture(true);
1020                 pTouchManager->SetTouchCanceled(null);
1021                 pTouchManager->SetTouchCanceledOnGestureSuccess(true);
1022         }
1023
1024         bool allDetected = true;
1025         IMapEnumeratorT <_TouchGestureDetector*, _TouchGestureDetectorState>* pMapEnumerator = pControl->GetStartedGestureDetectorEnumeratorN();
1026         if (pMapEnumerator)
1027         {
1028                 while(pMapEnumerator->MoveNext() == E_SUCCESS)
1029                 {
1030                         _TouchGestureDetectorState state = _TOUCH_GESTURE_DETECTOR_STATE_READY;
1031                         pMapEnumerator->GetValue(state);
1032
1033                         if (state == _TOUCH_GESTURE_DETECTOR_STATE_STARTED)
1034                         {
1035                                 allDetected = false;
1036                                 break;
1037                         }
1038                 }
1039                 delete pMapEnumerator;
1040         }
1041
1042         if (allDetected)
1043         {
1044                 pControl->ClearStartedGestureDetectorList();
1045         }
1046 }
1047
1048 void
1049 _TouchGestureDetector::SendDelayedTouchEvent(_Control* pControl)
1050 {
1051         _TouchManager* pTouchManager = _TouchManager::GetInstance();
1052         SysTryReturnVoidResult(NID_UI, pTouchManager, E_SYSTEM, "[E_SYSTEM] _ControlManager does not exist.");
1053
1054         //send delayed event if all started gesture are failed.
1055         IListT<_TouchInfo*>* pList = pControl->GetTouchInfoList();
1056         if (pList)
1057         {
1058                 IEnumeratorT<_TouchInfo*>* pEnumerator = pList->GetEnumeratorN();
1059                 if (pEnumerator)
1060                 {
1061                         while(pEnumerator->MoveNext() == E_SUCCESS)
1062                         {
1063                                 _TouchInfo* pTouchInfo = null;
1064                                 pEnumerator->GetCurrent(pTouchInfo);
1065                                 if (pTouchInfo == null)
1066                                 {
1067                                         continue;
1068                                 }
1069
1070                                 pControl->SetSendingDelayedEvent(true);
1071                                 pTouchManager->SendEvent(pControl, *pTouchInfo);
1072                         }
1073                         delete pEnumerator;
1074                         pControl->SetSendingDelayedEvent(false);
1075                         pControl->SetSentDelayedEvent(true);
1076                 }
1077         }
1078 }
1079
1080 IListT<_TouchGestureDetector*>*
1081 _TouchGestureDetector::GetCurrentWantToFailList(void) const
1082 {
1083         return __pCurrentWantToFailList;
1084 }
1085
1086 void
1087 _TouchGestureDetector::OnGestureDetectorStateChanged(const _TouchGestureDetector& gestureDetector)
1088 {
1089         if (GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS_AND_WAIT)
1090         {
1091                 _TouchGestureDetectorState state = gestureDetector.GetDetectorState();
1092                 if (state == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
1093                 {
1094                         SetDetectorState(_TOUCH_GESTURE_DETECTOR_STATE_FAILED);
1095                 }
1096                 else if (state == _TOUCH_GESTURE_DETECTOR_STATE_FAILED)
1097                 {
1098                         IListT<_TouchGestureDetector*>* pWaitingList = GetCurrentWantToFailList();
1099                         if (pWaitingList)
1100                         {
1101                                 bool exist = pWaitingList->Contains(const_cast<_TouchGestureDetector*>(&gestureDetector));
1102                                 if (exist)
1103                                 {
1104                                         _TouchGestureDetector* pGestureDetector = const_cast<_TouchGestureDetector*>(&gestureDetector);
1105                                         pWaitingList->Remove(pGestureDetector);
1106                                 }
1107                         }
1108                         _TouchGestureDetectorType type = GetDetectorType();
1109                         if (type != _TOUCH_GESTURE_DETECTOR_TYPE_PINCH && type != _TOUCH_GESTURE_DETECTOR_TYPE_ROTATION && type != _TOUCH_GESTURE_DETECTOR_TYPE_PANNING)
1110                         {
1111                                 SetDetectorState(_TOUCH_GESTURE_DETECTOR_STATE_SUCCESS);
1112                         }
1113                 }
1114         }
1115         else if (GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_READY)
1116         {
1117                 _TouchGestureDetectorState state = gestureDetector.GetDetectorState();
1118
1119                 if (state == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
1120                 {
1121                         SetDetectorState(_TOUCH_GESTURE_DETECTOR_STATE_FAILED);
1122                 }
1123                 else if (state == _TOUCH_GESTURE_DETECTOR_STATE_FAILED)
1124                 {
1125                         IListT<_TouchGestureDetector*>* pWaitingList = GetCurrentWantToFailList();
1126                         if (pWaitingList)
1127                         {
1128                                 bool exist = pWaitingList->Contains(const_cast<_TouchGestureDetector*>(&gestureDetector));
1129                                 if (exist)
1130                                 {
1131                                         _TouchGestureDetector* pGestureDetector = const_cast<_TouchGestureDetector*>(&gestureDetector);
1132                                         pWaitingList->Remove(pGestureDetector);
1133                                 }
1134                         }
1135                 }
1136         }
1137 }
1138
1139 void
1140 _TouchGestureDetector::SetGestureStart(bool start)
1141 {
1142         __isDetectionStarted = start;
1143
1144         if (start == true)
1145         {
1146                 _Control* pControl = GetControl();
1147                 if (pControl)
1148                 {
1149                         pControl->AddStartedGestureDetector(*this, _TOUCH_GESTURE_DETECTOR_STATE_STARTED);
1150                 }
1151         }
1152 }
1153
1154 bool
1155 _TouchGestureDetector::IsGestureStarted(void) const
1156 {
1157         return __isDetectionStarted;
1158 }
1159
1160 bool
1161 _TouchGestureDetector::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1162 {
1163         return false;
1164 }
1165
1166 bool
1167 _TouchGestureDetector::OnTouchMoved(const  _Control& source, const _TouchInfo& touchinfo)
1168 {
1169         return false;
1170 }
1171
1172 bool
1173 _TouchGestureDetector::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1174 {
1175         return false;
1176 }
1177
1178 bool
1179 _TouchGestureDetector::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1180 {
1181         return false;
1182 }
1183
1184 void
1185 _TouchGestureDetector::OnTouchGestureDetectorAdded(void)
1186 {
1187 }
1188
1189 void
1190 _TouchGestureDetector::OnTouchGestureDetectorRemoved(void)
1191 {
1192 }
1193
1194 }}  // Tizen::Ui