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