/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  This class handles the event list & process the events 

*                 while progressive rendering

*

*/

#include "SvgtEventHandlerAO.h"

#include <SVGTAppObserverUtil.h>

#include <imcvcodc.h>

#include "SvgtEvent.h"

const TInt KTimerIntervalInMiliSeconds = 1000;

const TInt KInitialTimeInterval = 100;

const TInt KMaxTimeInterval = 2000;

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::NewL

// Two phase construction

// -----------------------------------------------------------------------------

//

CSvgtEventHandlerAO* CSvgtEventHandlerAO::NewL(MSvgtAppObserver* aAppObserverUtil, 

                                CSVGTCustControl* aCustControl ,

                                const TThreadId aMainThreadId )

    {

    CSvgtEventHandlerAO* self = new ( ELeave ) CSvgtEventHandlerAO( aAppObserverUtil , 

                                                                    aCustControl, 

                                                                    aMainThreadId);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::CSvgtEventHandlerAO

// Constructor

// -----------------------------------------------------------------------------

//

CSvgtEventHandlerAO::CSvgtEventHandlerAO(MSvgtAppObserver* aAppObserverUtil, 

                                        CSVGTCustControl* aCustControl, 

                                        const TThreadId aMainThreadId):

                                        CActive( CActive::EPriorityStandard ),

                                        iCustControl(aCustControl),

                                        iMainThreadId( aMainThreadId ),

                                        iIsDocumentComplete( EFalse ),

                                        iStepCount( 1 ),

                                        iSvgTimeBetweenRedraw( KInitialTimeInterval )

    {

    iAppObserverUtil = static_cast<CSVGTAppObserverUtil*>(aAppObserverUtil);

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::ConstructL

// 2nd phase constructor

// -----------------------------------------------------------------------------

//

void CSvgtEventHandlerAO::ConstructL()

    {

    iPreviousRedrawClock.HomeTime();

    // Add to active scheduler

    CActiveScheduler::Add( this );

    // Set the status as pending

    iStatus = KRequestPending;

    // Set the active object as Active

    SetActive();

    // Create the critical section IPC for sync. the RequestComplete Calls

    iCritSection.CreateLocal();

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::~CSvgtEventHandlerAO

// Destructor

// -----------------------------------------------------------------------------

//

CSvgtEventHandlerAO::~CSvgtEventHandlerAO()

    {

    Cancel();

    iEventList.ResetAndDestroy();

    iEventList.Close();

    iCritSection.Close();

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::AddEventToList

// It adds the event (except redraw event) to the event queue.

// -----------------------------------------------------------------------------

//

TBool CSvgtEventHandlerAO::AddEventToList( CSvgtEvent* aEvent)

    {

    iEventList.Append( aEvent );

    return ETrue;        

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::AddRedrawEventToList

// It adds the redraw event to the event queue.

// -----------------------------------------------------------------------------

//

TBool CSvgtEventHandlerAO::AddRedrawEventToList( const TBool aForceAdd )

    {

    TBool isEventAdded = EFalse;

    if(aForceAdd || IsRedrawTimeElapsed())

        {

        CSvgtEvent* redrawEvent = new CSvgtEventRedraw;

        iEventList.Append( redrawEvent );

        isEventAdded = ETrue;

        }

    return isEventAdded;        

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::MakeRequestComplete

// It make the request complete.

// -----------------------------------------------------------------------------

//

void CSvgtEventHandlerAO::MakeRequestComplete( TInt aError )

    {

    // The Asynchronouse service provider must only call the RequestComplete()

    // once for each request. Multiple completion events on a single active

    // object result in a stray signal panic.

    // Hence use a critical section to synchronize access to RequestComplete()

    iCritSection.Wait();

    if( ( IsActive() ) && ( iStatus == KRequestPending ) )

        { 

        // The asynchronous service provider is the loading thread and since 

        // this is called from both loading thread as well as main thread

        // use the RThread object to complete the request for active

        // object present in the main thread's active scheduler

        TRequestStatus* status = &iStatus;

        RThread mainThread;

        if( mainThread.Open( iMainThreadId) )

            {

            // Problem opening thread, ignore error and return : Should not happen.

            return;

            }

        mainThread.RequestComplete( status, aError );

        mainThread.Close();

        }

    iCritSection.Signal();

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::AddEventToList

// It indicates that document is document loading completed.

// -----------------------------------------------------------------------------

//

void CSvgtEventHandlerAO::SetDocumentComplete()

    {

    iIsDocumentComplete = ETrue;

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::RunL

// Handles an active object's request completion event.

// -----------------------------------------------------------------------------

//

void CSvgtEventHandlerAO::RunL()

    {

    // Set the Active Object Active always

    if( !IsActive() )

        {

        iStatus = KRequestPending;

        SetActive();

        }

    if(iEventList.Count())    

        {

        CSvgtEvent* event = iEventList[0];

        iEventList.Remove( 0 );

        switch(event->EventType())

            {

            case CSvgtEvent::ESvgtEventEmbededImage:

                {

                CSvgtEventEmbededImage* svgEvent = 

                                        static_cast<CSvgtEventEmbededImage*>(event);

                iAppObserverUtil->AssignEmbededDataL( svgEvent->ImageUri() );

                }

                break;

            case CSvgtEvent::ESvgtEventFetchImage:

                {

                CSvgtEventFetchImage* fetchEvent = 

                                        static_cast<CSvgtEventFetchImage*>(event);

                iAppObserverUtil->NewFetchImageData(fetchEvent->ImageUri());

                }

                break;

            case CSvgtEvent::ESvgtEventLinkActivated:

                {

                CSvgtEventLinkActivated* linkEvent = 

                                            static_cast<CSvgtEventLinkActivated*>(event);

                iAppObserverUtil->LinkActivated(linkEvent->ImageUri());

                }

                break;

            case CSvgtEvent::ESvgtEventLinkActivatedWithShow:

                {

                CSvgtEventLinkActivatedWithShow* linkShowEvent = 

                                static_cast<CSvgtEventLinkActivatedWithShow*>(event);

                iAppObserverUtil->LinkActivatedWithShow(linkShowEvent->ImageUri(), 

                                                        linkShowEvent->Show());

                }

                break;

            case CSvgtEvent::ESvgtEventRedraw:

                {

                //DO REDRAW

                iCustControl->PerformEngineRedraw();

                iCustControl->DrawNow();

                }

                break;

            default:

                break;

            }

        delete event;

        }

        if( iEventList.Count() )

            {

            // Pending events in the list, reschedule active

            // object

            MakeRequestComplete( KErrNone );

            }

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::DoCancel

// Cancels all the pending request

// -----------------------------------------------------------------------------

//

void CSvgtEventHandlerAO::DoCancel()

    {

    // The service provided for this active object is the 

    // loading thread. Since the loading thread is already indicated to stop

    // generating requests, need to terminate the request

    // pending in the main thread

    DoTerminate();

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::RunError

// Handles a leave occurring in the request completion event handler RunL().

// -----------------------------------------------------------------------------

//

TInt CSvgtEventHandlerAO::RunError( TInt aError )

    {

    // When an error occurs, call base class error handler

    // Note that active object should not be Cancel() here

    // as Loading thread could still be alive and do a

    // MakeRequestComplete. This would generate a stray

    // signal.

    return ( CActive::RunError( aError ) );

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::IsRedrawTimeElapsed

// It determines whether the time elapsed or not.

// -----------------------------------------------------------------------------

//

TBool CSvgtEventHandlerAO::IsRedrawTimeElapsed()

    {

    TBool isTimeElapsed = EFalse;

    TTime currentClock;

    currentClock.HomeTime();

    TTimeIntervalMicroSeconds time64;

    time64 = currentClock.MicroSecondsFrom( iPreviousRedrawClock );

    TUint32 timeDelta = I64INT( time64.Int64() ) / KTimerIntervalInMiliSeconds; 

                                                            // milliseconds

    if ( timeDelta > iSvgTimeBetweenRedraw )//KSvgTimeBetweenRedraw=500  

        {

        if( iSvgTimeBetweenRedraw < KMaxTimeInterval )

            {

            iSvgTimeBetweenRedraw *= ++iStepCount;

            }

        isTimeElapsed = ETrue;

        // Save the current time to calculate interframe delay

        iPreviousRedrawClock.HomeTime();        

        }

    return isTimeElapsed;

    }

// -----------------------------------------------------------------------------

// CSvgtEventHandlerAO::DoTerminate

// Cancels the pending async request 

// -----------------------------------------------------------------------------

//

void CSvgtEventHandlerAO::DoTerminate()

    {

    // Post a pseudo complete, so that Cancel() is done 

    // successfully. The Loading thread which is the actual service

    // provider is by now already stopped.

    // The Asynchronous service provider should complete the 

    // request with KErrCancel as quickly as possible, because CActive::Cancel

    // blocks until completion occurs.

    MakeRequestComplete( KErrCancel );    

    }

//End of file