/*
* 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:
*
*/

#include "uieventsender.h"
#include "UiEvent.h"

#include "filelogger.h"

using namespace stmUiEventEngine;


CUiEventSender* CUiEventSender::NewL()
{
    CUiEventSender* self = new (ELeave) CUiEventSender();

    return self;
}

/*!
 * An active object for sending the UI events to the observers.
 * Depending on the m_directsending the asynchronous method is not
 * used but instead the observers will be called immediately.
 */
CUiEventSender::CUiEventSender()
{
    m_loggingenabled = false ;
    for (int i = 0; i < stmUiEventEngine::KMaxNumberOfPointers; i++)
    {
        iEvents[i] = NULL ;
    }
}

CUiEventSender::~CUiEventSender()
{
    // remove the possible events from the buffers if release was missed
    for (int i = 0; i < stmUiEventEngine::KMaxNumberOfPointers; i++)
    {
        if (iEvents[i]) delete iEvents[i] ;
    }
    iObserver.Reset() ;
}

/*!
 * Add new UI event to the list or send it directly to the observers
 * depending on the m_directsending flag.
 * \param aUiEvent the new UI event to be sent to the observers.
 */
TInt CUiEventSender::AddEvent(CUiEvent* aUiEvent)
{
    int pointerIndex = aUiEvent->Index() ;
    // Store the new UI event.  Check what kind of event it is and compress the set of events
    // stored so far if possible
    compressStack(aUiEvent) ;
    aUiEvent->setPrevious(iEvents[pointerIndex]) ;
    iEvents[pointerIndex] = aUiEvent ;  // Store the new event
    TRAPD(err, EmitEventL(*aUiEvent));
    if(err)
        return err;

    if (m_loggingenabled)
    {
        LOGARG("Sent event: %s: (ptr %d) (%d,%d)",
                stmUiEventEngine::EventName(aUiEvent->Code()), pointerIndex,
                aUiEvent->CurrentXY().iX, aUiEvent->CurrentXY().iY);
    }
    // If this was release event, then the chain can be removed
    if (aUiEvent->Code() == stmUiEventEngine::ERelease)
    {
        delete aUiEvent;    // This will delete the whole chain
        iEvents[pointerIndex] = NULL ;
    }
    return KErrNone;
}
/*!
 * Call each observer with the event
 */
void CUiEventSender::EmitEventL(const CUiEvent& aEvent)
{
    for (TInt i = 0; i < iObserver.Count(); i++)
    {
        iObserver[i]->HandleUiEventL(aEvent);
    }
}

/*!
 * Add a new observer.  Note that current implementation is very rude:
 * max 5 observers in a simple array.
 */
bool CUiEventSender::addObserver(MUiEventObserver* aObserver )
{
    iObserver.Append(aObserver) ;
    return true ;
}

/*
 * remove observer from list
 */
bool CUiEventSender::removeObserver(MUiEventObserver* aObserver )
{
    int x = iObserver.Find(aObserver) ;
    if (x != -1)
    {
        iObserver.Remove(x) ;
        return true ;

    }
    return EFalse ; // Could not find observer
}
void CUiEventSender::compressStack(CUiEvent* aUiEvent)
{
    int pointerIndex = aUiEvent->Index() ;
    CUiEvent*& top = iEvents[pointerIndex] ;
    if(!top)
    {
        return;
    }
    if (aUiEvent->Code() == stmUiEventEngine::EHold)
    {
        // assumption: in case of hold, we can discard all previous messages
        delete top ;
        top = NULL ;
    }
    else
    {
        // Check if there would too many moves
        CUiEvent* next = dynamic_cast<CUiEvent*>(top->previousEvent()) ;
        if (next != 0 && next->Code() == stmUiEventEngine::EMove)
        {
            // leave only the topmost to the stack
            top->setPrevious(0) ;
            delete next ;
        }
    }

}