/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Gesture helper implementation

*

*/

#include "GestureEngine.h"

#include "filelogger.h"

using namespace stmGesture ;

CGestureEngine::CGestureEngine()

{

    m_numOfActiveStreams = 0 ;

    m_currentGestureOwner = -1 ;

    m_currentLockedGesture = -1 ;

    for (int i = 0; i < stmUiEventEngine::KMaxNumberOfPointers; i++)

    {

        m_uiEventStream[i] = NULL ;

    }

}

CGestureEngine::~CGestureEngine()

{

    m_gestures.Reset() ;

}

bool CGestureEngine::addGesture(const MGestureRecogniserIf* aNewGesture)

{

    // Add the new gesture recogniser to our list of recognisers

    return m_gestures.Append(aNewGesture) == 0;

}

bool CGestureEngine::insertGesture(const MGestureRecogniserIf* aNewGesture)

{

    return insertGestureAt(aNewGesture, 0) == 0;

}

bool CGestureEngine::insertGestureAt(const MGestureRecogniserIf* aNewGesture, int position)

{

    return m_gestures.Insert(aNewGesture, position) == 0 ;

}

bool CGestureEngine::removeGesture(const MGestureRecogniserIf* aOldGesture)

{

    // If gestures are removed, there cannot be current gesture owner...

    if (m_currentGestureOwner != -1)

    {

        MGestureRecogniserIf* pgrif = m_gestures[m_currentGestureOwner] ;

        pgrif->release(this) ;

        m_currentGestureOwner = -1 ;    // no more gesture owners...

    }

    TInt ix = m_gestures.Find(aOldGesture) ;

    bool found = (ix != -1);

    if (found)

    {

        m_gestures.Remove(ix) ;

    }

    return found ;

}

int CGestureEngine::activeStreamCount() const

{

    return m_numOfActiveStreams ;

}

const stmUiEventEngine::MUiEvent* CGestureEngine::getUiEvents(int indexOfActiveStream) const

{

#if defined(ADVANCED_POINTER_EVENTS)

	// create temporary array of active event streams and initialize with zero

	const stmUiEventEngine::MUiEvent* activeEventPointers[stmUiEventEngine::KMaxNumberOfPointers] ;

	for (int x = 0; x < stmUiEventEngine::KMaxNumberOfPointers; x++) activeEventPointers[x] = 0 ;

	// then fill from currently active event streams

	int indextoactiveEventPointers = 0 ;

    for (int i = 0; i < stmUiEventEngine::KMaxNumberOfPointers; i++)

    {

    	if (m_uiEventStream[i])

    	    activeEventPointers[indextoactiveEventPointers++] = m_uiEventStream[i] ;

    }

	// then return the active event stream asked

    return activeEventPointers[indexOfActiveStream] ;

#else

    // in single touch it is enough to return the only possible pointer

    return m_uiEventStream[indexOfActiveStream] ;

#endif

}

/*!

 * Process the UI events

 */

void CGestureEngine::HandleUiEventL(const stmUiEventEngine::MUiEvent& aEvent )

{

    // process one incoming UI event

    storeUiEvent(aEvent) ;  // store the event to the "stream" based on the index of pointer

    walkTroughGestures() ;  // and walk trough the gestures to process the UI event

    updateUiEvents() ;

    // If it was last release event, make sure no-one has the gestures locked

    m_numOfActiveStreams = 0 ;

    for (int i = 0; i < stmUiEventEngine::KMaxNumberOfPointers; i++)

    {

        if (m_uiEventStream[i]) m_numOfActiveStreams++ ;

    }

    if (m_numOfActiveStreams == 0)

    {

        if (m_currentLockedGesture != -1)

        {

            MGestureRecogniserIf* pgrif = m_gestures[m_currentLockedGesture] ;

            pgrif->release(this) ;

        }

        m_currentLockedGesture = -1 ;

    }

}

/*!

 * Store the UI event.  There are max X "streams" of events, one for each

 * pointer.  The streams are actually just pointers to the latest event, since the

 * MUiEvent interface has methods to walk trough the chain of events.

 */

void CGestureEngine::storeUiEvent(const stmUiEventEngine::MUiEvent& aEvent)

{

    m_uiEventStream[aEvent.Index()] = &aEvent ;

    m_numOfActiveStreams = 0 ;

    for (int i = 0; i < stmUiEventEngine::KMaxNumberOfPointers; i++)

    {

        if (m_uiEventStream[i]) m_numOfActiveStreams++ ;

    }

}

/*!

 *  Call each gesture handler in turn until one claims to be in control of the gesture.

 */

void CGestureEngine::walkTroughGestures()

{

    int newowner = -1 ;

    int newlocker = m_currentLockedGesture ;

    // check if someone has locked the gesture

    TGestureRecognitionState thestate = ENotMyGesture ;

    if (m_currentLockedGesture != -1)

    {

        MGestureRecogniserIf* pgrif = m_gestures[m_currentLockedGesture] ;

        if (pgrif)

        {

            if (m_loggingEnabled)

            {

                // log entry about locked gesture (hmm.. should have added names to the MGestureRecogniserIf

                LOGARG("locked gesture recognizer %d (addr %d), active streams %d",

                        m_currentLockedGesture, pgrif, m_numOfActiveStreams);

            }

            thestate = pgrif->recognise(m_numOfActiveStreams, this) ;

            switch (thestate)

            {

            case EGestureActive:

            {

                // This gesture recogniser owns the gesture, so release the lock

                newlocker = -1 ;

                newowner = m_currentLockedGesture ;

                if (m_loggingEnabled)

                {

                    LOGARG("new owner %d lock release", m_currentLockedGesture);

                }

                break;

            }

            case ELockToThisGesture:

            {

                // this gesture recogniser wants to keep the lock

                newowner = m_currentLockedGesture ;

                newlocker = m_currentLockedGesture ;

                if (m_loggingEnabled)

                {

                    LOGARG("new owner %d keep lock", m_currentLockedGesture);

                }

                break;

            }

            case ENotMyGesture:

            {

                break;

            }

            }

        }

        else

        {

            if (m_loggingEnabled)

            {

                LOGARG("NULL recogniser for %d", m_currentLockedGesture);

            }

        }

    }

    if (thestate == ENotMyGesture)

    {

        if (m_loggingEnabled)

        {

            LOGARG("walk trough recognizers active streams %d", m_numOfActiveStreams);

        }

        // No locking gesture, walk trough the list until someone handles this

        for (int i = 0; i < m_gestures.Count(); i++)

        {

            bool controlObtained = false;

            MGestureRecogniserIf* pgrif = m_gestures[i];

            if (pgrif)

            {

                switch (pgrif->recognise(m_numOfActiveStreams, this))

                {

                case EGestureActive:

                {

                    // This gesture recogniser owns the gesture, stop looping...

                    controlObtained = true;

                    newowner = i;

                    break;

                }

                case ELockToThisGesture:

                {

                    // this gesture recogniser wants to take ownership

                    controlObtained = true;

                    newowner = i;

                    newlocker = i;

                    break;

                }

                case ENotMyGesture:

                {

                    break;

                }

                }

            }

            if (controlObtained)

            {

                break; // do not process rest of the gestures

            }

        }

    }

    if (newowner != -1 && newowner != m_currentGestureOwner)

    {

        if (m_currentGestureOwner != -1)

        {

            MGestureRecogniserIf* pgrif = m_gestures[m_currentGestureOwner] ;

            pgrif->release(this) ;

        }

        m_currentGestureOwner = newowner ;

    }

    m_currentLockedGesture = newlocker ;    // if someone locked it or released the lock

}

void CGestureEngine::updateUiEvents()

{

    for (int i = 0; i < stmUiEventEngine::KMaxNumberOfPointers; i++)

    {

        if (m_uiEventStream[i])

        {

            if (m_uiEventStream[i]->Code() == stmUiEventEngine::ERelease)

            {

                // Event can be removed since Release is the last event

                // note that it is the lower layer event engine

                // which actually deletes the object

                m_uiEventStream[i] = NULL ;

            }

        }

    }

}