1 /*

     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Gesture helper implementation

    15 *

    16 */

    17 

    18 

    19 // Gesture UI Engine

    20 #include "statemachine.h"

    21 

    22 // Gesture Library: Framework

    23 #include "gestureframework.h"

    24 #include "rt_gestureengineif.h"

    25 

    26 // Gesture Library: Recognizers

    27 #include "tapgesturerecogniser.h"

    28 #include "pangesturerecogniser.h"

    29 #include "edgescrollgesturerecogniser.h"

    30 #include "longpressgesturerecogniser.h"

    31 #include "pinchgesturerecogniser.h"

    32 #include "touchgesturerecogniser.h"

    33 #include "releasegesturerecogniser.h"

    34 #include "flickgesturerecogniser.h"

    35 #include "zoomgesturerecogniser.h"

    36 

    37 #include "stmgestureinterface.h"

    38 #include "gesturehelpereventsender.h"

    39 

    40 #ifndef ICS_DCHECK

    41 #define ICS_DCHECK(test)

    42 #endif

    43 

    44 #define LOG(args...)

    45 

    46 

    47 EXPORT_C CStmGestureParameters::CStmGestureParameters()

    48     {

    49 

    50     }

    51 

    52 EXPORT_C CStmGestureParameters::CStmGestureParameters(

    53     const CStmGestureParameters& aParams )

    54     {

    55     Mem::Copy(&iParam[0], &aParams.iParam[0], sizeof(iParam));

    56     Mem::Copy(&iAreaSettings[0], &aParams.iAreaSettings[0], sizeof(iAreaSettings));

    57     Mem::Copy(&iEnabled[0], &aParams.iEnabled[0], sizeof(iEnabled));

    58     }

    59 

    60 EXPORT_C CStmGestureEngine* CStmGestureEngine::NewL()

    61     {

    62     CStmGestureEngine* eng = new(ELeave) CStmGestureEngine();

    63     CleanupStack::PushL(eng);

    64     eng->ConstructL();

    65     CleanupStack::Pop(eng);

    66     return eng;

    67     }

    68 

    69 CStmGestureEngine::CStmGestureEngine()

    70     {

    71 

    72     }

    73 

    74 void CStmGestureEngine::ConstructL()

    75     {

    76     iGf = stmGesture::CGestureFramework::NewL();

    77     }

    78 

    79 CStmGestureEngine::~CStmGestureEngine()

    80     {

    81     // Prevent reactivation of contexts as they remove themselves

    82     iDtorPhase = ETrue;

    83 

    84     iContexts.ResetAndDestroy();

    85     iCtxtStack.Reset();

    86     delete iGf;

    87     }

    88 

    89 EXPORT_C CStmGestureContext* CStmGestureEngine::CreateContextL(

    90     TInt /*aId*/ )

    91     {

    92     CStmGestureContext* ctxt = new(ELeave) CStmGestureContext(*this);

    93     CleanupStack::PushL(ctxt);

    94     ctxt->ConstructL();

    95     CleanupStack::Pop(ctxt);

    96     return ctxt;

    97     }

    98 

    99 EXPORT_C CStmGestureContext* CStmGestureEngine::Context(

   100     TInt /*aId*/ )

   101     {

   102     return NULL;

   103     }

   104 

   105 void CStmGestureEngine::EnableContextL(

   106     CStmGestureContext& aContext )

   107     {

   108     // NB: enabling context puts it on top of the Context Stack

   109     TInt idx = iCtxtStack.Find(&aContext);

   110     if(idx >= 0)

   111         {

   112         iCtxtStack.Remove(idx);

   113         }

   114 

   115     SetupRecognizersL(aContext, ETrue);

   116 

   117     iCtxtStack.AppendL(&aContext);

   118     }

   119 

   120 void CStmGestureEngine::DisableContextL(

   121     CStmGestureContext& aContext )

   122     {

   123     TInt idx = iCtxtStack.Find(&aContext);

   124     ICS_DCHECK(idx >= 0);

   125     if(idx == KErrNotFound)

   126         {

   127         return;

   128         }

   129 

   130     iCtxtStack.Remove(idx);

   131 

   132     stmGesture::MGestureEngineIf* ge = iGf->getGestureEngine();

   133 

   134     for(TInt i = 0; i < stmGesture::EStmGestureUid_Count; ++i)

   135         {

   136         MStmGestureRecogniser* rec = aContext.iRecognizers[i];

   137         if(rec)

   138             {

   139             ge->removeGesture(rec);

   140             }

   141         }

   142 

   143     // re-activate previous (new top-most) context

   144     // NB: if deleted context is not top-most (active) one, no updates done

   145     TInt count = iCtxtStack.Count();

   146     if(idx == count && count > 0 && !iDtorPhase)

   147         {

   148         CStmGestureContext* previous = iCtxtStack[count - 1];

   149         SetupRecognizersL(*previous, EFalse);

   150         }

   151     }

   152 

   153 template<class T>

   154 void CStmGestureEngine::InitRecognizerL(

   155     T*& aGesture,

   156     CStmGestureContext& aContext,

   157     TBool aNewContext )

   158     {

   159     stmGesture::MGestureRecogniserIf*& recognizer = aContext.iRecognizers[T::KUid];

   160     aGesture = static_cast<T*>(recognizer);

   161     if(!aGesture && aNewContext)

   162         {

   163         recognizer = aGesture = T::NewL(&aContext);

   164         recognizer->enableLogging((aContext.iLogging & (1<<T::KUid)) != 0);

   165         }

   166     else

   167         {

   168         ICS_DCHECK(gesture && !aNewContext); // should exist in restored top context

   169         }

   170 

   171     // TODO: Add in right place according to gesture class

   172     TBool added = iGf->getGestureEngine()->addGesture(aGesture);

   173     if(!added)

   174         {

   175         User::Leave(KErrNoMemory);

   176         }

   177     }

   178 

   179 void CStmGestureEngine::SetupRecognizersL(

   180     CStmGestureContext& aContext,

   181     TBool aNewContext )

   182     {

   183     LOG("Setup recognizers");

   184     // Order of recognizers in the Gesture Engine (upper ones receive input before lower ones)

   185     //

   186     // PINCH

   187     // CORNER_ZOOM

   188     // EDGE_SCROLL

   189     // LONGPRESS

   190     // TOUCH

   191     // UP_DOWN

   192     // LEFT_RIGHT

   193     // HOVER

   194     // PAN

   195     // TAP / DOUBLE_TAP

   196     // FLICK

   197     // RELEASE

   198     // UNKNOWN

   199 

   200     stmUiEventEngine::CStateMachine* stateMachine = iGf->getUiStateMachine();

   201     stmGesture::MGestureEngineIf* gestureEngine = iGf->getGestureEngine();

   202 

   203     MStmGestureParameters& conf = aContext.Config();

   204 

   205     TBool filter = conf.Param(stmGesture::EEnableFiltering) != 0;

   206 

   207     // TOUCH AREA

   208     TStmGestureArea& touchArea = *conf.Area(stmGesture::ETouchArea);

   209     TInt touchAreaSizeInMm = touchArea.iSize.iWidth;

   210     stateMachine->setTouchAreaShape ( stmUiEventEngine::TAreaShape(touchArea.iShape) );

   211     stateMachine->setTouchArea      ( !filter ? 0 : touchAreaSizeInMm );

   212     stateMachine->setTouchTimeout   ( !filter ? 0 : touchArea.iTimeout * 1000);

   213     CCoeControl* gestureContext = aContext.getOwner();

   214     TRect ctxtRect = gestureContext->Rect();

   215 

   216     // ===================================================== PINCH

   217     using stmGesture::CPinchGestureRecogniser;

   218 

   219     if (conf.Enabled(CPinchGestureRecogniser::KUid))

   220         {

   221         CPinchGestureRecogniser* gesture = NULL;

   222         InitRecognizerL(gesture, aContext, aNewContext);

   223 

   224         if(gesture)

   225             {

   226             TReal32 pspeed = conf.Param(stmGesture::EPinchSpeed) / 1000.f;

   227             gesture->setPinchingSpeed(pspeed);

   228             }

   229         }

   230 

   231     // ===================================================== LONG PRESS

   232     using stmGesture::CLongPressGestureRecogniser;

   233 

   234     if (conf.Enabled(CLongPressGestureRecogniser::KUid))

   235         {

   236         CLongPressGestureRecogniser* gesture = NULL;

   237         InitRecognizerL(gesture, aContext, aNewContext);

   238 

   239         if(gesture)

   240             {

   241             gesture->setArea(ctxtRect);

   242             }

   243         }

   244 

   245     // ===================================================== TOUCH

   246     using stmGesture::CTouchGestureRecogniser;

   247 

   248     if (conf.Enabled(CTouchGestureRecogniser::KUid))

   249         {

   250         CTouchGestureRecogniser* gesture = NULL;

   251         InitRecognizerL(gesture, aContext, aNewContext);

   252 

   253         if(gesture)

   254             {

   255             // define empty area so that touch is reported only inside

   256             // our window (touch recogniser handles either an area or the target window)

   257             gesture->setArea(TRect());

   258             }

   259         }

   260 

   261 

   262     // ===================================================== PAN

   263     using stmGesture::CPanGestureRecogniser;

   264 

   265     if (conf.Enabled(CPanGestureRecogniser::KUid))

   266         {

   267         CPanGestureRecogniser* gesture = NULL;

   268         InitRecognizerL(gesture, aContext, aNewContext);

   269 

   270         if(gesture)

   271             {

   272             gesture->setPanningSpeedLow ( conf.Param(stmGesture::EPanSpeedLow)  / 1000.f );

   273             gesture->setPanningSpeedHigh( conf.Param(stmGesture::EPanSpeedHigh) / 1000.f );

   274             }

   275         }

   276 

   277     // ===================================================== TAP / DOUBLE TAP

   278     /// Add recognizer before any existing Flick, Release, Unknown

   279     // Add the gesture to the gesture engine

   280     // TODO: Tap recognizer is special - it can combine multiple listeners,

   281     //       so no need to create new one if it already exists, just add new listeners to it

   282 

   283     using stmGesture::CTapGestureRecogniser;

   284 

   285     if (conf.Enabled(CTapGestureRecogniser::KUid))

   286         {

   287         CTapGestureRecogniser* gesture = NULL;

   288         InitRecognizerL(gesture, aContext, aNewContext);

   289 

   290         if(gesture)

   291             {

   292             gesture->setDoubleTapTimeout(conf.Param(stmGesture::EDoubleTapTimeout) * 1000);

   293             gesture->setDoubleTapRange( touchAreaSizeInMm );

   294             gesture->ignoreFirstTap(EFalse);

   295 

   296             aContext.iLogging |= 1<<CTapGestureRecogniser::KUid;

   297             }

   298         }

   299 

   300     // ===================================================== FLICK

   301     using stmGesture::CFlickGestureRecogniser;

   302 

   303     if (conf.Enabled(CFlickGestureRecogniser::KUid))

   304         {

   305         CFlickGestureRecogniser* gesture = NULL;

   306         InitRecognizerL(gesture, aContext, aNewContext);

   307 

   308         if(gesture)

   309             {

   310             TReal32 flickSpeed = conf.Param(stmGesture::EFlickSpeed) / 1000.f;

   311             gesture->setFlickingSpeed(flickSpeed);

   312             }

   313         }

   314 

   315     // ===================================================== RELEASE

   316     using stmGesture::CReleaseGestureRecogniser;

   317 

   318     if (conf.Enabled(CReleaseGestureRecogniser::KUid))

   319         {

   320         CReleaseGestureRecogniser* gesture = NULL;

   321         InitRecognizerL(gesture, aContext, aNewContext);

   322 

   323         if(gesture)

   324             {

   325             gesture->setArea(TRect());

   326             }

   327         }

   328 

   329 #if 0 // use in future depending upon browser requirement

   330     // ===================================================== CORNER ZOOM

   331     using stmGesture::CZoomGestureRecogniser;

   332 

   333     if (conf.Enabled(CZoomGestureRecogniser::KUid))

   334         {

   335         CZoomGestureRecogniser* gesture = NULL;

   336         InitRecognizerL(gesture, aContext, aNewContext);

   337 

   338         if(gesture)

   339             {

   340             gesture->setArea(ctxtRect);

   341             gesture->setRange(conf.Param(stmGesture::EZoomCornerSize));

   342             }

   343         }

   344 

   345     // ===================================================== EDGE SCROLL

   346     using stmGesture::CEdgeScrollGestureRecogniser;

   347 

   348     if (conf.Enabled(CEdgeScrollGestureRecogniser::KUid))

   349         {

   350         CEdgeScrollGestureRecogniser* gesture = NULL;

   351         InitRecognizerL(gesture, aContext, aNewContext);

   352 

   353         if(gesture)

   354             {

   355             gesture->setArea(ctxtRect);

   356             gesture->setScrollRange(conf.Param(stmGesture::EEdgeScrollRange)); // range is 20 pixels from the edge TODO: add this to settings...

   357             }

   358         }

   359 

   360     // ===================================================== LEFT-RIGHT

   361     using stmGesture::CLeftrightGestureRecogniser;

   362 

   363     if (conf.Enabled(CLeftrightGestureRecogniser::KUid))

   364         {

   365         CLeftrightGestureRecogniser* gesture = NULL;

   366         InitRecognizerL(gesture, aContext, aNewContext);

   367         }

   368 

   369     // ===================================================== UP-DOWN

   370     using stmGesture::CUpdownGestureRecogniser;

   371 

   372     if (conf.Enabled(CUpdownGestureRecogniser::KUid))

   373         {

   374         CUpdownGestureRecogniser* gesture = NULL;

   375         InitRecognizerL(gesture, aContext, aNewContext);

   376         }

   377 

   378     // ===================================================== HOVER

   379     using stmGesture::CHoveringGestureRecogniser;

   380 

   381     if (conf.Enabled(CHoveringGestureRecogniser::KUid))

   382         {

   383         CHoveringGestureRecogniser* gesture = NULL;

   384         InitRecognizerL(gesture, aContext, aNewContext);

   385         if(gesture)

   386             {

   387             gesture->setHoveringSpeed(conf.Param(stmGesture::EHoverSpeed) / 1000.f);

   388             }

   389         }

   390 

   391     // ===================================================== UNKNOWN

   392     using stmGesture::CUnknownGestureRecogniser;

   393 

   394     if (conf.Enabled(CUnknownGestureRecogniser::KUid))

   395         {

   396         CUnknownGestureRecogniser* gesture = NULL;

   397         InitRecognizerL(gesture, aContext, aNewContext);

   398         }

   399 #endif

   400 

   401     // ===========================================================

   402     if(aNewContext)

   403         {

   404         for(TInt i = 0; i < stmGesture::EStmGestureUid_Count; ++i)

   405             {

   406             MStmGestureRecogniser* rec = aContext.iRecognizers[i];

   407             if(rec)

   408                 {

   409                 rec->enableLogging(aContext.iLogging & (1<<i)) ;

   410                 }

   411             }

   412         }

   413 

   414 

   415     // HOLD AREA

   416     TStmGestureArea& holdArea = *conf.Area(stmGesture::EHoldArea);

   417     TInt holdAreaSizeInMm = holdArea.iSize.iWidth;

   418     stateMachine->setHoldAreaShape  ( stmUiEventEngine::TAreaShape(holdArea.iShape) );

   419     stateMachine->setHoldArea       ( !filter ? 0 : holdAreaSizeInMm );

   420     stateMachine->setHoldTimeout    ( !filter ? 0 : holdArea.iTimeout * 1000);

   421 

   422     // TOUCH-TIME AREA

   423     TStmGestureArea& tTimeArea = *conf.Area(stmGesture::ETouchTimeArea);

   424     TInt tTimeAreaSizeInMm = tTimeArea.iSize.iWidth;

   425     // NB: shape <-- TouchAreaShape

   426     stateMachine->setTouchTimeArea      ( !filter ? 0 : tTimeAreaSizeInMm );

   427 

   428     // Timeouts, Adjustments, etc.

   429     stateMachine->setTouchSuppressTimeout(!filter ? 0 :

   430                                             conf.Param(stmGesture::ESuppressTimeout)*1000) ;

   431     stateMachine->setMoveSuppressTimeout(!filter ? 0 :

   432                                             conf.Param(stmGesture::EMoveSuppressTimeout)*1000) ;

   433     stateMachine->enableCapacitiveUp    (!filter ? 0 :

   434                                             conf.Param(stmGesture::ECapacitiveUpUsed));

   435     stateMachine->enableYadjustment     (!filter ? 0 : conf.Param(stmGesture::EAdjustYPos));

   436     stateMachine->enableLogging(false);

   437 

   438     stateMachine->EnableWsEventMonitoring(false);

   439     LOG("Setup recognizers -- DONE");

   440     }

   441 

   442 EXPORT_C void CStmGestureEngine::HandlePointerEventL(

   443     const TPointerEvent& aPointerEvent,

   444     void* target)

   445     {

   446     iGf->getUiStateMachine()->HandlePointerEventL(aPointerEvent,target);

   447     }

   448 

   449 // =============================================================

   450 

   451 CStmGestureContext::CStmGestureContext(

   452     CStmGestureEngine& aEngine ) :

   453     iEngine(aEngine),

   454     iEventSender(NULL)

   455     {

   456 

   457     }

   458 

   459 void CStmGestureContext::ConstructL()

   460     {

   461     iEngine.iContexts.AppendL(this);

   462     iConfig = new(ELeave) CStmGestureParameters();

   463     }

   464 

   465 CStmGestureContext::~CStmGestureContext()

   466     {

   467     // Remove all gesture listeners

   468     for(TInt i = iListeners.Count() - 1; i >= 0; --i)

   469         {

   470         MStmGestureListener* listener = iListeners[i];

   471         iListeners.Remove(i);

   472         }

   473 

   474     iListeners.Reset();

   475 

   476     // Remove all context's recognizers from the Gesture Engine

   477     Deactivate();

   478 

   479     if (iEventSender)

   480         delete iEventSender;

   481 

   482     // Destroy all recognizers

   483     for(TInt r = 0; r < stmGesture::EStmGestureUid_Count; ++r)

   484         {

   485         MStmGestureRecogniser*& rec = iRecognizers[r];

   486         if(rec)

   487             {

   488             delete rec;

   489             rec = NULL;

   490             }

   491         }

   492 

   493     // Remove context from the Gesture Engine

   494     TInt idx = iEngine.iContexts.Find(this);

   495     if(idx != -1)

   496         {

   497         iEngine.iContexts.Remove(idx);

   498         }

   499     delete iConfig;

   500     }

   501 

   502 EXPORT_C void CStmGestureContext::AddListenerL(

   503     MStmGestureListener* aListener,

   504     TInt aPos )

   505     {

   506     iEventSender = CGestureEventSender::NewL(*aListener);

   507     iListeners.InsertL(aListener, aPos);

   508     }

   509 

   510 EXPORT_C TInt CStmGestureContext::RemoveListener(

   511     MStmGestureListener* aListener )

   512     {

   513     TInt ind = iListeners.Find(aListener);

   514     if(ind >= 0)

   515         {

   516         iListeners.Remove(ind);

   517         }

   518     return ind;

   519     }

   520 

   521 EXPORT_C void CStmGestureContext::SetContext(

   522     CCoeControl* aControl )

   523     {

   524     iOwnerControl = aControl;

   525 

   526     for(TInt i = 0; i < stmGesture::EStmGestureUid_Count; ++i)

   527         {

   528         MStmGestureRecogniser* rec = iRecognizers[i];

   529         if(rec)

   530             {

   531             rec->setOwner(aControl);

   532             }

   533         }

   534     }

   535 

   536 EXPORT_C void CStmGestureContext::ActivateL()

   537     {

   538     if(IsActive())

   539         {

   540         // re-enable all recognizers

   541         EnableRecognizersL();

   542         return;

   543         }

   544     /// 1. Tell Engine to deactivate active context

   545 

   546     /// 2. Setup all gesture recognizers

   547     iEngine.EnableContextL(*this);

   548 

   549     /// 3. Notify listeners

   550 

   551     //

   552     EnableRecognizersL();

   553 

   554     ///

   555     iActivated = ETrue;

   556     }

   557 

   558 EXPORT_C void CStmGestureContext::Deactivate()

   559     {

   560     // NB: reactivation of previous context may leave

   561     TRAP_IGNORE(iEngine.DisableContextL(*this));

   562     iActivated = EFalse;

   563     }

   564 

   565 void CStmGestureContext::gestureEnter(

   566     MStmGesture& aGesture )

   567     {

   568     TRAP_IGNORE(DispatchGestureEventL(aGesture.gestureUid(), &aGesture));

   569     }

   570 

   571 void CStmGestureContext::gestureExit(

   572     TStmGestureUid aGestureUid )

   573     {

   574     TRAP_IGNORE(DispatchGestureEventL(aGestureUid, NULL));

   575     }

   576 

   577 CCoeControl* CStmGestureContext::getOwner()

   578     {

   579     return iOwnerControl;

   580     }

   581 

   582 void CStmGestureContext::DispatchGestureEventL(

   583     TStmGestureUid aUid,

   584     MStmGesture* aGesture )

   585     {

   586     iEventSender->AddEvent(aUid, aGesture);

   587     }

   588 

   589 void CStmGestureContext::SuspendRecognizer(

   590     TStmGestureUid aUid )

   591     {

   592     MStmGestureRecogniser* rec = iRecognizers[aUid];

   593     if(rec && !rec->isEnabled())

   594         {

   595         rec->enable(EFalse);

   596         // TODO: Notify listener

   597         }

   598     }

   599 

   600 void CStmGestureContext::EnableRecognizersL()

   601     {

   602     for(TInt i = 0; i < stmGesture::EStmGestureUid_Count; ++i)

   603         {

   604         EnableRecognizerL(TStmGestureUid(i));

   605         }

   606     }

   607 

   608 void CStmGestureContext::EnableRecognizerL(

   609     TStmGestureUid aUid )

   610     {

   611     MStmGestureRecogniser* rec = iRecognizers[aUid];

   612     if(rec && !rec->isEnabled())

   613         {

   614         rec->enable(ETrue);

   615         // TODO: Notify listener

   616         }

   617     }

   618