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                         IMapEnumeratorT <_TouchGestureDetector*, _TouchGestureDetectorState>*  pMapEnumerator = pControl->GetStartedGestureDetectorEnumeratorN();
 344                         if (pMapEnumerator)
 345                         {
 346                                 while(pMapEnumerator->MoveNext() == E_SUCCESS)
 347                                 {
 348                                         _TouchGestureDetector* pStartedGestureDetector = null;
 349                                         pMapEnumerator->GetKey(pStartedGestureDetector);
 350
 351                                         if (pStartedGestureDetector && (pStartedGestureDetector == this))
 352                                         {
 353                                                 _TouchGestureDetectorEventType eventType = pStartedGestureDetector->GetGestureDetectorEventType();
 354                                                 if (eventType == _TOUCH_GESTURE_DETECTOR_EVENT_TYPE_DISCRETE ||
 355                                                         (eventType == _TOUCH_GESTURE_DETECTOR_EVENT_TYPE_CONTINUOUS && state == _TOUCH_GESTURE_DETECTOR_STATE_FINISHED))
 356                                                 {
 357                                                         pControl->SetStartedGestureDetector(*this, _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS);
 358                                                 }
 359                                         }
 360                                 }
 361                                 delete pMapEnumerator;
 362                         }
 363                 }
 364
 365                 ProcessPublicListener(*this);
 366                 ProcessCoreListener(*this);
 367                 NotifyStateChanged();
 368         }
 369         else if (state == _TOUCH_GESTURE_DETECTOR_STATE_FAILED)
 370         {
 371                 _Control* pControl = GetControl();
 372                 if (pControl)
 373                 {
 374                         IMapEnumeratorT <_TouchGestureDetector*, _TouchGestureDetectorState>*  pMapEnumerator = pControl->GetStartedGestureDetectorEnumeratorN();
 375                         if (pMapEnumerator)
 376                         {
 377                                 while(pMapEnumerator->MoveNext() == E_SUCCESS)
 378                                 {
 379                                         _TouchGestureDetector* pStartedGestureDetector = null;
 380                                         pMapEnumerator->GetKey(pStartedGestureDetector);
 381
 382                                         if (pStartedGestureDetector && (pStartedGestureDetector == this))
 383                                         {
 384                                                 pControl->SetStartedGestureDetector(*this, _TOUCH_GESTURE_DETECTOR_STATE_FAILED);
 385                                         }
 386                                 }
 387                                 delete pMapEnumerator;
 388                         }
 389                 }
 390
 391                 NotifyStateChanged();
 392         }
 393         else if (state == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 394         {
 395                 if (!IsGestureStarted())
 396                 {
 397                         SetToDefaultState();
 398                 }
 399
 400                 SetGestureStart(false);
 401         }
 402
 403         _TouchGestureDetectorState currentState = GetDetectorState();
 404         if (( !__isDetectionStarted && currentState == _TOUCH_GESTURE_DETECTOR_STATE_FINISHED) || currentState == _TOUCH_GESTURE_DETECTOR_STATE_FAILED || currentState == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 405         {
 406                 SetToDefaultState();
 407         }
 408 }
 409
 410 void
 411 _TouchGestureDetector::SetToDefaultState(void)
 412 {
 413         __pCurrentWantToFailList->RemoveAll();
 414         __isDetectionStarted = false;
 415         SetDetectorState(_TOUCH_GESTURE_DETECTOR_STATE_READY);
 416 }
 417
 418 _TouchGestureDetectorEventType
 419 _TouchGestureDetector::GetGestureDetectorEventType(void)
 420 {
 421         _TouchGestureDetectorType type = GetDetectorType();
 422
 423         if (type == _TOUCH_GESTURE_DETECTOR_TYPE_PINCH ||type == _TOUCH_GESTURE_DETECTOR_TYPE_CUSTOM
 424                 ||type == _TOUCH_GESTURE_DETECTOR_TYPE_ROTATION || type == _TOUCH_GESTURE_DETECTOR_TYPE_PANNING)
 425         {
 426                 return _TOUCH_GESTURE_DETECTOR_EVENT_TYPE_CONTINUOUS;
 427         }
 428         else
 429         {
 430                 return _TOUCH_GESTURE_DETECTOR_EVENT_TYPE_DISCRETE;
 431         }
 432 }
 433
 434 String
 435 _TouchGestureDetector::GetDescription(void)
 436 {
 437         String type(L"");
 438
 439         switch (GetDetectorType())
 440         {
 441         case _TOUCH_GESTURE_DETECTOR_TYPE_CUSTOM:
 442                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_CUSTOM";
 443                 break;
 444
 445         case _TOUCH_GESTURE_DETECTOR_TYPE_TAP:
 446                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_TAP";
 447                 break;
 448
 449         case _TOUCH_GESTURE_DETECTOR_TYPE_LONG_PRESS:
 450                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_LONG_PRESS";
 451                 break;
 452
 453         case _TOUCH_GESTURE_DETECTOR_TYPE_PINCH:
 454                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_PINCH";
 455                 break;
 456
 457         case _TOUCH_GESTURE_DETECTOR_TYPE_FLICK:
 458                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_FLICK";
 459                 break;
 460
 461         case _TOUCH_GESTURE_DETECTOR_TYPE_ROTATION:
 462                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_ROTATION";
 463                 break;
 464
 465         case _TOUCH_GESTURE_DETECTOR_TYPE_PANNING:
 466                 type = L"_TOUCH_GESTURE_DETECTOR_TYPE_PANNING";
 467                 break;
 468
 469         default:
 470                 break;
 471         }
 472
 473         String description(L"");
 474
 475         description.Format(LOG_LEN_MAX, L"%ls state(%d) delay(%d) cancelonSuccess(%d)",
 476                 type.GetPointer(), GetDetectorState(),
 477                         IsDelayTouchEventEnabled(), IsCancelTouchEventOnSuccessEnabled());
 478
 479         return description;
 480 }
 481
 482 IListT <_TouchGestureDetector*>*
 483 _TouchGestureDetector::GetWantToFailList(void) const
 484 {
 485         return __pWantToFailList;
 486 }
 487
 488 void
 489 _TouchGestureDetector::ProcessPublicListener(_TouchGestureDetector& gesture)
 490 {
 491         _TouchGestureDetectorImpl* pImpl = static_cast<_TouchGestureDetectorImpl*>(gesture.GetUserData());
 492         if (!pImpl)
 493         {
 494                 return;
 495         }
 496
 497         IListT<ITouchGestureEventListener*>* pPublicList = pImpl->GetGestureEventListenerList();
 498         if (!pPublicList)
 499         {
 500                 return;
 501         }
 502
 503         IEnumeratorT<ITouchGestureEventListener*>* pEnumerator = pPublicList->GetEnumeratorN();
 504         SysTryReturnVoidResult(NID_UI, pEnumerator, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 505
 506         while(pEnumerator->MoveNext() == E_SUCCESS)
 507         {
 508                 ITouchGestureEventListener* pListener = null;
 509                 pEnumerator->GetCurrent(pListener);
 510
 511                 if (pListener == null)
 512                 {
 513                         continue;
 514                 }
 515
 516                 switch(gesture.GetDetectorType())
 517                 {
 518                 case _TOUCH_GESTURE_DETECTOR_TYPE_TAP:
 519                 {
 520                         ITouchTapGestureEventListener* pPublicListener = dynamic_cast<ITouchTapGestureEventListener*>(pListener);
 521                         TouchTapGestureDetector* pPublicGestureDetector = dynamic_cast<TouchTapGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 522
 523                         if (pPublicListener && pPublicGestureDetector)
 524                         {
 525                                 if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 526                                 {
 527                                         pPublicListener->OnTapGestureCanceled(*pPublicGestureDetector);
 528                                         gesture.SetToDefaultState();
 529                                 }
 530                                 else if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 531                                 {
 532                                         pPublicListener->OnTapGestureDetected(*pPublicGestureDetector);
 533                                 }
 534                         }
 535                 }
 536                 break;
 537
 538                 case _TOUCH_GESTURE_DETECTOR_TYPE_LONG_PRESS:
 539                 {
 540                         ITouchLongPressGestureEventListener* pPublicListener = dynamic_cast<ITouchLongPressGestureEventListener*>(pListener);
 541                         TouchLongPressGestureDetector* pPublicGestureDetector = dynamic_cast<TouchLongPressGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 542
 543                         if (pPublicListener && pPublicGestureDetector)
 544                         {
 545                                 if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 546                                 {
 547                                         pPublicListener->OnLongPressGestureCanceled(*pPublicGestureDetector);
 548                                         gesture.SetToDefaultState();
 549                                 }
 550                                 else if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 551                                 {
 552                                         pPublicListener->OnLongPressGestureDetected(*pPublicGestureDetector);
 553                                 }
 554                         }
 555                 }
 556                 break;
 557
 558                 case _TOUCH_GESTURE_DETECTOR_TYPE_PINCH:
 559                 {
 560                         ITouchPinchGestureEventListener* pPublicListener = dynamic_cast<ITouchPinchGestureEventListener*>(pListener);
 561                         TouchPinchGestureDetector* pPublicGestureDetector = dynamic_cast<TouchPinchGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 562
 563                         if (pPublicListener && pPublicGestureDetector)
 564                         {
 565                                 switch(gesture.GetDetectorState())
 566                                 {
 567                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 568                                         pPublicListener->OnPinchGestureStarted(*pPublicGestureDetector);
 569                                         break;
 570
 571                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 572                                         pPublicListener->OnPinchGestureChanged(*pPublicGestureDetector);
 573                                         break;
 574
 575                                 case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 576                                         pPublicListener->OnPinchGestureFinished(*pPublicGestureDetector);
 577                                         break;
 578
 579                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 580                                         pPublicListener->OnPinchGestureCanceled(*pPublicGestureDetector);
 581                                         gesture.SetToDefaultState();
 582                                         break;
 583
 584                                 default:
 585                                         break;
 586                                 }
 587                         }
 588                 }
 589                 break;
 590
 591                 case _TOUCH_GESTURE_DETECTOR_TYPE_FLICK:
 592                 {
 593                         ITouchFlickGestureEventListener* pPublicListener = dynamic_cast<ITouchFlickGestureEventListener*>(pListener);
 594                         TouchFlickGestureDetector* pPublicGestureDetector = dynamic_cast<TouchFlickGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 595
 596                         if (pPublicListener && pPublicGestureDetector)
 597                         {
 598                                 if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 599                                 {
 600                                         pPublicListener->OnFlickGestureCanceled(*pPublicGestureDetector);
 601                                         gesture.SetToDefaultState();
 602                                 }
 603                                 else if (gesture.GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 604                                 {
 605                                         pPublicListener->OnFlickGestureDetected(*pPublicGestureDetector);
 606                                 }
 607                         }
 608                 }
 609                 break;
 610
 611                 case _TOUCH_GESTURE_DETECTOR_TYPE_ROTATION:
 612                 {
 613                         ITouchRotationGestureEventListener* pPublicListener = dynamic_cast<ITouchRotationGestureEventListener*>(pListener);
 614                         TouchRotationGestureDetector* pPublicGestureDetector = dynamic_cast<TouchRotationGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 615
 616                         if (pPublicListener && pPublicGestureDetector)
 617                         {
 618                                 switch(gesture.GetDetectorState())
 619                                 {
 620                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 621                                         pPublicListener->OnRotationGestureStarted(*pPublicGestureDetector);
 622                                         break;
 623
 624                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 625                                         pPublicListener->OnRotationGestureChanged(*pPublicGestureDetector);
 626                                         break;
 627
 628                                 case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 629                                         pPublicListener->OnRotationGestureFinished(*pPublicGestureDetector);
 630                                         break;
 631
 632                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 633                                         pPublicListener->OnRotationGestureCanceled(*pPublicGestureDetector);
 634                                         gesture.SetToDefaultState();
 635                                         break;
 636
 637                                 default:
 638                                         break;
 639                                 }
 640                         }
 641                 }
 642                 break;
 643
 644                 case _TOUCH_GESTURE_DETECTOR_TYPE_PANNING:
 645                 {
 646                         ITouchPanningGestureEventListener* pPublicListener = dynamic_cast<ITouchPanningGestureEventListener*>(pListener);
 647                         TouchPanningGestureDetector* pPublicGestureDetector = dynamic_cast<TouchPanningGestureDetector*>(dynamic_cast<TouchGestureDetector*>(&pImpl->GetPublic()));
 648
 649                         if (pPublicListener && pPublicGestureDetector)
 650                         {
 651                                         switch(gesture.GetDetectorState())
 652                                         {
 653                                         case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 654                                                 pPublicListener->OnPanningGestureStarted(*pPublicGestureDetector);
 655                                                 break;
 656
 657                                         case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 658                                                 pPublicListener->OnPanningGestureChanged(*pPublicGestureDetector);
 659                                                 break;
 660
 661                                         case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 662                                                 pPublicListener->OnPanningGestureFinished(*pPublicGestureDetector);
 663                                                 break;
 664
 665                                         case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 666                                                 pPublicListener->OnPanningGestureCanceled(*pPublicGestureDetector);
 667                                                 gesture.SetToDefaultState();
 668                                                 break;
 669
 670                                         default:
 671                                                 break;
 672                                         }
 673                                 }
 674                 }
 675                 break;
 676
 677                 case _TOUCH_GESTURE_DETECTOR_TYPE_CUSTOM:
 678                 default:
 679                 {
 680                         ITouchCustomGestureEventListener* pPublicListener = dynamic_cast<ITouchCustomGestureEventListener*>(pListener);
 681
 682                         if (pPublicListener)
 683                         {
 684                                 switch(gesture.GetDetectorState())
 685                                 {
 686                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 687                                         pPublicListener->OnCustomGestureStarted(pImpl->GetPublic());
 688                                         break;
 689
 690                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 691                                         pPublicListener->OnCustomGestureChanged(pImpl->GetPublic());
 692                                         break;
 693
 694                                 case _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS:
 695                                         pPublicListener->OnCustomGestureFinished(pImpl->GetPublic());
 696                                         break;
 697
 698                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 699                                         pPublicListener->OnCustomGestureCanceled(pImpl->GetPublic());
 700                                         gesture.SetToDefaultState();
 701                                         break;
 702
 703                                 default:
 704                                         break;
 705                                 }
 706                         }
 707                 }
 708                 break;
 709                 }
 710         }
 711         delete pEnumerator;
 712 }
 713
 714 void
 715 _TouchGestureDetector::ProcessCoreListener(_TouchGestureDetector& gesture)
 716 {
 717         IListT <_ITouchGestureEventListener*>* pList = gesture.GetGestureListenerList();
 718         if (!pList)
 719         {
 720                 return;
 721         }
 722
 723         IEnumeratorT<_ITouchGestureEventListener*>* pEnumerator = pList->GetEnumeratorN();
 724         SysTryReturnVoidResult(NID_UI, pEnumerator, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 725
 726         while(pEnumerator->MoveNext() == E_SUCCESS)
 727         {
 728                 _ITouchGestureEventListener* pListener = null;
 729                 pEnumerator->GetCurrent(pListener);
 730
 731                 if (pListener == null)
 732                 {
 733                         continue;
 734                 }
 735
 736                 switch(gesture.GetDetectorType())
 737                 {
 738                 case _TOUCH_GESTURE_DETECTOR_TYPE_TAP:
 739                 {
 740                         _ITouchTapGestureEventListener* pCoreListener = dynamic_cast<_ITouchTapGestureEventListener*>(pListener);
 741                         _TouchTapGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchTapGestureDetector*>(&gesture);
 742
 743                         if (pCoreListener && pCoreGestureDetector)
 744                         {
 745                                 if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 746                                 {
 747                                         pCoreListener->OnTapGestureCanceled(*pCoreGestureDetector);
 748                                         pCoreGestureDetector->SetToDefaultState();
 749                                 }
 750                                 else if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 751                                 {
 752                                         pCoreListener->OnTapGestureDetected(*pCoreGestureDetector);
 753                                 }
 754                         }
 755                 }
 756                 break;
 757
 758                 case _TOUCH_GESTURE_DETECTOR_TYPE_LONG_PRESS:
 759                 {
 760                         _ITouchLongPressGestureEventListener* pCoreListener = dynamic_cast<_ITouchLongPressGestureEventListener*>(pListener);
 761                         _TouchLongPressGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchLongPressGestureDetector*>(&gesture);
 762
 763                         if (pCoreListener && pCoreGestureDetector)
 764                         {
 765                                 if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 766                                 {
 767                                         pCoreListener->OnLongPressGestureCanceled(*pCoreGestureDetector);
 768                                         pCoreGestureDetector->SetToDefaultState();
 769                                 }
 770                                 else if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 771                                 {
 772                                         pCoreListener->OnLongPressGestureDetected(*pCoreGestureDetector);
 773                                 }
 774                         }
 775                 }
 776                 break;
 777
 778                 case _TOUCH_GESTURE_DETECTOR_TYPE_PINCH:
 779                 {
 780                         _ITouchPinchGestureEventListener* pCoreListener = dynamic_cast<_ITouchPinchGestureEventListener*>(pListener);
 781                         _TouchPinchGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchPinchGestureDetector*>(&gesture);
 782
 783                         if (pCoreListener && pCoreGestureDetector)
 784                         {
 785                                 switch(GetDetectorState())
 786                                 {
 787                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 788                                         pCoreListener->OnPinchGestureStarted(*pCoreGestureDetector);
 789                                         break;
 790
 791                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 792                                         pCoreListener->OnPinchGestureChanged(*pCoreGestureDetector);
 793                                         break;
 794
 795                                 case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 796                                         pCoreListener->OnPinchGestureFinished(*pCoreGestureDetector);
 797                                         break;
 798
 799                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 800                                         pCoreListener->OnPinchGestureCanceled(*pCoreGestureDetector);
 801                                         pCoreGestureDetector->SetToDefaultState();
 802                                         break;
 803
 804                                 default:
 805                                         break;
 806                                 }
 807                         }
 808                 }
 809                 break;
 810
 811                 case _TOUCH_GESTURE_DETECTOR_TYPE_FLICK:
 812                 {
 813                         _ITouchFlickGestureEventListener* pCoreListener = dynamic_cast<_ITouchFlickGestureEventListener*>(pListener);
 814                         _TouchFlickGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchFlickGestureDetector*>(&gesture);
 815
 816                         if (pCoreListener && pCoreGestureDetector)
 817                         {
 818                                 if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_CANCELED)
 819                                 {
 820                                         pCoreListener->OnFlickGestureCanceled(*pCoreGestureDetector);
 821                                         pCoreGestureDetector->SetToDefaultState();
 822                                 }
 823                                 else if (pCoreGestureDetector->GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
 824                                 {
 825                                         pCoreListener->OnFlickGestureDetected(*pCoreGestureDetector);
 826                                 }
 827                         }
 828                 }
 829                 break;
 830
 831                 case _TOUCH_GESTURE_DETECTOR_TYPE_ROTATION:
 832                 {
 833                         _ITouchRotationGestureEventListener* pCoreListener = dynamic_cast<_ITouchRotationGestureEventListener*>(pListener);
 834                         _TouchRotationGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchRotationGestureDetector*>(&gesture);
 835
 836                         if (pCoreListener && pCoreGestureDetector)
 837                         {
 838                                 switch(GetDetectorState())
 839                                 {
 840                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 841                                         pCoreListener->OnRotationGestureStarted(*pCoreGestureDetector);
 842                                         break;
 843
 844                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 845                                         pCoreListener->OnRotationGestureChanged(*pCoreGestureDetector);
 846                                         break;
 847
 848                                 case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 849                                         pCoreListener->OnRotationGestureFinished(*pCoreGestureDetector);
 850                                         break;
 851
 852                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 853                                         pCoreListener->OnRotationGestureCanceled(*pCoreGestureDetector);
 854                                         pCoreGestureDetector->SetToDefaultState();
 855                                         break;
 856
 857                                 default:
 858                                         break;
 859                                 }
 860                         }
 861                 }
 862                 break;
 863
 864                 case _TOUCH_GESTURE_DETECTOR_TYPE_PANNING:
 865                 {
 866                         _ITouchPanningGestureEventListener* pCoreListener = dynamic_cast<_ITouchPanningGestureEventListener*>(pListener);
 867                         _TouchPanningGestureDetector* pCoreGestureDetector = dynamic_cast<_TouchPanningGestureDetector*>(&gesture);
 868
 869                         if (pCoreListener && pCoreGestureDetector)
 870                         {
 871                                 switch(GetDetectorState())
 872                                 {
 873                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 874                                         pCoreListener->OnPanningGestureStarted(*pCoreGestureDetector);
 875                                         break;
 876
 877                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 878                                         pCoreListener->OnPanningGestureChanged(*pCoreGestureDetector);
 879                                         break;
 880
 881                                 case _TOUCH_GESTURE_DETECTOR_STATE_FINISHED:
 882                                         pCoreListener->OnPanningGestureFinished(*pCoreGestureDetector);
 883                                         break;
 884
 885                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 886                                         pCoreListener->OnPanningGestureCanceled(*pCoreGestureDetector);
 887                                         pCoreGestureDetector->SetToDefaultState();
 888                                         break;
 889
 890                                 default:
 891                                         break;
 892                                 }
 893                         }
 894                 }
 895                 break;
 896
 897                 case _TOUCH_GESTURE_DETECTOR_TYPE_CUSTOM:
 898                 default:
 899                 {
 900                         _ITouchCustomGestureEventListener* pCoreListener = dynamic_cast<_ITouchCustomGestureEventListener*>(pListener);
 901
 902                         if (pCoreListener)
 903                         {
 904                                 switch(GetDetectorState())
 905                                 {
 906                                 case _TOUCH_GESTURE_DETECTOR_STATE_STARTED:
 907                                         pCoreListener->OnCustomGestureStarted(gesture);
 908                                         break;
 909
 910                                 case _TOUCH_GESTURE_DETECTOR_STATE_CHANGED:
 911                                         pCoreListener->OnCustomGestureChanged(gesture);
 912                                         break;
 913
 914                                 case _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS:
 915                                         pCoreListener->OnCustomGestureFinished(gesture);
 916                                         break;
 917
 918                                 case _TOUCH_GESTURE_DETECTOR_STATE_CANCELED:
 919                                         pCoreListener->OnCustomGestureCanceled(gesture);
 920                                         gesture.SetToDefaultState();
 921                                         break;
 922
 923                                 default:
 924                                         break;
 925                                 }
 926                         }
 927                 }
 928                 break;
 929                 }
 930         }
 931         delete pEnumerator;
 932 }
 933
 934 void
 935 _TouchGestureDetector::NotifyStateChanged(void)
 936 {
 937         _ControlManager* pControlManager = _ControlManager::GetInstance();
 938         SysTryReturnVoidResult(NID_UI, pControlManager, E_SYSTEM, "[E_SYSTEM] _ControlManager does not exist.");
 939
 940         _Control* pControl = GetControl();
 941         SysTryReturnVoidResult(NID_UI, pControl, E_INVALID_CONDITION, "[E_INVALID_CONDITION] invalid GestureDetectorControl()");
 942
 943         IListT<_TouchGestureDetector*>* pGestureList = pControlManager->GetGestureDetectorList();
 944         if (!pGestureList || (pGestureList && pGestureList->GetCount() == 0))
 945         {
 946                 pGestureList = pControl->GetGestureDetectorList();
 947         }
 948
 949         if (pGestureList)
 950         {
 951                 IEnumeratorT<_TouchGestureDetector*>* pEnumerator = pGestureList->GetEnumeratorN();
 952                 if (pEnumerator)
 953                 {
 954                         while(pEnumerator->MoveNext() == E_SUCCESS)
 955                         {
 956                                 _TouchGestureDetector* pGestureDetector = null;
 957                                 pEnumerator->GetCurrent(pGestureDetector);
 958                                 if (pGestureDetector == null || !pGestureDetector->ExistWaitingList())
 959                                 {
 960                                         continue;
 961                                 }
 962
 963                                 IListT<_TouchGestureDetector*>* pWaitingList = pGestureDetector->GetWantToFailList();
 964                                 if (pWaitingList)
 965                                 {
 966                                         IEnumeratorT<_TouchGestureDetector*>* pWaitingEnumerator = pWaitingList->GetEnumeratorN();
 967                                         if (pWaitingEnumerator)
 968                                         {
 969                                                 while(pWaitingEnumerator->MoveNext() == E_SUCCESS)
 970                                                 {
 971                                                         _TouchGestureDetector* pWaitingGestureDetector = null;
 972                                                         pWaitingEnumerator->GetCurrent(pWaitingGestureDetector);
 973                                                         if (pWaitingGestureDetector == null)
 974                                                         {
 975                                                                 continue;
 976                                                         }
 977
 978                                                         if (pWaitingGestureDetector == this)
 979                                                         {
 980                                                                 pGestureDetector->OnGestureDetectorStateChanged(*this);
 981                                                         }
 982                                                 }
 983                                                 delete pWaitingEnumerator;
 984                                         }
 985                                 }
 986                         }
 987                         delete pEnumerator;
 988                 }
 989         }
 990
 991         ProcessGestureCondition();
 992 }
 993
 994 void
 995 _TouchGestureDetector::ProcessGestureCondition(void)
 996 {
 997         _TouchManager* pTouchManager = _TouchManager::GetInstance();
 998         SysTryReturnVoidResult(NID_UI, pTouchManager, E_SYSTEM, "[E_SYSTEM] _ControlManager does not exist.");
 999
1000         _Control* pControl = GetControl();
1001         SysTryReturnVoidResult(NID_UI, pControl, E_INVALID_CONDITION, "[E_INVALID_CONDITION] invalid GestureDetectorControl()");
1002
1003         //send delayed touch event when all gestures set delayed touch events decided its state(success or failed) and all failed.
1004         if (!pControl->IsDelayedTouchEventEnabled() && pControl->IsPossibleToSendDelayedTouchEvent() && !pControl->IsSentDelayedEvent())
1005         {
1006                 SendDelayedTouchEvent(pControl);
1007         }
1008
1009         if (pControl->IsCancelOnGestureSuccess())
1010         {
1011                 pTouchManager->SetTouchCancelOnGesture(true);
1012                 pTouchManager->SetTouchCanceled(null);
1013                 pTouchManager->SetTouchCanceledOnGestureSuccess(true);
1014         }
1015
1016         bool allDetected = true;
1017         IMapEnumeratorT <_TouchGestureDetector*, _TouchGestureDetectorState>* pMapEnumerator = pControl->GetStartedGestureDetectorEnumeratorN();
1018         if (pMapEnumerator)
1019         {
1020                 while(pMapEnumerator->MoveNext() == E_SUCCESS)
1021                 {
1022                         _TouchGestureDetectorState state = _TOUCH_GESTURE_DETECTOR_STATE_READY;
1023                         pMapEnumerator->GetValue(state);
1024
1025                         if (state == _TOUCH_GESTURE_DETECTOR_STATE_STARTED)
1026                         {
1027                                 allDetected = false;
1028                                 break;
1029                         }
1030                 }
1031                 delete pMapEnumerator;
1032         }
1033
1034         if (allDetected)
1035         {
1036                 pControl->ClearStartedGestureDetectorList();
1037         }
1038 }
1039
1040 void
1041 _TouchGestureDetector::SendDelayedTouchEvent(_Control* pControl)
1042 {
1043         _TouchManager* pTouchManager = _TouchManager::GetInstance();
1044         SysTryReturnVoidResult(NID_UI, pTouchManager, E_SYSTEM, "[E_SYSTEM] _ControlManager does not exist.");
1045
1046         //send delayed event if all started gesture are failed.
1047         IListT<_TouchInfo*>* pList = pControl->GetTouchInfoList();
1048         if (pList)
1049         {
1050                 IEnumeratorT<_TouchInfo*>* pEnumerator = pList->GetEnumeratorN();
1051                 if (pEnumerator)
1052                 {
1053                         while(pEnumerator->MoveNext() == E_SUCCESS)
1054                         {
1055                                 _TouchInfo* pTouchInfo = null;
1056                                 pEnumerator->GetCurrent(pTouchInfo);
1057                                 if (pTouchInfo == null)
1058                                 {
1059                                         continue;
1060                                 }
1061
1062                                 pControl->SetSendingDelayedEvent(true);
1063                                 pTouchManager->SendEvent(pControl, *pTouchInfo);
1064                         }
1065                         delete pEnumerator;
1066                         pControl->SetSendingDelayedEvent(false);
1067                         pControl->SetSentDelayedEvent(true);
1068                 }
1069         }
1070 }
1071
1072 IListT<_TouchGestureDetector*>*
1073 _TouchGestureDetector::GetCurrentWantToFailList(void) const
1074 {
1075         return __pCurrentWantToFailList;
1076 }
1077
1078 void
1079 _TouchGestureDetector::OnGestureDetectorStateChanged(const _TouchGestureDetector& gestureDetector)
1080 {
1081         if (GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS_AND_WAIT)
1082         {
1083                 _TouchGestureDetectorState state = gestureDetector.GetDetectorState();
1084                 if (state == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
1085                 {
1086                         SetDetectorState(_TOUCH_GESTURE_DETECTOR_STATE_FAILED);
1087                 }
1088                 else if (state == _TOUCH_GESTURE_DETECTOR_STATE_FAILED)
1089                 {
1090                         IListT<_TouchGestureDetector*>* pWaitingList = GetCurrentWantToFailList();
1091                         if (pWaitingList)
1092                         {
1093                                 bool exist = pWaitingList->Contains(const_cast<_TouchGestureDetector*>(&gestureDetector));
1094                                 if (exist)
1095                                 {
1096                                         _TouchGestureDetector* pGestureDetector = const_cast<_TouchGestureDetector*>(&gestureDetector);
1097                                         pWaitingList->Remove(pGestureDetector);
1098                                 }
1099                         }
1100                         _TouchGestureDetectorType type = GetDetectorType();
1101                         if (type != _TOUCH_GESTURE_DETECTOR_TYPE_PINCH && type != _TOUCH_GESTURE_DETECTOR_TYPE_ROTATION && type != _TOUCH_GESTURE_DETECTOR_TYPE_PANNING)
1102                         {
1103                                 SetDetectorState(_TOUCH_GESTURE_DETECTOR_STATE_SUCCESS);
1104                         }
1105                 }
1106         }
1107         else if (GetDetectorState() == _TOUCH_GESTURE_DETECTOR_STATE_READY)
1108         {
1109                 _TouchGestureDetectorState state = gestureDetector.GetDetectorState();
1110
1111                 if (state == _TOUCH_GESTURE_DETECTOR_STATE_SUCCESS)
1112                 {
1113                         SetDetectorState(_TOUCH_GESTURE_DETECTOR_STATE_FAILED);
1114                 }
1115                 else if (state == _TOUCH_GESTURE_DETECTOR_STATE_FAILED)
1116                 {
1117                         IListT<_TouchGestureDetector*>* pWaitingList = GetCurrentWantToFailList();
1118                         if (pWaitingList)
1119                         {
1120                                 bool exist = pWaitingList->Contains(const_cast<_TouchGestureDetector*>(&gestureDetector));
1121                                 if (exist)
1122                                 {
1123                                         _TouchGestureDetector* pGestureDetector = const_cast<_TouchGestureDetector*>(&gestureDetector);
1124                                         pWaitingList->Remove(pGestureDetector);
1125                                 }
1126                         }
1127                 }
1128         }
1129 }
1130
1131 void
1132 _TouchGestureDetector::SetGestureStart(bool start)
1133 {
1134         __isDetectionStarted = start;
1135
1136         if (start == true)
1137         {
1138                 _Control* pControl = GetControl();
1139                 if (pControl)
1140                 {
1141                         pControl->AddStartedGestureDetector(*this, _TOUCH_GESTURE_DETECTOR_STATE_STARTED);
1142                 }
1143         }
1144 }
1145
1146 bool
1147 _TouchGestureDetector::IsGestureStarted(void) const
1148 {
1149         return __isDetectionStarted;
1150 }
1151
1152 bool
1153 _TouchGestureDetector::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1154 {
1155         return false;
1156 }
1157
1158 bool
1159 _TouchGestureDetector::OnTouchMoved(const  _Control& source, const _TouchInfo& touchinfo)
1160 {
1161         return false;
1162 }
1163
1164 bool
1165 _TouchGestureDetector::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1166 {
1167         return false;
1168 }
1169
1170 bool
1171 _TouchGestureDetector::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1172 {
1173         return false;
1174 }
1175
1176 void
1177 _TouchGestureDetector::OnTouchGestureDetectorAdded(void)
1178 {
1179 }
1180
1181 void
1182 _TouchGestureDetector::OnTouchGestureDetectorRemoved(void)
1183 {
1184 }
1185
1186 }}  // Tizen::Ui